drivers/net/ethernet/faraday/ftgmac100.c

   1 /*
   2  * Faraday FTGMAC100 Gigabit Ethernet
   3  *
   4  * (C) Copyright 2009-2011 Faraday Technology
   5  * Po-Yu Chuang <ratbert@faraday-tech.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
  23
  24 #include <linux/dma-mapping.h>
  25 #include <linux/etherdevice.h>
  26 #include <linux/ethtool.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/io.h>
  29 #include <linux/module.h>
  30 #include <linux/netdevice.h>
  31 #include <linux/of.h>
  32 #include <linux/phy.h>
  33 #include <linux/platform_device.h>
  34 #include <linux/property.h>
  35 #include <net/ip.h>
  36 #include <net/ncsi.h>
  37
  38 #include "ftgmac100.h"
  39
  40 #define DRV_NAME        "ftgmac100"
  41 #define DRV_VERSION     "0.7"
  42
  43 #define RX_QUEUE_ENTRIES        256     /* must be power of 2 */
  44 #define TX_QUEUE_ENTRIES        512     /* must be power of 2 */
  45
  46 #define MAX_PKT_SIZE            1536
  47 #define RX_BUF_SIZE             MAX_PKT_SIZE    /* must be smaller than 0x3fff */
  48
  49 struct ftgmac100_descs {
  50         struct ftgmac100_rxdes rxdes[RX_QUEUE_ENTRIES];
  51         struct ftgmac100_txdes txdes[TX_QUEUE_ENTRIES];
  52 };
  53
  54 struct ftgmac100 {
  55         /* Registers */
  56         struct resource *res;
  57         void __iomem *base;
  58
  59         struct ftgmac100_descs *descs;
  60         dma_addr_t descs_dma_addr;
  61
  62         /* Rx ring */
  63         struct sk_buff *rx_skbs[RX_QUEUE_ENTRIES];
  64         unsigned int rx_pointer;
  65         u32 rxdes0_edorr_mask;
  66
  67         /* Tx ring */
  68         unsigned int tx_clean_pointer;
  69         unsigned int tx_pointer;
  70         unsigned int tx_pending;
  71         u32 txdes0_edotr_mask;
  72         spinlock_t tx_lock;
  73
  74         /* Scratch page to use when rx skb alloc fails */
  75         void *rx_scratch;
  76         dma_addr_t rx_scratch_dma;
  77
  78         /* Component structures */
  79         struct net_device *netdev;
  80         struct device *dev;
  81         struct ncsi_dev *ndev;
  82         struct napi_struct napi;
  83         struct work_struct reset_task;
  84         struct mii_bus *mii_bus;
  85
  86         /* Link management */
  87         int cur_speed;
  88         int cur_duplex;
  89         bool use_ncsi;
  90
  91         /* Misc */
  92         bool need_mac_restart;
  93 };
  94
  95 static void ftgmac100_set_rx_ring_base(struct ftgmac100 *priv, dma_addr_t addr)
  96 {
  97         iowrite32(addr, priv->base + FTGMAC100_OFFSET_RXR_BADR);
  98 }
  99
 100 static void ftgmac100_set_rx_buffer_size(struct ftgmac100 *priv,
 101                 unsigned int size)
 102 {
 103         size = FTGMAC100_RBSR_SIZE(size);
 104         iowrite32(size, priv->base + FTGMAC100_OFFSET_RBSR);
 105 }
 106
 107 static void ftgmac100_set_normal_prio_tx_ring_base(struct ftgmac100 *priv,
 108                                                    dma_addr_t addr)
 109 {
 110         iowrite32(addr, priv->base + FTGMAC100_OFFSET_NPTXR_BADR);
 111 }
 112
 113 static void ftgmac100_txdma_normal_prio_start_polling(struct ftgmac100 *priv)
 114 {
 115         iowrite32(1, priv->base + FTGMAC100_OFFSET_NPTXPD);
 116 }
 117
 118 static int ftgmac100_reset_mac(struct ftgmac100 *priv, u32 maccr)
 119 {
 120         struct net_device *netdev = priv->netdev;
 121         int i;
 122
 123         /* NOTE: reset clears all registers */
 124         iowrite32(maccr, priv->base + FTGMAC100_OFFSET_MACCR);
 125         iowrite32(maccr | FTGMAC100_MACCR_SW_RST,
 126                   priv->base + FTGMAC100_OFFSET_MACCR);
 127         for (i = 0; i < 50; i++) {
 128                 unsigned int maccr;
 129
 130                 maccr = ioread32(priv->base + FTGMAC100_OFFSET_MACCR);
 131                 if (!(maccr & FTGMAC100_MACCR_SW_RST))
 132                         return 0;
 133
 134                 udelay(1);
 135         }
 136
 137         netdev_err(netdev, "Hardware reset failed\n");
 138         return -EIO;
 139 }
 140
 141 static int ftgmac100_reset_and_config_mac(struct ftgmac100 *priv)
 142 {
 143         u32 maccr = 0;
 144
 145         switch (priv->cur_speed) {
 146         case SPEED_10:
 147         case 0: /* no link */
 148                 break;
 149
 150         case SPEED_100:
 151                 maccr |= FTGMAC100_MACCR_FAST_MODE;
 152                 break;
 153
 154         case SPEED_1000:
 155                 maccr |= FTGMAC100_MACCR_GIGA_MODE;
 156                 break;
 157         default:
 158                 netdev_err(priv->netdev, "Unknown speed %d !\n",
 159                            priv->cur_speed);
 160                 break;
 161         }
 162
 163         /* (Re)initialize the queue pointers */
 164         priv->rx_pointer = 0;
 165         priv->tx_clean_pointer = 0;
 166         priv->tx_pointer = 0;
 167         priv->tx_pending = 0;
 168
 169         /* The doc says reset twice with 10us interval */
 170         if (ftgmac100_reset_mac(priv, maccr))
 171                 return -EIO;
 172         usleep_range(10, 1000);
 173         return ftgmac100_reset_mac(priv, maccr);
 174 }
 175
 176 static void ftgmac100_set_mac(struct ftgmac100 *priv, const unsigned char *mac)
 177 {
 178         unsigned int maddr = mac[0] << 8 | mac[1];
 179         unsigned int laddr = mac[2] << 24 | mac[3] << 16 | mac[4] << 8 | mac[5];
 180
 181         iowrite32(maddr, priv->base + FTGMAC100_OFFSET_MAC_MADR);
 182         iowrite32(laddr, priv->base + FTGMAC100_OFFSET_MAC_LADR);
 183 }
 184
 185 static void ftgmac100_setup_mac(struct ftgmac100 *priv)
 186 {
 187         u8 mac[ETH_ALEN];
 188         unsigned int m;
 189         unsigned int l;
 190         void *addr;
 191
 192         addr = device_get_mac_address(priv->dev, mac, ETH_ALEN);
 193         if (addr) {
 194                 ether_addr_copy(priv->netdev->dev_addr, mac);
 195                 dev_info(priv->dev, "Read MAC address %pM from device tree\n",
 196                          mac);
 197                 return;
 198         }
 199
 200         m = ioread32(priv->base + FTGMAC100_OFFSET_MAC_MADR);
 201         l = ioread32(priv->base + FTGMAC100_OFFSET_MAC_LADR);
 202
 203         mac[0] = (m >> 8) & 0xff;
 204         mac[1] = m & 0xff;
 205         mac[2] = (l >> 24) & 0xff;
 206         mac[3] = (l >> 16) & 0xff;
 207         mac[4] = (l >> 8) & 0xff;
 208         mac[5] = l & 0xff;
 209
 210         if (is_valid_ether_addr(mac)) {
 211                 ether_addr_copy(priv->netdev->dev_addr, mac);
 212                 dev_info(priv->dev, "Read MAC address %pM from chip\n", mac);
 213         } else {
 214                 eth_hw_addr_random(priv->netdev);
 215                 dev_info(priv->dev, "Generated random MAC address %pM\n",
 216                          priv->netdev->dev_addr);
 217         }
 218 }
 219
 220 static int ftgmac100_set_mac_addr(struct net_device *dev, void *p)
 221 {
 222         int ret;
 223
 224         ret = eth_prepare_mac_addr_change(dev, p);
 225         if (ret < 0)
 226                 return ret;
 227
 228         eth_commit_mac_addr_change(dev, p);
 229         ftgmac100_set_mac(netdev_priv(dev), dev->dev_addr);
 230
 231         return 0;
 232 }
 233
 234 static void ftgmac100_init_hw(struct ftgmac100 *priv)
 235 {
 236         /* setup ring buffer base registers */
 237         ftgmac100_set_rx_ring_base(priv,
 238                                    priv->descs_dma_addr +
 239                                    offsetof(struct ftgmac100_descs, rxdes));
 240         ftgmac100_set_normal_prio_tx_ring_base(priv,
 241                                                priv->descs_dma_addr +
 242                                                offsetof(struct ftgmac100_descs, txdes));
 243
 244         ftgmac100_set_rx_buffer_size(priv, RX_BUF_SIZE);
 245
 246         iowrite32(FTGMAC100_APTC_RXPOLL_CNT(1), priv->base + FTGMAC100_OFFSET_APTC);
 247
 248         ftgmac100_set_mac(priv, priv->netdev->dev_addr);
 249 }
 250
 251 static void ftgmac100_start_hw(struct ftgmac100 *priv)
 252 {
 253         u32 maccr = ioread32(priv->base + FTGMAC100_OFFSET_MACCR);
 254
 255         /* Keep the original GMAC and FAST bits */
 256         maccr &= (FTGMAC100_MACCR_FAST_MODE | FTGMAC100_MACCR_GIGA_MODE);
 257
 258         /* Add all the main enable bits */
 259         maccr |= FTGMAC100_MACCR_TXDMA_EN       |
 260                  FTGMAC100_MACCR_RXDMA_EN       |
 261                  FTGMAC100_MACCR_TXMAC_EN       |
 262                  FTGMAC100_MACCR_RXMAC_EN       |
 263                  FTGMAC100_MACCR_CRC_APD        |
 264                  FTGMAC100_MACCR_PHY_LINK_LEVEL |
 265                  FTGMAC100_MACCR_RX_RUNT        |
 266                  FTGMAC100_MACCR_RX_BROADPKT;
 267
 268         /* Add other bits as needed */
 269         if (priv->cur_duplex == DUPLEX_FULL)
 270                 maccr |= FTGMAC100_MACCR_FULLDUP;
 271
 272         /* Hit the HW */
 273         iowrite32(maccr, priv->base + FTGMAC100_OFFSET_MACCR);
 274 }
 275
 276 static void ftgmac100_stop_hw(struct ftgmac100 *priv)
 277 {
 278         iowrite32(0, priv->base + FTGMAC100_OFFSET_MACCR);
 279 }
 280
 281 static int ftgmac100_alloc_rx_buf(struct ftgmac100 *priv, unsigned int entry,
 282                                   struct ftgmac100_rxdes *rxdes, gfp_t gfp)
 283 {
 284         struct net_device *netdev = priv->netdev;
 285         struct sk_buff *skb;
 286         dma_addr_t map;
 287         int err;
 288
 289         skb = netdev_alloc_skb_ip_align(netdev, RX_BUF_SIZE);
 290         if (unlikely(!skb)) {
 291                 if (net_ratelimit())
 292                         netdev_warn(netdev, "failed to allocate rx skb\n");
 293                 err = -ENOMEM;
 294                 map = priv->rx_scratch_dma;
 295         } else {
 296                 map = dma_map_single(priv->dev, skb->data, RX_BUF_SIZE,
 297                                      DMA_FROM_DEVICE);
 298                 if (unlikely(dma_mapping_error(priv->dev, map))) {
 299                         if (net_ratelimit())
 300                                 netdev_err(netdev, "failed to map rx page\n");
 301                         dev_kfree_skb_any(skb);
 302                         map = priv->rx_scratch_dma;
 303                         skb = NULL;
 304                         err = -ENOMEM;
 305                 }
 306         }
 307
 308         /* Store skb */
 309         priv->rx_skbs[entry] = skb;
 310
 311         /* Store DMA address into RX desc */
 312         rxdes->rxdes3 = cpu_to_le32(map);
 313
 314         /* Ensure the above is ordered vs clearing the OWN bit */
 315         dma_wmb();
 316
 317         /* Clean status (which resets own bit) */
 318         if (entry == (RX_QUEUE_ENTRIES - 1))
 319                 rxdes->rxdes0 = cpu_to_le32(priv->rxdes0_edorr_mask);
 320         else
 321                 rxdes->rxdes0 = 0;
 322
 323         return 0;
 324 }
 325
 326 static int ftgmac100_next_rx_pointer(int pointer)
 327 {
 328         return (pointer + 1) & (RX_QUEUE_ENTRIES - 1);
 329 }
 330
 331 static void ftgmac100_rx_packet_error(struct ftgmac100 *priv, u32 status)
 332 {
 333         struct net_device *netdev = priv->netdev;
 334
 335         if (status & FTGMAC100_RXDES0_RX_ERR)
 336                 netdev->stats.rx_errors++;
 337
 338         if (status & FTGMAC100_RXDES0_CRC_ERR)
 339                 netdev->stats.rx_crc_errors++;
 340
 341         if (status & (FTGMAC100_RXDES0_FTL |
 342                       FTGMAC100_RXDES0_RUNT |
 343                       FTGMAC100_RXDES0_RX_ODD_NB))
 344                 netdev->stats.rx_length_errors++;
 345 }
 346
 347 static bool ftgmac100_rx_packet(struct ftgmac100 *priv, int *processed)
 348 {
 349         struct net_device *netdev = priv->netdev;
 350         struct ftgmac100_rxdes *rxdes;
 351         struct sk_buff *skb;
 352         unsigned int pointer, size;
 353         u32 status, csum_vlan;
 354         dma_addr_t map;
 355
 356         /* Grab next RX descriptor */
 357         pointer = priv->rx_pointer;
 358         rxdes = &priv->descs->rxdes[pointer];
 359
 360         /* Grab descriptor status */
 361         status = le32_to_cpu(rxdes->rxdes0);
 362
 363         /* Do we have a packet ? */
 364         if (!(status & FTGMAC100_RXDES0_RXPKT_RDY))
 365                 return false;
 366
 367         /* Order subsequent reads with the test for the ready bit */
 368         dma_rmb();
 369
 370         /* We don't cope with fragmented RX packets */
 371         if (unlikely(!(status & FTGMAC100_RXDES0_FRS) ||
 372                      !(status & FTGMAC100_RXDES0_LRS)))
 373                 goto drop;
 374
 375         /* Grab received size and csum vlan field in the descriptor */
 376         size = status & FTGMAC100_RXDES0_VDBC;
 377         csum_vlan = le32_to_cpu(rxdes->rxdes1);
 378
 379         /* Any error (other than csum offload) flagged ? */
 380         if (unlikely(status & RXDES0_ANY_ERROR)) {
 381                 /* Correct for incorrect flagging of runt packets
 382                  * with vlan tags... Just accept a runt packet that
 383                  * has been flagged as vlan and whose size is at
 384                  * least 60 bytes.
 385                  */
 386                 if ((status & FTGMAC100_RXDES0_RUNT) &&
 387                     (csum_vlan & FTGMAC100_RXDES1_VLANTAG_AVAIL) &&
 388                     (size >= 60))
 389                         status &= ~FTGMAC100_RXDES0_RUNT;
 390
 391                 /* Any error still in there ? */
 392                 if (status & RXDES0_ANY_ERROR) {
 393                         ftgmac100_rx_packet_error(priv, status);
 394                         goto drop;
 395                 }
 396         }
 397
 398         /* If the packet had no skb (failed to allocate earlier)
 399          * then try to allocate one and skip
 400          */
 401         skb = priv->rx_skbs[pointer];
 402         if (!unlikely(skb)) {
 403                 ftgmac100_alloc_rx_buf(priv, pointer, rxdes, GFP_ATOMIC);
 404                 goto drop;
 405         }
 406
 407         if (unlikely(status & FTGMAC100_RXDES0_MULTICAST))
 408                 netdev->stats.multicast++;
 409
 410         /* If the HW found checksum errors, bounce it to software.
 411          *
 412          * If we didn't, we need to see if the packet was recognized
 413          * by HW as one of the supported checksummed protocols before
 414          * we accept the HW test results.
 415          */
 416         if (netdev->features & NETIF_F_RXCSUM) {
 417                 u32 err_bits = FTGMAC100_RXDES1_TCP_CHKSUM_ERR |
 418                         FTGMAC100_RXDES1_UDP_CHKSUM_ERR |
 419                         FTGMAC100_RXDES1_IP_CHKSUM_ERR;
 420                 if ((csum_vlan & err_bits) ||
 421                     !(csum_vlan & FTGMAC100_RXDES1_PROT_MASK))
 422                         skb->ip_summed = CHECKSUM_NONE;
 423                 else
 424                         skb->ip_summed = CHECKSUM_UNNECESSARY;
 425         }
 426
 427         /* Transfer received size to skb */
 428         skb_put(skb, size);
 429
 430         /* Tear down DMA mapping, do necessary cache management */
 431         map = le32_to_cpu(rxdes->rxdes3);
 432
 433 #if defined(CONFIG_ARM) && !defined(CONFIG_ARM_DMA_USE_IOMMU)
 434         /* When we don't have an iommu, we can save cycles by not
 435          * invalidating the cache for the part of the packet that
 436          * wasn't received.
 437          */
 438         dma_unmap_single(priv->dev, map, size, DMA_FROM_DEVICE);
 439 #else
 440         dma_unmap_single(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
 441 #endif
 442
 443
 444         /* Resplenish rx ring */
 445         ftgmac100_alloc_rx_buf(priv, pointer, rxdes, GFP_ATOMIC);
 446         priv->rx_pointer = ftgmac100_next_rx_pointer(pointer);
 447
 448         skb->protocol = eth_type_trans(skb, netdev);
 449
 450         netdev->stats.rx_packets++;
 451         netdev->stats.rx_bytes += size;
 452
 453         /* push packet to protocol stack */
 454         if (skb->ip_summed == CHECKSUM_NONE)
 455                 netif_receive_skb(skb);
 456         else
 457                 napi_gro_receive(&priv->napi, skb);
 458
 459         (*processed)++;
 460         return true;
 461
 462  drop:
 463         /* Clean rxdes0 (which resets own bit) */
 464         rxdes->rxdes0 = cpu_to_le32(status & priv->rxdes0_edorr_mask);
 465         priv->rx_pointer = ftgmac100_next_rx_pointer(pointer);
 466         netdev->stats.rx_dropped++;
 467         return true;
 468 }
 469
 470 static void ftgmac100_txdes_reset(const struct ftgmac100 *priv,
 471                                   struct ftgmac100_txdes *txdes)
 472 {
 473         /* clear all except end of ring bit */
 474         txdes->txdes0 &= cpu_to_le32(priv->txdes0_edotr_mask);
 475         txdes->txdes1 = 0;
 476         txdes->txdes2 = 0;
 477         txdes->txdes3 = 0;
 478 }
 479
 480 static bool ftgmac100_txdes_owned_by_dma(struct ftgmac100_txdes *txdes)
 481 {
 482         return txdes->txdes0 & cpu_to_le32(FTGMAC100_TXDES0_TXDMA_OWN);
 483 }
 484
 485 static void ftgmac100_txdes_set_dma_own(struct ftgmac100_txdes *txdes)
 486 {
 487         /*
 488          * Make sure dma own bit will not be set before any other
 489          * descriptor fields.
 490          */
 491         wmb();
 492         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_TXDMA_OWN);
 493 }
 494
 495 static void ftgmac100_txdes_set_end_of_ring(const struct ftgmac100 *priv,
 496                                             struct ftgmac100_txdes *txdes)
 497 {
 498         txdes->txdes0 |= cpu_to_le32(priv->txdes0_edotr_mask);
 499 }
 500
 501 static void ftgmac100_txdes_set_first_segment(struct ftgmac100_txdes *txdes)
 502 {
 503         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_FTS);
 504 }
 505
 506 static void ftgmac100_txdes_set_last_segment(struct ftgmac100_txdes *txdes)
 507 {
 508         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_LTS);
 509 }
 510
 511 static void ftgmac100_txdes_set_buffer_size(struct ftgmac100_txdes *txdes,
 512                                             unsigned int len)
 513 {
 514         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_TXBUF_SIZE(len));
 515 }
 516
 517 static void ftgmac100_txdes_set_txint(struct ftgmac100_txdes *txdes)
 518 {
 519         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_TXIC);
 520 }
 521
 522 static void ftgmac100_txdes_set_tcpcs(struct ftgmac100_txdes *txdes)
 523 {
 524         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_TCP_CHKSUM);
 525 }
 526
 527 static void ftgmac100_txdes_set_udpcs(struct ftgmac100_txdes *txdes)
 528 {
 529         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_UDP_CHKSUM);
 530 }
 531
 532 static void ftgmac100_txdes_set_ipcs(struct ftgmac100_txdes *txdes)
 533 {
 534         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_IP_CHKSUM);
 535 }
 536
 537 static void ftgmac100_txdes_set_dma_addr(struct ftgmac100_txdes *txdes,
 538                                          dma_addr_t addr)
 539 {
 540         txdes->txdes3 = cpu_to_le32(addr);
 541 }
 542
 543 static dma_addr_t ftgmac100_txdes_get_dma_addr(struct ftgmac100_txdes *txdes)
 544 {
 545         return le32_to_cpu(txdes->txdes3);
 546 }
 547
 548 /*
 549  * txdes2 is not used by hardware. We use it to keep track of socket buffer.
 550  * Since hardware does not touch it, we can skip cpu_to_le32()/le32_to_cpu().
 551  */
 552 static void ftgmac100_txdes_set_skb(struct ftgmac100_txdes *txdes,
 553                                     struct sk_buff *skb)
 554 {
 555         txdes->txdes2 = (unsigned int)skb;
 556 }
 557
 558 static struct sk_buff *ftgmac100_txdes_get_skb(struct ftgmac100_txdes *txdes)
 559 {
 560         return (struct sk_buff *)txdes->txdes2;
 561 }
 562
 563 static int ftgmac100_next_tx_pointer(int pointer)
 564 {
 565         return (pointer + 1) & (TX_QUEUE_ENTRIES - 1);
 566 }
 567
 568 static void ftgmac100_tx_pointer_advance(struct ftgmac100 *priv)
 569 {
 570         priv->tx_pointer = ftgmac100_next_tx_pointer(priv->tx_pointer);
 571 }
 572
 573 static void ftgmac100_tx_clean_pointer_advance(struct ftgmac100 *priv)
 574 {
 575         priv->tx_clean_pointer = ftgmac100_next_tx_pointer(priv->tx_clean_pointer);
 576 }
 577
 578 static struct ftgmac100_txdes *ftgmac100_current_txdes(struct ftgmac100 *priv)
 579 {
 580         return &priv->descs->txdes[priv->tx_pointer];
 581 }
 582
 583 static struct ftgmac100_txdes *
 584 ftgmac100_current_clean_txdes(struct ftgmac100 *priv)
 585 {
 586         return &priv->descs->txdes[priv->tx_clean_pointer];
 587 }
 588
 589 static bool ftgmac100_tx_complete_packet(struct ftgmac100 *priv)
 590 {
 591         struct net_device *netdev = priv->netdev;
 592         struct ftgmac100_txdes *txdes;
 593         struct sk_buff *skb;
 594         dma_addr_t map;
 595
 596         if (priv->tx_pending == 0)
 597                 return false;
 598
 599         txdes = ftgmac100_current_clean_txdes(priv);
 600
 601         if (ftgmac100_txdes_owned_by_dma(txdes))
 602                 return false;
 603
 604         skb = ftgmac100_txdes_get_skb(txdes);
 605         map = ftgmac100_txdes_get_dma_addr(txdes);
 606
 607         netdev->stats.tx_packets++;
 608         netdev->stats.tx_bytes += skb->len;
 609
 610         dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
 611
 612         dev_kfree_skb(skb);
 613
 614         ftgmac100_txdes_reset(priv, txdes);
 615
 616         ftgmac100_tx_clean_pointer_advance(priv);
 617
 618         spin_lock(&priv->tx_lock);
 619         priv->tx_pending--;
 620         spin_unlock(&priv->tx_lock);
 621         netif_wake_queue(netdev);
 622
 623         return true;
 624 }
 625
 626 static void ftgmac100_tx_complete(struct ftgmac100 *priv)
 627 {
 628         while (ftgmac100_tx_complete_packet(priv))
 629                 ;
 630 }
 631
 632 static int ftgmac100_xmit(struct ftgmac100 *priv, struct sk_buff *skb,
 633                           dma_addr_t map)
 634 {
 635         struct net_device *netdev = priv->netdev;
 636         struct ftgmac100_txdes *txdes;
 637         unsigned int len = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
 638
 639         txdes = ftgmac100_current_txdes(priv);
 640         ftgmac100_tx_pointer_advance(priv);
 641
 642         /* setup TX descriptor */
 643         ftgmac100_txdes_set_skb(txdes, skb);
 644         ftgmac100_txdes_set_dma_addr(txdes, map);
 645         ftgmac100_txdes_set_buffer_size(txdes, len);
 646
 647         ftgmac100_txdes_set_first_segment(txdes);
 648         ftgmac100_txdes_set_last_segment(txdes);
 649         ftgmac100_txdes_set_txint(txdes);
 650         if (skb->ip_summed == CHECKSUM_PARTIAL) {
 651                 __be16 protocol = skb->protocol;
 652
 653                 if (protocol == cpu_to_be16(ETH_P_IP)) {
 654                         u8 ip_proto = ip_hdr(skb)->protocol;
 655
 656                         ftgmac100_txdes_set_ipcs(txdes);
 657                         if (ip_proto == IPPROTO_TCP)
 658                                 ftgmac100_txdes_set_tcpcs(txdes);
 659                         else if (ip_proto == IPPROTO_UDP)
 660                                 ftgmac100_txdes_set_udpcs(txdes);
 661                 }
 662         }
 663
 664         spin_lock(&priv->tx_lock);
 665         priv->tx_pending++;
 666         if (priv->tx_pending == TX_QUEUE_ENTRIES)
 667                 netif_stop_queue(netdev);
 668
 669         /* start transmit */
 670         ftgmac100_txdes_set_dma_own(txdes);
 671         spin_unlock(&priv->tx_lock);
 672
 673         ftgmac100_txdma_normal_prio_start_polling(priv);
 674
 675         return NETDEV_TX_OK;
 676 }
 677
 678 static int ftgmac100_hard_start_xmit(struct sk_buff *skb,
 679                                      struct net_device *netdev)
 680 {
 681         struct ftgmac100 *priv = netdev_priv(netdev);
 682         dma_addr_t map;
 683
 684         if (unlikely(skb->len > MAX_PKT_SIZE)) {
 685                 if (net_ratelimit())
 686                         netdev_dbg(netdev, "tx packet too big\n");
 687
 688                 netdev->stats.tx_dropped++;
 689                 kfree_skb(skb);
 690                 return NETDEV_TX_OK;
 691         }
 692
 693         map = dma_map_single(priv->dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE);
 694         if (unlikely(dma_mapping_error(priv->dev, map))) {
 695                 /* drop packet */
 696                 if (net_ratelimit())
 697                         netdev_err(netdev, "map socket buffer failed\n");
 698
 699                 netdev->stats.tx_dropped++;
 700                 kfree_skb(skb);
 701                 return NETDEV_TX_OK;
 702         }
 703
 704         return ftgmac100_xmit(priv, skb, map);
 705 }
 706
 707 static void ftgmac100_free_buffers(struct ftgmac100 *priv)
 708 {
 709         int i;
 710
 711         /* Free all RX buffers */
 712         for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
 713                 struct ftgmac100_rxdes *rxdes = &priv->descs->rxdes[i];
 714                 struct sk_buff *skb = priv->rx_skbs[i];
 715                 dma_addr_t map = le32_to_cpu(rxdes->rxdes3);
 716
 717                 if (!skb)
 718                         continue;
 719
 720                 priv->rx_skbs[i] = NULL;
 721                 dma_unmap_single(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
 722                 dev_kfree_skb_any(skb);
 723         }
 724
 725         /* Free all TX buffers */
 726         for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
 727                 struct ftgmac100_txdes *txdes = &priv->descs->txdes[i];
 728                 struct sk_buff *skb = ftgmac100_txdes_get_skb(txdes);
 729                 dma_addr_t map = ftgmac100_txdes_get_dma_addr(txdes);
 730
 731                 if (!skb)
 732                         continue;
 733
 734                 dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
 735                 kfree_skb(skb);
 736         }
 737 }
 738
 739 static void ftgmac100_free_rings(struct ftgmac100 *priv)
 740 {
 741         /* Free descriptors */
 742         if (priv->descs)
 743                 dma_free_coherent(priv->dev, sizeof(struct ftgmac100_descs),
 744                                   priv->descs, priv->descs_dma_addr);
 745
 746         /* Free scratch packet buffer */
 747         if (priv->rx_scratch)
 748                 dma_free_coherent(priv->dev, RX_BUF_SIZE,
 749                                   priv->rx_scratch, priv->rx_scratch_dma);
 750 }
 751
 752 static int ftgmac100_alloc_rings(struct ftgmac100 *priv)
 753 {
 754         /* Allocate descriptors */
 755         priv->descs = dma_zalloc_coherent(priv->dev,
 756                                           sizeof(struct ftgmac100_descs),
 757                                           &priv->descs_dma_addr, GFP_KERNEL);
 758         if (!priv->descs)
 759                 return -ENOMEM;
 760
 761         /* Allocate scratch packet buffer */
 762         priv->rx_scratch = dma_alloc_coherent(priv->dev,
 763                                               RX_BUF_SIZE,
 764                                               &priv->rx_scratch_dma,
 765                                               GFP_KERNEL);
 766         if (!priv->rx_scratch)
 767                 return -ENOMEM;
 768
 769         return 0;
 770 }
 771
 772 static void ftgmac100_init_rings(struct ftgmac100 *priv)
 773 {
 774         struct ftgmac100_rxdes *rxdes;
 775         int i;
 776
 777         /* Initialize RX ring */
 778         for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
 779                 rxdes = &priv->descs->rxdes[i];
 780                 rxdes->rxdes0 = 0;
 781                 rxdes->rxdes3 = cpu_to_le32(priv->rx_scratch_dma);
 782         }
 783         /* Mark the end of the ring */
 784         rxdes->rxdes0 |= cpu_to_le32(priv->rxdes0_edorr_mask);
 785
 786         /* Initialize TX ring */
 787         for (i = 0; i < TX_QUEUE_ENTRIES; i++)
 788                 priv->descs->txdes[i].txdes0 = 0;
 789         ftgmac100_txdes_set_end_of_ring(priv, &priv->descs->txdes[i -1]);
 790 }
 791
 792 static int ftgmac100_alloc_rx_buffers(struct ftgmac100 *priv)
 793 {
 794         int i;
 795
 796         for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
 797                 struct ftgmac100_rxdes *rxdes = &priv->descs->rxdes[i];
 798
 799                 if (ftgmac100_alloc_rx_buf(priv, i, rxdes, GFP_KERNEL))
 800                         return -ENOMEM;
 801         }
 802         return 0;
 803 }
 804
 805 static void ftgmac100_adjust_link(struct net_device *netdev)
 806 {
 807         struct ftgmac100 *priv = netdev_priv(netdev);
 808         struct phy_device *phydev = netdev->phydev;
 809         int new_speed;
 810
 811         /* We store "no link" as speed 0 */
 812         if (!phydev->link)
 813                 new_speed = 0;
 814         else
 815                 new_speed = phydev->speed;
 816
 817         if (phydev->speed == priv->cur_speed &&
 818             phydev->duplex == priv->cur_duplex)
 819                 return;
 820
 821         /* Print status if we have a link or we had one and just lost it,
 822          * don't print otherwise.
 823          */
 824         if (new_speed || priv->cur_speed)
 825                 phy_print_status(phydev);
 826
 827         priv->cur_speed = new_speed;
 828         priv->cur_duplex = phydev->duplex;
 829
 830         /* Link is down, do nothing else */
 831         if (!new_speed)
 832                 return;
 833
 834         /* Disable all interrupts */
 835         iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
 836
 837         /* Reset the adapter asynchronously */
 838         schedule_work(&priv->reset_task);
 839 }
 840
 841 static int ftgmac100_mii_probe(struct ftgmac100 *priv)
 842 {
 843         struct net_device *netdev = priv->netdev;
 844         struct phy_device *phydev;
 845
 846         phydev = phy_find_first(priv->mii_bus);
 847         if (!phydev) {
 848                 netdev_info(netdev, "%s: no PHY found\n", netdev->name);
 849                 return -ENODEV;
 850         }
 851
 852         phydev = phy_connect(netdev, phydev_name(phydev),
 853                              &ftgmac100_adjust_link, PHY_INTERFACE_MODE_GMII);
 854
 855         if (IS_ERR(phydev)) {
 856                 netdev_err(netdev, "%s: Could not attach to PHY\n", netdev->name);
 857                 return PTR_ERR(phydev);
 858         }
 859
 860         return 0;
 861 }
 862
 863 static int ftgmac100_mdiobus_read(struct mii_bus *bus, int phy_addr, int regnum)
 864 {
 865         struct net_device *netdev = bus->priv;
 866         struct ftgmac100 *priv = netdev_priv(netdev);
 867         unsigned int phycr;
 868         int i;
 869
 870         phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
 871
 872         /* preserve MDC cycle threshold */
 873         phycr &= FTGMAC100_PHYCR_MDC_CYCTHR_MASK;
 874
 875         phycr |= FTGMAC100_PHYCR_PHYAD(phy_addr) |
 876                  FTGMAC100_PHYCR_REGAD(regnum) |
 877                  FTGMAC100_PHYCR_MIIRD;
 878
 879         iowrite32(phycr, priv->base + FTGMAC100_OFFSET_PHYCR);
 880
 881         for (i = 0; i < 10; i++) {
 882                 phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
 883
 884                 if ((phycr & FTGMAC100_PHYCR_MIIRD) == 0) {
 885                         int data;
 886
 887                         data = ioread32(priv->base + FTGMAC100_OFFSET_PHYDATA);
 888                         return FTGMAC100_PHYDATA_MIIRDATA(data);
 889                 }
 890
 891                 udelay(100);
 892         }
 893
 894         netdev_err(netdev, "mdio read timed out\n");
 895         return -EIO;
 896 }
 897
 898 static int ftgmac100_mdiobus_write(struct mii_bus *bus, int phy_addr,
 899                                    int regnum, u16 value)
 900 {
 901         struct net_device *netdev = bus->priv;
 902         struct ftgmac100 *priv = netdev_priv(netdev);
 903         unsigned int phycr;
 904         int data;
 905         int i;
 906
 907         phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
 908
 909         /* preserve MDC cycle threshold */
 910         phycr &= FTGMAC100_PHYCR_MDC_CYCTHR_MASK;
 911
 912         phycr |= FTGMAC100_PHYCR_PHYAD(phy_addr) |
 913                  FTGMAC100_PHYCR_REGAD(regnum) |
 914                  FTGMAC100_PHYCR_MIIWR;
 915
 916         data = FTGMAC100_PHYDATA_MIIWDATA(value);
 917
 918         iowrite32(data, priv->base + FTGMAC100_OFFSET_PHYDATA);
 919         iowrite32(phycr, priv->base + FTGMAC100_OFFSET_PHYCR);
 920
 921         for (i = 0; i < 10; i++) {
 922                 phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
 923
 924                 if ((phycr & FTGMAC100_PHYCR_MIIWR) == 0)
 925                         return 0;
 926
 927                 udelay(100);
 928         }
 929
 930         netdev_err(netdev, "mdio write timed out\n");
 931         return -EIO;
 932 }
 933
 934 static void ftgmac100_get_drvinfo(struct net_device *netdev,
 935                                   struct ethtool_drvinfo *info)
 936 {
 937         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
 938         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
 939         strlcpy(info->bus_info, dev_name(&netdev->dev), sizeof(info->bus_info));
 940 }
 941
 942 static const struct ethtool_ops ftgmac100_ethtool_ops = {
 943         .get_drvinfo            = ftgmac100_get_drvinfo,
 944         .get_link               = ethtool_op_get_link,
 945         .get_link_ksettings     = phy_ethtool_get_link_ksettings,
 946         .set_link_ksettings     = phy_ethtool_set_link_ksettings,
 947 };
 948
 949 static irqreturn_t ftgmac100_interrupt(int irq, void *dev_id)
 950 {
 951         struct net_device *netdev = dev_id;
 952         struct ftgmac100 *priv = netdev_priv(netdev);
 953         unsigned int status, new_mask = FTGMAC100_INT_BAD;
 954
 955         /* Fetch and clear interrupt bits, process abnormal ones */
 956         status = ioread32(priv->base + FTGMAC100_OFFSET_ISR);
 957         iowrite32(status, priv->base + FTGMAC100_OFFSET_ISR);
 958         if (unlikely(status & FTGMAC100_INT_BAD)) {
 959
 960                 /* RX buffer unavailable */
 961                 if (status & FTGMAC100_INT_NO_RXBUF)
 962                         netdev->stats.rx_over_errors++;
 963
 964                 /* received packet lost due to RX FIFO full */
 965                 if (status & FTGMAC100_INT_RPKT_LOST)
 966                         netdev->stats.rx_fifo_errors++;
 967
 968                 /* sent packet lost due to excessive TX collision */
 969                 if (status & FTGMAC100_INT_XPKT_LOST)
 970                         netdev->stats.tx_fifo_errors++;
 971
 972                 /* AHB error -> Reset the chip */
 973                 if (status & FTGMAC100_INT_AHB_ERR) {
 974                         if (net_ratelimit())
 975                                 netdev_warn(netdev,
 976                                            "AHB bus error ! Resetting chip.\n");
 977                         iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
 978                         schedule_work(&priv->reset_task);
 979                         return IRQ_HANDLED;
 980                 }
 981
 982                 /* We may need to restart the MAC after such errors, delay
 983                  * this until after we have freed some Rx buffers though
 984                  */
 985                 priv->need_mac_restart = true;
 986
 987                 /* Disable those errors until we restart */
 988                 new_mask &= ~status;
 989         }
 990
 991         /* Only enable "bad" interrupts while NAPI is on */
 992         iowrite32(new_mask, priv->base + FTGMAC100_OFFSET_IER);
 993
 994         /* Schedule NAPI bh */
 995         napi_schedule_irqoff(&priv->napi);
 996
 997         return IRQ_HANDLED;
 998 }
 999
1000 static bool ftgmac100_check_rx(struct ftgmac100 *priv)
1001 {
1002         struct ftgmac100_rxdes *rxdes = &priv->descs->rxdes[priv->rx_pointer];
1003
1004         /* Do we have a packet ? */
1005         return !!(rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_RXPKT_RDY));
1006 }
1007
1008 static int ftgmac100_poll(struct napi_struct *napi, int budget)
1009 {
1010         struct ftgmac100 *priv = container_of(napi, struct ftgmac100, napi);
1011         bool more, completed = true;
1012         int rx = 0;
1013
1014         ftgmac100_tx_complete(priv);
1015
1016         do {
1017                 more = ftgmac100_rx_packet(priv, &rx);
1018         } while (more && rx < budget);
1019
1020         if (more && rx == budget)
1021                 completed = false;
1022
1023
1024         /* The interrupt is telling us to kick the MAC back to life
1025          * after an RX overflow
1026          */
1027         if (unlikely(priv->need_mac_restart)) {
1028                 ftgmac100_start_hw(priv);
1029
1030                 /* Re-enable "bad" interrupts */
1031                 iowrite32(FTGMAC100_INT_BAD,
1032                           priv->base + FTGMAC100_OFFSET_IER);
1033         }
1034
1035         /* Keep NAPI going if we have still packets to reclaim */
1036         if (priv->tx_pending)
1037                 return budget;
1038
1039         if (completed) {
1040                 /* We are about to re-enable all interrupts. However
1041                  * the HW has been latching RX/TX packet interrupts while
1042                  * they were masked. So we clear them first, then we need
1043                  * to re-check if there's something to process
1044                  */
1045                 iowrite32(FTGMAC100_INT_RXTX,
1046                           priv->base + FTGMAC100_OFFSET_ISR);
1047                 if (ftgmac100_check_rx(priv) || priv->tx_pending)
1048                         return budget;
1049
1050                 /* deschedule NAPI */
1051                 napi_complete(napi);
1052
1053                 /* enable all interrupts */
1054                 iowrite32(FTGMAC100_INT_ALL,
1055                           priv->base + FTGMAC100_OFFSET_IER);
1056         }
1057
1058         return rx;
1059 }
1060
1061 static int ftgmac100_init_all(struct ftgmac100 *priv, bool ignore_alloc_err)
1062 {
1063         int err = 0;
1064
1065         /* Re-init descriptors (adjust queue sizes) */
1066         ftgmac100_init_rings(priv);
1067
1068         /* Realloc rx descriptors */
1069         err = ftgmac100_alloc_rx_buffers(priv);
1070         if (err && !ignore_alloc_err)
1071                 return err;
1072
1073         /* Reinit and restart HW */
1074         ftgmac100_init_hw(priv);
1075         ftgmac100_start_hw(priv);
1076
1077         /* Re-enable the device */
1078         napi_enable(&priv->napi);
1079         netif_start_queue(priv->netdev);
1080
1081         /* Enable all interrupts */
1082         iowrite32(FTGMAC100_INT_ALL, priv->base + FTGMAC100_OFFSET_IER);
1083
1084         return err;
1085 }
1086
1087 static void ftgmac100_reset_task(struct work_struct *work)
1088 {
1089         struct ftgmac100 *priv = container_of(work, struct ftgmac100,
1090                                               reset_task);
1091         struct net_device *netdev = priv->netdev;
1092         int err;
1093
1094         netdev_dbg(netdev, "Resetting NIC...\n");
1095
1096         /* Lock the world */
1097         rtnl_lock();
1098         if (netdev->phydev)
1099                 mutex_lock(&netdev->phydev->lock);
1100         if (priv->mii_bus)
1101                 mutex_lock(&priv->mii_bus->mdio_lock);
1102
1103
1104         /* Check if the interface is still up */
1105         if (!netif_running(netdev))
1106                 goto bail;
1107
1108         /* Stop the network stack */
1109         netif_trans_update(netdev);
1110         napi_disable(&priv->napi);
1111         netif_tx_disable(netdev);
1112
1113         /* Stop and reset the MAC */
1114         ftgmac100_stop_hw(priv);
1115         err = ftgmac100_reset_and_config_mac(priv);
1116         if (err) {
1117                 /* Not much we can do ... it might come back... */
1118                 netdev_err(netdev, "attempting to continue...\n");
1119         }
1120
1121         /* Free all rx and tx buffers */
1122         ftgmac100_free_buffers(priv);
1123
1124         /* Setup everything again and restart chip */
1125         ftgmac100_init_all(priv, true);
1126
1127         netdev_dbg(netdev, "Reset done !\n");
1128  bail:
1129         if (priv->mii_bus)
1130                 mutex_unlock(&priv->mii_bus->mdio_lock);
1131         if (netdev->phydev)
1132                 mutex_unlock(&netdev->phydev->lock);
1133         rtnl_unlock();
1134 }
1135
1136 static int ftgmac100_open(struct net_device *netdev)
1137 {
1138         struct ftgmac100 *priv = netdev_priv(netdev);
1139         int err;
1140
1141         /* Allocate ring buffers  */
1142         err = ftgmac100_alloc_rings(priv);
1143         if (err) {
1144                 netdev_err(netdev, "Failed to allocate descriptors\n");
1145                 return err;
1146         }
1147
1148         /* When using NC-SI we force the speed to 100Mbit/s full duplex,
1149          *
1150          * Otherwise we leave it set to 0 (no link), the link
1151          * message from the PHY layer will handle setting it up to
1152          * something else if needed.
1153          */
1154         if (priv->use_ncsi) {
1155                 priv->cur_duplex = DUPLEX_FULL;
1156                 priv->cur_speed = SPEED_100;
1157         } else {
1158                 priv->cur_duplex = 0;
1159                 priv->cur_speed = 0;
1160         }
1161
1162         /* Reset the hardware */
1163         err = ftgmac100_reset_and_config_mac(priv);
1164         if (err)
1165                 goto err_hw;
1166
1167         /* Initialize NAPI */
1168         netif_napi_add(netdev, &priv->napi, ftgmac100_poll, 64);
1169
1170         /* Grab our interrupt */
1171         err = request_irq(netdev->irq, ftgmac100_interrupt, 0, netdev->name, netdev);
1172         if (err) {
1173                 netdev_err(netdev, "failed to request irq %d\n", netdev->irq);
1174                 goto err_irq;
1175         }
1176
1177         /* Start things up */
1178         err = ftgmac100_init_all(priv, false);
1179         if (err) {
1180                 netdev_err(netdev, "Failed to allocate packet buffers\n");
1181                 goto err_alloc;
1182         }
1183
1184         if (netdev->phydev) {
1185                 /* If we have a PHY, start polling */
1186                 phy_start(netdev->phydev);
1187         } else if (priv->use_ncsi) {
1188                 /* If using NC-SI, set our carrier on and start the stack */
1189                 netif_carrier_on(netdev);
1190
1191                 /* Start the NCSI device */
1192                 err = ncsi_start_dev(priv->ndev);
1193                 if (err)
1194                         goto err_ncsi;
1195         }
1196
1197         return 0;
1198
1199  err_ncsi:
1200         napi_disable(&priv->napi);
1201         netif_stop_queue(netdev);
1202  err_alloc:
1203         ftgmac100_free_buffers(priv);
1204         free_irq(netdev->irq, netdev);
1205  err_irq:
1206         netif_napi_del(&priv->napi);
1207  err_hw:
1208         iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
1209         ftgmac100_free_rings(priv);
1210         return err;
1211 }
1212
1213 static int ftgmac100_stop(struct net_device *netdev)
1214 {
1215         struct ftgmac100 *priv = netdev_priv(netdev);
1216
1217         /* Note about the reset task: We are called with the rtnl lock
1218          * held, so we are synchronized against the core of the reset
1219          * task. We must not try to synchronously cancel it otherwise
1220          * we can deadlock. But since it will test for netif_running()
1221          * which has already been cleared by the net core, we don't
1222          * anything special to do.
1223          */
1224
1225         /* disable all interrupts */
1226         iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
1227
1228         netif_stop_queue(netdev);
1229         napi_disable(&priv->napi);
1230         netif_napi_del(&priv->napi);
1231         if (netdev->phydev)
1232                 phy_stop(netdev->phydev);
1233         else if (priv->use_ncsi)
1234                 ncsi_stop_dev(priv->ndev);
1235
1236         ftgmac100_stop_hw(priv);
1237         free_irq(netdev->irq, netdev);
1238         ftgmac100_free_buffers(priv);
1239         ftgmac100_free_rings(priv);
1240
1241         return 0;
1242 }
1243
1244 /* optional */
1245 static int ftgmac100_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1246 {
1247         if (!netdev->phydev)
1248                 return -ENXIO;
1249
1250         return phy_mii_ioctl(netdev->phydev, ifr, cmd);
1251 }
1252
1253 static void ftgmac100_tx_timeout(struct net_device *netdev)
1254 {
1255         struct ftgmac100 *priv = netdev_priv(netdev);
1256
1257         /* Disable all interrupts */
1258         iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
1259
1260         /* Do the reset outside of interrupt context */
1261         schedule_work(&priv->reset_task);
1262 }
1263
1264 static const struct net_device_ops ftgmac100_netdev_ops = {
1265         .ndo_open               = ftgmac100_open,
1266         .ndo_stop               = ftgmac100_stop,
1267         .ndo_start_xmit         = ftgmac100_hard_start_xmit,
1268         .ndo_set_mac_address    = ftgmac100_set_mac_addr,
1269         .ndo_validate_addr      = eth_validate_addr,
1270         .ndo_do_ioctl           = ftgmac100_do_ioctl,
1271         .ndo_tx_timeout         = ftgmac100_tx_timeout,
1272 };
1273
1274 static int ftgmac100_setup_mdio(struct net_device *netdev)
1275 {
1276         struct ftgmac100 *priv = netdev_priv(netdev);
1277         struct platform_device *pdev = to_platform_device(priv->dev);
1278         int i, err = 0;
1279         u32 reg;
1280
1281         /* initialize mdio bus */
1282         priv->mii_bus = mdiobus_alloc();
1283         if (!priv->mii_bus)
1284                 return -EIO;
1285
1286         if (of_machine_is_compatible("aspeed,ast2400") ||
1287             of_machine_is_compatible("aspeed,ast2500")) {
1288                 /* This driver supports the old MDIO interface */
1289                 reg = ioread32(priv->base + FTGMAC100_OFFSET_REVR);
1290                 reg &= ~FTGMAC100_REVR_NEW_MDIO_INTERFACE;
1291                 iowrite32(reg, priv->base + FTGMAC100_OFFSET_REVR);
1292         };
1293
1294         priv->mii_bus->name = "ftgmac100_mdio";
1295         snprintf(priv->mii_bus->id, MII_BUS_ID_SIZE, "%s-%d",
1296                  pdev->name, pdev->id);
1297         priv->mii_bus->priv = priv->netdev;
1298         priv->mii_bus->read = ftgmac100_mdiobus_read;
1299         priv->mii_bus->write = ftgmac100_mdiobus_write;
1300
1301         for (i = 0; i < PHY_MAX_ADDR; i++)
1302                 priv->mii_bus->irq[i] = PHY_POLL;
1303
1304         err = mdiobus_register(priv->mii_bus);
1305         if (err) {
1306                 dev_err(priv->dev, "Cannot register MDIO bus!\n");
1307                 goto err_register_mdiobus;
1308         }
1309
1310         err = ftgmac100_mii_probe(priv);
1311         if (err) {
1312                 dev_err(priv->dev, "MII Probe failed!\n");
1313                 goto err_mii_probe;
1314         }
1315
1316         return 0;
1317
1318 err_mii_probe:
1319         mdiobus_unregister(priv->mii_bus);
1320 err_register_mdiobus:
1321         mdiobus_free(priv->mii_bus);
1322         return err;
1323 }
1324
1325 static void ftgmac100_destroy_mdio(struct net_device *netdev)
1326 {
1327         struct ftgmac100 *priv = netdev_priv(netdev);
1328
1329         if (!netdev->phydev)
1330                 return;
1331
1332         phy_disconnect(netdev->phydev);
1333         mdiobus_unregister(priv->mii_bus);
1334         mdiobus_free(priv->mii_bus);
1335 }
1336
1337 static void ftgmac100_ncsi_handler(struct ncsi_dev *nd)
1338 {
1339         if (unlikely(nd->state != ncsi_dev_state_functional))
1340                 return;
1341
1342         netdev_info(nd->dev, "NCSI interface %s\n",
1343                     nd->link_up ? "up" : "down");
1344 }
1345
1346 static int ftgmac100_probe(struct platform_device *pdev)
1347 {
1348         struct resource *res;
1349         int irq;
1350         struct net_device *netdev;
1351         struct ftgmac100 *priv;
1352         int err = 0;
1353
1354         if (!pdev)
1355                 return -ENODEV;
1356
1357         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1358         if (!res)
1359                 return -ENXIO;
1360
1361         irq = platform_get_irq(pdev, 0);
1362         if (irq < 0)
1363                 return irq;
1364
1365         /* setup net_device */
1366         netdev = alloc_etherdev(sizeof(*priv));
1367         if (!netdev) {
1368                 err = -ENOMEM;
1369                 goto err_alloc_etherdev;
1370         }
1371
1372         SET_NETDEV_DEV(netdev, &pdev->dev);
1373
1374         netdev->ethtool_ops = &ftgmac100_ethtool_ops;
1375         netdev->netdev_ops = &ftgmac100_netdev_ops;
1376         netdev->watchdog_timeo = 5 * HZ;
1377
1378         platform_set_drvdata(pdev, netdev);
1379
1380         /* setup private data */
1381         priv = netdev_priv(netdev);
1382         priv->netdev = netdev;
1383         priv->dev = &pdev->dev;
1384         INIT_WORK(&priv->reset_task, ftgmac100_reset_task);
1385
1386         spin_lock_init(&priv->tx_lock);
1387
1388         /* map io memory */
1389         priv->res = request_mem_region(res->start, resource_size(res),
1390                                        dev_name(&pdev->dev));
1391         if (!priv->res) {
1392                 dev_err(&pdev->dev, "Could not reserve memory region\n");
1393                 err = -ENOMEM;
1394                 goto err_req_mem;
1395         }
1396
1397         priv->base = ioremap(res->start, resource_size(res));
1398         if (!priv->base) {
1399                 dev_err(&pdev->dev, "Failed to ioremap ethernet registers\n");
1400                 err = -EIO;
1401                 goto err_ioremap;
1402         }
1403
1404         netdev->irq = irq;
1405
1406         /* MAC address from chip or random one */
1407         ftgmac100_setup_mac(priv);
1408
1409         if (of_machine_is_compatible("aspeed,ast2400") ||
1410             of_machine_is_compatible("aspeed,ast2500")) {
1411                 priv->rxdes0_edorr_mask = BIT(30);
1412                 priv->txdes0_edotr_mask = BIT(30);
1413         } else {
1414                 priv->rxdes0_edorr_mask = BIT(15);
1415                 priv->txdes0_edotr_mask = BIT(15);
1416         }
1417
1418         if (pdev->dev.of_node &&
1419             of_get_property(pdev->dev.of_node, "use-ncsi", NULL)) {
1420                 if (!IS_ENABLED(CONFIG_NET_NCSI)) {
1421                         dev_err(&pdev->dev, "NCSI stack not enabled\n");
1422                         goto err_ncsi_dev;
1423                 }
1424
1425                 dev_info(&pdev->dev, "Using NCSI interface\n");
1426                 priv->use_ncsi = true;
1427                 priv->ndev = ncsi_register_dev(netdev, ftgmac100_ncsi_handler);
1428                 if (!priv->ndev)
1429                         goto err_ncsi_dev;
1430         } else {
1431                 priv->use_ncsi = false;
1432                 err = ftgmac100_setup_mdio(netdev);
1433                 if (err)
1434                         goto err_setup_mdio;
1435         }
1436
1437         /* We have to disable on-chip IP checksum functionality
1438          * when NCSI is enabled on the interface. It doesn't work
1439          * in that case.
1440          */
1441         netdev->features = NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_GRO;
1442         if (priv->use_ncsi &&
1443             of_get_property(pdev->dev.of_node, "no-hw-checksum", NULL))
1444                 netdev->features &= ~NETIF_F_IP_CSUM;
1445
1446
1447         /* register network device */
1448         err = register_netdev(netdev);
1449         if (err) {
1450                 dev_err(&pdev->dev, "Failed to register netdev\n");
1451                 goto err_register_netdev;
1452         }
1453
1454         netdev_info(netdev, "irq %d, mapped at %p\n", netdev->irq, priv->base);
1455
1456         return 0;
1457
1458 err_ncsi_dev:
1459 err_register_netdev:
1460         ftgmac100_destroy_mdio(netdev);
1461 err_setup_mdio:
1462         iounmap(priv->base);
1463 err_ioremap:
1464         release_resource(priv->res);
1465 err_req_mem:
1466         netif_napi_del(&priv->napi);
1467         free_netdev(netdev);
1468 err_alloc_etherdev:
1469         return err;
1470 }
1471
1472 static int ftgmac100_remove(struct platform_device *pdev)
1473 {
1474         struct net_device *netdev;
1475         struct ftgmac100 *priv;
1476
1477         netdev = platform_get_drvdata(pdev);
1478         priv = netdev_priv(netdev);
1479
1480         unregister_netdev(netdev);
1481
1482         /* There's a small chance the reset task will have been re-queued,
1483          * during stop, make sure it's gone before we free the structure.
1484          */
1485         cancel_work_sync(&priv->reset_task);
1486
1487         ftgmac100_destroy_mdio(netdev);
1488
1489         iounmap(priv->base);
1490         release_resource(priv->res);
1491
1492         netif_napi_del(&priv->napi);
1493         free_netdev(netdev);
1494         return 0;
1495 }
1496
1497 static const struct of_device_id ftgmac100_of_match[] = {
1498         { .compatible = "faraday,ftgmac100" },
1499         { }
1500 };
1501 MODULE_DEVICE_TABLE(of, ftgmac100_of_match);
1502
1503 static struct platform_driver ftgmac100_driver = {
1504         .probe  = ftgmac100_probe,
1505         .remove = ftgmac100_remove,
1506         .driver = {
1507                 .name           = DRV_NAME,
1508                 .of_match_table = ftgmac100_of_match,
1509         },
1510 };
1511 module_platform_driver(ftgmac100_driver);
1512
1513 MODULE_AUTHOR("Po-Yu Chuang <ratbert@faraday-tech.com>");
1514 MODULE_DESCRIPTION("FTGMAC100 driver");
1515 MODULE_LICENSE("GPL");