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 <net/ip.h>
  35
  36 #include "ftgmac100.h"
  37
  38 #define DRV_NAME        "ftgmac100"
  39 #define DRV_VERSION     "0.7"
  40
  41 #define RX_QUEUE_ENTRIES        256     /* must be power of 2 */
  42 #define TX_QUEUE_ENTRIES        512     /* must be power of 2 */
  43
  44 #define MAX_PKT_SIZE            1518
  45 #define RX_BUF_SIZE             PAGE_SIZE       /* must be smaller than 0x3fff */
  46
  47 /******************************************************************************
  48  * private data
  49  *****************************************************************************/
  50 struct ftgmac100_descs {
  51         struct ftgmac100_rxdes rxdes[RX_QUEUE_ENTRIES];
  52         struct ftgmac100_txdes txdes[TX_QUEUE_ENTRIES];
  53 };
  54
  55 struct ftgmac100 {
  56         struct resource *res;
  57         void __iomem *base;
  58         int irq;
  59
  60         struct ftgmac100_descs *descs;
  61         dma_addr_t descs_dma_addr;
  62
  63         unsigned int rx_pointer;
  64         unsigned int tx_clean_pointer;
  65         unsigned int tx_pointer;
  66         unsigned int tx_pending;
  67
  68         spinlock_t tx_lock;
  69
  70         struct net_device *netdev;
  71         struct device *dev;
  72         struct napi_struct napi;
  73
  74         struct mii_bus *mii_bus;
  75         int phy_irq[PHY_MAX_ADDR];
  76         struct phy_device *phydev;
  77         int old_speed;
  78 };
  79
  80 static int ftgmac100_alloc_rx_page(struct ftgmac100 *priv,
  81                                    struct ftgmac100_rxdes *rxdes, gfp_t gfp);
  82
  83 /******************************************************************************
  84  * internal functions (hardware register access)
  85  *****************************************************************************/
  86 #define INT_MASK_ALL_ENABLED    (FTGMAC100_INT_RPKT_LOST        | \
  87                                  FTGMAC100_INT_XPKT_ETH         | \
  88                                  FTGMAC100_INT_XPKT_LOST        | \
  89                                  FTGMAC100_INT_AHB_ERR          | \
  90                                  FTGMAC100_INT_PHYSTS_CHG       | \
  91                                  FTGMAC100_INT_RPKT_BUF         | \
  92                                  FTGMAC100_INT_NO_RXBUF)
  93
  94 static void ftgmac100_set_rx_ring_base(struct ftgmac100 *priv, dma_addr_t addr)
  95 {
  96         iowrite32(addr, priv->base + FTGMAC100_OFFSET_RXR_BADR);
  97 }
  98
  99 static void ftgmac100_set_rx_buffer_size(struct ftgmac100 *priv,
 100                 unsigned int size)
 101 {
 102         size = FTGMAC100_RBSR_SIZE(size);
 103         iowrite32(size, priv->base + FTGMAC100_OFFSET_RBSR);
 104 }
 105
 106 static void ftgmac100_set_normal_prio_tx_ring_base(struct ftgmac100 *priv,
 107                                                    dma_addr_t addr)
 108 {
 109         iowrite32(addr, priv->base + FTGMAC100_OFFSET_NPTXR_BADR);
 110 }
 111
 112 static void ftgmac100_txdma_normal_prio_start_polling(struct ftgmac100 *priv)
 113 {
 114         iowrite32(1, priv->base + FTGMAC100_OFFSET_NPTXPD);
 115 }
 116
 117 static int ftgmac100_reset_hw(struct ftgmac100 *priv)
 118 {
 119         struct net_device *netdev = priv->netdev;
 120         int i;
 121
 122         /* NOTE: reset clears all registers */
 123         iowrite32(FTGMAC100_MACCR_SW_RST, priv->base + FTGMAC100_OFFSET_MACCR);
 124         for (i = 0; i < 5; i++) {
 125                 unsigned int maccr;
 126
 127                 maccr = ioread32(priv->base + FTGMAC100_OFFSET_MACCR);
 128                 if (!(maccr & FTGMAC100_MACCR_SW_RST))
 129                         return 0;
 130
 131                 udelay(1000);
 132         }
 133
 134         netdev_err(netdev, "software reset failed\n");
 135         return -EIO;
 136 }
 137
 138 static void ftgmac100_set_mac(struct ftgmac100 *priv, const unsigned char *mac)
 139 {
 140         unsigned int maddr = mac[0] << 8 | mac[1];
 141         unsigned int laddr = mac[2] << 24 | mac[3] << 16 | mac[4] << 8 | mac[5];
 142
 143         iowrite32(maddr, priv->base + FTGMAC100_OFFSET_MAC_MADR);
 144         iowrite32(laddr, priv->base + FTGMAC100_OFFSET_MAC_LADR);
 145 }
 146
 147 static void ftgmac100_init_hw(struct ftgmac100 *priv)
 148 {
 149         /* setup ring buffer base registers */
 150         ftgmac100_set_rx_ring_base(priv,
 151                                    priv->descs_dma_addr +
 152                                    offsetof(struct ftgmac100_descs, rxdes));
 153         ftgmac100_set_normal_prio_tx_ring_base(priv,
 154                                                priv->descs_dma_addr +
 155                                                offsetof(struct ftgmac100_descs, txdes));
 156
 157         ftgmac100_set_rx_buffer_size(priv, RX_BUF_SIZE);
 158
 159         iowrite32(FTGMAC100_APTC_RXPOLL_CNT(1), priv->base + FTGMAC100_OFFSET_APTC);
 160
 161         ftgmac100_set_mac(priv, priv->netdev->dev_addr);
 162 }
 163
 164 #define MACCR_ENABLE_ALL        (FTGMAC100_MACCR_TXDMA_EN       | \
 165                                  FTGMAC100_MACCR_RXDMA_EN       | \
 166                                  FTGMAC100_MACCR_TXMAC_EN       | \
 167                                  FTGMAC100_MACCR_RXMAC_EN       | \
 168                                  FTGMAC100_MACCR_FULLDUP        | \
 169                                  FTGMAC100_MACCR_CRC_APD        | \
 170                                  FTGMAC100_MACCR_RX_RUNT        | \
 171                                  FTGMAC100_MACCR_RX_BROADPKT)
 172
 173 static void ftgmac100_start_hw(struct ftgmac100 *priv, int speed)
 174 {
 175         int maccr = MACCR_ENABLE_ALL;
 176
 177         switch (speed) {
 178         default:
 179         case 10:
 180                 break;
 181
 182         case 100:
 183                 maccr |= FTGMAC100_MACCR_FAST_MODE;
 184                 break;
 185
 186         case 1000:
 187                 maccr |= FTGMAC100_MACCR_GIGA_MODE;
 188                 break;
 189         }
 190
 191         iowrite32(maccr, priv->base + FTGMAC100_OFFSET_MACCR);
 192 }
 193
 194 static void ftgmac100_stop_hw(struct ftgmac100 *priv)
 195 {
 196         iowrite32(0, priv->base + FTGMAC100_OFFSET_MACCR);
 197 }
 198
 199 /******************************************************************************
 200  * internal functions (receive descriptor)
 201  *****************************************************************************/
 202 static bool ftgmac100_rxdes_first_segment(struct ftgmac100_rxdes *rxdes)
 203 {
 204         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_FRS);
 205 }
 206
 207 static bool ftgmac100_rxdes_last_segment(struct ftgmac100_rxdes *rxdes)
 208 {
 209         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_LRS);
 210 }
 211
 212 static bool ftgmac100_rxdes_packet_ready(struct ftgmac100_rxdes *rxdes)
 213 {
 214         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_RXPKT_RDY);
 215 }
 216
 217 static void ftgmac100_rxdes_set_dma_own(struct ftgmac100_rxdes *rxdes)
 218 {
 219         /* clear status bits */
 220         rxdes->rxdes0 &= cpu_to_le32(FTGMAC100_RXDES0_EDORR);
 221 }
 222
 223 static bool ftgmac100_rxdes_rx_error(struct ftgmac100_rxdes *rxdes)
 224 {
 225         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_RX_ERR);
 226 }
 227
 228 static bool ftgmac100_rxdes_crc_error(struct ftgmac100_rxdes *rxdes)
 229 {
 230         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_CRC_ERR);
 231 }
 232
 233 static bool ftgmac100_rxdes_frame_too_long(struct ftgmac100_rxdes *rxdes)
 234 {
 235         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_FTL);
 236 }
 237
 238 static bool ftgmac100_rxdes_runt(struct ftgmac100_rxdes *rxdes)
 239 {
 240         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_RUNT);
 241 }
 242
 243 static bool ftgmac100_rxdes_odd_nibble(struct ftgmac100_rxdes *rxdes)
 244 {
 245         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_RX_ODD_NB);
 246 }
 247
 248 static unsigned int ftgmac100_rxdes_data_length(struct ftgmac100_rxdes *rxdes)
 249 {
 250         return le32_to_cpu(rxdes->rxdes0) & FTGMAC100_RXDES0_VDBC;
 251 }
 252
 253 static bool ftgmac100_rxdes_multicast(struct ftgmac100_rxdes *rxdes)
 254 {
 255         return rxdes->rxdes0 & cpu_to_le32(FTGMAC100_RXDES0_MULTICAST);
 256 }
 257
 258 static void ftgmac100_rxdes_set_end_of_ring(struct ftgmac100_rxdes *rxdes)
 259 {
 260         rxdes->rxdes0 |= cpu_to_le32(FTGMAC100_RXDES0_EDORR);
 261 }
 262
 263 static void ftgmac100_rxdes_set_dma_addr(struct ftgmac100_rxdes *rxdes,
 264                                          dma_addr_t addr)
 265 {
 266         rxdes->rxdes3 = cpu_to_le32(addr);
 267 }
 268
 269 static dma_addr_t ftgmac100_rxdes_get_dma_addr(struct ftgmac100_rxdes *rxdes)
 270 {
 271         return le32_to_cpu(rxdes->rxdes3);
 272 }
 273
 274 static bool ftgmac100_rxdes_is_tcp(struct ftgmac100_rxdes *rxdes)
 275 {
 276         return (rxdes->rxdes1 & cpu_to_le32(FTGMAC100_RXDES1_PROT_MASK)) ==
 277                cpu_to_le32(FTGMAC100_RXDES1_PROT_TCPIP);
 278 }
 279
 280 static bool ftgmac100_rxdes_is_udp(struct ftgmac100_rxdes *rxdes)
 281 {
 282         return (rxdes->rxdes1 & cpu_to_le32(FTGMAC100_RXDES1_PROT_MASK)) ==
 283                cpu_to_le32(FTGMAC100_RXDES1_PROT_UDPIP);
 284 }
 285
 286 static bool ftgmac100_rxdes_tcpcs_err(struct ftgmac100_rxdes *rxdes)
 287 {
 288         return rxdes->rxdes1 & cpu_to_le32(FTGMAC100_RXDES1_TCP_CHKSUM_ERR);
 289 }
 290
 291 static bool ftgmac100_rxdes_udpcs_err(struct ftgmac100_rxdes *rxdes)
 292 {
 293         return rxdes->rxdes1 & cpu_to_le32(FTGMAC100_RXDES1_UDP_CHKSUM_ERR);
 294 }
 295
 296 static bool ftgmac100_rxdes_ipcs_err(struct ftgmac100_rxdes *rxdes)
 297 {
 298         return rxdes->rxdes1 & cpu_to_le32(FTGMAC100_RXDES1_IP_CHKSUM_ERR);
 299 }
 300
 301 /*
 302  * rxdes2 is not used by hardware. We use it to keep track of page.
 303  * Since hardware does not touch it, we can skip cpu_to_le32()/le32_to_cpu().
 304  */
 305 static void ftgmac100_rxdes_set_page(struct ftgmac100_rxdes *rxdes, struct page *page)
 306 {
 307         rxdes->rxdes2 = (unsigned int)page;
 308 }
 309
 310 static struct page *ftgmac100_rxdes_get_page(struct ftgmac100_rxdes *rxdes)
 311 {
 312         return (struct page *)rxdes->rxdes2;
 313 }
 314
 315 /******************************************************************************
 316  * internal functions (receive)
 317  *****************************************************************************/
 318 static int ftgmac100_next_rx_pointer(int pointer)
 319 {
 320         return (pointer + 1) & (RX_QUEUE_ENTRIES - 1);
 321 }
 322
 323 static void ftgmac100_rx_pointer_advance(struct ftgmac100 *priv)
 324 {
 325         priv->rx_pointer = ftgmac100_next_rx_pointer(priv->rx_pointer);
 326 }
 327
 328 static struct ftgmac100_rxdes *ftgmac100_current_rxdes(struct ftgmac100 *priv)
 329 {
 330         return &priv->descs->rxdes[priv->rx_pointer];
 331 }
 332
 333 static struct ftgmac100_rxdes *
 334 ftgmac100_rx_locate_first_segment(struct ftgmac100 *priv)
 335 {
 336         struct ftgmac100_rxdes *rxdes = ftgmac100_current_rxdes(priv);
 337
 338         while (ftgmac100_rxdes_packet_ready(rxdes)) {
 339                 if (ftgmac100_rxdes_first_segment(rxdes))
 340                         return rxdes;
 341
 342                 ftgmac100_rxdes_set_dma_own(rxdes);
 343                 ftgmac100_rx_pointer_advance(priv);
 344                 rxdes = ftgmac100_current_rxdes(priv);
 345         }
 346
 347         return NULL;
 348 }
 349
 350 static bool ftgmac100_rx_packet_error(struct ftgmac100 *priv,
 351                                       struct ftgmac100_rxdes *rxdes)
 352 {
 353         struct net_device *netdev = priv->netdev;
 354         bool error = false;
 355
 356         if (unlikely(ftgmac100_rxdes_rx_error(rxdes))) {
 357                 if (net_ratelimit())
 358                         netdev_info(netdev, "rx err\n");
 359
 360                 netdev->stats.rx_errors++;
 361                 error = true;
 362         }
 363
 364         if (unlikely(ftgmac100_rxdes_crc_error(rxdes))) {
 365                 if (net_ratelimit())
 366                         netdev_info(netdev, "rx crc err\n");
 367
 368                 netdev->stats.rx_crc_errors++;
 369                 error = true;
 370         } else if (unlikely(ftgmac100_rxdes_ipcs_err(rxdes))) {
 371                 if (net_ratelimit())
 372                         netdev_info(netdev, "rx IP checksum err\n");
 373
 374                 error = true;
 375         }
 376
 377         if (unlikely(ftgmac100_rxdes_frame_too_long(rxdes))) {
 378                 if (net_ratelimit())
 379                         netdev_info(netdev, "rx frame too long\n");
 380
 381                 netdev->stats.rx_length_errors++;
 382                 error = true;
 383         } else if (unlikely(ftgmac100_rxdes_runt(rxdes))) {
 384                 if (net_ratelimit())
 385                         netdev_info(netdev, "rx runt\n");
 386
 387                 netdev->stats.rx_length_errors++;
 388                 error = true;
 389         } else if (unlikely(ftgmac100_rxdes_odd_nibble(rxdes))) {
 390                 if (net_ratelimit())
 391                         netdev_info(netdev, "rx odd nibble\n");
 392
 393                 netdev->stats.rx_length_errors++;
 394                 error = true;
 395         }
 396
 397         return error;
 398 }
 399
 400 static void ftgmac100_rx_drop_packet(struct ftgmac100 *priv)
 401 {
 402         struct net_device *netdev = priv->netdev;
 403         struct ftgmac100_rxdes *rxdes = ftgmac100_current_rxdes(priv);
 404         bool done = false;
 405
 406         if (net_ratelimit())
 407                 netdev_dbg(netdev, "drop packet %p\n", rxdes);
 408
 409         do {
 410                 if (ftgmac100_rxdes_last_segment(rxdes))
 411                         done = true;
 412
 413                 ftgmac100_rxdes_set_dma_own(rxdes);
 414                 ftgmac100_rx_pointer_advance(priv);
 415                 rxdes = ftgmac100_current_rxdes(priv);
 416         } while (!done && ftgmac100_rxdes_packet_ready(rxdes));
 417
 418         netdev->stats.rx_dropped++;
 419 }
 420
 421 static bool ftgmac100_rx_packet(struct ftgmac100 *priv, int *processed)
 422 {
 423         struct net_device *netdev = priv->netdev;
 424         struct ftgmac100_rxdes *rxdes;
 425         struct sk_buff *skb;
 426         bool done = false;
 427
 428         rxdes = ftgmac100_rx_locate_first_segment(priv);
 429         if (!rxdes)
 430                 return false;
 431
 432         if (unlikely(ftgmac100_rx_packet_error(priv, rxdes))) {
 433                 ftgmac100_rx_drop_packet(priv);
 434                 return true;
 435         }
 436
 437         /* start processing */
 438         skb = netdev_alloc_skb_ip_align(netdev, 128);
 439         if (unlikely(!skb)) {
 440                 if (net_ratelimit())
 441                         netdev_err(netdev, "rx skb alloc failed\n");
 442
 443                 ftgmac100_rx_drop_packet(priv);
 444                 return true;
 445         }
 446
 447         if (unlikely(ftgmac100_rxdes_multicast(rxdes)))
 448                 netdev->stats.multicast++;
 449
 450         /*
 451          * It seems that HW does checksum incorrectly with fragmented packets,
 452          * so we are conservative here - if HW checksum error, let software do
 453          * the checksum again.
 454          */
 455         if ((ftgmac100_rxdes_is_tcp(rxdes) && !ftgmac100_rxdes_tcpcs_err(rxdes)) ||
 456             (ftgmac100_rxdes_is_udp(rxdes) && !ftgmac100_rxdes_udpcs_err(rxdes)))
 457                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 458
 459         do {
 460                 dma_addr_t map = ftgmac100_rxdes_get_dma_addr(rxdes);
 461                 struct page *page = ftgmac100_rxdes_get_page(rxdes);
 462                 unsigned int size;
 463
 464                 dma_unmap_page(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
 465
 466                 size = ftgmac100_rxdes_data_length(rxdes);
 467                 skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page, 0, size);
 468
 469                 skb->len += size;
 470                 skb->data_len += size;
 471                 skb->truesize += PAGE_SIZE;
 472
 473                 if (ftgmac100_rxdes_last_segment(rxdes))
 474                         done = true;
 475
 476                 ftgmac100_alloc_rx_page(priv, rxdes, GFP_ATOMIC);
 477
 478                 ftgmac100_rx_pointer_advance(priv);
 479                 rxdes = ftgmac100_current_rxdes(priv);
 480         } while (!done);
 481
 482         /* Small frames are copied into linear part of skb to free one page */
 483         if (skb->len <= 128) {
 484                 skb->truesize -= PAGE_SIZE;
 485                 __pskb_pull_tail(skb, skb->len);
 486         } else {
 487                 /* We pull the minimum amount into linear part */
 488                 __pskb_pull_tail(skb, ETH_HLEN);
 489         }
 490         skb->protocol = eth_type_trans(skb, netdev);
 491
 492         netdev->stats.rx_packets++;
 493         netdev->stats.rx_bytes += skb->len;
 494
 495         /* push packet to protocol stack */
 496         napi_gro_receive(&priv->napi, skb);
 497
 498         (*processed)++;
 499         return true;
 500 }
 501
 502 /******************************************************************************
 503  * internal functions (transmit descriptor)
 504  *****************************************************************************/
 505 static void ftgmac100_txdes_reset(struct ftgmac100_txdes *txdes)
 506 {
 507         /* clear all except end of ring bit */
 508         txdes->txdes0 &= cpu_to_le32(FTGMAC100_TXDES0_EDOTR);
 509         txdes->txdes1 = 0;
 510         txdes->txdes2 = 0;
 511         txdes->txdes3 = 0;
 512 }
 513
 514 static bool ftgmac100_txdes_owned_by_dma(struct ftgmac100_txdes *txdes)
 515 {
 516         return txdes->txdes0 & cpu_to_le32(FTGMAC100_TXDES0_TXDMA_OWN);
 517 }
 518
 519 static void ftgmac100_txdes_set_dma_own(struct ftgmac100_txdes *txdes)
 520 {
 521         /*
 522          * Make sure dma own bit will not be set before any other
 523          * descriptor fields.
 524          */
 525         wmb();
 526         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_TXDMA_OWN);
 527 }
 528
 529 static void ftgmac100_txdes_set_end_of_ring(struct ftgmac100_txdes *txdes)
 530 {
 531         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_EDOTR);
 532 }
 533
 534 static void ftgmac100_txdes_set_first_segment(struct ftgmac100_txdes *txdes)
 535 {
 536         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_FTS);
 537 }
 538
 539 static void ftgmac100_txdes_set_last_segment(struct ftgmac100_txdes *txdes)
 540 {
 541         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_LTS);
 542 }
 543
 544 static void ftgmac100_txdes_set_buffer_size(struct ftgmac100_txdes *txdes,
 545                                             unsigned int len)
 546 {
 547         txdes->txdes0 |= cpu_to_le32(FTGMAC100_TXDES0_TXBUF_SIZE(len));
 548 }
 549
 550 static void ftgmac100_txdes_set_txint(struct ftgmac100_txdes *txdes)
 551 {
 552         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_TXIC);
 553 }
 554
 555 static void ftgmac100_txdes_set_tcpcs(struct ftgmac100_txdes *txdes)
 556 {
 557         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_TCP_CHKSUM);
 558 }
 559
 560 static void ftgmac100_txdes_set_udpcs(struct ftgmac100_txdes *txdes)
 561 {
 562         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_UDP_CHKSUM);
 563 }
 564
 565 static void ftgmac100_txdes_set_ipcs(struct ftgmac100_txdes *txdes)
 566 {
 567         txdes->txdes1 |= cpu_to_le32(FTGMAC100_TXDES1_IP_CHKSUM);
 568 }
 569
 570 static void ftgmac100_txdes_set_dma_addr(struct ftgmac100_txdes *txdes,
 571                                          dma_addr_t addr)
 572 {
 573         txdes->txdes3 = cpu_to_le32(addr);
 574 }
 575
 576 static dma_addr_t ftgmac100_txdes_get_dma_addr(struct ftgmac100_txdes *txdes)
 577 {
 578         return le32_to_cpu(txdes->txdes3);
 579 }
 580
 581 /*
 582  * txdes2 is not used by hardware. We use it to keep track of socket buffer.
 583  * Since hardware does not touch it, we can skip cpu_to_le32()/le32_to_cpu().
 584  */
 585 static void ftgmac100_txdes_set_skb(struct ftgmac100_txdes *txdes,
 586                                     struct sk_buff *skb)
 587 {
 588         txdes->txdes2 = (unsigned int)skb;
 589 }
 590
 591 static struct sk_buff *ftgmac100_txdes_get_skb(struct ftgmac100_txdes *txdes)
 592 {
 593         return (struct sk_buff *)txdes->txdes2;
 594 }
 595
 596 /******************************************************************************
 597  * internal functions (transmit)
 598  *****************************************************************************/
 599 static int ftgmac100_next_tx_pointer(int pointer)
 600 {
 601         return (pointer + 1) & (TX_QUEUE_ENTRIES - 1);
 602 }
 603
 604 static void ftgmac100_tx_pointer_advance(struct ftgmac100 *priv)
 605 {
 606         priv->tx_pointer = ftgmac100_next_tx_pointer(priv->tx_pointer);
 607 }
 608
 609 static void ftgmac100_tx_clean_pointer_advance(struct ftgmac100 *priv)
 610 {
 611         priv->tx_clean_pointer = ftgmac100_next_tx_pointer(priv->tx_clean_pointer);
 612 }
 613
 614 static struct ftgmac100_txdes *ftgmac100_current_txdes(struct ftgmac100 *priv)
 615 {
 616         return &priv->descs->txdes[priv->tx_pointer];
 617 }
 618
 619 static struct ftgmac100_txdes *
 620 ftgmac100_current_clean_txdes(struct ftgmac100 *priv)
 621 {
 622         return &priv->descs->txdes[priv->tx_clean_pointer];
 623 }
 624
 625 static bool ftgmac100_tx_complete_packet(struct ftgmac100 *priv)
 626 {
 627         struct net_device *netdev = priv->netdev;
 628         struct ftgmac100_txdes *txdes;
 629         struct sk_buff *skb;
 630         dma_addr_t map;
 631
 632         if (priv->tx_pending == 0)
 633                 return false;
 634
 635         txdes = ftgmac100_current_clean_txdes(priv);
 636
 637         if (ftgmac100_txdes_owned_by_dma(txdes))
 638                 return false;
 639
 640         skb = ftgmac100_txdes_get_skb(txdes);
 641         map = ftgmac100_txdes_get_dma_addr(txdes);
 642
 643         netdev->stats.tx_packets++;
 644         netdev->stats.tx_bytes += skb->len;
 645
 646         dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
 647
 648         dev_kfree_skb(skb);
 649
 650         ftgmac100_txdes_reset(txdes);
 651
 652         ftgmac100_tx_clean_pointer_advance(priv);
 653
 654         spin_lock(&priv->tx_lock);
 655         priv->tx_pending--;
 656         spin_unlock(&priv->tx_lock);
 657         netif_wake_queue(netdev);
 658
 659         return true;
 660 }
 661
 662 static void ftgmac100_tx_complete(struct ftgmac100 *priv)
 663 {
 664         while (ftgmac100_tx_complete_packet(priv))
 665                 ;
 666 }
 667
 668 static int ftgmac100_xmit(struct ftgmac100 *priv, struct sk_buff *skb,
 669                           dma_addr_t map)
 670 {
 671         struct net_device *netdev = priv->netdev;
 672         struct ftgmac100_txdes *txdes;
 673         unsigned int len = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
 674
 675         txdes = ftgmac100_current_txdes(priv);
 676         ftgmac100_tx_pointer_advance(priv);
 677
 678         /* setup TX descriptor */
 679         ftgmac100_txdes_set_skb(txdes, skb);
 680         ftgmac100_txdes_set_dma_addr(txdes, map);
 681         ftgmac100_txdes_set_buffer_size(txdes, len);
 682
 683         ftgmac100_txdes_set_first_segment(txdes);
 684         ftgmac100_txdes_set_last_segment(txdes);
 685         ftgmac100_txdes_set_txint(txdes);
 686         if (skb->ip_summed == CHECKSUM_PARTIAL) {
 687                 __be16 protocol = skb->protocol;
 688
 689                 if (protocol == cpu_to_be16(ETH_P_IP)) {
 690                         u8 ip_proto = ip_hdr(skb)->protocol;
 691
 692                         ftgmac100_txdes_set_ipcs(txdes);
 693                         if (ip_proto == IPPROTO_TCP)
 694                                 ftgmac100_txdes_set_tcpcs(txdes);
 695                         else if (ip_proto == IPPROTO_UDP)
 696                                 ftgmac100_txdes_set_udpcs(txdes);
 697                 }
 698         }
 699
 700         spin_lock(&priv->tx_lock);
 701         priv->tx_pending++;
 702         if (priv->tx_pending == TX_QUEUE_ENTRIES)
 703                 netif_stop_queue(netdev);
 704
 705         /* start transmit */
 706         ftgmac100_txdes_set_dma_own(txdes);
 707         spin_unlock(&priv->tx_lock);
 708
 709         ftgmac100_txdma_normal_prio_start_polling(priv);
 710
 711         return NETDEV_TX_OK;
 712 }
 713
 714 /******************************************************************************
 715  * internal functions (buffer)
 716  *****************************************************************************/
 717 static int ftgmac100_alloc_rx_page(struct ftgmac100 *priv,
 718                                    struct ftgmac100_rxdes *rxdes, gfp_t gfp)
 719 {
 720         struct net_device *netdev = priv->netdev;
 721         struct page *page;
 722         dma_addr_t map;
 723
 724         page = alloc_page(gfp);
 725         if (!page) {
 726                 if (net_ratelimit())
 727                         netdev_err(netdev, "failed to allocate rx page\n");
 728                 return -ENOMEM;
 729         }
 730
 731         map = dma_map_page(priv->dev, page, 0, RX_BUF_SIZE, DMA_FROM_DEVICE);
 732         if (unlikely(dma_mapping_error(priv->dev, map))) {
 733                 if (net_ratelimit())
 734                         netdev_err(netdev, "failed to map rx page\n");
 735                 __free_page(page);
 736                 return -ENOMEM;
 737         }
 738
 739         ftgmac100_rxdes_set_page(rxdes, page);
 740         ftgmac100_rxdes_set_dma_addr(rxdes, map);
 741         ftgmac100_rxdes_set_dma_own(rxdes);
 742         return 0;
 743 }
 744
 745 static void ftgmac100_free_buffers(struct ftgmac100 *priv)
 746 {
 747         int i;
 748
 749         for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
 750                 struct ftgmac100_rxdes *rxdes = &priv->descs->rxdes[i];
 751                 struct page *page = ftgmac100_rxdes_get_page(rxdes);
 752                 dma_addr_t map = ftgmac100_rxdes_get_dma_addr(rxdes);
 753
 754                 if (!page)
 755                         continue;
 756
 757                 dma_unmap_page(priv->dev, map, RX_BUF_SIZE, DMA_FROM_DEVICE);
 758                 __free_page(page);
 759         }
 760
 761         for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
 762                 struct ftgmac100_txdes *txdes = &priv->descs->txdes[i];
 763                 struct sk_buff *skb = ftgmac100_txdes_get_skb(txdes);
 764                 dma_addr_t map = ftgmac100_txdes_get_dma_addr(txdes);
 765
 766                 if (!skb)
 767                         continue;
 768
 769                 dma_unmap_single(priv->dev, map, skb_headlen(skb), DMA_TO_DEVICE);
 770                 kfree_skb(skb);
 771         }
 772
 773         dma_free_coherent(priv->dev, sizeof(struct ftgmac100_descs),
 774                           priv->descs, priv->descs_dma_addr);
 775 }
 776
 777 static int ftgmac100_alloc_buffers(struct ftgmac100 *priv)
 778 {
 779         int i;
 780
 781         priv->descs = dma_zalloc_coherent(priv->dev,
 782                                           sizeof(struct ftgmac100_descs),
 783                                           &priv->descs_dma_addr, GFP_KERNEL);
 784         if (!priv->descs)
 785                 return -ENOMEM;
 786
 787         /* initialize RX ring */
 788         ftgmac100_rxdes_set_end_of_ring(&priv->descs->rxdes[RX_QUEUE_ENTRIES - 1]);
 789
 790         for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
 791                 struct ftgmac100_rxdes *rxdes = &priv->descs->rxdes[i];
 792
 793                 if (ftgmac100_alloc_rx_page(priv, rxdes, GFP_KERNEL))
 794                         goto err;
 795         }
 796
 797         /* initialize TX ring */
 798         ftgmac100_txdes_set_end_of_ring(&priv->descs->txdes[TX_QUEUE_ENTRIES - 1]);
 799         return 0;
 800
 801 err:
 802         ftgmac100_free_buffers(priv);
 803         return -ENOMEM;
 804 }
 805
 806 /******************************************************************************
 807  * internal functions (mdio)
 808  *****************************************************************************/
 809 static void ftgmac100_adjust_link(struct net_device *netdev)
 810 {
 811         struct ftgmac100 *priv = netdev_priv(netdev);
 812         struct phy_device *phydev = priv->phydev;
 813         int ier;
 814
 815         if (phydev->speed == priv->old_speed)
 816                 return;
 817
 818         priv->old_speed = phydev->speed;
 819
 820         ier = ioread32(priv->base + FTGMAC100_OFFSET_IER);
 821
 822         /* disable all interrupts */
 823         iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
 824
 825         netif_stop_queue(netdev);
 826         ftgmac100_stop_hw(priv);
 827
 828         netif_start_queue(netdev);
 829         ftgmac100_init_hw(priv);
 830         ftgmac100_start_hw(priv, phydev->speed);
 831
 832         /* re-enable interrupts */
 833         iowrite32(ier, priv->base + FTGMAC100_OFFSET_IER);
 834 }
 835
 836 static int ftgmac100_mii_probe(struct ftgmac100 *priv)
 837 {
 838         struct net_device *netdev = priv->netdev;
 839         struct phy_device *phydev = NULL;
 840         int i;
 841
 842         /* search for connect PHY device */
 843         for (i = 0; i < PHY_MAX_ADDR; i++) {
 844                 struct phy_device *tmp = priv->mii_bus->phy_map[i];
 845
 846                 if (tmp) {
 847                         phydev = tmp;
 848                         break;
 849                 }
 850         }
 851
 852         /* now we are supposed to have a proper phydev, to attach to... */
 853         if (!phydev) {
 854                 netdev_info(netdev, "%s: no PHY found\n", netdev->name);
 855                 return -ENODEV;
 856         }
 857
 858         phydev = phy_connect(netdev, dev_name(&phydev->dev),
 859                              &ftgmac100_adjust_link, PHY_INTERFACE_MODE_GMII);
 860
 861         if (IS_ERR(phydev)) {
 862                 netdev_err(netdev, "%s: Could not attach to PHY\n", netdev->name);
 863                 return PTR_ERR(phydev);
 864         }
 865
 866         priv->phydev = phydev;
 867         return 0;
 868 }
 869
 870 /******************************************************************************
 871  * struct mii_bus functions
 872  *****************************************************************************/
 873 static int ftgmac100_mdiobus_read(struct mii_bus *bus, int phy_addr, int regnum)
 874 {
 875         struct net_device *netdev = bus->priv;
 876         struct ftgmac100 *priv = netdev_priv(netdev);
 877         unsigned int phycr;
 878         int i;
 879
 880         phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
 881
 882         /* preserve MDC cycle threshold */
 883         phycr &= FTGMAC100_PHYCR_MDC_CYCTHR_MASK;
 884
 885         phycr |= FTGMAC100_PHYCR_PHYAD(phy_addr) |
 886                  FTGMAC100_PHYCR_REGAD(regnum) |
 887                  FTGMAC100_PHYCR_MIIRD;
 888
 889         iowrite32(phycr, priv->base + FTGMAC100_OFFSET_PHYCR);
 890
 891         for (i = 0; i < 10; i++) {
 892                 phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
 893
 894                 if ((phycr & FTGMAC100_PHYCR_MIIRD) == 0) {
 895                         int data;
 896
 897                         data = ioread32(priv->base + FTGMAC100_OFFSET_PHYDATA);
 898                         return FTGMAC100_PHYDATA_MIIRDATA(data);
 899                 }
 900
 901                 udelay(100);
 902         }
 903
 904         netdev_err(netdev, "mdio read timed out\n");
 905         return -EIO;
 906 }
 907
 908 static int ftgmac100_mdiobus_write(struct mii_bus *bus, int phy_addr,
 909                                    int regnum, u16 value)
 910 {
 911         struct net_device *netdev = bus->priv;
 912         struct ftgmac100 *priv = netdev_priv(netdev);
 913         unsigned int phycr;
 914         int data;
 915         int i;
 916
 917         phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
 918
 919         /* preserve MDC cycle threshold */
 920         phycr &= FTGMAC100_PHYCR_MDC_CYCTHR_MASK;
 921
 922         phycr |= FTGMAC100_PHYCR_PHYAD(phy_addr) |
 923                  FTGMAC100_PHYCR_REGAD(regnum) |
 924                  FTGMAC100_PHYCR_MIIWR;
 925
 926         data = FTGMAC100_PHYDATA_MIIWDATA(value);
 927
 928         iowrite32(data, priv->base + FTGMAC100_OFFSET_PHYDATA);
 929         iowrite32(phycr, priv->base + FTGMAC100_OFFSET_PHYCR);
 930
 931         for (i = 0; i < 10; i++) {
 932                 phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);
 933
 934                 if ((phycr & FTGMAC100_PHYCR_MIIWR) == 0)
 935                         return 0;
 936
 937                 udelay(100);
 938         }
 939
 940         netdev_err(netdev, "mdio write timed out\n");
 941         return -EIO;
 942 }
 943
 944 /******************************************************************************
 945  * struct ethtool_ops functions
 946  *****************************************************************************/
 947 static void ftgmac100_get_drvinfo(struct net_device *netdev,
 948                                   struct ethtool_drvinfo *info)
 949 {
 950         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
 951         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
 952         strlcpy(info->bus_info, dev_name(&netdev->dev), sizeof(info->bus_info));
 953 }
 954
 955 static int ftgmac100_get_settings(struct net_device *netdev,
 956                                   struct ethtool_cmd *cmd)
 957 {
 958         struct ftgmac100 *priv = netdev_priv(netdev);
 959
 960         return phy_ethtool_gset(priv->phydev, cmd);
 961 }
 962
 963 static int ftgmac100_set_settings(struct net_device *netdev,
 964                                   struct ethtool_cmd *cmd)
 965 {
 966         struct ftgmac100 *priv = netdev_priv(netdev);
 967
 968         return phy_ethtool_sset(priv->phydev, cmd);
 969 }
 970
 971 static const struct ethtool_ops ftgmac100_ethtool_ops = {
 972         .set_settings           = ftgmac100_set_settings,
 973         .get_settings           = ftgmac100_get_settings,
 974         .get_drvinfo            = ftgmac100_get_drvinfo,
 975         .get_link               = ethtool_op_get_link,
 976 };
 977
 978 /******************************************************************************
 979  * interrupt handler
 980  *****************************************************************************/
 981 static irqreturn_t ftgmac100_interrupt(int irq, void *dev_id)
 982 {
 983         struct net_device *netdev = dev_id;
 984         struct ftgmac100 *priv = netdev_priv(netdev);
 985
 986         if (likely(netif_running(netdev))) {
 987                 /* Disable interrupts for polling */
 988                 iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
 989                 napi_schedule(&priv->napi);
 990         }
 991
 992         return IRQ_HANDLED;
 993 }
 994
 995 /******************************************************************************
 996  * struct napi_struct functions
 997  *****************************************************************************/
 998 static int ftgmac100_poll(struct napi_struct *napi, int budget)
 999 {
1000         struct ftgmac100 *priv = container_of(napi, struct ftgmac100, napi);
1001         struct net_device *netdev = priv->netdev;
1002         unsigned int status;
1003         bool completed = true;
1004         int rx = 0;
1005
1006         status = ioread32(priv->base + FTGMAC100_OFFSET_ISR);
1007         iowrite32(status, priv->base + FTGMAC100_OFFSET_ISR);
1008
1009         if (status & (FTGMAC100_INT_RPKT_BUF | FTGMAC100_INT_NO_RXBUF)) {
1010                 /*
1011                  * FTGMAC100_INT_RPKT_BUF:
1012                  *      RX DMA has received packets into RX buffer successfully
1013                  *
1014                  * FTGMAC100_INT_NO_RXBUF:
1015                  *      RX buffer unavailable
1016                  */
1017                 bool retry;
1018
1019                 do {
1020                         retry = ftgmac100_rx_packet(priv, &rx);
1021                 } while (retry && rx < budget);
1022
1023                 if (retry && rx == budget)
1024                         completed = false;
1025         }
1026
1027         if (status & (FTGMAC100_INT_XPKT_ETH | FTGMAC100_INT_XPKT_LOST)) {
1028                 /*
1029                  * FTGMAC100_INT_XPKT_ETH:
1030                  *      packet transmitted to ethernet successfully
1031                  *
1032                  * FTGMAC100_INT_XPKT_LOST:
1033                  *      packet transmitted to ethernet lost due to late
1034                  *      collision or excessive collision
1035                  */
1036                 ftgmac100_tx_complete(priv);
1037         }
1038
1039         if (status & (FTGMAC100_INT_NO_RXBUF | FTGMAC100_INT_RPKT_LOST |
1040                       FTGMAC100_INT_AHB_ERR | FTGMAC100_INT_PHYSTS_CHG)) {
1041                 if (net_ratelimit())
1042                         netdev_info(netdev, "[ISR] = 0x%x: %s%s%s%s\n", status,
1043                                     status & FTGMAC100_INT_NO_RXBUF ? "NO_RXBUF " : "",
1044                                     status & FTGMAC100_INT_RPKT_LOST ? "RPKT_LOST " : "",
1045                                     status & FTGMAC100_INT_AHB_ERR ? "AHB_ERR " : "",
1046                                     status & FTGMAC100_INT_PHYSTS_CHG ? "PHYSTS_CHG" : "");
1047
1048                 if (status & FTGMAC100_INT_NO_RXBUF) {
1049                         /* RX buffer unavailable */
1050                         netdev->stats.rx_over_errors++;
1051                 }
1052
1053                 if (status & FTGMAC100_INT_RPKT_LOST) {
1054                         /* received packet lost due to RX FIFO full */
1055                         netdev->stats.rx_fifo_errors++;
1056                 }
1057         }
1058
1059         if (completed) {
1060                 napi_complete(napi);
1061
1062                 /* enable all interrupts */
1063                 iowrite32(INT_MASK_ALL_ENABLED, priv->base + FTGMAC100_OFFSET_IER);
1064         }
1065
1066         return rx;
1067 }
1068
1069 /******************************************************************************
1070  * struct net_device_ops functions
1071  *****************************************************************************/
1072 static int ftgmac100_open(struct net_device *netdev)
1073 {
1074         struct ftgmac100 *priv = netdev_priv(netdev);
1075         int err;
1076
1077         err = ftgmac100_alloc_buffers(priv);
1078         if (err) {
1079                 netdev_err(netdev, "failed to allocate buffers\n");
1080                 goto err_alloc;
1081         }
1082
1083         err = request_irq(priv->irq, ftgmac100_interrupt, 0, netdev->name, netdev);
1084         if (err) {
1085                 netdev_err(netdev, "failed to request irq %d\n", priv->irq);
1086                 goto err_irq;
1087         }
1088
1089         priv->rx_pointer = 0;
1090         priv->tx_clean_pointer = 0;
1091         priv->tx_pointer = 0;
1092         priv->tx_pending = 0;
1093
1094         err = ftgmac100_reset_hw(priv);
1095         if (err)
1096                 goto err_hw;
1097
1098         ftgmac100_init_hw(priv);
1099         ftgmac100_start_hw(priv, 10);
1100
1101         phy_start(priv->phydev);
1102
1103         napi_enable(&priv->napi);
1104         netif_start_queue(netdev);
1105
1106         /* enable all interrupts */
1107         iowrite32(INT_MASK_ALL_ENABLED, priv->base + FTGMAC100_OFFSET_IER);
1108         return 0;
1109
1110 err_hw:
1111         free_irq(priv->irq, netdev);
1112 err_irq:
1113         ftgmac100_free_buffers(priv);
1114 err_alloc:
1115         return err;
1116 }
1117
1118 static int ftgmac100_stop(struct net_device *netdev)
1119 {
1120         struct ftgmac100 *priv = netdev_priv(netdev);
1121
1122         /* disable all interrupts */
1123         iowrite32(0, priv->base + FTGMAC100_OFFSET_IER);
1124
1125         netif_stop_queue(netdev);
1126         napi_disable(&priv->napi);
1127         phy_stop(priv->phydev);
1128
1129         ftgmac100_stop_hw(priv);
1130         free_irq(priv->irq, netdev);
1131         ftgmac100_free_buffers(priv);
1132
1133         return 0;
1134 }
1135
1136 static int ftgmac100_hard_start_xmit(struct sk_buff *skb,
1137                                      struct net_device *netdev)
1138 {
1139         struct ftgmac100 *priv = netdev_priv(netdev);
1140         dma_addr_t map;
1141
1142         if (unlikely(skb->len > MAX_PKT_SIZE)) {
1143                 if (net_ratelimit())
1144                         netdev_dbg(netdev, "tx packet too big\n");
1145
1146                 netdev->stats.tx_dropped++;
1147                 kfree_skb(skb);
1148                 return NETDEV_TX_OK;
1149         }
1150
1151         map = dma_map_single(priv->dev, skb->data, skb_headlen(skb), DMA_TO_DEVICE);
1152         if (unlikely(dma_mapping_error(priv->dev, map))) {
1153                 /* drop packet */
1154                 if (net_ratelimit())
1155                         netdev_err(netdev, "map socket buffer failed\n");
1156
1157                 netdev->stats.tx_dropped++;
1158                 kfree_skb(skb);
1159                 return NETDEV_TX_OK;
1160         }
1161
1162         return ftgmac100_xmit(priv, skb, map);
1163 }
1164
1165 /* optional */
1166 static int ftgmac100_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
1167 {
1168         struct ftgmac100 *priv = netdev_priv(netdev);
1169
1170         return phy_mii_ioctl(priv->phydev, ifr, cmd);
1171 }
1172
1173 static const struct net_device_ops ftgmac100_netdev_ops = {
1174         .ndo_open               = ftgmac100_open,
1175         .ndo_stop               = ftgmac100_stop,
1176         .ndo_start_xmit         = ftgmac100_hard_start_xmit,
1177         .ndo_set_mac_address    = eth_mac_addr,
1178         .ndo_validate_addr      = eth_validate_addr,
1179         .ndo_do_ioctl           = ftgmac100_do_ioctl,
1180 };
1181
1182 /******************************************************************************
1183  * struct platform_driver functions
1184  *****************************************************************************/
1185 static int ftgmac100_probe(struct platform_device *pdev)
1186 {
1187         struct resource *res;
1188         int irq;
1189         struct net_device *netdev;
1190         struct ftgmac100 *priv;
1191         int err;
1192         int i;
1193
1194         if (!pdev)
1195                 return -ENODEV;
1196
1197         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1198         if (!res)
1199                 return -ENXIO;
1200
1201         irq = platform_get_irq(pdev, 0);
1202         if (irq < 0)
1203                 return irq;
1204
1205         /* setup net_device */
1206         netdev = alloc_etherdev(sizeof(*priv));
1207         if (!netdev) {
1208                 err = -ENOMEM;
1209                 goto err_alloc_etherdev;
1210         }
1211
1212         SET_NETDEV_DEV(netdev, &pdev->dev);
1213
1214         netdev->ethtool_ops = &ftgmac100_ethtool_ops;
1215         netdev->netdev_ops = &ftgmac100_netdev_ops;
1216         netdev->features = NETIF_F_IP_CSUM | NETIF_F_GRO;
1217
1218         platform_set_drvdata(pdev, netdev);
1219
1220         /* setup private data */
1221         priv = netdev_priv(netdev);
1222         priv->netdev = netdev;
1223         priv->dev = &pdev->dev;
1224
1225         spin_lock_init(&priv->tx_lock);
1226
1227         /* initialize NAPI */
1228         netif_napi_add(netdev, &priv->napi, ftgmac100_poll, 64);
1229
1230         /* map io memory */
1231         priv->res = request_mem_region(res->start, resource_size(res),
1232                                        dev_name(&pdev->dev));
1233         if (!priv->res) {
1234                 dev_err(&pdev->dev, "Could not reserve memory region\n");
1235                 err = -ENOMEM;
1236                 goto err_req_mem;
1237         }
1238
1239         priv->base = ioremap(res->start, resource_size(res));
1240         if (!priv->base) {
1241                 dev_err(&pdev->dev, "Failed to ioremap ethernet registers\n");
1242                 err = -EIO;
1243                 goto err_ioremap;
1244         }
1245
1246         priv->irq = irq;
1247
1248         /* initialize mdio bus */
1249         priv->mii_bus = mdiobus_alloc();
1250         if (!priv->mii_bus) {
1251                 err = -EIO;
1252                 goto err_alloc_mdiobus;
1253         }
1254
1255         priv->mii_bus->name = "ftgmac100_mdio";
1256         snprintf(priv->mii_bus->id, MII_BUS_ID_SIZE, "ftgmac100_mii");
1257
1258         priv->mii_bus->priv = netdev;
1259         priv->mii_bus->read = ftgmac100_mdiobus_read;
1260         priv->mii_bus->write = ftgmac100_mdiobus_write;
1261         priv->mii_bus->irq = priv->phy_irq;
1262
1263         for (i = 0; i < PHY_MAX_ADDR; i++)
1264                 priv->mii_bus->irq[i] = PHY_POLL;
1265
1266         err = mdiobus_register(priv->mii_bus);
1267         if (err) {
1268                 dev_err(&pdev->dev, "Cannot register MDIO bus!\n");
1269                 goto err_register_mdiobus;
1270         }
1271
1272         err = ftgmac100_mii_probe(priv);
1273         if (err) {
1274                 dev_err(&pdev->dev, "MII Probe failed!\n");
1275                 goto err_mii_probe;
1276         }
1277
1278         /* register network device */
1279         err = register_netdev(netdev);
1280         if (err) {
1281                 dev_err(&pdev->dev, "Failed to register netdev\n");
1282                 goto err_register_netdev;
1283         }
1284
1285         netdev_info(netdev, "irq %d, mapped at %p\n", priv->irq, priv->base);
1286
1287         if (!is_valid_ether_addr(netdev->dev_addr)) {
1288                 eth_hw_addr_random(netdev);
1289                 netdev_info(netdev, "generated random MAC address %pM\n",
1290                             netdev->dev_addr);
1291         }
1292
1293         return 0;
1294
1295 err_register_netdev:
1296         phy_disconnect(priv->phydev);
1297 err_mii_probe:
1298         mdiobus_unregister(priv->mii_bus);
1299 err_register_mdiobus:
1300         mdiobus_free(priv->mii_bus);
1301 err_alloc_mdiobus:
1302         iounmap(priv->base);
1303 err_ioremap:
1304         release_resource(priv->res);
1305 err_req_mem:
1306         netif_napi_del(&priv->napi);
1307         free_netdev(netdev);
1308 err_alloc_etherdev:
1309         return err;
1310 }
1311
1312 static int __exit ftgmac100_remove(struct platform_device *pdev)
1313 {
1314         struct net_device *netdev;
1315         struct ftgmac100 *priv;
1316
1317         netdev = platform_get_drvdata(pdev);
1318         priv = netdev_priv(netdev);
1319
1320         unregister_netdev(netdev);
1321
1322         phy_disconnect(priv->phydev);
1323         mdiobus_unregister(priv->mii_bus);
1324         mdiobus_free(priv->mii_bus);
1325
1326         iounmap(priv->base);
1327         release_resource(priv->res);
1328
1329         netif_napi_del(&priv->napi);
1330         free_netdev(netdev);
1331         return 0;
1332 }
1333
1334 static struct platform_driver ftgmac100_driver = {
1335         .probe          = ftgmac100_probe,
1336         .remove         = __exit_p(ftgmac100_remove),
1337         .driver         = {
1338                 .name   = DRV_NAME,
1339         },
1340 };
1341
1342 module_platform_driver(ftgmac100_driver);
1343
1344 MODULE_AUTHOR("Po-Yu Chuang <ratbert@faraday-tech.com>");
1345 MODULE_DESCRIPTION("FTGMAC100 driver");
1346 MODULE_LICENSE("GPL");