Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * Driver for the MPC5200 Fast Ethernet Controller
0003  *
0004  * Originally written by Dale Farnsworth <dfarnsworth@mvista.com> and
0005  * now maintained by Sylvain Munaut <tnt@246tNt.com>
0006  *
0007  * Copyright (C) 2007  Domen Puncer, Telargo, Inc.
0008  * Copyright (C) 2007  Sylvain Munaut <tnt@246tNt.com>
0009  * Copyright (C) 2003-2004  MontaVista, Software, Inc.
0010  *
0011  * This file is licensed under the terms of the GNU General Public License
0012  * version 2. This program is licensed "as is" without any warranty of any
0013  * kind, whether express or implied.
0014  *
0015  */
0016 
0017 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0018 
0019 #include <linux/dma-mapping.h>
0020 #include <linux/module.h>
0021 
0022 #include <linux/kernel.h>
0023 #include <linux/types.h>
0024 #include <linux/spinlock.h>
0025 #include <linux/slab.h>
0026 #include <linux/errno.h>
0027 #include <linux/init.h>
0028 #include <linux/interrupt.h>
0029 #include <linux/crc32.h>
0030 #include <linux/hardirq.h>
0031 #include <linux/delay.h>
0032 #include <linux/of_address.h>
0033 #include <linux/of_device.h>
0034 #include <linux/of_irq.h>
0035 #include <linux/of_mdio.h>
0036 #include <linux/of_net.h>
0037 #include <linux/of_platform.h>
0038 
0039 #include <linux/netdevice.h>
0040 #include <linux/etherdevice.h>
0041 #include <linux/ethtool.h>
0042 #include <linux/skbuff.h>
0043 
0044 #include <asm/io.h>
0045 #include <asm/delay.h>
0046 #include <asm/mpc52xx.h>
0047 
0048 #include <linux/fsl/bestcomm/bestcomm.h>
0049 #include <linux/fsl/bestcomm/fec.h>
0050 
0051 #include "fec_mpc52xx.h"
0052 
0053 #define DRIVER_NAME "mpc52xx-fec"
0054 
0055 /* Private driver data structure */
0056 struct mpc52xx_fec_priv {
0057     struct net_device *ndev;
0058     int duplex;
0059     int speed;
0060     int r_irq;
0061     int t_irq;
0062     struct mpc52xx_fec __iomem *fec;
0063     struct bcom_task *rx_dmatsk;
0064     struct bcom_task *tx_dmatsk;
0065     spinlock_t lock;
0066     int msg_enable;
0067 
0068     /* MDIO link details */
0069     unsigned int mdio_speed;
0070     struct device_node *phy_node;
0071     enum phy_state link;
0072     int seven_wire_mode;
0073 };
0074 
0075 
0076 static irqreturn_t mpc52xx_fec_interrupt(int, void *);
0077 static irqreturn_t mpc52xx_fec_rx_interrupt(int, void *);
0078 static irqreturn_t mpc52xx_fec_tx_interrupt(int, void *);
0079 static void mpc52xx_fec_stop(struct net_device *dev, bool may_sleep);
0080 static void mpc52xx_fec_start(struct net_device *dev);
0081 static void mpc52xx_fec_reset(struct net_device *dev);
0082 
0083 #define MPC52xx_MESSAGES_DEFAULT ( NETIF_MSG_DRV | NETIF_MSG_PROBE | \
0084         NETIF_MSG_LINK | NETIF_MSG_IFDOWN | NETIF_MSG_IFUP)
0085 static int debug = -1;  /* the above default */
0086 module_param(debug, int, 0);
0087 MODULE_PARM_DESC(debug, "debugging messages level");
0088 
0089 static void mpc52xx_fec_tx_timeout(struct net_device *dev, unsigned int txqueue)
0090 {
0091     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0092     unsigned long flags;
0093 
0094     dev_warn(&dev->dev, "transmit timed out\n");
0095 
0096     spin_lock_irqsave(&priv->lock, flags);
0097     mpc52xx_fec_reset(dev);
0098     dev->stats.tx_errors++;
0099     spin_unlock_irqrestore(&priv->lock, flags);
0100 
0101     netif_wake_queue(dev);
0102 }
0103 
0104 static void mpc52xx_fec_set_paddr(struct net_device *dev, const u8 *mac)
0105 {
0106     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0107     struct mpc52xx_fec __iomem *fec = priv->fec;
0108 
0109     out_be32(&fec->paddr1, *(const u32 *)(&mac[0]));
0110     out_be32(&fec->paddr2, (*(const u16 *)(&mac[4]) << 16) | FEC_PADDR2_TYPE);
0111 }
0112 
0113 static int mpc52xx_fec_set_mac_address(struct net_device *dev, void *addr)
0114 {
0115     struct sockaddr *sock = addr;
0116 
0117     eth_hw_addr_set(dev, sock->sa_data);
0118 
0119     mpc52xx_fec_set_paddr(dev, sock->sa_data);
0120     return 0;
0121 }
0122 
0123 static void mpc52xx_fec_free_rx_buffers(struct net_device *dev, struct bcom_task *s)
0124 {
0125     while (!bcom_queue_empty(s)) {
0126         struct bcom_fec_bd *bd;
0127         struct sk_buff *skb;
0128 
0129         skb = bcom_retrieve_buffer(s, NULL, (struct bcom_bd **)&bd);
0130         dma_unmap_single(dev->dev.parent, bd->skb_pa, skb->len,
0131                  DMA_FROM_DEVICE);
0132         kfree_skb(skb);
0133     }
0134 }
0135 
0136 static void
0137 mpc52xx_fec_rx_submit(struct net_device *dev, struct sk_buff *rskb)
0138 {
0139     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0140     struct bcom_fec_bd *bd;
0141 
0142     bd = (struct bcom_fec_bd *) bcom_prepare_next_buffer(priv->rx_dmatsk);
0143     bd->status = FEC_RX_BUFFER_SIZE;
0144     bd->skb_pa = dma_map_single(dev->dev.parent, rskb->data,
0145                     FEC_RX_BUFFER_SIZE, DMA_FROM_DEVICE);
0146     bcom_submit_next_buffer(priv->rx_dmatsk, rskb);
0147 }
0148 
0149 static int mpc52xx_fec_alloc_rx_buffers(struct net_device *dev, struct bcom_task *rxtsk)
0150 {
0151     struct sk_buff *skb;
0152 
0153     while (!bcom_queue_full(rxtsk)) {
0154         skb = netdev_alloc_skb(dev, FEC_RX_BUFFER_SIZE);
0155         if (!skb)
0156             return -EAGAIN;
0157 
0158         /* zero out the initial receive buffers to aid debugging */
0159         memset(skb->data, 0, FEC_RX_BUFFER_SIZE);
0160         mpc52xx_fec_rx_submit(dev, skb);
0161     }
0162     return 0;
0163 }
0164 
0165 /* based on generic_adjust_link from fs_enet-main.c */
0166 static void mpc52xx_fec_adjust_link(struct net_device *dev)
0167 {
0168     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0169     struct phy_device *phydev = dev->phydev;
0170     int new_state = 0;
0171 
0172     if (phydev->link != PHY_DOWN) {
0173         if (phydev->duplex != priv->duplex) {
0174             struct mpc52xx_fec __iomem *fec = priv->fec;
0175             u32 rcntrl;
0176             u32 tcntrl;
0177 
0178             new_state = 1;
0179             priv->duplex = phydev->duplex;
0180 
0181             rcntrl = in_be32(&fec->r_cntrl);
0182             tcntrl = in_be32(&fec->x_cntrl);
0183 
0184             rcntrl &= ~FEC_RCNTRL_DRT;
0185             tcntrl &= ~FEC_TCNTRL_FDEN;
0186             if (phydev->duplex == DUPLEX_FULL)
0187                 tcntrl |= FEC_TCNTRL_FDEN;  /* FD enable */
0188             else
0189                 rcntrl |= FEC_RCNTRL_DRT;   /* disable Rx on Tx (HD) */
0190 
0191             out_be32(&fec->r_cntrl, rcntrl);
0192             out_be32(&fec->x_cntrl, tcntrl);
0193         }
0194 
0195         if (phydev->speed != priv->speed) {
0196             new_state = 1;
0197             priv->speed = phydev->speed;
0198         }
0199 
0200         if (priv->link == PHY_DOWN) {
0201             new_state = 1;
0202             priv->link = phydev->link;
0203         }
0204 
0205     } else if (priv->link) {
0206         new_state = 1;
0207         priv->link = PHY_DOWN;
0208         priv->speed = 0;
0209         priv->duplex = -1;
0210     }
0211 
0212     if (new_state && netif_msg_link(priv))
0213         phy_print_status(phydev);
0214 }
0215 
0216 static int mpc52xx_fec_open(struct net_device *dev)
0217 {
0218     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0219     struct phy_device *phydev = NULL;
0220     int err = -EBUSY;
0221 
0222     if (priv->phy_node) {
0223         phydev = of_phy_connect(priv->ndev, priv->phy_node,
0224                     mpc52xx_fec_adjust_link, 0, 0);
0225         if (!phydev) {
0226             dev_err(&dev->dev, "of_phy_connect failed\n");
0227             return -ENODEV;
0228         }
0229         phy_start(phydev);
0230     }
0231 
0232     if (request_irq(dev->irq, mpc52xx_fec_interrupt, IRQF_SHARED,
0233                     DRIVER_NAME "_ctrl", dev)) {
0234         dev_err(&dev->dev, "ctrl interrupt request failed\n");
0235         goto free_phy;
0236     }
0237     if (request_irq(priv->r_irq, mpc52xx_fec_rx_interrupt, 0,
0238                     DRIVER_NAME "_rx", dev)) {
0239         dev_err(&dev->dev, "rx interrupt request failed\n");
0240         goto free_ctrl_irq;
0241     }
0242     if (request_irq(priv->t_irq, mpc52xx_fec_tx_interrupt, 0,
0243                     DRIVER_NAME "_tx", dev)) {
0244         dev_err(&dev->dev, "tx interrupt request failed\n");
0245         goto free_2irqs;
0246     }
0247 
0248     bcom_fec_rx_reset(priv->rx_dmatsk);
0249     bcom_fec_tx_reset(priv->tx_dmatsk);
0250 
0251     err = mpc52xx_fec_alloc_rx_buffers(dev, priv->rx_dmatsk);
0252     if (err) {
0253         dev_err(&dev->dev, "mpc52xx_fec_alloc_rx_buffers failed\n");
0254         goto free_irqs;
0255     }
0256 
0257     bcom_enable(priv->rx_dmatsk);
0258     bcom_enable(priv->tx_dmatsk);
0259 
0260     mpc52xx_fec_start(dev);
0261 
0262     netif_start_queue(dev);
0263 
0264     return 0;
0265 
0266  free_irqs:
0267     free_irq(priv->t_irq, dev);
0268  free_2irqs:
0269     free_irq(priv->r_irq, dev);
0270  free_ctrl_irq:
0271     free_irq(dev->irq, dev);
0272  free_phy:
0273     if (phydev) {
0274         phy_stop(phydev);
0275         phy_disconnect(phydev);
0276     }
0277 
0278     return err;
0279 }
0280 
0281 static int mpc52xx_fec_close(struct net_device *dev)
0282 {
0283     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0284     struct phy_device *phydev = dev->phydev;
0285 
0286     netif_stop_queue(dev);
0287 
0288     mpc52xx_fec_stop(dev, true);
0289 
0290     mpc52xx_fec_free_rx_buffers(dev, priv->rx_dmatsk);
0291 
0292     free_irq(dev->irq, dev);
0293     free_irq(priv->r_irq, dev);
0294     free_irq(priv->t_irq, dev);
0295 
0296     if (phydev) {
0297         /* power down phy */
0298         phy_stop(phydev);
0299         phy_disconnect(phydev);
0300     }
0301 
0302     return 0;
0303 }
0304 
0305 /* This will only be invoked if your driver is _not_ in XOFF state.
0306  * What this means is that you need not check it, and that this
0307  * invariant will hold if you make sure that the netif_*_queue()
0308  * calls are done at the proper times.
0309  */
0310 static netdev_tx_t
0311 mpc52xx_fec_start_xmit(struct sk_buff *skb, struct net_device *dev)
0312 {
0313     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0314     struct bcom_fec_bd *bd;
0315     unsigned long flags;
0316 
0317     if (bcom_queue_full(priv->tx_dmatsk)) {
0318         if (net_ratelimit())
0319             dev_err(&dev->dev, "transmit queue overrun\n");
0320         return NETDEV_TX_BUSY;
0321     }
0322 
0323     spin_lock_irqsave(&priv->lock, flags);
0324 
0325     bd = (struct bcom_fec_bd *)
0326         bcom_prepare_next_buffer(priv->tx_dmatsk);
0327 
0328     bd->status = skb->len | BCOM_FEC_TX_BD_TFD | BCOM_FEC_TX_BD_TC;
0329     bd->skb_pa = dma_map_single(dev->dev.parent, skb->data, skb->len,
0330                     DMA_TO_DEVICE);
0331 
0332     skb_tx_timestamp(skb);
0333     bcom_submit_next_buffer(priv->tx_dmatsk, skb);
0334     spin_unlock_irqrestore(&priv->lock, flags);
0335 
0336     if (bcom_queue_full(priv->tx_dmatsk)) {
0337         netif_stop_queue(dev);
0338     }
0339 
0340     return NETDEV_TX_OK;
0341 }
0342 
0343 #ifdef CONFIG_NET_POLL_CONTROLLER
0344 static void mpc52xx_fec_poll_controller(struct net_device *dev)
0345 {
0346     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0347 
0348     disable_irq(priv->t_irq);
0349     mpc52xx_fec_tx_interrupt(priv->t_irq, dev);
0350     enable_irq(priv->t_irq);
0351     disable_irq(priv->r_irq);
0352     mpc52xx_fec_rx_interrupt(priv->r_irq, dev);
0353     enable_irq(priv->r_irq);
0354 }
0355 #endif
0356 
0357 
0358 /* This handles BestComm transmit task interrupts
0359  */
0360 static irqreturn_t mpc52xx_fec_tx_interrupt(int irq, void *dev_id)
0361 {
0362     struct net_device *dev = dev_id;
0363     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0364 
0365     spin_lock(&priv->lock);
0366     while (bcom_buffer_done(priv->tx_dmatsk)) {
0367         struct sk_buff *skb;
0368         struct bcom_fec_bd *bd;
0369         skb = bcom_retrieve_buffer(priv->tx_dmatsk, NULL,
0370                 (struct bcom_bd **)&bd);
0371         dma_unmap_single(dev->dev.parent, bd->skb_pa, skb->len,
0372                  DMA_TO_DEVICE);
0373 
0374         dev_consume_skb_irq(skb);
0375     }
0376     spin_unlock(&priv->lock);
0377 
0378     netif_wake_queue(dev);
0379 
0380     return IRQ_HANDLED;
0381 }
0382 
0383 static irqreturn_t mpc52xx_fec_rx_interrupt(int irq, void *dev_id)
0384 {
0385     struct net_device *dev = dev_id;
0386     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0387     struct sk_buff *rskb; /* received sk_buff */
0388     struct sk_buff *skb;  /* new sk_buff to enqueue in its place */
0389     struct bcom_fec_bd *bd;
0390     u32 status, physaddr;
0391     int length;
0392 
0393     spin_lock(&priv->lock);
0394 
0395     while (bcom_buffer_done(priv->rx_dmatsk)) {
0396 
0397         rskb = bcom_retrieve_buffer(priv->rx_dmatsk, &status,
0398                         (struct bcom_bd **)&bd);
0399         physaddr = bd->skb_pa;
0400 
0401         /* Test for errors in received frame */
0402         if (status & BCOM_FEC_RX_BD_ERRORS) {
0403             /* Drop packet and reuse the buffer */
0404             mpc52xx_fec_rx_submit(dev, rskb);
0405             dev->stats.rx_dropped++;
0406             continue;
0407         }
0408 
0409         /* skbs are allocated on open, so now we allocate a new one,
0410          * and remove the old (with the packet) */
0411         skb = netdev_alloc_skb(dev, FEC_RX_BUFFER_SIZE);
0412         if (!skb) {
0413             /* Can't get a new one : reuse the same & drop pkt */
0414             dev_notice(&dev->dev, "Low memory - dropped packet.\n");
0415             mpc52xx_fec_rx_submit(dev, rskb);
0416             dev->stats.rx_dropped++;
0417             continue;
0418         }
0419 
0420         /* Enqueue the new sk_buff back on the hardware */
0421         mpc52xx_fec_rx_submit(dev, skb);
0422 
0423         /* Process the received skb - Drop the spin lock while
0424          * calling into the network stack */
0425         spin_unlock(&priv->lock);
0426 
0427         dma_unmap_single(dev->dev.parent, physaddr, rskb->len,
0428                  DMA_FROM_DEVICE);
0429         length = status & BCOM_FEC_RX_BD_LEN_MASK;
0430         skb_put(rskb, length - 4);  /* length without CRC32 */
0431         rskb->protocol = eth_type_trans(rskb, dev);
0432         if (!skb_defer_rx_timestamp(rskb))
0433             netif_rx(rskb);
0434 
0435         spin_lock(&priv->lock);
0436     }
0437 
0438     spin_unlock(&priv->lock);
0439 
0440     return IRQ_HANDLED;
0441 }
0442 
0443 static irqreturn_t mpc52xx_fec_interrupt(int irq, void *dev_id)
0444 {
0445     struct net_device *dev = dev_id;
0446     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0447     struct mpc52xx_fec __iomem *fec = priv->fec;
0448     u32 ievent;
0449 
0450     ievent = in_be32(&fec->ievent);
0451 
0452     ievent &= ~FEC_IEVENT_MII;  /* mii is handled separately */
0453     if (!ievent)
0454         return IRQ_NONE;
0455 
0456     out_be32(&fec->ievent, ievent);     /* clear pending events */
0457 
0458     /* on fifo error, soft-reset fec */
0459     if (ievent & (FEC_IEVENT_RFIFO_ERROR | FEC_IEVENT_XFIFO_ERROR)) {
0460 
0461         if (net_ratelimit() && (ievent & FEC_IEVENT_RFIFO_ERROR))
0462             dev_warn(&dev->dev, "FEC_IEVENT_RFIFO_ERROR\n");
0463         if (net_ratelimit() && (ievent & FEC_IEVENT_XFIFO_ERROR))
0464             dev_warn(&dev->dev, "FEC_IEVENT_XFIFO_ERROR\n");
0465 
0466         spin_lock(&priv->lock);
0467         mpc52xx_fec_reset(dev);
0468         spin_unlock(&priv->lock);
0469 
0470         return IRQ_HANDLED;
0471     }
0472 
0473     if (ievent & ~FEC_IEVENT_TFINT)
0474         dev_dbg(&dev->dev, "ievent: %08x\n", ievent);
0475 
0476     return IRQ_HANDLED;
0477 }
0478 
0479 /*
0480  * Get the current statistics.
0481  * This may be called with the card open or closed.
0482  */
0483 static struct net_device_stats *mpc52xx_fec_get_stats(struct net_device *dev)
0484 {
0485     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0486     struct net_device_stats *stats = &dev->stats;
0487     struct mpc52xx_fec __iomem *fec = priv->fec;
0488 
0489     stats->rx_bytes = in_be32(&fec->rmon_r_octets);
0490     stats->rx_packets = in_be32(&fec->rmon_r_packets);
0491     stats->rx_errors = in_be32(&fec->rmon_r_crc_align) +
0492         in_be32(&fec->rmon_r_undersize) +
0493         in_be32(&fec->rmon_r_oversize) +
0494         in_be32(&fec->rmon_r_frag) +
0495         in_be32(&fec->rmon_r_jab);
0496 
0497     stats->tx_bytes = in_be32(&fec->rmon_t_octets);
0498     stats->tx_packets = in_be32(&fec->rmon_t_packets);
0499     stats->tx_errors = in_be32(&fec->rmon_t_crc_align) +
0500         in_be32(&fec->rmon_t_undersize) +
0501         in_be32(&fec->rmon_t_oversize) +
0502         in_be32(&fec->rmon_t_frag) +
0503         in_be32(&fec->rmon_t_jab);
0504 
0505     stats->multicast = in_be32(&fec->rmon_r_mc_pkt);
0506     stats->collisions = in_be32(&fec->rmon_t_col);
0507 
0508     /* detailed rx_errors: */
0509     stats->rx_length_errors = in_be32(&fec->rmon_r_undersize)
0510                     + in_be32(&fec->rmon_r_oversize)
0511                     + in_be32(&fec->rmon_r_frag)
0512                     + in_be32(&fec->rmon_r_jab);
0513     stats->rx_over_errors = in_be32(&fec->r_macerr);
0514     stats->rx_crc_errors = in_be32(&fec->ieee_r_crc);
0515     stats->rx_frame_errors = in_be32(&fec->ieee_r_align);
0516     stats->rx_fifo_errors = in_be32(&fec->rmon_r_drop);
0517     stats->rx_missed_errors = in_be32(&fec->rmon_r_drop);
0518 
0519     /* detailed tx_errors: */
0520     stats->tx_aborted_errors = 0;
0521     stats->tx_carrier_errors = in_be32(&fec->ieee_t_cserr);
0522     stats->tx_fifo_errors = in_be32(&fec->rmon_t_drop);
0523     stats->tx_heartbeat_errors = in_be32(&fec->ieee_t_sqe);
0524     stats->tx_window_errors = in_be32(&fec->ieee_t_lcol);
0525 
0526     return stats;
0527 }
0528 
0529 /*
0530  * Read MIB counters in order to reset them,
0531  * then zero all the stats fields in memory
0532  */
0533 static void mpc52xx_fec_reset_stats(struct net_device *dev)
0534 {
0535     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0536     struct mpc52xx_fec __iomem *fec = priv->fec;
0537 
0538     out_be32(&fec->mib_control, FEC_MIB_DISABLE);
0539     memset_io(&fec->rmon_t_drop, 0,
0540            offsetof(struct mpc52xx_fec, reserved10) -
0541            offsetof(struct mpc52xx_fec, rmon_t_drop));
0542     out_be32(&fec->mib_control, 0);
0543 
0544     memset(&dev->stats, 0, sizeof(dev->stats));
0545 }
0546 
0547 /*
0548  * Set or clear the multicast filter for this adaptor.
0549  */
0550 static void mpc52xx_fec_set_multicast_list(struct net_device *dev)
0551 {
0552     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0553     struct mpc52xx_fec __iomem *fec = priv->fec;
0554     u32 rx_control;
0555 
0556     rx_control = in_be32(&fec->r_cntrl);
0557 
0558     if (dev->flags & IFF_PROMISC) {
0559         rx_control |= FEC_RCNTRL_PROM;
0560         out_be32(&fec->r_cntrl, rx_control);
0561     } else {
0562         rx_control &= ~FEC_RCNTRL_PROM;
0563         out_be32(&fec->r_cntrl, rx_control);
0564 
0565         if (dev->flags & IFF_ALLMULTI) {
0566             out_be32(&fec->gaddr1, 0xffffffff);
0567             out_be32(&fec->gaddr2, 0xffffffff);
0568         } else {
0569             u32 crc;
0570             struct netdev_hw_addr *ha;
0571             u32 gaddr1 = 0x00000000;
0572             u32 gaddr2 = 0x00000000;
0573 
0574             netdev_for_each_mc_addr(ha, dev) {
0575                 crc = ether_crc_le(6, ha->addr) >> 26;
0576                 if (crc >= 32)
0577                     gaddr1 |= 1 << (crc-32);
0578                 else
0579                     gaddr2 |= 1 << crc;
0580             }
0581             out_be32(&fec->gaddr1, gaddr1);
0582             out_be32(&fec->gaddr2, gaddr2);
0583         }
0584     }
0585 }
0586 
0587 /**
0588  * mpc52xx_fec_hw_init
0589  * @dev: network device
0590  *
0591  * Setup various hardware setting, only needed once on start
0592  */
0593 static void mpc52xx_fec_hw_init(struct net_device *dev)
0594 {
0595     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0596     struct mpc52xx_fec __iomem *fec = priv->fec;
0597     int i;
0598 
0599     /* Whack a reset.  We should wait for this. */
0600     out_be32(&fec->ecntrl, FEC_ECNTRL_RESET);
0601     for (i = 0; i < FEC_RESET_DELAY; ++i) {
0602         if ((in_be32(&fec->ecntrl) & FEC_ECNTRL_RESET) == 0)
0603             break;
0604         udelay(1);
0605     }
0606     if (i == FEC_RESET_DELAY)
0607         dev_err(&dev->dev, "FEC Reset timeout!\n");
0608 
0609     /* set pause to 0x20 frames */
0610     out_be32(&fec->op_pause, FEC_OP_PAUSE_OPCODE | 0x20);
0611 
0612     /* high service request will be deasserted when there's < 7 bytes in fifo
0613      * low service request will be deasserted when there's < 4*7 bytes in fifo
0614      */
0615     out_be32(&fec->rfifo_cntrl, FEC_FIFO_CNTRL_FRAME | FEC_FIFO_CNTRL_LTG_7);
0616     out_be32(&fec->tfifo_cntrl, FEC_FIFO_CNTRL_FRAME | FEC_FIFO_CNTRL_LTG_7);
0617 
0618     /* alarm when <= x bytes in FIFO */
0619     out_be32(&fec->rfifo_alarm, 0x0000030c);
0620     out_be32(&fec->tfifo_alarm, 0x00000100);
0621 
0622     /* begin transmittion when 256 bytes are in FIFO (or EOF or FIFO full) */
0623     out_be32(&fec->x_wmrk, FEC_FIFO_WMRK_256B);
0624 
0625     /* enable crc generation */
0626     out_be32(&fec->xmit_fsm, FEC_XMIT_FSM_APPEND_CRC | FEC_XMIT_FSM_ENABLE_CRC);
0627     out_be32(&fec->iaddr1, 0x00000000); /* No individual filter */
0628     out_be32(&fec->iaddr2, 0x00000000); /* No individual filter */
0629 
0630     /* set phy speed.
0631      * this can't be done in phy driver, since it needs to be called
0632      * before fec stuff (even on resume) */
0633     out_be32(&fec->mii_speed, priv->mdio_speed);
0634 }
0635 
0636 /**
0637  * mpc52xx_fec_start
0638  * @dev: network device
0639  *
0640  * This function is called to start or restart the FEC during a link
0641  * change.  This happens on fifo errors or when switching between half
0642  * and full duplex.
0643  */
0644 static void mpc52xx_fec_start(struct net_device *dev)
0645 {
0646     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0647     struct mpc52xx_fec __iomem *fec = priv->fec;
0648     u32 rcntrl;
0649     u32 tcntrl;
0650     u32 tmp;
0651 
0652     /* clear sticky error bits */
0653     tmp = FEC_FIFO_STATUS_ERR | FEC_FIFO_STATUS_UF | FEC_FIFO_STATUS_OF;
0654     out_be32(&fec->rfifo_status, in_be32(&fec->rfifo_status) & tmp);
0655     out_be32(&fec->tfifo_status, in_be32(&fec->tfifo_status) & tmp);
0656 
0657     /* FIFOs will reset on mpc52xx_fec_enable */
0658     out_be32(&fec->reset_cntrl, FEC_RESET_CNTRL_ENABLE_IS_RESET);
0659 
0660     /* Set station address. */
0661     mpc52xx_fec_set_paddr(dev, dev->dev_addr);
0662 
0663     mpc52xx_fec_set_multicast_list(dev);
0664 
0665     /* set max frame len, enable flow control, select mii mode */
0666     rcntrl = FEC_RX_BUFFER_SIZE << 16;  /* max frame length */
0667     rcntrl |= FEC_RCNTRL_FCE;
0668 
0669     if (!priv->seven_wire_mode)
0670         rcntrl |= FEC_RCNTRL_MII_MODE;
0671 
0672     if (priv->duplex == DUPLEX_FULL)
0673         tcntrl = FEC_TCNTRL_FDEN;   /* FD enable */
0674     else {
0675         rcntrl |= FEC_RCNTRL_DRT;   /* disable Rx on Tx (HD) */
0676         tcntrl = 0;
0677     }
0678     out_be32(&fec->r_cntrl, rcntrl);
0679     out_be32(&fec->x_cntrl, tcntrl);
0680 
0681     /* Clear any outstanding interrupt. */
0682     out_be32(&fec->ievent, 0xffffffff);
0683 
0684     /* Enable interrupts we wish to service. */
0685     out_be32(&fec->imask, FEC_IMASK_ENABLE);
0686 
0687     /* And last, enable the transmit and receive processing. */
0688     out_be32(&fec->ecntrl, FEC_ECNTRL_ETHER_EN);
0689     out_be32(&fec->r_des_active, 0x01000000);
0690 }
0691 
0692 /**
0693  * mpc52xx_fec_stop
0694  * @dev: network device
0695  *
0696  * stop all activity on fec and empty dma buffers
0697  */
0698 static void mpc52xx_fec_stop(struct net_device *dev, bool may_sleep)
0699 {
0700     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0701     struct mpc52xx_fec __iomem *fec = priv->fec;
0702     unsigned long timeout;
0703 
0704     /* disable all interrupts */
0705     out_be32(&fec->imask, 0);
0706 
0707     /* Disable the rx task. */
0708     bcom_disable(priv->rx_dmatsk);
0709 
0710     /* Wait for tx queue to drain, but only if we're in process context */
0711     if (may_sleep) {
0712         timeout = jiffies + msecs_to_jiffies(2000);
0713         while (time_before(jiffies, timeout) &&
0714                 !bcom_queue_empty(priv->tx_dmatsk))
0715             msleep(100);
0716 
0717         if (time_after_eq(jiffies, timeout))
0718             dev_err(&dev->dev, "queues didn't drain\n");
0719 #if 1
0720         if (time_after_eq(jiffies, timeout)) {
0721             dev_err(&dev->dev, "  tx: index: %i, outdex: %i\n",
0722                     priv->tx_dmatsk->index,
0723                     priv->tx_dmatsk->outdex);
0724             dev_err(&dev->dev, "  rx: index: %i, outdex: %i\n",
0725                     priv->rx_dmatsk->index,
0726                     priv->rx_dmatsk->outdex);
0727         }
0728 #endif
0729     }
0730 
0731     bcom_disable(priv->tx_dmatsk);
0732 
0733     /* Stop FEC */
0734     out_be32(&fec->ecntrl, in_be32(&fec->ecntrl) & ~FEC_ECNTRL_ETHER_EN);
0735 }
0736 
0737 /* reset fec and bestcomm tasks */
0738 static void mpc52xx_fec_reset(struct net_device *dev)
0739 {
0740     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0741     struct mpc52xx_fec __iomem *fec = priv->fec;
0742 
0743     mpc52xx_fec_stop(dev, false);
0744 
0745     out_be32(&fec->rfifo_status, in_be32(&fec->rfifo_status));
0746     out_be32(&fec->reset_cntrl, FEC_RESET_CNTRL_RESET_FIFO);
0747 
0748     mpc52xx_fec_free_rx_buffers(dev, priv->rx_dmatsk);
0749 
0750     mpc52xx_fec_hw_init(dev);
0751 
0752     bcom_fec_rx_reset(priv->rx_dmatsk);
0753     bcom_fec_tx_reset(priv->tx_dmatsk);
0754 
0755     mpc52xx_fec_alloc_rx_buffers(dev, priv->rx_dmatsk);
0756 
0757     bcom_enable(priv->rx_dmatsk);
0758     bcom_enable(priv->tx_dmatsk);
0759 
0760     mpc52xx_fec_start(dev);
0761 
0762     netif_wake_queue(dev);
0763 }
0764 
0765 
0766 /* ethtool interface */
0767 
0768 static u32 mpc52xx_fec_get_msglevel(struct net_device *dev)
0769 {
0770     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0771     return priv->msg_enable;
0772 }
0773 
0774 static void mpc52xx_fec_set_msglevel(struct net_device *dev, u32 level)
0775 {
0776     struct mpc52xx_fec_priv *priv = netdev_priv(dev);
0777     priv->msg_enable = level;
0778 }
0779 
0780 static const struct ethtool_ops mpc52xx_fec_ethtool_ops = {
0781     .get_link = ethtool_op_get_link,
0782     .get_msglevel = mpc52xx_fec_get_msglevel,
0783     .set_msglevel = mpc52xx_fec_set_msglevel,
0784     .get_ts_info = ethtool_op_get_ts_info,
0785     .get_link_ksettings = phy_ethtool_get_link_ksettings,
0786     .set_link_ksettings = phy_ethtool_set_link_ksettings,
0787 };
0788 
0789 
0790 static const struct net_device_ops mpc52xx_fec_netdev_ops = {
0791     .ndo_open = mpc52xx_fec_open,
0792     .ndo_stop = mpc52xx_fec_close,
0793     .ndo_start_xmit = mpc52xx_fec_start_xmit,
0794     .ndo_set_rx_mode = mpc52xx_fec_set_multicast_list,
0795     .ndo_set_mac_address = mpc52xx_fec_set_mac_address,
0796     .ndo_validate_addr = eth_validate_addr,
0797     .ndo_eth_ioctl = phy_do_ioctl,
0798     .ndo_tx_timeout = mpc52xx_fec_tx_timeout,
0799     .ndo_get_stats = mpc52xx_fec_get_stats,
0800 #ifdef CONFIG_NET_POLL_CONTROLLER
0801     .ndo_poll_controller = mpc52xx_fec_poll_controller,
0802 #endif
0803 };
0804 
0805 /* ======================================================================== */
0806 /* OF Driver                                                                */
0807 /* ======================================================================== */
0808 
0809 static int mpc52xx_fec_probe(struct platform_device *op)
0810 {
0811     int rv;
0812     struct net_device *ndev;
0813     struct mpc52xx_fec_priv *priv = NULL;
0814     struct resource mem;
0815     const u32 *prop;
0816     int prop_size;
0817     struct device_node *np = op->dev.of_node;
0818 
0819     phys_addr_t rx_fifo;
0820     phys_addr_t tx_fifo;
0821 
0822     /* Get the ether ndev & it's private zone */
0823     ndev = alloc_etherdev(sizeof(struct mpc52xx_fec_priv));
0824     if (!ndev)
0825         return -ENOMEM;
0826 
0827     priv = netdev_priv(ndev);
0828     priv->ndev = ndev;
0829 
0830     /* Reserve FEC control zone */
0831     rv = of_address_to_resource(np, 0, &mem);
0832     if (rv) {
0833         pr_err("Error while parsing device node resource\n");
0834         goto err_netdev;
0835     }
0836     if (resource_size(&mem) < sizeof(struct mpc52xx_fec)) {
0837         pr_err("invalid resource size (%lx < %x), check mpc52xx_devices.c\n",
0838                (unsigned long)resource_size(&mem),
0839                sizeof(struct mpc52xx_fec));
0840         rv = -EINVAL;
0841         goto err_netdev;
0842     }
0843 
0844     if (!request_mem_region(mem.start, sizeof(struct mpc52xx_fec),
0845                 DRIVER_NAME)) {
0846         rv = -EBUSY;
0847         goto err_netdev;
0848     }
0849 
0850     /* Init ether ndev with what we have */
0851     ndev->netdev_ops    = &mpc52xx_fec_netdev_ops;
0852     ndev->ethtool_ops   = &mpc52xx_fec_ethtool_ops;
0853     ndev->watchdog_timeo    = FEC_WATCHDOG_TIMEOUT;
0854     ndev->base_addr     = mem.start;
0855     SET_NETDEV_DEV(ndev, &op->dev);
0856 
0857     spin_lock_init(&priv->lock);
0858 
0859     /* ioremap the zones */
0860     priv->fec = ioremap(mem.start, sizeof(struct mpc52xx_fec));
0861 
0862     if (!priv->fec) {
0863         rv = -ENOMEM;
0864         goto err_mem_region;
0865     }
0866 
0867     /* Bestcomm init */
0868     rx_fifo = ndev->base_addr + offsetof(struct mpc52xx_fec, rfifo_data);
0869     tx_fifo = ndev->base_addr + offsetof(struct mpc52xx_fec, tfifo_data);
0870 
0871     priv->rx_dmatsk = bcom_fec_rx_init(FEC_RX_NUM_BD, rx_fifo, FEC_RX_BUFFER_SIZE);
0872     priv->tx_dmatsk = bcom_fec_tx_init(FEC_TX_NUM_BD, tx_fifo);
0873 
0874     if (!priv->rx_dmatsk || !priv->tx_dmatsk) {
0875         pr_err("Can not init SDMA tasks\n");
0876         rv = -ENOMEM;
0877         goto err_rx_tx_dmatsk;
0878     }
0879 
0880     /* Get the IRQ we need one by one */
0881         /* Control */
0882     ndev->irq = irq_of_parse_and_map(np, 0);
0883 
0884         /* RX */
0885     priv->r_irq = bcom_get_task_irq(priv->rx_dmatsk);
0886 
0887         /* TX */
0888     priv->t_irq = bcom_get_task_irq(priv->tx_dmatsk);
0889 
0890     /*
0891      * MAC address init:
0892      *
0893      * First try to read MAC address from DT
0894      */
0895     rv = of_get_ethdev_address(np, ndev);
0896     if (rv) {
0897         struct mpc52xx_fec __iomem *fec = priv->fec;
0898         u8 addr[ETH_ALEN] __aligned(4);
0899 
0900         /*
0901          * If the MAC addresse is not provided via DT then read
0902          * it back from the controller regs
0903          */
0904         *(u32 *)(&addr[0]) = in_be32(&fec->paddr1);
0905         *(u16 *)(&addr[4]) = in_be32(&fec->paddr2) >> 16;
0906         eth_hw_addr_set(ndev, addr);
0907     }
0908 
0909     /*
0910      * Check if the MAC address is valid, if not get a random one
0911      */
0912     if (!is_valid_ether_addr(ndev->dev_addr)) {
0913         eth_hw_addr_random(ndev);
0914         dev_warn(&ndev->dev, "using random MAC address %pM\n",
0915              ndev->dev_addr);
0916     }
0917 
0918     priv->msg_enable = netif_msg_init(debug, MPC52xx_MESSAGES_DEFAULT);
0919 
0920     /*
0921      * Link mode configuration
0922      */
0923 
0924     /* Start with safe defaults for link connection */
0925     priv->speed = 100;
0926     priv->duplex = DUPLEX_HALF;
0927     priv->mdio_speed = ((mpc5xxx_get_bus_frequency(&op->dev) >> 20) / 5) << 1;
0928 
0929     /* The current speed preconfigures the speed of the MII link */
0930     prop = of_get_property(np, "current-speed", &prop_size);
0931     if (prop && (prop_size >= sizeof(u32) * 2)) {
0932         priv->speed = prop[0];
0933         priv->duplex = prop[1] ? DUPLEX_FULL : DUPLEX_HALF;
0934     }
0935 
0936     /* If there is a phy handle, then get the PHY node */
0937     priv->phy_node = of_parse_phandle(np, "phy-handle", 0);
0938 
0939     /* the 7-wire property means don't use MII mode */
0940     if (of_find_property(np, "fsl,7-wire-mode", NULL)) {
0941         priv->seven_wire_mode = 1;
0942         dev_info(&ndev->dev, "using 7-wire PHY mode\n");
0943     }
0944 
0945     /* Hardware init */
0946     mpc52xx_fec_hw_init(ndev);
0947     mpc52xx_fec_reset_stats(ndev);
0948 
0949     rv = register_netdev(ndev);
0950     if (rv < 0)
0951         goto err_node;
0952 
0953     /* We're done ! */
0954     platform_set_drvdata(op, ndev);
0955     netdev_info(ndev, "%pOF MAC %pM\n",
0956             op->dev.of_node, ndev->dev_addr);
0957 
0958     return 0;
0959 
0960 err_node:
0961     of_node_put(priv->phy_node);
0962     irq_dispose_mapping(ndev->irq);
0963 err_rx_tx_dmatsk:
0964     if (priv->rx_dmatsk)
0965         bcom_fec_rx_release(priv->rx_dmatsk);
0966     if (priv->tx_dmatsk)
0967         bcom_fec_tx_release(priv->tx_dmatsk);
0968     iounmap(priv->fec);
0969 err_mem_region:
0970     release_mem_region(mem.start, sizeof(struct mpc52xx_fec));
0971 err_netdev:
0972     free_netdev(ndev);
0973 
0974     return rv;
0975 }
0976 
0977 static int
0978 mpc52xx_fec_remove(struct platform_device *op)
0979 {
0980     struct net_device *ndev;
0981     struct mpc52xx_fec_priv *priv;
0982 
0983     ndev = platform_get_drvdata(op);
0984     priv = netdev_priv(ndev);
0985 
0986     unregister_netdev(ndev);
0987 
0988     of_node_put(priv->phy_node);
0989     priv->phy_node = NULL;
0990 
0991     irq_dispose_mapping(ndev->irq);
0992 
0993     bcom_fec_rx_release(priv->rx_dmatsk);
0994     bcom_fec_tx_release(priv->tx_dmatsk);
0995 
0996     iounmap(priv->fec);
0997 
0998     release_mem_region(ndev->base_addr, sizeof(struct mpc52xx_fec));
0999 
1000     free_netdev(ndev);
1001 
1002     return 0;
1003 }
1004 
1005 #ifdef CONFIG_PM
1006 static int mpc52xx_fec_of_suspend(struct platform_device *op, pm_message_t state)
1007 {
1008     struct net_device *dev = platform_get_drvdata(op);
1009 
1010     if (netif_running(dev))
1011         mpc52xx_fec_close(dev);
1012 
1013     return 0;
1014 }
1015 
1016 static int mpc52xx_fec_of_resume(struct platform_device *op)
1017 {
1018     struct net_device *dev = platform_get_drvdata(op);
1019 
1020     mpc52xx_fec_hw_init(dev);
1021     mpc52xx_fec_reset_stats(dev);
1022 
1023     if (netif_running(dev))
1024         mpc52xx_fec_open(dev);
1025 
1026     return 0;
1027 }
1028 #endif
1029 
1030 static const struct of_device_id mpc52xx_fec_match[] = {
1031     { .compatible = "fsl,mpc5200b-fec", },
1032     { .compatible = "fsl,mpc5200-fec", },
1033     { .compatible = "mpc5200-fec", },
1034     { }
1035 };
1036 
1037 MODULE_DEVICE_TABLE(of, mpc52xx_fec_match);
1038 
1039 static struct platform_driver mpc52xx_fec_driver = {
1040     .driver = {
1041         .name = DRIVER_NAME,
1042         .of_match_table = mpc52xx_fec_match,
1043     },
1044     .probe      = mpc52xx_fec_probe,
1045     .remove     = mpc52xx_fec_remove,
1046 #ifdef CONFIG_PM
1047     .suspend    = mpc52xx_fec_of_suspend,
1048     .resume     = mpc52xx_fec_of_resume,
1049 #endif
1050 };
1051 
1052 
1053 /* ======================================================================== */
1054 /* Module                                                                   */
1055 /* ======================================================================== */
1056 
1057 static struct platform_driver * const drivers[] = {
1058 #ifdef CONFIG_FEC_MPC52xx_MDIO
1059     &mpc52xx_fec_mdio_driver,
1060 #endif
1061     &mpc52xx_fec_driver,
1062 };
1063 
1064 static int __init
1065 mpc52xx_fec_init(void)
1066 {
1067     return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
1068 }
1069 
1070 static void __exit
1071 mpc52xx_fec_exit(void)
1072 {
1073     platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
1074 }
1075 
1076 
1077 module_init(mpc52xx_fec_init);
1078 module_exit(mpc52xx_fec_exit);
1079 
1080 MODULE_LICENSE("GPL");
1081 MODULE_AUTHOR("Dale Farnsworth");
1082 MODULE_DESCRIPTION("Ethernet driver for the Freescale MPC52xx FEC");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!