drivers/net/ethernet/cadence/at91_ether.c

   1 /*
   2  * Ethernet driver for the Atmel AT91RM9200 (Thunder)
   3  *
   4  *  Copyright (C) 2003 SAN People (Pty) Ltd
   5  *
   6  * Based on an earlier Atmel EMAC macrocell driver by Atmel and Lineo Inc.
   7  * Initial version by Rick Bronson 01/11/2003
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version
  12  * 2 of the License, or (at your option) any later version.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/netdevice.h>
  19 #include <linux/etherdevice.h>
  20 #include <linux/skbuff.h>
  21 #include <linux/dma-mapping.h>
  22 #include <linux/ethtool.h>
  23 #include <linux/platform_data/macb.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/clk.h>
  26 #include <linux/gfp.h>
  27 #include <linux/phy.h>
  28 #include <linux/io.h>
  29 #include <linux/of.h>
  30 #include <linux/of_device.h>
  31 #include <linux/of_net.h>
  32
  33 #include "macb.h"
  34
  35 /* 1518 rounded up */
  36 #define MAX_RBUFF_SZ    0x600
  37 /* max number of receive buffers */
  38 #define MAX_RX_DESCR    9
  39
  40 /* Initialize and start the Receiver and Transmit subsystems */
  41 static int at91ether_start(struct net_device *dev)
  42 {
  43         struct macb *lp = netdev_priv(dev);
  44         dma_addr_t addr;
  45         u32 ctl;
  46         int i;
  47
  48         lp->rx_ring = dma_alloc_coherent(&lp->pdev->dev,
  49                                          (MAX_RX_DESCR *
  50                                           sizeof(struct macb_dma_desc)),
  51                                          &lp->rx_ring_dma, GFP_KERNEL);
  52         if (!lp->rx_ring)
  53                 return -ENOMEM;
  54
  55         lp->rx_buffers = dma_alloc_coherent(&lp->pdev->dev,
  56                                             MAX_RX_DESCR * MAX_RBUFF_SZ,
  57                                             &lp->rx_buffers_dma, GFP_KERNEL);
  58         if (!lp->rx_buffers) {
  59                 dma_free_coherent(&lp->pdev->dev,
  60                                   MAX_RX_DESCR * sizeof(struct macb_dma_desc),
  61                                   lp->rx_ring, lp->rx_ring_dma);
  62                 lp->rx_ring = NULL;
  63                 return -ENOMEM;
  64         }
  65
  66         addr = lp->rx_buffers_dma;
  67         for (i = 0; i < MAX_RX_DESCR; i++) {
  68                 lp->rx_ring[i].addr = addr;
  69                 lp->rx_ring[i].ctrl = 0;
  70                 addr += MAX_RBUFF_SZ;
  71         }
  72
  73         /* Set the Wrap bit on the last descriptor */
  74         lp->rx_ring[MAX_RX_DESCR - 1].addr |= MACB_BIT(RX_WRAP);
  75
  76         /* Reset buffer index */
  77         lp->rx_tail = 0;
  78
  79         /* Program address of descriptor list in Rx Buffer Queue register */
  80         macb_writel(lp, RBQP, lp->rx_ring_dma);
  81
  82         /* Enable Receive and Transmit */
  83         ctl = macb_readl(lp, NCR);
  84         macb_writel(lp, NCR, ctl | MACB_BIT(RE) | MACB_BIT(TE));
  85
  86         return 0;
  87 }
  88
  89 /* Open the ethernet interface */
  90 static int at91ether_open(struct net_device *dev)
  91 {
  92         struct macb *lp = netdev_priv(dev);
  93         u32 ctl;
  94         int ret;
  95
  96         /* Clear internal statistics */
  97         ctl = macb_readl(lp, NCR);
  98         macb_writel(lp, NCR, ctl | MACB_BIT(CLRSTAT));
  99
 100         macb_set_hwaddr(lp);
 101
 102         ret = at91ether_start(dev);
 103         if (ret)
 104                 return ret;
 105
 106         /* Enable MAC interrupts */
 107         macb_writel(lp, IER, MACB_BIT(RCOMP)    |
 108                              MACB_BIT(RXUBR)    |
 109                              MACB_BIT(ISR_TUND) |
 110                              MACB_BIT(ISR_RLE)  |
 111                              MACB_BIT(TCOMP)    |
 112                              MACB_BIT(ISR_ROVR) |
 113                              MACB_BIT(HRESP));
 114
 115         /* schedule a link state check */
 116         phy_start(lp->phy_dev);
 117
 118         netif_start_queue(dev);
 119
 120         return 0;
 121 }
 122
 123 /* Close the interface */
 124 static int at91ether_close(struct net_device *dev)
 125 {
 126         struct macb *lp = netdev_priv(dev);
 127         u32 ctl;
 128
 129         /* Disable Receiver and Transmitter */
 130         ctl = macb_readl(lp, NCR);
 131         macb_writel(lp, NCR, ctl & ~(MACB_BIT(TE) | MACB_BIT(RE)));
 132
 133         /* Disable MAC interrupts */
 134         macb_writel(lp, IDR, MACB_BIT(RCOMP)    |
 135                              MACB_BIT(RXUBR)    |
 136                              MACB_BIT(ISR_TUND) |
 137                              MACB_BIT(ISR_RLE)  |
 138                              MACB_BIT(TCOMP)    |
 139                              MACB_BIT(ISR_ROVR) |
 140                              MACB_BIT(HRESP));
 141
 142         netif_stop_queue(dev);
 143
 144         dma_free_coherent(&lp->pdev->dev,
 145                                 MAX_RX_DESCR * sizeof(struct macb_dma_desc),
 146                                 lp->rx_ring, lp->rx_ring_dma);
 147         lp->rx_ring = NULL;
 148
 149         dma_free_coherent(&lp->pdev->dev,
 150                                 MAX_RX_DESCR * MAX_RBUFF_SZ,
 151                                 lp->rx_buffers, lp->rx_buffers_dma);
 152         lp->rx_buffers = NULL;
 153
 154         return 0;
 155 }
 156
 157 /* Transmit packet */
 158 static int at91ether_start_xmit(struct sk_buff *skb, struct net_device *dev)
 159 {
 160         struct macb *lp = netdev_priv(dev);
 161
 162         if (macb_readl(lp, TSR) & MACB_BIT(RM9200_BNQ)) {
 163                 netif_stop_queue(dev);
 164
 165                 /* Store packet information (to free when Tx completed) */
 166                 lp->skb = skb;
 167                 lp->skb_length = skb->len;
 168                 lp->skb_physaddr = dma_map_single(NULL, skb->data, skb->len,
 169                                                         DMA_TO_DEVICE);
 170
 171                 /* Set address of the data in the Transmit Address register */
 172                 macb_writel(lp, TAR, lp->skb_physaddr);
 173                 /* Set length of the packet in the Transmit Control register */
 174                 macb_writel(lp, TCR, skb->len);
 175
 176         } else {
 177                 netdev_err(dev, "%s called, but device is busy!\n", __func__);
 178                 return NETDEV_TX_BUSY;
 179         }
 180
 181         return NETDEV_TX_OK;
 182 }
 183
 184 /* Extract received frame from buffer descriptors and sent to upper layers.
 185  * (Called from interrupt context)
 186  */
 187 static void at91ether_rx(struct net_device *dev)
 188 {
 189         struct macb *lp = netdev_priv(dev);
 190         unsigned char *p_recv;
 191         struct sk_buff *skb;
 192         unsigned int pktlen;
 193
 194         while (lp->rx_ring[lp->rx_tail].addr & MACB_BIT(RX_USED)) {
 195                 p_recv = lp->rx_buffers + lp->rx_tail * MAX_RBUFF_SZ;
 196                 pktlen = MACB_BF(RX_FRMLEN, lp->rx_ring[lp->rx_tail].ctrl);
 197                 skb = netdev_alloc_skb(dev, pktlen + 2);
 198                 if (skb) {
 199                         skb_reserve(skb, 2);
 200                         memcpy(skb_put(skb, pktlen), p_recv, pktlen);
 201
 202                         skb->protocol = eth_type_trans(skb, dev);
 203                         lp->stats.rx_packets++;
 204                         lp->stats.rx_bytes += pktlen;
 205                         netif_rx(skb);
 206                 } else {
 207                         lp->stats.rx_dropped++;
 208                 }
 209
 210                 if (lp->rx_ring[lp->rx_tail].ctrl & MACB_BIT(RX_MHASH_MATCH))
 211                         lp->stats.multicast++;
 212
 213                 /* reset ownership bit */
 214                 lp->rx_ring[lp->rx_tail].addr &= ~MACB_BIT(RX_USED);
 215
 216                 /* wrap after last buffer */
 217                 if (lp->rx_tail == MAX_RX_DESCR - 1)
 218                         lp->rx_tail = 0;
 219                 else
 220                         lp->rx_tail++;
 221         }
 222 }
 223
 224 /* MAC interrupt handler */
 225 static irqreturn_t at91ether_interrupt(int irq, void *dev_id)
 226 {
 227         struct net_device *dev = dev_id;
 228         struct macb *lp = netdev_priv(dev);
 229         u32 intstatus, ctl;
 230
 231         /* MAC Interrupt Status register indicates what interrupts are pending.
 232          * It is automatically cleared once read.
 233          */
 234         intstatus = macb_readl(lp, ISR);
 235
 236         /* Receive complete */
 237         if (intstatus & MACB_BIT(RCOMP))
 238                 at91ether_rx(dev);
 239
 240         /* Transmit complete */
 241         if (intstatus & MACB_BIT(TCOMP)) {
 242                 /* The TCOM bit is set even if the transmission failed */
 243                 if (intstatus & (MACB_BIT(ISR_TUND) | MACB_BIT(ISR_RLE)))
 244                         lp->stats.tx_errors++;
 245
 246                 if (lp->skb) {
 247                         dev_kfree_skb_irq(lp->skb);
 248                         lp->skb = NULL;
 249                         dma_unmap_single(NULL, lp->skb_physaddr, lp->skb_length, DMA_TO_DEVICE);
 250                         lp->stats.tx_packets++;
 251                         lp->stats.tx_bytes += lp->skb_length;
 252                 }
 253                 netif_wake_queue(dev);
 254         }
 255
 256         /* Work-around for EMAC Errata section 41.3.1 */
 257         if (intstatus & MACB_BIT(RXUBR)) {
 258                 ctl = macb_readl(lp, NCR);
 259                 macb_writel(lp, NCR, ctl & ~MACB_BIT(RE));
 260                 macb_writel(lp, NCR, ctl | MACB_BIT(RE));
 261         }
 262
 263         if (intstatus & MACB_BIT(ISR_ROVR))
 264                 netdev_err(dev, "ROVR error\n");
 265
 266         return IRQ_HANDLED;
 267 }
 268
 269 #ifdef CONFIG_NET_POLL_CONTROLLER
 270 static void at91ether_poll_controller(struct net_device *dev)
 271 {
 272         unsigned long flags;
 273
 274         local_irq_save(flags);
 275         at91ether_interrupt(dev->irq, dev);
 276         local_irq_restore(flags);
 277 }
 278 #endif
 279
 280 static const struct net_device_ops at91ether_netdev_ops = {
 281         .ndo_open               = at91ether_open,
 282         .ndo_stop               = at91ether_close,
 283         .ndo_start_xmit         = at91ether_start_xmit,
 284         .ndo_get_stats          = macb_get_stats,
 285         .ndo_set_rx_mode        = macb_set_rx_mode,
 286         .ndo_set_mac_address    = eth_mac_addr,
 287         .ndo_do_ioctl           = macb_ioctl,
 288         .ndo_validate_addr      = eth_validate_addr,
 289         .ndo_change_mtu         = eth_change_mtu,
 290 #ifdef CONFIG_NET_POLL_CONTROLLER
 291         .ndo_poll_controller    = at91ether_poll_controller,
 292 #endif
 293 };
 294
 295 #if defined(CONFIG_OF)
 296 static const struct of_device_id at91ether_dt_ids[] = {
 297         { .compatible = "cdns,at91rm9200-emac" },
 298         { .compatible = "cdns,emac" },
 299         { /* sentinel */ }
 300 };
 301 MODULE_DEVICE_TABLE(of, at91ether_dt_ids);
 302 #endif
 303
 304 /* Detect MAC & PHY and perform ethernet interface initialization */
 305 static int __init at91ether_probe(struct platform_device *pdev)
 306 {
 307         struct macb_platform_data *board_data = dev_get_platdata(&pdev->dev);
 308         struct resource *regs;
 309         struct net_device *dev;
 310         struct phy_device *phydev;
 311         struct macb *lp;
 312         int res;
 313         u32 reg;
 314         const char *mac;
 315
 316         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 317         if (!regs)
 318                 return -ENOENT;
 319
 320         dev = alloc_etherdev(sizeof(struct macb));
 321         if (!dev)
 322                 return -ENOMEM;
 323
 324         lp = netdev_priv(dev);
 325         lp->pdev = pdev;
 326         lp->dev = dev;
 327         spin_lock_init(&lp->lock);
 328
 329         /* physical base address */
 330         dev->base_addr = regs->start;
 331         lp->regs = devm_ioremap(&pdev->dev, regs->start, resource_size(regs));
 332         if (!lp->regs) {
 333                 res = -ENOMEM;
 334                 goto err_free_dev;
 335         }
 336
 337         /* Clock */
 338         lp->pclk = devm_clk_get(&pdev->dev, "ether_clk");
 339         if (IS_ERR(lp->pclk)) {
 340                 res = PTR_ERR(lp->pclk);
 341                 goto err_free_dev;
 342         }
 343         clk_prepare_enable(lp->pclk);
 344
 345         lp->hclk = ERR_PTR(-ENOENT);
 346         lp->tx_clk = ERR_PTR(-ENOENT);
 347
 348         /* Install the interrupt handler */
 349         dev->irq = platform_get_irq(pdev, 0);
 350         res = devm_request_irq(&pdev->dev, dev->irq, at91ether_interrupt, 0, dev->name, dev);
 351         if (res)
 352                 goto err_disable_clock;
 353
 354         dev->netdev_ops = &at91ether_netdev_ops;
 355         dev->ethtool_ops = &macb_ethtool_ops;
 356         platform_set_drvdata(pdev, dev);
 357         SET_NETDEV_DEV(dev, &pdev->dev);
 358
 359         mac = of_get_mac_address(pdev->dev.of_node);
 360         if (mac)
 361                 memcpy(lp->dev->dev_addr, mac, ETH_ALEN);
 362         else
 363                 macb_get_hwaddr(lp);
 364
 365         res = of_get_phy_mode(pdev->dev.of_node);
 366         if (res < 0) {
 367                 if (board_data && board_data->is_rmii)
 368                         lp->phy_interface = PHY_INTERFACE_MODE_RMII;
 369                 else
 370                         lp->phy_interface = PHY_INTERFACE_MODE_MII;
 371         } else {
 372                 lp->phy_interface = res;
 373         }
 374
 375         macb_writel(lp, NCR, 0);
 376
 377         reg = MACB_BF(CLK, MACB_CLK_DIV32) | MACB_BIT(BIG);
 378         if (lp->phy_interface == PHY_INTERFACE_MODE_RMII)
 379                 reg |= MACB_BIT(RM9200_RMII);
 380
 381         macb_writel(lp, NCFGR, reg);
 382
 383         /* Register the network interface */
 384         res = register_netdev(dev);
 385         if (res)
 386                 goto err_disable_clock;
 387
 388         res = macb_mii_init(lp);
 389         if (res)
 390                 goto err_out_unregister_netdev;
 391
 392         /* will be enabled in open() */
 393         netif_carrier_off(dev);
 394
 395         phydev = lp->phy_dev;
 396         netdev_info(dev, "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
 397                                 phydev->drv->name, dev_name(&phydev->dev),
 398                                 phydev->irq);
 399
 400         /* Display ethernet banner */
 401         netdev_info(dev, "AT91 ethernet at 0x%08lx int=%d (%pM)\n",
 402                                 dev->base_addr, dev->irq, dev->dev_addr);
 403
 404         return 0;
 405
 406 err_out_unregister_netdev:
 407         unregister_netdev(dev);
 408 err_disable_clock:
 409         clk_disable_unprepare(lp->pclk);
 410 err_free_dev:
 411         free_netdev(dev);
 412         return res;
 413 }
 414
 415 static int at91ether_remove(struct platform_device *pdev)
 416 {
 417         struct net_device *dev = platform_get_drvdata(pdev);
 418         struct macb *lp = netdev_priv(dev);
 419
 420         if (lp->phy_dev)
 421                 phy_disconnect(lp->phy_dev);
 422
 423         mdiobus_unregister(lp->mii_bus);
 424         kfree(lp->mii_bus->irq);
 425         mdiobus_free(lp->mii_bus);
 426         unregister_netdev(dev);
 427         clk_disable_unprepare(lp->pclk);
 428         free_netdev(dev);
 429
 430         return 0;
 431 }
 432
 433 #ifdef CONFIG_PM
 434 static int at91ether_suspend(struct platform_device *pdev, pm_message_t mesg)
 435 {
 436         struct net_device *net_dev = platform_get_drvdata(pdev);
 437         struct macb *lp = netdev_priv(net_dev);
 438
 439         if (netif_running(net_dev)) {
 440                 netif_stop_queue(net_dev);
 441                 netif_device_detach(net_dev);
 442
 443                 clk_disable_unprepare(lp->pclk);
 444         }
 445         return 0;
 446 }
 447
 448 static int at91ether_resume(struct platform_device *pdev)
 449 {
 450         struct net_device *net_dev = platform_get_drvdata(pdev);
 451         struct macb *lp = netdev_priv(net_dev);
 452
 453         if (netif_running(net_dev)) {
 454                 clk_prepare_enable(lp->pclk);
 455
 456                 netif_device_attach(net_dev);
 457                 netif_start_queue(net_dev);
 458         }
 459         return 0;
 460 }
 461 #else
 462 #define at91ether_suspend       NULL
 463 #define at91ether_resume        NULL
 464 #endif
 465
 466 static struct platform_driver at91ether_driver = {
 467         .remove         = at91ether_remove,
 468         .suspend        = at91ether_suspend,
 469         .resume         = at91ether_resume,
 470         .driver         = {
 471                 .name   = "at91_ether",
 472                 .of_match_table = of_match_ptr(at91ether_dt_ids),
 473         },
 474 };
 475
 476 module_platform_driver_probe(at91ether_driver, at91ether_probe);
 477
 478 MODULE_LICENSE("GPL");
 479 MODULE_DESCRIPTION("AT91RM9200 EMAC Ethernet driver");
 480 MODULE_AUTHOR("Andrew Victor");
 481 MODULE_ALIAS("platform:at91_ether");