2 * Marvell 88E6060 switch driver
3 * Copyright (c) 2008 Felix Fietkau <nbd@nbd.name>
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License v2 as published by the
7 * Free Software Foundation
9 #include <linux/kernel.h>
10 #include <linux/string.h>
11 #include <linux/errno.h>
12 #include <linux/unistd.h>
13 #include <linux/slab.h>
14 #include <linux/interrupt.h>
15 #include <linux/init.h>
16 #include <linux/delay.h>
17 #include <linux/netdevice.h>
18 #include <linux/etherdevice.h>
19 #include <linux/skbuff.h>
20 #include <linux/spinlock.h>
22 #include <linux/module.h>
23 #include <linux/mii.h>
24 #include <linux/ethtool.h>
25 #include <linux/phy.h>
26 #include <linux/if_vlan.h>
30 #include <asm/uaccess.h>
33 /* Undefine this to use trailer mode instead.
34 * I don't know if header mode works with all chips */
37 MODULE_DESCRIPTION("Marvell 88E6060 Switch driver");
38 MODULE_AUTHOR("Felix Fietkau");
39 MODULE_LICENSE("GPL");
41 #define MVSWITCH_MAGIC 0x88E6060
43 struct mvswitch_priv
{
44 netdev_features_t orig_features
;
48 #define to_mvsw(_phy) ((struct mvswitch_priv *) (_phy)->priv)
51 r16(struct phy_device
*phydev
, int addr
, int reg
)
53 struct mii_bus
*bus
= phydev
->mdio
.bus
;
55 return bus
->read(bus
, addr
, reg
);
59 w16(struct phy_device
*phydev
, int addr
, int reg
, u16 val
)
61 struct mii_bus
*bus
= phydev
->mdio
.bus
;
63 bus
->write(bus
, addr
, reg
, val
);
67 static struct sk_buff
*
68 mvswitch_mangle_tx(struct net_device
*dev
, struct sk_buff
*skb
)
70 struct mvswitch_priv
*priv
;
78 if (unlikely(skb
->len
< 16))
82 if (__vlan_hwaccel_get_tag(skb
, &vid
))
85 if (skb_cloned(skb
) || (skb
->len
<= 62) || (skb_headroom(skb
) < MV_HEADER_SIZE
)) {
86 if (pskb_expand_head(skb
, MV_HEADER_SIZE
, (skb
->len
< 62 ? 62 - skb
->len
: 0), GFP_ATOMIC
))
91 buf
= skb_push(skb
, MV_HEADER_SIZE
);
93 if (__vlan_get_tag(skb
, &vid
))
96 if (unlikely((vid
> 15 || !priv
->vlans
[vid
])))
100 if (pskb_expand_head(skb
, 0, 64 + MV_TRAILER_SIZE
- skb
->len
, GFP_ATOMIC
))
103 buf
= skb
->data
+ 64;
104 skb
->len
= 64 + MV_TRAILER_SIZE
;
106 if (skb_cloned(skb
) || unlikely(skb_tailroom(skb
) < 4)) {
107 if (pskb_expand_head(skb
, 0, 4, GFP_ATOMIC
))
110 buf
= skb_put(skb
, 4);
113 /* move the ethernet header 4 bytes forward, overwriting the vlan tag */
114 memmove(skb
->data
+ 4, skb
->data
, 12);
117 skb
->mac_header
+= 4;
125 /* prepend the tag */
126 *((__be16
*) buf
) = cpu_to_be16(
127 ((vid
<< MV_HEADER_VLAN_S
) & MV_HEADER_VLAN_M
) |
128 ((priv
->vlans
[vid
] << MV_HEADER_PORTS_S
) & MV_HEADER_PORTS_M
)
132 *((__be32
*) buf
) = cpu_to_be32((
133 (MV_TRAILER_OVERRIDE
<< MV_TRAILER_FLAGS_S
) |
134 ((priv
->vlans
[vid
] & MV_TRAILER_PORTS_M
) << MV_TRAILER_PORTS_S
)
142 printk("%s: failed to expand/update skb for the switch\n", dev
->name
);
145 /* any errors? drop the packet! */
146 dev_kfree_skb_any(skb
);
151 mvswitch_mangle_rx(struct net_device
*dev
, struct sk_buff
*skb
)
153 struct mvswitch_priv
*priv
;
159 if (WARN_ON_ONCE(!priv
))
164 skb_pull(skb
, MV_HEADER_SIZE
);
166 buf
= skb
->data
+ skb
->len
- MV_TRAILER_SIZE
;
171 /* look for the vlan matching the incoming port */
172 for (i
= 0; i
< ARRAY_SIZE(priv
->vlans
); i
++) {
173 if ((1 << buf
[1]) & priv
->vlans
[i
])
180 __vlan_hwaccel_put_tag(skb
, htons(ETH_P_8021Q
), vlan
);
185 mvswitch_wait_mask(struct phy_device
*pdev
, int addr
, int reg
, u16 mask
, u16 val
)
191 r
= r16(pdev
, addr
, reg
) & mask
;
199 mvswitch_config_init(struct phy_device
*pdev
)
201 struct mvswitch_priv
*priv
= to_mvsw(pdev
);
202 struct net_device
*dev
= pdev
->attached_dev
;
209 printk("%s: Marvell 88E6060 PHY driver attached.\n", dev
->name
);
210 pdev
->supported
= ADVERTISED_100baseT_Full
;
211 pdev
->advertising
= ADVERTISED_100baseT_Full
;
213 pdev
->irq
= PHY_POLL
;
215 dev
->flags
|= IFF_PROMISC
;
218 /* initialize default vlans */
219 for (i
= 0; i
< MV_PORTS
; i
++)
220 priv
->vlans
[(i
== MV_WANPORT
? 2 : 1)] |= (1 << i
);
222 /* before entering reset, disable all ports */
223 for (i
= 0; i
< MV_PORTS
; i
++)
224 w16(pdev
, MV_PORTREG(CONTROL
, i
), 0x00);
226 msleep(2); /* wait for the status change to settle in */
228 /* put the ATU in reset */
229 w16(pdev
, MV_SWITCHREG(ATU_CTRL
), MV_ATUCTL_RESET
);
231 i
= mvswitch_wait_mask(pdev
, MV_SWITCHREG(ATU_CTRL
), MV_ATUCTL_RESET
, 0);
233 printk("%s: Timeout waiting for the switch to reset.\n", dev
->name
);
237 /* set the ATU flags */
238 w16(pdev
, MV_SWITCHREG(ATU_CTRL
),
241 MV_ATUCTL_AGETIME(MV_ATUCTL_AGETIME_MIN
) /* minimum without disabling ageing */
244 /* initialize the cpu port */
245 w16(pdev
, MV_PORTREG(CONTROL
, MV_CPUPORT
),
254 /* wait for the phy change to settle in */
256 for (i
= 0; i
< MV_PORTS
; i
++) {
262 /* look for the matching vlan */
263 for (j
= 0; j
< ARRAY_SIZE(priv
->vlans
); j
++) {
264 if (priv
->vlans
[j
] & (1 << i
)) {
265 vlmap
= priv
->vlans
[j
];
269 /* leave port unconfigured if it's not part of a vlan */
273 /* add the cpu port to the allowed destinations list */
274 vlmap
|= (1 << MV_CPUPORT
);
276 /* take port out of its own vlan destination map */
279 /* apply vlan settings */
280 w16(pdev
, MV_PORTREG(VLANMAP
, i
),
281 MV_PORTVLAN_PORTS(vlmap
) |
286 w16(pdev
, MV_PORTREG(CONTROL
, i
),
291 w16(pdev
, MV_PORTREG(VLANMAP
, MV_CPUPORT
),
292 MV_PORTVLAN_ID(MV_CPUPORT
)
295 /* set the port association vector */
296 for (i
= 0; i
<= MV_PORTS
; i
++) {
297 w16(pdev
, MV_PORTREG(ASSOC
, i
),
298 MV_PORTASSOC_PORTS(1 << i
)
302 /* init switch control */
303 w16(pdev
, MV_SWITCHREG(CTRL
),
308 dev
->eth_mangle_rx
= mvswitch_mangle_rx
;
309 dev
->eth_mangle_tx
= mvswitch_mangle_tx
;
310 priv
->orig_features
= dev
->features
;
313 dev
->priv_flags
|= IFF_NO_IP_ALIGN
;
314 dev
->features
|= NETIF_F_HW_VLAN_CTAG_RX
| NETIF_F_HW_VLAN_CTAG_TX
;
316 dev
->features
|= NETIF_F_HW_VLAN_CTAG_RX
;
323 mvswitch_read_status(struct phy_device
*pdev
)
325 pdev
->speed
= SPEED_100
;
326 pdev
->duplex
= DUPLEX_FULL
;
329 /* XXX ugly workaround: we can't force the switch
330 * to gracefully handle hosts moving from one port to another,
331 * so we have to regularly clear the ATU database */
333 /* wait for the ATU to become available */
334 mvswitch_wait_mask(pdev
, MV_SWITCHREG(ATU_OP
), MV_ATUOP_INPROGRESS
, 0);
337 w16(pdev
, MV_SWITCHREG(ATU_OP
),
338 MV_ATUOP_INPROGRESS
|
342 /* wait for operation to complete */
343 mvswitch_wait_mask(pdev
, MV_SWITCHREG(ATU_OP
), MV_ATUOP_INPROGRESS
, 0);
349 mvswitch_aneg_done(struct phy_device
*phydev
)
351 return 1; /* Return any positive value */
355 mvswitch_config_aneg(struct phy_device
*phydev
)
361 mvswitch_detach(struct phy_device
*pdev
)
363 struct mvswitch_priv
*priv
= to_mvsw(pdev
);
364 struct net_device
*dev
= pdev
->attached_dev
;
370 dev
->eth_mangle_rx
= NULL
;
371 dev
->eth_mangle_tx
= NULL
;
372 dev
->features
= priv
->orig_features
;
373 dev
->priv_flags
&= ~IFF_NO_IP_ALIGN
;
377 mvswitch_remove(struct phy_device
*pdev
)
379 struct mvswitch_priv
*priv
= to_mvsw(pdev
);
385 mvswitch_probe(struct phy_device
*pdev
)
387 struct mvswitch_priv
*priv
;
389 priv
= kzalloc(sizeof(struct mvswitch_priv
), GFP_KERNEL
);
399 mvswitch_fixup(struct phy_device
*dev
)
401 struct mii_bus
*bus
= dev
->mdio
.bus
;
404 if (dev
->mdio
.addr
!= 0x10)
407 reg
= bus
->read(bus
, MV_PORTREG(IDENT
, 0)) & MV_IDENT_MASK
;
408 if (reg
!= MV_IDENT_VALUE
)
411 dev
->phy_id
= MVSWITCH_MAGIC
;
416 static struct phy_driver mvswitch_driver
= {
417 .name
= "Marvell 88E6060",
418 .phy_id
= MVSWITCH_MAGIC
,
419 .phy_id_mask
= 0xffffffff,
420 .features
= PHY_BASIC_FEATURES
,
421 .probe
= &mvswitch_probe
,
422 .remove
= &mvswitch_remove
,
423 .detach
= &mvswitch_detach
,
424 .config_init
= &mvswitch_config_init
,
425 .config_aneg
= &mvswitch_config_aneg
,
426 .aneg_done
= &mvswitch_aneg_done
,
427 .read_status
= &mvswitch_read_status
,
433 phy_register_fixup_for_id(PHY_ANY_ID
, mvswitch_fixup
);
434 return phy_driver_register(&mvswitch_driver
, THIS_MODULE
);
440 phy_driver_unregister(&mvswitch_driver
);
443 module_init(mvswitch_init
);
444 module_exit(mvswitch_exit
);