2 * Driver for the MPC5200 Fast Ethernet Controller
4 * Originally written by Dale Farnsworth <dfarnsworth@mvista.com> and
5 * now maintained by Sylvain Munaut <tnt@246tNt.com>
7 * Copyright (C) 2007 Domen Puncer, Telargo, Inc.
8 * Copyright (C) 2007 Sylvain Munaut <tnt@246tNt.com>
9 * Copyright (C) 2003-2004 MontaVista, Software, Inc.
11 * This file is licensed under the terms of the GNU General Public License
12 * version 2. This program is licensed "as is" without any warranty of any
13 * kind, whether express or implied.
17 #include <linux/module.h>
19 #include <linux/kernel.h>
20 #include <linux/types.h>
21 #include <linux/spinlock.h>
22 #include <linux/errno.h>
23 #include <linux/init.h>
24 #include <linux/crc32.h>
25 #include <linux/hardirq.h>
26 #include <linux/delay.h>
27 #include <linux/of_device.h>
28 #include <linux/of_platform.h>
30 #include <linux/netdevice.h>
31 #include <linux/etherdevice.h>
32 #include <linux/ethtool.h>
33 #include <linux/skbuff.h>
36 #include <asm/delay.h>
37 #include <asm/mpc52xx.h>
39 #include <sysdev/bestcomm/bestcomm.h>
40 #include <sysdev/bestcomm/fec.h>
42 #include "fec_mpc52xx.h"
44 #define DRIVER_NAME "mpc52xx-fec"
46 #define FEC5200_PHYADDR_NONE (-1)
47 #define FEC5200_PHYADDR_7WIRE (-2)
49 /* Private driver data structure */
50 struct mpc52xx_fec_priv
{
55 struct mpc52xx_fec __iomem
*fec
;
56 struct bcom_task
*rx_dmatsk
;
57 struct bcom_task
*tx_dmatsk
;
61 /* MDIO link details */
63 unsigned int phy_speed
;
64 struct phy_device
*phydev
;
69 static irqreturn_t
mpc52xx_fec_interrupt(int, void *);
70 static irqreturn_t
mpc52xx_fec_rx_interrupt(int, void *);
71 static irqreturn_t
mpc52xx_fec_tx_interrupt(int, void *);
72 static void mpc52xx_fec_stop(struct net_device
*dev
);
73 static void mpc52xx_fec_start(struct net_device
*dev
);
74 static void mpc52xx_fec_reset(struct net_device
*dev
);
76 static u8 mpc52xx_fec_mac_addr
[6];
77 module_param_array_named(mac
, mpc52xx_fec_mac_addr
, byte
, NULL
, 0);
78 MODULE_PARM_DESC(mac
, "six hex digits, ie. 0x1,0x2,0xc0,0x01,0xba,0xbe");
80 #define MPC52xx_MESSAGES_DEFAULT ( NETIF_MSG_DRV | NETIF_MSG_PROBE | \
81 NETIF_MSG_LINK | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP)
82 static int debug
= -1; /* the above default */
83 module_param(debug
, int, 0);
84 MODULE_PARM_DESC(debug
, "debugging messages level");
86 static void mpc52xx_fec_tx_timeout(struct net_device
*dev
)
88 dev_warn(&dev
->dev
, "transmit timed out\n");
90 mpc52xx_fec_reset(dev
);
92 dev
->stats
.tx_errors
++;
94 netif_wake_queue(dev
);
97 static void mpc52xx_fec_set_paddr(struct net_device
*dev
, u8
*mac
)
99 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
100 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
102 out_be32(&fec
->paddr1
, *(u32
*)(&mac
[0]));
103 out_be32(&fec
->paddr2
, (*(u16
*)(&mac
[4]) << 16) | FEC_PADDR2_TYPE
);
106 static void mpc52xx_fec_get_paddr(struct net_device
*dev
, u8
*mac
)
108 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
109 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
111 *(u32
*)(&mac
[0]) = in_be32(&fec
->paddr1
);
112 *(u16
*)(&mac
[4]) = in_be32(&fec
->paddr2
) >> 16;
115 static int mpc52xx_fec_set_mac_address(struct net_device
*dev
, void *addr
)
117 struct sockaddr
*sock
= addr
;
119 memcpy(dev
->dev_addr
, sock
->sa_data
, dev
->addr_len
);
121 mpc52xx_fec_set_paddr(dev
, sock
->sa_data
);
125 static void mpc52xx_fec_free_rx_buffers(struct net_device
*dev
, struct bcom_task
*s
)
127 while (!bcom_queue_empty(s
)) {
128 struct bcom_fec_bd
*bd
;
131 skb
= bcom_retrieve_buffer(s
, NULL
, (struct bcom_bd
**)&bd
);
132 dma_unmap_single(&dev
->dev
, bd
->skb_pa
, skb
->len
, DMA_FROM_DEVICE
);
137 static int mpc52xx_fec_alloc_rx_buffers(struct net_device
*dev
, struct bcom_task
*rxtsk
)
139 while (!bcom_queue_full(rxtsk
)) {
141 struct bcom_fec_bd
*bd
;
143 skb
= dev_alloc_skb(FEC_RX_BUFFER_SIZE
);
147 /* zero out the initial receive buffers to aid debugging */
148 memset(skb
->data
, 0, FEC_RX_BUFFER_SIZE
);
150 bd
= (struct bcom_fec_bd
*)bcom_prepare_next_buffer(rxtsk
);
152 bd
->status
= FEC_RX_BUFFER_SIZE
;
153 bd
->skb_pa
= dma_map_single(&dev
->dev
, skb
->data
,
154 FEC_RX_BUFFER_SIZE
, DMA_FROM_DEVICE
);
156 bcom_submit_next_buffer(rxtsk
, skb
);
162 /* based on generic_adjust_link from fs_enet-main.c */
163 static void mpc52xx_fec_adjust_link(struct net_device
*dev
)
165 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
166 struct phy_device
*phydev
= priv
->phydev
;
169 if (phydev
->link
!= PHY_DOWN
) {
170 if (phydev
->duplex
!= priv
->duplex
) {
171 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
176 priv
->duplex
= phydev
->duplex
;
178 rcntrl
= in_be32(&fec
->r_cntrl
);
179 tcntrl
= in_be32(&fec
->x_cntrl
);
181 rcntrl
&= ~FEC_RCNTRL_DRT
;
182 tcntrl
&= ~FEC_TCNTRL_FDEN
;
183 if (phydev
->duplex
== DUPLEX_FULL
)
184 tcntrl
|= FEC_TCNTRL_FDEN
; /* FD enable */
186 rcntrl
|= FEC_RCNTRL_DRT
; /* disable Rx on Tx (HD) */
188 out_be32(&fec
->r_cntrl
, rcntrl
);
189 out_be32(&fec
->x_cntrl
, tcntrl
);
192 if (phydev
->speed
!= priv
->speed
) {
194 priv
->speed
= phydev
->speed
;
197 if (priv
->link
== PHY_DOWN
) {
199 priv
->link
= phydev
->link
;
202 } else if (priv
->link
) {
204 priv
->link
= PHY_DOWN
;
209 if (new_state
&& netif_msg_link(priv
))
210 phy_print_status(phydev
);
213 static int mpc52xx_fec_init_phy(struct net_device
*dev
)
215 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
216 struct phy_device
*phydev
;
217 char phy_id
[BUS_ID_SIZE
];
219 snprintf(phy_id
, BUS_ID_SIZE
, "%x:%02x",
220 (unsigned int)dev
->base_addr
, priv
->phy_addr
);
222 priv
->link
= PHY_DOWN
;
226 phydev
= phy_connect(dev
, phy_id
, &mpc52xx_fec_adjust_link
, 0, PHY_INTERFACE_MODE_MII
);
227 if (IS_ERR(phydev
)) {
228 dev_err(&dev
->dev
, "phy_connect failed\n");
229 return PTR_ERR(phydev
);
231 dev_info(&dev
->dev
, "attached phy %i to driver %s\n",
232 phydev
->addr
, phydev
->drv
->name
);
234 priv
->phydev
= phydev
;
239 static int mpc52xx_fec_phy_start(struct net_device
*dev
)
241 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
244 if (priv
->phy_addr
< 0)
247 err
= mpc52xx_fec_init_phy(dev
);
249 dev_err(&dev
->dev
, "mpc52xx_fec_init_phy failed\n");
253 /* reset phy - this also wakes it from PDOWN */
254 phy_write(priv
->phydev
, MII_BMCR
, BMCR_RESET
);
255 phy_start(priv
->phydev
);
260 static void mpc52xx_fec_phy_stop(struct net_device
*dev
)
262 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
267 phy_disconnect(priv
->phydev
);
269 phy_stop(priv
->phydev
);
270 phy_write(priv
->phydev
, MII_BMCR
, BMCR_PDOWN
);
273 static int mpc52xx_fec_phy_mii_ioctl(struct mpc52xx_fec_priv
*priv
,
274 struct mii_ioctl_data
*mii_data
, int cmd
)
279 return phy_mii_ioctl(priv
->phydev
, mii_data
, cmd
);
282 static void mpc52xx_fec_phy_hw_init(struct mpc52xx_fec_priv
*priv
)
284 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
289 out_be32(&fec
->mii_speed
, priv
->phy_speed
);
292 static int mpc52xx_fec_open(struct net_device
*dev
)
294 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
297 if (request_irq(dev
->irq
, &mpc52xx_fec_interrupt
, IRQF_SHARED
,
298 DRIVER_NAME
"_ctrl", dev
)) {
299 dev_err(&dev
->dev
, "ctrl interrupt request failed\n");
302 if (request_irq(priv
->r_irq
, &mpc52xx_fec_rx_interrupt
, 0,
303 DRIVER_NAME
"_rx", dev
)) {
304 dev_err(&dev
->dev
, "rx interrupt request failed\n");
307 if (request_irq(priv
->t_irq
, &mpc52xx_fec_tx_interrupt
, 0,
308 DRIVER_NAME
"_tx", dev
)) {
309 dev_err(&dev
->dev
, "tx interrupt request failed\n");
313 bcom_fec_rx_reset(priv
->rx_dmatsk
);
314 bcom_fec_tx_reset(priv
->tx_dmatsk
);
316 err
= mpc52xx_fec_alloc_rx_buffers(dev
, priv
->rx_dmatsk
);
318 dev_err(&dev
->dev
, "mpc52xx_fec_alloc_rx_buffers failed\n");
322 err
= mpc52xx_fec_phy_start(dev
);
326 bcom_enable(priv
->rx_dmatsk
);
327 bcom_enable(priv
->tx_dmatsk
);
329 mpc52xx_fec_start(dev
);
331 netif_start_queue(dev
);
336 mpc52xx_fec_free_rx_buffers(dev
, priv
->rx_dmatsk
);
339 free_irq(priv
->t_irq
, dev
);
341 free_irq(priv
->r_irq
, dev
);
343 free_irq(dev
->irq
, dev
);
349 static int mpc52xx_fec_close(struct net_device
*dev
)
351 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
353 netif_stop_queue(dev
);
355 mpc52xx_fec_stop(dev
);
357 mpc52xx_fec_free_rx_buffers(dev
, priv
->rx_dmatsk
);
359 free_irq(dev
->irq
, dev
);
360 free_irq(priv
->r_irq
, dev
);
361 free_irq(priv
->t_irq
, dev
);
363 mpc52xx_fec_phy_stop(dev
);
368 /* This will only be invoked if your driver is _not_ in XOFF state.
369 * What this means is that you need not check it, and that this
370 * invariant will hold if you make sure that the netif_*_queue()
371 * calls are done at the proper times.
373 static int mpc52xx_fec_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
375 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
376 struct bcom_fec_bd
*bd
;
378 if (bcom_queue_full(priv
->tx_dmatsk
)) {
380 dev_err(&dev
->dev
, "transmit queue overrun\n");
384 spin_lock_irq(&priv
->lock
);
385 dev
->trans_start
= jiffies
;
387 bd
= (struct bcom_fec_bd
*)
388 bcom_prepare_next_buffer(priv
->tx_dmatsk
);
390 bd
->status
= skb
->len
| BCOM_FEC_TX_BD_TFD
| BCOM_FEC_TX_BD_TC
;
391 bd
->skb_pa
= dma_map_single(&dev
->dev
, skb
->data
, skb
->len
, DMA_TO_DEVICE
);
393 bcom_submit_next_buffer(priv
->tx_dmatsk
, skb
);
395 if (bcom_queue_full(priv
->tx_dmatsk
)) {
396 netif_stop_queue(dev
);
399 spin_unlock_irq(&priv
->lock
);
404 #ifdef CONFIG_NET_POLL_CONTROLLER
405 static void mpc52xx_fec_poll_controller(struct net_device
*dev
)
407 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
409 disable_irq(priv
->t_irq
);
410 mpc52xx_fec_tx_interrupt(priv
->t_irq
, dev
);
411 enable_irq(priv
->t_irq
);
412 disable_irq(priv
->r_irq
);
413 mpc52xx_fec_rx_interrupt(priv
->r_irq
, dev
);
414 enable_irq(priv
->r_irq
);
419 /* This handles BestComm transmit task interrupts
421 static irqreturn_t
mpc52xx_fec_tx_interrupt(int irq
, void *dev_id
)
423 struct net_device
*dev
= dev_id
;
424 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
426 spin_lock(&priv
->lock
);
428 while (bcom_buffer_done(priv
->tx_dmatsk
)) {
430 struct bcom_fec_bd
*bd
;
431 skb
= bcom_retrieve_buffer(priv
->tx_dmatsk
, NULL
,
432 (struct bcom_bd
**)&bd
);
433 dma_unmap_single(&dev
->dev
, bd
->skb_pa
, skb
->len
, DMA_TO_DEVICE
);
435 dev_kfree_skb_irq(skb
);
438 netif_wake_queue(dev
);
440 spin_unlock(&priv
->lock
);
445 static irqreturn_t
mpc52xx_fec_rx_interrupt(int irq
, void *dev_id
)
447 struct net_device
*dev
= dev_id
;
448 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
450 while (bcom_buffer_done(priv
->rx_dmatsk
)) {
452 struct sk_buff
*rskb
;
453 struct bcom_fec_bd
*bd
;
456 rskb
= bcom_retrieve_buffer(priv
->rx_dmatsk
, &status
,
457 (struct bcom_bd
**)&bd
);
458 dma_unmap_single(&dev
->dev
, bd
->skb_pa
, rskb
->len
, DMA_FROM_DEVICE
);
460 /* Test for errors in received frame */
461 if (status
& BCOM_FEC_RX_BD_ERRORS
) {
462 /* Drop packet and reuse the buffer */
463 bd
= (struct bcom_fec_bd
*)
464 bcom_prepare_next_buffer(priv
->rx_dmatsk
);
466 bd
->status
= FEC_RX_BUFFER_SIZE
;
467 bd
->skb_pa
= dma_map_single(&dev
->dev
, rskb
->data
,
468 FEC_RX_BUFFER_SIZE
, DMA_FROM_DEVICE
);
470 bcom_submit_next_buffer(priv
->rx_dmatsk
, rskb
);
472 dev
->stats
.rx_dropped
++;
477 /* skbs are allocated on open, so now we allocate a new one,
478 * and remove the old (with the packet) */
479 skb
= dev_alloc_skb(FEC_RX_BUFFER_SIZE
);
481 /* Process the received skb */
482 int length
= status
& BCOM_FEC_RX_BD_LEN_MASK
;
484 skb_put(rskb
, length
- 4); /* length without CRC32 */
487 rskb
->protocol
= eth_type_trans(rskb
, dev
);
491 /* Can't get a new one : reuse the same & drop pkt */
492 dev_notice(&dev
->dev
, "Memory squeeze, dropping packet.\n");
493 dev
->stats
.rx_dropped
++;
498 bd
= (struct bcom_fec_bd
*)
499 bcom_prepare_next_buffer(priv
->rx_dmatsk
);
501 bd
->status
= FEC_RX_BUFFER_SIZE
;
502 bd
->skb_pa
= dma_map_single(&dev
->dev
, skb
->data
,
503 FEC_RX_BUFFER_SIZE
, DMA_FROM_DEVICE
);
505 bcom_submit_next_buffer(priv
->rx_dmatsk
, skb
);
511 static irqreturn_t
mpc52xx_fec_interrupt(int irq
, void *dev_id
)
513 struct net_device
*dev
= dev_id
;
514 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
515 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
518 ievent
= in_be32(&fec
->ievent
);
520 ievent
&= ~FEC_IEVENT_MII
; /* mii is handled separately */
524 out_be32(&fec
->ievent
, ievent
); /* clear pending events */
526 /* on fifo error, soft-reset fec */
527 if (ievent
& (FEC_IEVENT_RFIFO_ERROR
| FEC_IEVENT_XFIFO_ERROR
)) {
529 if (net_ratelimit() && (ievent
& FEC_IEVENT_RFIFO_ERROR
))
530 dev_warn(&dev
->dev
, "FEC_IEVENT_RFIFO_ERROR\n");
531 if (net_ratelimit() && (ievent
& FEC_IEVENT_XFIFO_ERROR
))
532 dev_warn(&dev
->dev
, "FEC_IEVENT_XFIFO_ERROR\n");
534 mpc52xx_fec_reset(dev
);
536 netif_wake_queue(dev
);
540 if (ievent
& ~FEC_IEVENT_TFINT
)
541 dev_dbg(&dev
->dev
, "ievent: %08x\n", ievent
);
547 * Get the current statistics.
548 * This may be called with the card open or closed.
550 static struct net_device_stats
*mpc52xx_fec_get_stats(struct net_device
*dev
)
552 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
553 struct net_device_stats
*stats
= &dev
->stats
;
554 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
556 stats
->rx_bytes
= in_be32(&fec
->rmon_r_octets
);
557 stats
->rx_packets
= in_be32(&fec
->rmon_r_packets
);
558 stats
->rx_errors
= in_be32(&fec
->rmon_r_crc_align
) +
559 in_be32(&fec
->rmon_r_undersize
) +
560 in_be32(&fec
->rmon_r_oversize
) +
561 in_be32(&fec
->rmon_r_frag
) +
562 in_be32(&fec
->rmon_r_jab
);
564 stats
->tx_bytes
= in_be32(&fec
->rmon_t_octets
);
565 stats
->tx_packets
= in_be32(&fec
->rmon_t_packets
);
566 stats
->tx_errors
= in_be32(&fec
->rmon_t_crc_align
) +
567 in_be32(&fec
->rmon_t_undersize
) +
568 in_be32(&fec
->rmon_t_oversize
) +
569 in_be32(&fec
->rmon_t_frag
) +
570 in_be32(&fec
->rmon_t_jab
);
572 stats
->multicast
= in_be32(&fec
->rmon_r_mc_pkt
);
573 stats
->collisions
= in_be32(&fec
->rmon_t_col
);
575 /* detailed rx_errors: */
576 stats
->rx_length_errors
= in_be32(&fec
->rmon_r_undersize
)
577 + in_be32(&fec
->rmon_r_oversize
)
578 + in_be32(&fec
->rmon_r_frag
)
579 + in_be32(&fec
->rmon_r_jab
);
580 stats
->rx_over_errors
= in_be32(&fec
->r_macerr
);
581 stats
->rx_crc_errors
= in_be32(&fec
->ieee_r_crc
);
582 stats
->rx_frame_errors
= in_be32(&fec
->ieee_r_align
);
583 stats
->rx_fifo_errors
= in_be32(&fec
->rmon_r_drop
);
584 stats
->rx_missed_errors
= in_be32(&fec
->rmon_r_drop
);
586 /* detailed tx_errors: */
587 stats
->tx_aborted_errors
= 0;
588 stats
->tx_carrier_errors
= in_be32(&fec
->ieee_t_cserr
);
589 stats
->tx_fifo_errors
= in_be32(&fec
->rmon_t_drop
);
590 stats
->tx_heartbeat_errors
= in_be32(&fec
->ieee_t_sqe
);
591 stats
->tx_window_errors
= in_be32(&fec
->ieee_t_lcol
);
597 * Read MIB counters in order to reset them,
598 * then zero all the stats fields in memory
600 static void mpc52xx_fec_reset_stats(struct net_device
*dev
)
602 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
603 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
605 out_be32(&fec
->mib_control
, FEC_MIB_DISABLE
);
606 memset_io(&fec
->rmon_t_drop
, 0,
607 offsetof(struct mpc52xx_fec
, reserved10
) -
608 offsetof(struct mpc52xx_fec
, rmon_t_drop
));
609 out_be32(&fec
->mib_control
, 0);
611 memset(&dev
->stats
, 0, sizeof(dev
->stats
));
615 * Set or clear the multicast filter for this adaptor.
617 static void mpc52xx_fec_set_multicast_list(struct net_device
*dev
)
619 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
620 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
623 rx_control
= in_be32(&fec
->r_cntrl
);
625 if (dev
->flags
& IFF_PROMISC
) {
626 rx_control
|= FEC_RCNTRL_PROM
;
627 out_be32(&fec
->r_cntrl
, rx_control
);
629 rx_control
&= ~FEC_RCNTRL_PROM
;
630 out_be32(&fec
->r_cntrl
, rx_control
);
632 if (dev
->flags
& IFF_ALLMULTI
) {
633 out_be32(&fec
->gaddr1
, 0xffffffff);
634 out_be32(&fec
->gaddr2
, 0xffffffff);
638 struct dev_mc_list
*dmi
;
639 u32 gaddr1
= 0x00000000;
640 u32 gaddr2
= 0x00000000;
643 for (i
=0; i
<dev
->mc_count
; i
++) {
644 crc
= ether_crc_le(6, dmi
->dmi_addr
) >> 26;
646 gaddr1
|= 1 << (crc
-32);
651 out_be32(&fec
->gaddr1
, gaddr1
);
652 out_be32(&fec
->gaddr2
, gaddr2
);
658 * mpc52xx_fec_hw_init
659 * @dev: network device
661 * Setup various hardware setting, only needed once on start
663 static void mpc52xx_fec_hw_init(struct net_device
*dev
)
665 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
666 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
669 /* Whack a reset. We should wait for this. */
670 out_be32(&fec
->ecntrl
, FEC_ECNTRL_RESET
);
671 for (i
= 0; i
< FEC_RESET_DELAY
; ++i
) {
672 if ((in_be32(&fec
->ecntrl
) & FEC_ECNTRL_RESET
) == 0)
676 if (i
== FEC_RESET_DELAY
)
677 dev_err(&dev
->dev
, "FEC Reset timeout!\n");
679 /* set pause to 0x20 frames */
680 out_be32(&fec
->op_pause
, FEC_OP_PAUSE_OPCODE
| 0x20);
682 /* high service request will be deasserted when there's < 7 bytes in fifo
683 * low service request will be deasserted when there's < 4*7 bytes in fifo
685 out_be32(&fec
->rfifo_cntrl
, FEC_FIFO_CNTRL_FRAME
| FEC_FIFO_CNTRL_LTG_7
);
686 out_be32(&fec
->tfifo_cntrl
, FEC_FIFO_CNTRL_FRAME
| FEC_FIFO_CNTRL_LTG_7
);
688 /* alarm when <= x bytes in FIFO */
689 out_be32(&fec
->rfifo_alarm
, 0x0000030c);
690 out_be32(&fec
->tfifo_alarm
, 0x00000100);
692 /* begin transmittion when 256 bytes are in FIFO (or EOF or FIFO full) */
693 out_be32(&fec
->x_wmrk
, FEC_FIFO_WMRK_256B
);
695 /* enable crc generation */
696 out_be32(&fec
->xmit_fsm
, FEC_XMIT_FSM_APPEND_CRC
| FEC_XMIT_FSM_ENABLE_CRC
);
697 out_be32(&fec
->iaddr1
, 0x00000000); /* No individual filter */
698 out_be32(&fec
->iaddr2
, 0x00000000); /* No individual filter */
701 * this can't be done in phy driver, since it needs to be called
702 * before fec stuff (even on resume) */
703 mpc52xx_fec_phy_hw_init(priv
);
708 * @dev: network device
710 * This function is called to start or restart the FEC during a link
711 * change. This happens on fifo errors or when switching between half
714 static void mpc52xx_fec_start(struct net_device
*dev
)
716 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
717 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
722 /* clear sticky error bits */
723 tmp
= FEC_FIFO_STATUS_ERR
| FEC_FIFO_STATUS_UF
| FEC_FIFO_STATUS_OF
;
724 out_be32(&fec
->rfifo_status
, in_be32(&fec
->rfifo_status
) & tmp
);
725 out_be32(&fec
->tfifo_status
, in_be32(&fec
->tfifo_status
) & tmp
);
727 /* FIFOs will reset on mpc52xx_fec_enable */
728 out_be32(&fec
->reset_cntrl
, FEC_RESET_CNTRL_ENABLE_IS_RESET
);
730 /* Set station address. */
731 mpc52xx_fec_set_paddr(dev
, dev
->dev_addr
);
733 mpc52xx_fec_set_multicast_list(dev
);
735 /* set max frame len, enable flow control, select mii mode */
736 rcntrl
= FEC_RX_BUFFER_SIZE
<< 16; /* max frame length */
737 rcntrl
|= FEC_RCNTRL_FCE
;
739 if (priv
->phy_addr
!= FEC5200_PHYADDR_7WIRE
)
740 rcntrl
|= FEC_RCNTRL_MII_MODE
;
742 if (priv
->duplex
== DUPLEX_FULL
)
743 tcntrl
= FEC_TCNTRL_FDEN
; /* FD enable */
745 rcntrl
|= FEC_RCNTRL_DRT
; /* disable Rx on Tx (HD) */
748 out_be32(&fec
->r_cntrl
, rcntrl
);
749 out_be32(&fec
->x_cntrl
, tcntrl
);
751 /* Clear any outstanding interrupt. */
752 out_be32(&fec
->ievent
, 0xffffffff);
754 /* Enable interrupts we wish to service. */
755 out_be32(&fec
->imask
, FEC_IMASK_ENABLE
);
757 /* And last, enable the transmit and receive processing. */
758 out_be32(&fec
->ecntrl
, FEC_ECNTRL_ETHER_EN
);
759 out_be32(&fec
->r_des_active
, 0x01000000);
764 * @dev: network device
766 * stop all activity on fec and empty dma buffers
768 static void mpc52xx_fec_stop(struct net_device
*dev
)
770 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
771 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
772 unsigned long timeout
;
774 /* disable all interrupts */
775 out_be32(&fec
->imask
, 0);
777 /* Disable the rx task. */
778 bcom_disable(priv
->rx_dmatsk
);
780 /* Wait for tx queue to drain, but only if we're in process context */
781 if (!in_interrupt()) {
782 timeout
= jiffies
+ msecs_to_jiffies(2000);
783 while (time_before(jiffies
, timeout
) &&
784 !bcom_queue_empty(priv
->tx_dmatsk
))
787 if (time_after_eq(jiffies
, timeout
))
788 dev_err(&dev
->dev
, "queues didn't drain\n");
790 if (time_after_eq(jiffies
, timeout
)) {
791 dev_err(&dev
->dev
, " tx: index: %i, outdex: %i\n",
792 priv
->tx_dmatsk
->index
,
793 priv
->tx_dmatsk
->outdex
);
794 dev_err(&dev
->dev
, " rx: index: %i, outdex: %i\n",
795 priv
->rx_dmatsk
->index
,
796 priv
->rx_dmatsk
->outdex
);
801 bcom_disable(priv
->tx_dmatsk
);
804 out_be32(&fec
->ecntrl
, in_be32(&fec
->ecntrl
) & ~FEC_ECNTRL_ETHER_EN
);
809 /* reset fec and bestcomm tasks */
810 static void mpc52xx_fec_reset(struct net_device
*dev
)
812 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
813 struct mpc52xx_fec __iomem
*fec
= priv
->fec
;
815 mpc52xx_fec_stop(dev
);
817 out_be32(&fec
->rfifo_status
, in_be32(&fec
->rfifo_status
));
818 out_be32(&fec
->reset_cntrl
, FEC_RESET_CNTRL_RESET_FIFO
);
820 mpc52xx_fec_free_rx_buffers(dev
, priv
->rx_dmatsk
);
822 mpc52xx_fec_hw_init(dev
);
824 phy_stop(priv
->phydev
);
825 phy_write(priv
->phydev
, MII_BMCR
, BMCR_RESET
);
826 phy_start(priv
->phydev
);
828 bcom_fec_rx_reset(priv
->rx_dmatsk
);
829 bcom_fec_tx_reset(priv
->tx_dmatsk
);
831 mpc52xx_fec_alloc_rx_buffers(dev
, priv
->rx_dmatsk
);
833 bcom_enable(priv
->rx_dmatsk
);
834 bcom_enable(priv
->tx_dmatsk
);
836 mpc52xx_fec_start(dev
);
840 /* ethtool interface */
841 static void mpc52xx_fec_get_drvinfo(struct net_device
*dev
,
842 struct ethtool_drvinfo
*info
)
844 strcpy(info
->driver
, DRIVER_NAME
);
847 static int mpc52xx_fec_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
849 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
850 return phy_ethtool_gset(priv
->phydev
, cmd
);
853 static int mpc52xx_fec_set_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
855 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
856 return phy_ethtool_sset(priv
->phydev
, cmd
);
859 static u32
mpc52xx_fec_get_msglevel(struct net_device
*dev
)
861 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
862 return priv
->msg_enable
;
865 static void mpc52xx_fec_set_msglevel(struct net_device
*dev
, u32 level
)
867 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
868 priv
->msg_enable
= level
;
871 static const struct ethtool_ops mpc52xx_fec_ethtool_ops
= {
872 .get_drvinfo
= mpc52xx_fec_get_drvinfo
,
873 .get_settings
= mpc52xx_fec_get_settings
,
874 .set_settings
= mpc52xx_fec_set_settings
,
875 .get_link
= ethtool_op_get_link
,
876 .get_msglevel
= mpc52xx_fec_get_msglevel
,
877 .set_msglevel
= mpc52xx_fec_set_msglevel
,
881 static int mpc52xx_fec_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
883 struct mpc52xx_fec_priv
*priv
= netdev_priv(dev
);
885 return mpc52xx_fec_phy_mii_ioctl(priv
, if_mii(rq
), cmd
);
888 /* ======================================================================== */
890 /* ======================================================================== */
893 mpc52xx_fec_probe(struct of_device
*op
, const struct of_device_id
*match
)
896 struct net_device
*ndev
;
897 struct mpc52xx_fec_priv
*priv
= NULL
;
899 struct device_node
*phy_node
;
900 const phandle
*phy_handle
;
907 /* Get the ether ndev & it's private zone */
908 ndev
= alloc_etherdev(sizeof(struct mpc52xx_fec_priv
));
912 priv
= netdev_priv(ndev
);
914 /* Reserve FEC control zone */
915 rv
= of_address_to_resource(op
->node
, 0, &mem
);
917 printk(KERN_ERR DRIVER_NAME
": "
918 "Error while parsing device node resource\n" );
921 if ((mem
.end
- mem
.start
+ 1) < sizeof(struct mpc52xx_fec
)) {
922 printk(KERN_ERR DRIVER_NAME
923 " - invalid resource size (%lx < %x), check mpc52xx_devices.c\n",
924 (unsigned long)(mem
.end
- mem
.start
+ 1), sizeof(struct mpc52xx_fec
));
928 if (!request_mem_region(mem
.start
, sizeof(struct mpc52xx_fec
), DRIVER_NAME
))
931 /* Init ether ndev with what we have */
932 ndev
->open
= mpc52xx_fec_open
;
933 ndev
->stop
= mpc52xx_fec_close
;
934 ndev
->hard_start_xmit
= mpc52xx_fec_hard_start_xmit
;
935 ndev
->do_ioctl
= mpc52xx_fec_ioctl
;
936 ndev
->ethtool_ops
= &mpc52xx_fec_ethtool_ops
;
937 ndev
->get_stats
= mpc52xx_fec_get_stats
;
938 ndev
->set_mac_address
= mpc52xx_fec_set_mac_address
;
939 ndev
->set_multicast_list
= mpc52xx_fec_set_multicast_list
;
940 ndev
->tx_timeout
= mpc52xx_fec_tx_timeout
;
941 ndev
->watchdog_timeo
= FEC_WATCHDOG_TIMEOUT
;
942 ndev
->base_addr
= mem
.start
;
943 #ifdef CONFIG_NET_POLL_CONTROLLER
944 ndev
->poll_controller
= mpc52xx_fec_poll_controller
;
947 priv
->t_irq
= priv
->r_irq
= ndev
->irq
= NO_IRQ
; /* IRQ are free for now */
949 spin_lock_init(&priv
->lock
);
951 /* ioremap the zones */
952 priv
->fec
= ioremap(mem
.start
, sizeof(struct mpc52xx_fec
));
960 rx_fifo
= ndev
->base_addr
+ offsetof(struct mpc52xx_fec
, rfifo_data
);
961 tx_fifo
= ndev
->base_addr
+ offsetof(struct mpc52xx_fec
, tfifo_data
);
963 priv
->rx_dmatsk
= bcom_fec_rx_init(FEC_RX_NUM_BD
, rx_fifo
, FEC_RX_BUFFER_SIZE
);
964 priv
->tx_dmatsk
= bcom_fec_tx_init(FEC_TX_NUM_BD
, tx_fifo
);
966 if (!priv
->rx_dmatsk
|| !priv
->tx_dmatsk
) {
967 printk(KERN_ERR DRIVER_NAME
": Can not init SDMA tasks\n" );
972 /* Get the IRQ we need one by one */
974 ndev
->irq
= irq_of_parse_and_map(op
->node
, 0);
977 priv
->r_irq
= bcom_get_task_irq(priv
->rx_dmatsk
);
980 priv
->t_irq
= bcom_get_task_irq(priv
->tx_dmatsk
);
982 /* MAC address init */
983 if (!is_zero_ether_addr(mpc52xx_fec_mac_addr
))
984 memcpy(ndev
->dev_addr
, mpc52xx_fec_mac_addr
, 6);
986 mpc52xx_fec_get_paddr(ndev
, ndev
->dev_addr
);
988 priv
->msg_enable
= netif_msg_init(debug
, MPC52xx_MESSAGES_DEFAULT
);
991 * Link mode configuration
994 /* Start with safe defaults for link connection */
995 priv
->phy_addr
= FEC5200_PHYADDR_NONE
;
997 priv
->duplex
= DUPLEX_HALF
;
998 priv
->phy_speed
= ((mpc52xx_find_ipb_freq(op
->node
) >> 20) / 5) << 1;
1000 /* the 7-wire property means don't use MII mode */
1001 if (of_find_property(op
->node
, "fsl,7-wire-mode", NULL
))
1002 priv
->phy_addr
= FEC5200_PHYADDR_7WIRE
;
1004 /* The current speed preconfigures the speed of the MII link */
1005 prop
= of_get_property(op
->node
, "current-speed", &prop_size
);
1006 if (prop
&& (prop_size
>= sizeof(u32
) * 2)) {
1007 priv
->speed
= prop
[0];
1008 priv
->duplex
= prop
[1] ? DUPLEX_FULL
: DUPLEX_HALF
;
1011 /* If there is a phy handle, setup link to that phy */
1012 phy_handle
= of_get_property(op
->node
, "phy-handle", &prop_size
);
1013 if (phy_handle
&& (prop_size
>= sizeof(phandle
))) {
1014 phy_node
= of_find_node_by_phandle(*phy_handle
);
1015 prop
= of_get_property(phy_node
, "reg", &prop_size
);
1016 if (prop
&& (prop_size
>= sizeof(u32
)))
1017 if ((*prop
>= 0) && (*prop
< PHY_MAX_ADDR
))
1018 priv
->phy_addr
= *prop
;
1019 of_node_put(phy_node
);
1023 mpc52xx_fec_hw_init(ndev
);
1025 mpc52xx_fec_reset_stats(ndev
);
1027 SET_NETDEV_DEV(ndev
, &op
->dev
);
1029 /* Register the new network device */
1030 rv
= register_netdev(ndev
);
1034 /* Now report the link setup */
1035 switch (priv
->phy_addr
) {
1036 case FEC5200_PHYADDR_NONE
:
1037 dev_info(&ndev
->dev
, "Fixed speed MII link: %i%cD\n",
1038 priv
->speed
, priv
->duplex
? 'F' : 'H');
1040 case FEC5200_PHYADDR_7WIRE
:
1041 dev_info(&ndev
->dev
, "using 7-wire PHY mode\n");
1044 dev_info(&ndev
->dev
, "Using PHY at MDIO address %i\n",
1049 dev_set_drvdata(&op
->dev
, ndev
);
1054 /* Error handling - free everything that might be allocated */
1057 irq_dispose_mapping(ndev
->irq
);
1059 if (priv
->rx_dmatsk
)
1060 bcom_fec_rx_release(priv
->rx_dmatsk
);
1061 if (priv
->tx_dmatsk
)
1062 bcom_fec_tx_release(priv
->tx_dmatsk
);
1067 release_mem_region(mem
.start
, sizeof(struct mpc52xx_fec
));
1075 mpc52xx_fec_remove(struct of_device
*op
)
1077 struct net_device
*ndev
;
1078 struct mpc52xx_fec_priv
*priv
;
1080 ndev
= dev_get_drvdata(&op
->dev
);
1081 priv
= netdev_priv(ndev
);
1083 unregister_netdev(ndev
);
1085 irq_dispose_mapping(ndev
->irq
);
1087 bcom_fec_rx_release(priv
->rx_dmatsk
);
1088 bcom_fec_tx_release(priv
->tx_dmatsk
);
1092 release_mem_region(ndev
->base_addr
, sizeof(struct mpc52xx_fec
));
1096 dev_set_drvdata(&op
->dev
, NULL
);
1101 static int mpc52xx_fec_of_suspend(struct of_device
*op
, pm_message_t state
)
1103 struct net_device
*dev
= dev_get_drvdata(&op
->dev
);
1105 if (netif_running(dev
))
1106 mpc52xx_fec_close(dev
);
1111 static int mpc52xx_fec_of_resume(struct of_device
*op
)
1113 struct net_device
*dev
= dev_get_drvdata(&op
->dev
);
1115 mpc52xx_fec_hw_init(dev
);
1116 mpc52xx_fec_reset_stats(dev
);
1118 if (netif_running(dev
))
1119 mpc52xx_fec_open(dev
);
1125 static struct of_device_id mpc52xx_fec_match
[] = {
1126 { .type
= "network", .compatible
= "fsl,mpc5200b-fec", },
1127 { .type
= "network", .compatible
= "fsl,mpc5200-fec", },
1128 { .type
= "network", .compatible
= "mpc5200-fec", },
1132 MODULE_DEVICE_TABLE(of
, mpc52xx_fec_match
);
1134 static struct of_platform_driver mpc52xx_fec_driver
= {
1135 .owner
= THIS_MODULE
,
1136 .name
= DRIVER_NAME
,
1137 .match_table
= mpc52xx_fec_match
,
1138 .probe
= mpc52xx_fec_probe
,
1139 .remove
= mpc52xx_fec_remove
,
1141 .suspend
= mpc52xx_fec_of_suspend
,
1142 .resume
= mpc52xx_fec_of_resume
,
1147 /* ======================================================================== */
1149 /* ======================================================================== */
1152 mpc52xx_fec_init(void)
1154 #ifdef CONFIG_FEC_MPC52xx_MDIO
1156 ret
= of_register_platform_driver(&mpc52xx_fec_mdio_driver
);
1158 printk(KERN_ERR DRIVER_NAME
": failed to register mdio driver\n");
1162 return of_register_platform_driver(&mpc52xx_fec_driver
);
1166 mpc52xx_fec_exit(void)
1168 of_unregister_platform_driver(&mpc52xx_fec_driver
);
1169 #ifdef CONFIG_FEC_MPC52xx_MDIO
1170 of_unregister_platform_driver(&mpc52xx_fec_mdio_driver
);
1175 module_init(mpc52xx_fec_init
);
1176 module_exit(mpc52xx_fec_exit
);
1178 MODULE_LICENSE("GPL");
1179 MODULE_AUTHOR("Dale Farnsworth");
1180 MODULE_DESCRIPTION("Ethernet driver for the Freescale MPC52xx FEC");