target/linux/mcs814x/files-3.14/drivers/net/ethernet/mcs8140/nuport_mac.c

   1 /*
   2  * Moschip MCS8140 Ethernet MAC driver
   3  *
   4  * Copyright (C) 2003, Moschip Semiconductors
   5  * Copyright (C) 2012, Florian Fainelli <florian@openwrt.org>
   6  *
   7  * Licensed under GPLv2
   8  */
   9 #include <linux/module.h>
  10 #include <linux/slab.h>
  11 #include <linux/kernel.h>
  12 #include <linux/init.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/etherdevice.h>
  15 #include <linux/delay.h>
  16 #include <linux/ethtool.h>
  17 #include <linux/mii.h>
  18 #include <linux/io.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/of.h>
  22 #include <linux/of_mdio.h>
  23 #include <linux/of_net.h>
  24 #include <linux/irq.h>
  25 #include <linux/err.h>
  26 #include <linux/phy.h>
  27 #include <linux/clk.h>
  28 #include <linux/dma-mapping.h>
  29
  30 #include <asm/unaligned.h>
  31 #include <asm/sizes.h>
  32
  33 /* Hardware registers */
  34 #define MAC_BASE_ADDR           ((priv->mac_base))
  35
  36 #define CTRL_REG                (MAC_BASE_ADDR)
  37 #define  MII_BUSY               (1 << 0)
  38 #define  MII_WRITE              (1 << 1)
  39 #define  RX_ENABLE              (1 << 2)
  40 #define  TX_ENABLE              (1 << 3)
  41 #define  DEFER_CHECK            (1 << 5)
  42 #define  STRIP_PAD              (1 << 8)
  43 #define  DRTRY_DISABLE          (1 << 10)
  44 #define  FULL_DUPLEX            (1 << 20)
  45 #define  HBD_DISABLE            (1 << 28)
  46 #define MAC_ADDR_HIGH_REG       (MAC_BASE_ADDR + 0x04)
  47 #define MAC_ADDR_LOW_REG        (MAC_BASE_ADDR + 0x08)
  48 #define MII_ADDR_REG            (MAC_BASE_ADDR + 0x14)
  49 #define  MII_ADDR_SHIFT         (11)
  50 #define  MII_REG_SHIFT          (6)
  51 #define MII_DATA_REG            (MAC_BASE_ADDR + 0x18)
  52 /* Link interrupt registers */
  53 #define LINK_INT_CSR            (MAC_BASE_ADDR + 0xD0)
  54 #define  LINK_INT_EN            (1 << 0)
  55 #define  LINK_PHY_ADDR_SHIFT    (1)
  56 #define  LINK_PHY_REG_SHIFT     (6)
  57 #define  LINK_BIT_UP_SHIFT      (11)
  58 #define  LINK_UP                (1 << 16)
  59 #define LINK_INT_POLL_TIME      (MAC_BASE_ADDR + 0xD4)
  60 #define  LINK_POLL_MASK         ((1 << 20) - 1)
  61
  62 #define DMA_CHAN_WIDTH          32
  63 #define DMA_RX_CHAN             0
  64 #define DMA_TX_CHAN             2
  65
  66 /* Receive DMA registers */
  67 #define RX_DMA_BASE             ((priv->dma_base) + \
  68                                 (DMA_CHAN_WIDTH * DMA_RX_CHAN))
  69 #define RX_BUFFER_ADDR          (RX_DMA_BASE + 0x00)
  70 #define RX_MAX_BYTES            (RX_DMA_BASE + 0x04)
  71 #define RX_ACT_BYTES            (RX_DMA_BASE + 0x08)
  72 #define RX_START_DMA            (RX_DMA_BASE + 0x0C)
  73 #define  RX_DMA_ENABLE          (1 << 0)
  74 #define  RX_DMA_RESET           (1 << 1)
  75 #define  RX_DMA_STATUS_FIFO     (1 << 12)
  76 #define RX_DMA_ENH              (RX_DMA_BASE + 0x14)
  77 #define  RX_DMA_INT_ENABLE      (1 << 1)
  78
  79 /* Transmit DMA registers */
  80 #define TX_DMA_BASE             ((priv->dma_base) + \
  81                                 (DMA_CHAN_WIDTH * DMA_TX_CHAN))
  82 #define TX_BUFFER_ADDR          (TX_DMA_BASE + 0x00)
  83 #define TX_PKT_BYTES            (TX_DMA_BASE + 0x04)
  84 #define TX_BYTES_SENT           (TX_DMA_BASE + 0x08)
  85 #define TX_START_DMA            (TX_DMA_BASE + 0x0C)
  86 #define  TX_DMA_ENABLE          (1 << 0)
  87 #define  TX_DMA_START_FRAME     (1 << 2)
  88 #define  TX_DMA_END_FRAME       (1 << 3)
  89 #define  TX_DMA_PAD_DISABLE     (1 << 8)
  90 #define  TX_DMA_CRC_DISABLE     (1 << 9)
  91 #define  TX_DMA_FIFO_FULL       (1 << 16)
  92 #define  TX_DMA_FIFO_EMPTY      (1 << 17)
  93 #define  TX_DMA_STATUS_AVAIL    (1 << 18)
  94 #define  TX_DMA_RESET           (1 << 24)
  95 #define TX_DMA_STATUS           (TX_DMA_BASE + 0x10)
  96 #define TX_DMA_ENH              (TX_DMA_BASE + 0x14)
  97 #define  TX_DMA_ENH_ENABLE      (1 << 0)
  98 #define  TX_DMA_INT_FIFO        (1 << 1)
  99
 100 #define RX_ALLOC_SIZE           SZ_2K
 101 #define MAX_ETH_FRAME_SIZE      1536
 102 #define RX_SKB_TAILROOM         128
 103 #define RX_SKB_HEADROOM         (RX_ALLOC_SIZE  - \
 104                                 (MAX_ETH_FRAME_SIZE + RX_SKB_TAILROOM) + 0)
 105
 106                         /* WDT     Late COL    Lenght     COL      Type */
 107 #define ERROR_FILTER_MASK ((1<<14) | (1<<15) | (1<<16) | (1<<17) | (0<<18) | \
 108                         /* MII    Dribbling    CRC    Len/type   Control */\
 109                         (1<<19) | (1<<20) | (1<<21) | (0<<24) | (1<<25) | \
 110                         /* Unsup   Missed */\
 111                         (1<<26) | (0<<31))
 112 #define  TX_RING_SIZE  30
 113 #define  RX_RING_SIZE  30
 114
 115 static inline u32 nuport_mac_readl(void __iomem *reg)
 116 {
 117         return readl_relaxed(reg);
 118 }
 119
 120 static inline u8 nuport_mac_readb(void __iomem *reg)
 121 {
 122         return readb_relaxed(reg);
 123 }
 124
 125 static inline void nuport_mac_writel(u32 value, void __iomem *reg)
 126 {
 127         writel_relaxed(value, reg);
 128 }
 129
 130 static inline void nuport_mac_writeb(u8 value, void __iomem *reg)
 131 {
 132         writel_relaxed(value, reg);
 133 }
 134
 135 /* MAC private data */
 136 struct nuport_mac_priv {
 137         spinlock_t lock;
 138
 139         void __iomem    *mac_base;
 140         void __iomem    *dma_base;
 141
 142         int             rx_irq;
 143         int             tx_irq;
 144         int             link_irq;
 145         struct clk      *emac_clk;
 146         struct clk      *ephy_clk;
 147
 148         /* Transmit buffers */
 149         struct sk_buff *tx_skb[TX_RING_SIZE];
 150         dma_addr_t tx_addr;
 151         unsigned int valid_txskb[TX_RING_SIZE];
 152         unsigned int cur_tx;
 153         unsigned int dma_tx;
 154         unsigned int tx_full;
 155
 156         /* Receive buffers */
 157         struct sk_buff *rx_skb[RX_RING_SIZE];
 158         dma_addr_t rx_addr;
 159         unsigned int irq_rxskb[RX_RING_SIZE];
 160         int pkt_len[RX_RING_SIZE];
 161         unsigned int cur_rx;
 162         unsigned int dma_rx;
 163         unsigned int rx_full;
 164
 165         unsigned int first_pkt;
 166
 167         /* Private data */
 168         struct napi_struct napi;
 169         struct net_device       *dev;
 170         struct platform_device  *pdev;
 171         struct mii_bus          *mii_bus;
 172         struct phy_device       *phydev;
 173         struct device_node      *phy_node;
 174         phy_interface_t         phy_interface;
 175         int                     old_link;
 176         int                     old_duplex;
 177         u32                     msg_level;
 178         unsigned int            buffer_shifting_len;
 179 };
 180
 181 static inline int nuport_mac_mii_busy_wait(struct nuport_mac_priv *priv)
 182 {
 183         unsigned long curr;
 184         unsigned long finish = jiffies + 3 * HZ;
 185
 186         do {
 187                 curr = jiffies;
 188                 if (!(nuport_mac_readl(MII_ADDR_REG) & MII_BUSY))
 189                         return 0;
 190                 cpu_relax();
 191         } while (!time_after_eq(curr, finish));
 192
 193         return -EBUSY;
 194 }
 195
 196 /* Read from PHY registers */
 197 static int nuport_mac_mii_read(struct mii_bus *bus,
 198                                 int mii_id, int regnum)
 199 {
 200         struct net_device *dev = bus->priv;
 201         struct nuport_mac_priv *priv = netdev_priv(dev);
 202         int ret;
 203         u32 val = 0;
 204
 205         ret = nuport_mac_mii_busy_wait(priv);
 206         if (ret)
 207                 return ret;
 208
 209         val |= (mii_id << MII_ADDR_SHIFT) | (regnum << MII_REG_SHIFT) | MII_BUSY;
 210         nuport_mac_writel(val, MII_ADDR_REG);
 211         ret = nuport_mac_mii_busy_wait(priv);
 212         if (ret)
 213                 return ret;
 214
 215         return nuport_mac_readl(MII_DATA_REG);
 216 }
 217
 218 static int nuport_mac_mii_write(struct mii_bus *bus, int mii_id,
 219                                 int regnum, u16 value)
 220 {
 221         struct net_device *dev = bus->priv;
 222         struct nuport_mac_priv *priv = netdev_priv(dev);
 223         int ret;
 224         u32 val = 0;
 225
 226         ret = nuport_mac_mii_busy_wait(priv);
 227         if (ret)
 228                 return ret;
 229
 230         val |= (mii_id << MII_ADDR_SHIFT) | (regnum << MII_REG_SHIFT);
 231         val |= MII_BUSY | MII_WRITE;
 232         nuport_mac_writel(value, MII_DATA_REG);
 233         nuport_mac_writel(val, MII_ADDR_REG);
 234
 235         return nuport_mac_mii_busy_wait(priv);
 236 }
 237
 238 static int nuport_mac_mii_reset(struct mii_bus *bus)
 239 {
 240         return 0;
 241 }
 242
 243 static int nuport_mac_start_tx_dma(struct nuport_mac_priv *priv,
 244                                         struct sk_buff *skb)
 245 {
 246         u32 reg;
 247         unsigned int timeout = 2048;
 248
 249         while (timeout--) {
 250                 reg = nuport_mac_readl(TX_START_DMA);
 251                 if (!(reg & TX_DMA_ENABLE)) {
 252                         netdev_dbg(priv->dev, "dma ready\n");
 253                         break;
 254                 }
 255                 cpu_relax();
 256         }
 257
 258         if (!timeout)
 259                 return -EBUSY;
 260
 261         priv->tx_addr = dma_map_single(&priv->pdev->dev, skb->data,
 262                         skb->len, DMA_TO_DEVICE);
 263         if (dma_mapping_error(&priv->pdev->dev, priv->tx_addr))
 264                 return -ENOMEM;
 265
 266         /* enable enhanced mode */
 267         nuport_mac_writel(TX_DMA_ENH_ENABLE, TX_DMA_ENH);
 268         nuport_mac_writel(priv->tx_addr, TX_BUFFER_ADDR);
 269         nuport_mac_writel((skb->len) - 1, TX_PKT_BYTES);
 270         wmb();
 271         reg = TX_DMA_ENABLE | TX_DMA_START_FRAME | TX_DMA_END_FRAME;
 272         nuport_mac_writel(reg, TX_START_DMA);
 273
 274         return 0;
 275 }
 276
 277 static void nuport_mac_reset_tx_dma(struct nuport_mac_priv *priv)
 278 {
 279         u32 reg;
 280
 281         reg = nuport_mac_readl(TX_START_DMA);
 282         reg |= TX_DMA_RESET;
 283         nuport_mac_writel(reg, TX_START_DMA);
 284 }
 285
 286 static int nuport_mac_start_rx_dma(struct nuport_mac_priv *priv,
 287                                         struct sk_buff *skb)
 288 {
 289         u32 reg;
 290         unsigned int timeout = 2048;
 291
 292         while (timeout--) {
 293                 reg = nuport_mac_readl(RX_START_DMA);
 294                 if (!(reg & RX_DMA_ENABLE)) {
 295                         netdev_dbg(priv->dev, "dma ready\n");
 296                         break;
 297                 }
 298                 cpu_relax();
 299         }
 300
 301         if (!timeout)
 302                 return -EBUSY;
 303
 304         priv->rx_addr = dma_map_single(&priv->pdev->dev, skb->data,
 305                                 RX_ALLOC_SIZE, DMA_FROM_DEVICE);
 306         if (dma_mapping_error(&priv->pdev->dev, priv->rx_addr))
 307                 return -ENOMEM;
 308
 309         nuport_mac_writel(priv->rx_addr, RX_BUFFER_ADDR);
 310         wmb();
 311         nuport_mac_writel(RX_DMA_ENABLE, RX_START_DMA);
 312
 313         return 0;
 314 }
 315
 316 static void nuport_mac_reset_rx_dma(struct nuport_mac_priv *priv)
 317 {
 318         u32 reg;
 319
 320         reg = nuport_mac_readl(RX_START_DMA);
 321         reg |= RX_DMA_RESET;
 322         nuport_mac_writel(reg, RX_START_DMA);
 323 }
 324
 325 /* I suppose this might do something, but I am not sure actually */
 326 static void nuport_mac_disable_rx_dma(struct nuport_mac_priv *priv)
 327 {
 328         u32 reg;
 329
 330         reg = nuport_mac_readl(RX_DMA_ENH);
 331         reg &= ~RX_DMA_INT_ENABLE;
 332         nuport_mac_writel(reg, RX_DMA_ENH);
 333 }
 334
 335 static void nuport_mac_enable_rx_dma(struct nuport_mac_priv *priv)
 336 {
 337         u32 reg;
 338
 339         reg = nuport_mac_readl(RX_DMA_ENH);
 340         reg |= RX_DMA_INT_ENABLE;
 341         nuport_mac_writel(reg, RX_DMA_ENH);
 342 }
 343
 344 /* Add packets to the transmit queue */
 345 static int nuport_mac_start_xmit(struct sk_buff *skb, struct net_device *dev)
 346 {
 347         unsigned long flags;
 348         struct nuport_mac_priv *priv = netdev_priv(dev);
 349         int ret;
 350
 351         if (netif_queue_stopped(dev)) {
 352                 netdev_warn(dev, "netif queue was stopped, restarting\n");
 353                 netif_start_queue(dev);
 354         }
 355
 356         spin_lock_irqsave(&priv->lock, flags);
 357         if (priv->first_pkt) {
 358                 ret = nuport_mac_start_tx_dma(priv, skb);
 359                 if (ret) {
 360                         netif_stop_queue(dev);
 361                         spin_unlock_irqrestore(&priv->lock, flags);
 362                         netdev_err(dev, "transmit path busy\n");
 363                         return NETDEV_TX_BUSY;
 364                 }
 365                 priv->first_pkt = 0;
 366         }
 367
 368         priv->tx_skb[priv->cur_tx] = skb;
 369         dev->stats.tx_bytes += skb->len;
 370         dev->stats.tx_packets++;
 371         priv->valid_txskb[priv->cur_tx] = 1;
 372         priv->cur_tx++;
 373         dev->trans_start = jiffies;
 374
 375         if (priv->cur_tx >= TX_RING_SIZE)
 376                 priv->cur_tx = 0;
 377
 378         spin_unlock_irqrestore(&priv->lock, flags);
 379
 380         if (priv->valid_txskb[priv->cur_tx]) {
 381                 priv->tx_full = 1;
 382                 netdev_err(dev, "stopping queue\n");
 383                 netif_stop_queue(dev);
 384         }
 385
 386         return NETDEV_TX_OK;
 387 }
 388
 389 static void nuport_mac_adjust_link(struct net_device *dev)
 390 {
 391         struct nuport_mac_priv *priv = netdev_priv(dev);
 392         struct phy_device *phydev = priv->phydev;
 393         unsigned int status_changed = 0;
 394         u32 reg;
 395
 396         BUG_ON(!phydev);
 397
 398         if (priv->old_link != phydev->link) {
 399                 status_changed = 1;
 400                 priv->old_link = phydev->link;
 401         }
 402
 403         if (phydev->link && (priv->old_duplex != phydev->duplex)) {
 404                 reg = nuport_mac_readl(CTRL_REG);
 405                 if (phydev->duplex == DUPLEX_FULL)
 406                         reg |= DUPLEX_FULL;
 407                 else
 408                         reg &= ~DUPLEX_FULL;
 409                 nuport_mac_writel(reg, CTRL_REG);
 410
 411                 status_changed = 1;
 412                 priv->old_duplex = phydev->duplex;
 413         }
 414
 415         if (!status_changed)
 416                 return;
 417
 418         pr_info("%s: link %s", dev->name, phydev->link ?
 419                 "UP" : "DOWN");
 420         if (phydev->link) {
 421                 pr_cont(" - %d/%s", phydev->speed,
 422                 phydev->duplex == DUPLEX_FULL ? "full" : "half");
 423         }
 424         pr_cont("\n");
 425 }
 426
 427 static irqreturn_t nuport_mac_link_interrupt(int irq, void *dev_id)
 428 {
 429         struct net_device *dev = dev_id;
 430         struct nuport_mac_priv *priv = netdev_priv(dev);
 431         u32 reg;
 432         u8 phy_addr;
 433         unsigned long flags;
 434         irqreturn_t ret = IRQ_HANDLED;
 435
 436         spin_lock_irqsave(&priv->lock, flags);
 437         reg = nuport_mac_readl(LINK_INT_CSR);
 438         phy_addr = (reg >> LINK_PHY_ADDR_SHIFT) & (PHY_MAX_ADDR - 1);
 439
 440         if (phy_addr != priv->phydev->addr) {
 441                 netdev_err(dev, "spurious PHY irq (phy: %d)\n", phy_addr);
 442                 ret = IRQ_NONE;
 443                 goto out;
 444         }
 445
 446         priv->phydev->link = (reg & LINK_UP);
 447         nuport_mac_adjust_link(dev);
 448
 449 out:
 450         spin_unlock_irqrestore(&priv->lock, flags);
 451         return ret;
 452 }
 453
 454 static irqreturn_t nuport_mac_tx_interrupt(int irq, void *dev_id)
 455 {
 456         struct net_device *dev = (struct net_device *)dev_id;
 457         struct nuport_mac_priv *priv = netdev_priv(dev);
 458         struct sk_buff *skb;
 459         unsigned long flags;
 460         int ret;
 461         u32 reg;
 462
 463         spin_lock_irqsave(&priv->lock, flags);
 464         /* clear status word available if ready */
 465         reg = nuport_mac_readl(TX_START_DMA);
 466         if (reg & TX_DMA_STATUS_AVAIL) {
 467                 nuport_mac_writel(reg, TX_START_DMA);
 468                 reg = nuport_mac_readl(TX_DMA_STATUS);
 469
 470                 if (reg & 1)
 471                         dev->stats.tx_errors++;
 472         } else
 473                 netdev_dbg(dev, "no status word: %08x\n", reg);
 474
 475         skb = priv->tx_skb[priv->dma_tx];
 476         priv->tx_skb[priv->dma_tx] = NULL;
 477         priv->valid_txskb[priv->dma_tx] = 0;
 478         dma_unmap_single(&priv->pdev->dev, priv->rx_addr, skb->len,
 479                                 DMA_TO_DEVICE);
 480         dev_kfree_skb_irq(skb);
 481
 482         priv->dma_tx++;
 483         if (priv->dma_tx >= TX_RING_SIZE)
 484                 priv->dma_tx = 0;
 485
 486         if (!priv->valid_txskb[priv->dma_tx])
 487                 priv->first_pkt = 1;
 488         else {
 489                 ret = nuport_mac_start_tx_dma(priv, priv->tx_skb[priv->dma_tx]);
 490                 if (ret)
 491                         netdev_err(dev, "failed to restart TX dma\n");
 492         }
 493
 494         if (priv->tx_full) {
 495                 netdev_dbg(dev, "restarting transmit queue\n");
 496                 netif_wake_queue(dev);
 497                 priv->tx_full = 0;
 498         }
 499
 500         spin_unlock_irqrestore(&priv->lock, flags);
 501
 502         return IRQ_HANDLED;
 503 }
 504
 505 static unsigned int nuport_mac_has_work(struct nuport_mac_priv *priv)
 506 {
 507         unsigned int i;
 508
 509         for (i = 0; i < RX_RING_SIZE; i++)
 510                 if (priv->rx_skb[i])
 511                         return 1;
 512
 513         return 0;
 514 }
 515
 516 static irqreturn_t nuport_mac_rx_interrupt(int irq, void *dev_id)
 517 {
 518         struct net_device *dev = (struct net_device *)dev_id;
 519         struct nuport_mac_priv *priv = netdev_priv(dev);
 520         unsigned long flags;
 521         int ret;
 522
 523         spin_lock_irqsave(&priv->lock, flags);
 524         if (!priv->rx_full) {
 525                 priv->pkt_len[priv->dma_rx] = nuport_mac_readl(RX_ACT_BYTES) - 4;
 526                 priv->irq_rxskb[priv->dma_rx] = 0;
 527                 priv->dma_rx++;
 528
 529                 if (priv->dma_rx >= RX_RING_SIZE)
 530                         priv->dma_rx = 0;
 531         } else
 532                 priv->rx_full = 0;
 533
 534         if (priv->irq_rxskb[priv->dma_rx] == 1) {
 535                 ret = nuport_mac_start_rx_dma(priv, priv->rx_skb[priv->dma_rx]);
 536                 if (ret)
 537                         netdev_err(dev, "failed to start rx dma\n");
 538         } else {
 539                 priv->rx_full = 1;
 540                 netdev_dbg(dev, "RX ring full\n");
 541         }
 542
 543         if (likely(nuport_mac_has_work(priv))) {
 544                 /* find a way to disable DMA rx irq */
 545                 nuport_mac_disable_rx_dma(priv);
 546                 napi_schedule(&priv->napi);
 547         }
 548         spin_unlock_irqrestore(&priv->lock, flags);
 549
 550         return IRQ_HANDLED;
 551 }
 552
 553 /* Process received packets in tasklet */
 554 static int nuport_mac_rx(struct net_device *dev, int limit)
 555 {
 556         struct nuport_mac_priv *priv = netdev_priv(dev);
 557         struct sk_buff *skb;
 558         int len, status;
 559         int count = 0;
 560
 561         while (count < limit && !priv->irq_rxskb[priv->cur_rx]) {
 562                 skb = priv->rx_skb[priv->cur_rx];
 563                 len = priv->pkt_len[priv->cur_rx];
 564
 565                 /* Remove 2 bytes added by RX buffer shifting */
 566                 len = len - priv->buffer_shifting_len;
 567                 skb->data = skb->data + priv->buffer_shifting_len;
 568
 569                 /* Get packet status */
 570                 status = get_unaligned((u32 *) (skb->data + len));
 571
 572                 dma_unmap_single(&priv->pdev->dev, priv->rx_addr, skb->len,
 573                                 DMA_FROM_DEVICE);
 574
 575                 /* packet filter failed */
 576                 if (!(status & (1 << 30))) {
 577                         dev_kfree_skb_irq(skb);
 578                         goto exit;
 579                 }
 580
 581                 /* missed frame */
 582                 if (status & (1 << 31)) {
 583                         dev->stats.rx_missed_errors++;
 584                         dev_kfree_skb_irq(skb);
 585                         goto exit;
 586                 }
 587
 588                 /* Not ethernet type */
 589                 if ((!(status & (1 << 18))) || (status & ERROR_FILTER_MASK))
 590                         dev->stats.rx_errors++;
 591
 592                 if (len > MAX_ETH_FRAME_SIZE) {
 593                         dev_kfree_skb_irq(skb);
 594                         goto exit;
 595                 } else
 596                         skb_put(skb, len);
 597
 598                 skb->protocol = eth_type_trans(skb, dev);
 599                 dev->stats.rx_packets++;
 600
 601                 if (status & (1 << 29))
 602                         skb->pkt_type = PACKET_OTHERHOST;
 603                 if (status & (1 << 27))
 604                         skb->pkt_type = PACKET_MULTICAST;
 605                 if (status & (1 << 28))
 606                         skb->pkt_type = PACKET_BROADCAST;
 607
 608                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 609
 610                 /* Pass the received packet to network layer */
 611                 status = netif_receive_skb(skb);
 612                 if (status != NET_RX_DROP)
 613                         dev->stats.rx_bytes += len - 4; /* Without CRC */
 614                 else
 615                         dev->stats.rx_dropped++;
 616
 617                 dev->last_rx = jiffies;
 618
 619 exit:
 620                 skb = netdev_alloc_skb(dev, RX_ALLOC_SIZE);
 621                 if (!skb)
 622                         goto out;
 623
 624                 skb_reserve(skb, RX_SKB_HEADROOM);
 625                 priv->rx_skb[priv->cur_rx] = skb;
 626                 priv->irq_rxskb[priv->cur_rx] = 1;
 627                 priv->cur_rx++;
 628
 629                 if (priv->cur_rx >= RX_RING_SIZE)
 630                         priv->cur_rx = 0;
 631                 count++;
 632         }
 633 out:
 634         return count;
 635 }
 636
 637 static int nuport_mac_poll(struct napi_struct *napi, int budget)
 638 {
 639         struct nuport_mac_priv *priv =
 640                 container_of(napi, struct nuport_mac_priv, napi);
 641         struct net_device *dev = priv->dev;
 642         int work_done;
 643
 644         work_done = nuport_mac_rx(dev, budget);
 645
 646         if (work_done < budget) {
 647                 napi_complete(napi);
 648                 nuport_mac_enable_rx_dma(priv);
 649         }
 650
 651         return work_done;
 652 }
 653
 654 static void nuport_mac_init_tx_ring(struct nuport_mac_priv *priv)
 655 {
 656         int i;
 657
 658         priv->cur_tx = priv->dma_tx = priv->tx_full = 0;
 659         for (i = 0; i < TX_RING_SIZE; i++) {
 660                 priv->tx_skb[i] = NULL;
 661                 priv->valid_txskb[i] = 0;
 662         }
 663         priv->first_pkt = 1;
 664 }
 665
 666 static int nuport_mac_init_rx_ring(struct net_device *dev)
 667 {
 668         struct nuport_mac_priv *priv = netdev_priv(dev);
 669         struct sk_buff *skb;
 670         int i;
 671
 672         priv->cur_rx = priv->dma_rx = priv->rx_full = 0;
 673
 674         for (i = 0; i < RX_RING_SIZE; i++) {
 675                 skb = netdev_alloc_skb(dev, RX_ALLOC_SIZE);
 676                 if (!skb)
 677                         return -ENOMEM;
 678                 skb_reserve(skb, RX_SKB_HEADROOM);
 679                 priv->rx_skb[i] = skb;
 680                 priv->irq_rxskb[i] = 1;
 681         }
 682
 683         return 0;
 684 }
 685
 686 static void nuport_mac_free_rx_ring(struct nuport_mac_priv *priv)
 687 {
 688         int i;
 689
 690         for (i = 0; i < RX_RING_SIZE; i++) {
 691                 if (!priv->rx_skb[i])
 692                         continue;
 693
 694                 dev_kfree_skb(priv->rx_skb[i]);
 695                 priv->rx_skb[i] = NULL;
 696         }
 697
 698         if (priv->rx_addr)
 699                 dma_unmap_single(&priv->pdev->dev, priv->rx_addr, RX_ALLOC_SIZE,
 700                                 DMA_TO_DEVICE);
 701 }
 702
 703 static void nuport_mac_read_mac_address(struct net_device *dev)
 704 {
 705         struct nuport_mac_priv *priv = netdev_priv(dev);
 706         int i;
 707
 708         for (i = 0; i < 4; i++)
 709                 dev->dev_addr[i] = nuport_mac_readb(MAC_ADDR_LOW_REG + i);
 710         dev->dev_addr[4] = nuport_mac_readb(MAC_ADDR_HIGH_REG);
 711         dev->dev_addr[5] = nuport_mac_readb(MAC_ADDR_HIGH_REG + 1);
 712
 713         if (!is_valid_ether_addr(dev->dev_addr)) {
 714                 dev_info(&priv->pdev->dev, "using random address\n");
 715                 random_ether_addr(dev->dev_addr);
 716         }
 717 }
 718
 719 static int nuport_mac_change_mac_address(struct net_device *dev, void *mac_addr)
 720 {
 721         struct sockaddr *addr = mac_addr;
 722         struct nuport_mac_priv *priv = netdev_priv(dev);
 723         unsigned long *temp = (unsigned long *)dev->dev_addr;
 724         u32 high, low;
 725
 726         if (netif_running(dev))
 727                 return -EBUSY;
 728
 729         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
 730
 731         spin_lock_irq(&priv->lock);
 732
 733         nuport_mac_writel(*temp, MAC_ADDR_LOW_REG);
 734         temp = (unsigned long *)(dev->dev_addr + 4);
 735         nuport_mac_writel(*temp, MAC_ADDR_HIGH_REG);
 736
 737         low = nuport_mac_readl(MAC_ADDR_LOW_REG);
 738         high = nuport_mac_readl(MAC_ADDR_HIGH_REG);
 739
 740         spin_unlock_irq(&priv->lock);
 741
 742         return 0;
 743 }
 744
 745 static int nuport_mac_open(struct net_device *dev)
 746 {
 747         int ret;
 748         struct nuport_mac_priv *priv = netdev_priv(dev);
 749         unsigned long flags;
 750         u32 reg = 0;
 751
 752         ret = clk_enable(priv->emac_clk);
 753         if (ret) {
 754                 netdev_err(dev, "failed to enable EMAC clock\n");
 755                 return ret;
 756         }
 757
 758         /* Set MAC into full duplex mode by default */
 759         reg |= RX_ENABLE | TX_ENABLE;
 760         reg |= DEFER_CHECK | STRIP_PAD | DRTRY_DISABLE;
 761         reg |= FULL_DUPLEX | HBD_DISABLE;
 762         nuport_mac_writel(reg, CTRL_REG);
 763
 764         /* set mac address in hardware in case it was not already */
 765         nuport_mac_change_mac_address(dev, dev->dev_addr);
 766
 767         ret = request_irq(priv->link_irq, &nuport_mac_link_interrupt,
 768                                 0, dev->name, dev);
 769         if (ret) {
 770                 netdev_err(dev, "unable to request link interrupt\n");
 771                 goto out_emac_clk;
 772         }
 773
 774         ret = request_irq(priv->tx_irq, &nuport_mac_tx_interrupt,
 775                                 0, dev->name, dev);
 776         if (ret) {
 777                 netdev_err(dev, "unable to request rx interrupt\n");
 778                 goto out_link_irq;
 779         }
 780
 781         /* Enable link interrupt monitoring for our PHY address */
 782         reg = LINK_INT_EN | (priv->phydev->addr << LINK_PHY_ADDR_SHIFT);
 783         /* MII_BMSR register to be watched */
 784         reg |= (1 << LINK_PHY_REG_SHIFT);
 785         /* BMSR_STATUS to be watched in particular */
 786         reg |= (2 << LINK_BIT_UP_SHIFT);
 787
 788         spin_lock_irqsave(&priv->lock, flags);
 789         nuport_mac_writel(reg, LINK_INT_CSR);
 790         nuport_mac_writel(LINK_POLL_MASK, LINK_INT_POLL_TIME);
 791         spin_unlock_irqrestore(&priv->lock, flags);
 792
 793         phy_start(priv->phydev);
 794
 795         ret = request_irq(priv->rx_irq, &nuport_mac_rx_interrupt,
 796                                 0, dev->name, dev);
 797         if (ret) {
 798                 netdev_err(dev, "unable to request tx interrupt\n");
 799                 goto out_tx_irq;
 800         }
 801
 802         netif_start_queue(dev);
 803
 804         nuport_mac_init_tx_ring(priv);
 805
 806         ret = nuport_mac_init_rx_ring(dev);
 807         if (ret) {
 808                 netdev_err(dev, "rx ring init failed\n");
 809                 goto out_rx_skb;
 810         }
 811
 812         nuport_mac_reset_tx_dma(priv);
 813         nuport_mac_reset_rx_dma(priv);
 814
 815         /* Start RX DMA */
 816         spin_lock_irqsave(&priv->lock, flags);
 817         ret = nuport_mac_start_rx_dma(priv, priv->rx_skb[0]);
 818         spin_unlock_irqrestore(&priv->lock, flags);
 819
 820         napi_enable(&priv->napi);
 821
 822         return ret;
 823
 824 out_rx_skb:
 825         nuport_mac_free_rx_ring(priv);
 826         free_irq(priv->rx_irq, dev);
 827 out_tx_irq:
 828         free_irq(priv->tx_irq, dev);
 829 out_link_irq:
 830         free_irq(priv->link_irq, dev);
 831 out_emac_clk:
 832         clk_disable(priv->emac_clk);
 833         return ret;
 834 }
 835
 836 static int nuport_mac_close(struct net_device *dev)
 837 {
 838         u32 reg;
 839         struct nuport_mac_priv *priv = netdev_priv(dev);
 840
 841         spin_lock_irq(&priv->lock);
 842         reg = nuport_mac_readl(CTRL_REG);
 843         reg &= ~(RX_ENABLE | TX_ENABLE);
 844         nuport_mac_writel(reg, CTRL_REG);
 845
 846         napi_disable(&priv->napi);
 847         netif_stop_queue(dev);
 848
 849         free_irq(priv->link_irq, dev);
 850         /* disable PHY polling */
 851         nuport_mac_writel(0, LINK_INT_CSR);
 852         nuport_mac_writel(0, LINK_INT_POLL_TIME);
 853         phy_stop(priv->phydev);
 854
 855         free_irq(priv->tx_irq, dev);
 856         free_irq(priv->rx_irq, dev);
 857         spin_unlock_irq(&priv->lock);
 858
 859         nuport_mac_free_rx_ring(priv);
 860
 861         clk_disable(priv->emac_clk);
 862
 863         return 0;
 864 }
 865
 866 static void nuport_mac_tx_timeout(struct net_device *dev)
 867 {
 868         struct nuport_mac_priv *priv = netdev_priv(dev);
 869         unsigned int i;
 870
 871         netdev_warn(dev, "transmit timeout, attempting recovery\n");
 872
 873         netdev_info(dev, "TX DMA regs\n");
 874         for (i = 0; i < DMA_CHAN_WIDTH; i += 4)
 875                 netdev_info(dev, "[%02x]: 0x%08x\n", i, nuport_mac_readl(TX_DMA_BASE + i));
 876         netdev_info(dev, "RX DMA regs\n");
 877         for (i = 0; i < DMA_CHAN_WIDTH; i += 4)
 878                 netdev_info(dev, "[%02x]: 0x%08x\n", i, nuport_mac_readl(RX_DMA_BASE + i));
 879
 880         nuport_mac_init_tx_ring(priv);
 881         nuport_mac_reset_tx_dma(priv);
 882
 883         netif_wake_queue(dev);
 884 }
 885
 886 static int nuport_mac_mii_probe(struct net_device *dev)
 887 {
 888         struct nuport_mac_priv *priv = netdev_priv(dev);
 889         struct phy_device *phydev = NULL;
 890         int ret;
 891
 892         ret = clk_enable(priv->ephy_clk);
 893         if (ret) {
 894                 netdev_err(dev, "unable to enable ePHY clk\n");
 895                 return ret;
 896         }
 897
 898         phydev = phy_find_first(priv->mii_bus);
 899         if (!phydev) {
 900                 netdev_err(dev, "no PHYs found\n");
 901                 ret = -ENODEV;
 902                 goto out;
 903         }
 904
 905         phydev = of_phy_connect(dev, priv->phy_node,
 906                         nuport_mac_adjust_link, 0,
 907                         priv->phy_interface);
 908         if (IS_ERR(phydev)) {
 909                 netdev_err(dev, "could not attach PHY\n");
 910                 ret = PTR_ERR(phydev);
 911                 goto out;
 912         }
 913
 914         phydev->supported &= PHY_BASIC_FEATURES;
 915         phydev->advertising = phydev->supported;
 916         priv->phydev = phydev;
 917         priv->old_link = 1;
 918         priv->old_duplex = DUPLEX_FULL;
 919
 920         dev_info(&priv->pdev->dev, "attached PHY driver [%s] "
 921                 "(mii_bus:phy_addr=%d)\n",
 922                 phydev->drv->name, phydev->addr);
 923
 924         return 0;
 925
 926 out:
 927         /* disable the Ethernet PHY clock for the moment */
 928         clk_disable(priv->ephy_clk);
 929
 930         return ret;
 931 }
 932
 933 static void nuport_mac_ethtool_drvinfo(struct net_device *dev,
 934                                         struct ethtool_drvinfo *info)
 935 {
 936         strncpy(info->driver, "nuport-mac", sizeof(info->driver));
 937         strncpy(info->version, "0.1", sizeof(info->version));
 938         strncpy(info->fw_version, "N/A", sizeof(info->fw_version));
 939         strncpy(info->bus_info, "internal", sizeof(info->bus_info));
 940         info->n_stats = 0;
 941         info->testinfo_len = 0;
 942         info->regdump_len = 0;
 943         info->eedump_len = 0;
 944 }
 945
 946 static int nuport_mac_ethtool_get_settings(struct net_device *dev,
 947                                         struct ethtool_cmd *cmd)
 948 {
 949         struct nuport_mac_priv *priv = netdev_priv(dev);
 950
 951         if (priv->phydev)
 952                 return phy_ethtool_gset(priv->phydev, cmd);
 953
 954         return -EINVAL;
 955 }
 956
 957 static int nuport_mac_ethtool_set_settings(struct net_device *dev,
 958                                         struct ethtool_cmd *cmd)
 959 {
 960         struct nuport_mac_priv *priv = netdev_priv(dev);
 961
 962         if (priv->phydev)
 963                 return phy_ethtool_sset(priv->phydev, cmd);
 964
 965         return -EINVAL;
 966 }
 967
 968 static void nuport_mac_set_msglevel(struct net_device *dev, u32 msg_level)
 969 {
 970         struct nuport_mac_priv *priv = netdev_priv(dev);
 971
 972         priv->msg_level = msg_level;
 973 }
 974
 975 static u32 nuport_mac_get_msglevel(struct net_device *dev)
 976 {
 977         struct nuport_mac_priv *priv = netdev_priv(dev);
 978
 979         return priv->msg_level;
 980 }
 981
 982 static const struct ethtool_ops nuport_mac_ethtool_ops = {
 983         .get_drvinfo            = nuport_mac_ethtool_drvinfo,
 984         .get_link               = ethtool_op_get_link,
 985         .get_settings           = nuport_mac_ethtool_get_settings,
 986         .set_settings           = nuport_mac_ethtool_set_settings,
 987         .set_msglevel           = nuport_mac_set_msglevel,
 988         .get_msglevel           = nuport_mac_get_msglevel,
 989 };
 990
 991 static const struct net_device_ops nuport_mac_ops = {
 992         .ndo_open               = nuport_mac_open,
 993         .ndo_stop               = nuport_mac_close,
 994         .ndo_start_xmit         = nuport_mac_start_xmit,
 995         .ndo_change_mtu         = eth_change_mtu,
 996         .ndo_validate_addr      = eth_validate_addr,
 997         .ndo_set_mac_address    = nuport_mac_change_mac_address,
 998         .ndo_tx_timeout         = nuport_mac_tx_timeout,
 999 };
1000
1001 static int __init nuport_mac_probe(struct platform_device *pdev)
1002 {
1003         struct net_device *dev;
1004         struct nuport_mac_priv *priv = NULL;
1005         struct resource *regs, *dma;
1006         int ret = 0;
1007         int rx_irq, tx_irq, link_irq;
1008         int i;
1009         const unsigned int *intspec;
1010
1011         dev = alloc_etherdev(sizeof(struct nuport_mac_priv));
1012         if (!dev) {
1013                 dev_err(&pdev->dev, "no memory for net_device\n");
1014                 return -ENOMEM;
1015         }
1016
1017         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1018         dma = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1019         if (!regs || !dma) {
1020                 dev_err(&pdev->dev, "failed to get regs resources\n");
1021                 ret = -ENODEV;
1022                 goto out;
1023         }
1024
1025         rx_irq = platform_get_irq(pdev, 0);
1026         tx_irq = platform_get_irq(pdev, 1);
1027         link_irq = platform_get_irq(pdev, 2);
1028         if (rx_irq < 0 || tx_irq < 0 || link_irq < 0) {
1029                 ret = -ENODEV;
1030                 goto out;
1031         }
1032
1033         platform_set_drvdata(pdev, dev);
1034         SET_NETDEV_DEV(dev, &pdev->dev);
1035         priv = netdev_priv(dev);
1036         priv->pdev = pdev;
1037         priv->dev = dev;
1038         spin_lock_init(&priv->lock);
1039
1040         intspec = of_get_property(pdev->dev.of_node,
1041                                 "nuport-mac,buffer-shifting", NULL);
1042         if (!intspec)
1043                 priv->buffer_shifting_len = 0;
1044         else
1045                 priv->buffer_shifting_len = 2;
1046
1047         priv->mac_base = devm_request_and_ioremap(&pdev->dev, regs);
1048         if (!priv->mac_base) {
1049                 dev_err(&pdev->dev, "failed to remap regs\n");
1050                 ret = -ENOMEM;
1051                 goto out_platform;
1052         }
1053
1054         priv->dma_base = devm_request_and_ioremap(&pdev->dev, dma);
1055         if (!priv->dma_base) {
1056                 dev_err(&pdev->dev, "failed to remap dma-regs\n");
1057                 ret = -ENOMEM;
1058                 goto out_platform;
1059         }
1060
1061         priv->emac_clk = clk_get(&pdev->dev, "emac");
1062         if (IS_ERR_OR_NULL(priv->emac_clk)) {
1063                 dev_err(&pdev->dev, "failed to get emac clk\n");
1064                 ret = PTR_ERR(priv->emac_clk);
1065                 goto out_platform;
1066         }
1067
1068         priv->ephy_clk = clk_get(&pdev->dev, "ephy");
1069         if (IS_ERR_OR_NULL(priv->ephy_clk)) {
1070                 dev_err(&pdev->dev, "failed to get ephy clk\n");
1071                 ret = PTR_ERR(priv->ephy_clk);
1072                 goto out_platform;
1073         }
1074
1075         priv->link_irq = link_irq;
1076         priv->rx_irq = rx_irq;
1077         priv->tx_irq = tx_irq;
1078         priv->msg_level = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK;
1079         dev->netdev_ops = &nuport_mac_ops;
1080         dev->ethtool_ops = &nuport_mac_ethtool_ops;
1081         dev->watchdog_timeo = HZ;
1082         dev->flags = IFF_BROADCAST;     /* Supports Broadcast */
1083         dev->tx_queue_len = TX_RING_SIZE / 2;
1084
1085         netif_napi_add(dev, &priv->napi, nuport_mac_poll, 64);
1086
1087         priv->phy_node = of_parse_phandle(pdev->dev.of_node, "phy", 0);
1088         if (!priv->phy_node) {
1089                 dev_err(&pdev->dev, "no associated PHY\n");
1090                 ret = -ENODEV;
1091                 goto out;
1092         }
1093
1094         priv->phy_interface = of_get_phy_mode(pdev->dev.of_node);
1095         if (priv->phy_interface < 0) {
1096                 dev_err(&pdev->dev, "invalid PHY mode\n");
1097                 ret = -EINVAL;
1098                 goto out;
1099         }
1100
1101         priv->mii_bus = mdiobus_alloc();
1102         if (!priv->mii_bus) {
1103                 dev_err(&pdev->dev, "mii bus allocation failed\n");
1104                 goto out;
1105         }
1106
1107         priv->mii_bus->priv = dev;
1108         priv->mii_bus->read = nuport_mac_mii_read;
1109         priv->mii_bus->write = nuport_mac_mii_write;
1110         priv->mii_bus->reset = nuport_mac_mii_reset;
1111         priv->mii_bus->name = "nuport-mac-mii";
1112         priv->mii_bus->phy_mask = (1 << 0);
1113         snprintf(priv->mii_bus->id, MII_BUS_ID_SIZE, "%s", pdev->name);
1114         priv->mii_bus->irq = kzalloc(PHY_MAX_ADDR * sizeof(int), GFP_KERNEL);
1115         if (!priv->mii_bus->irq) {
1116                 dev_err(&pdev->dev, "failed to allocate mii_bus irqs\n");
1117                 ret = -ENOMEM;
1118                 goto out_mdio;
1119         }
1120
1121         /* We support PHY interrupts routed back to the MAC */
1122         for (i = 0; i < PHY_MAX_ADDR; i++)
1123                 priv->mii_bus->irq[i] = PHY_IGNORE_INTERRUPT;
1124
1125         ret = of_mdiobus_register(priv->mii_bus, pdev->dev.of_node);
1126         if (ret) {
1127                 dev_err(&pdev->dev, "failed to register mii_bus\n");
1128                 goto out_mdio_irq;
1129         }
1130
1131         ret = nuport_mac_mii_probe(dev);
1132         if (ret) {
1133                 dev_err(&pdev->dev, "failed to probe MII bus\n");
1134                 goto out_mdio_unregister;
1135         }
1136
1137         ret = register_netdev(dev);
1138         if (ret) {
1139                 dev_err(&pdev->dev, "failed to register net_device\n");
1140                 goto out_mdio_probe;
1141         }
1142
1143         /* read existing mac address */
1144         nuport_mac_read_mac_address(dev);
1145
1146         dev_info(&pdev->dev, "registered (MAC: %pM)\n", dev->dev_addr);
1147
1148         return ret;
1149
1150 out_mdio_probe:
1151         phy_disconnect(priv->phydev);
1152 out_mdio_unregister:
1153         mdiobus_unregister(priv->mii_bus);
1154 out_mdio_irq:
1155         kfree(priv->mii_bus->irq);
1156 out_mdio:
1157         mdiobus_free(priv->mii_bus);
1158 out_platform:
1159         platform_set_drvdata(pdev, NULL);
1160 out:
1161         clk_put(priv->ephy_clk);
1162         clk_put(priv->emac_clk);
1163         free_netdev(dev);
1164         platform_set_drvdata(pdev, NULL);
1165         return ret;
1166 }
1167
1168 static int nuport_mac_remove(struct platform_device *pdev)
1169 {
1170         struct net_device *dev = platform_get_drvdata(pdev);
1171         struct nuport_mac_priv *priv = netdev_priv(dev);
1172
1173         unregister_netdev(dev);
1174         phy_disconnect(priv->phydev);
1175         mdiobus_unregister(priv->mii_bus);
1176         kfree(priv->mii_bus->irq);
1177         mdiobus_free(priv->mii_bus);
1178         clk_put(priv->ephy_clk);
1179         clk_put(priv->emac_clk);
1180         free_netdev(dev);
1181
1182         platform_set_drvdata(pdev, NULL);
1183
1184         return 0;
1185 }
1186
1187 static struct of_device_id nuport_eth_ids[] __initdata = {
1188         {.compatible = "moschip,nuport-mac",},
1189         { /* sentinel */ },
1190 };
1191
1192 static struct platform_driver nuport_eth_driver = {
1193         .driver = {
1194                 .name = "nuport-mac",
1195                 .owner = THIS_MODULE,
1196                 .of_match_table = nuport_eth_ids,
1197         },
1198         .probe  = nuport_mac_probe,
1199         .remove = nuport_mac_remove,
1200 };
1201
1202 module_platform_driver(nuport_eth_driver);
1203
1204 MODULE_AUTHOR("Moschip Semiconductors Ltd.");
1205 MODULE_DESCRIPTION("Moschip MCS8140 Ethernet MAC driver");
1206 MODULE_LICENSE("GPL");