drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c

   1 /*
   2  * Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
   3  *
   4  * Copyright (c) 2003 Intracom S.A.
   5  *  by Pantelis Antoniou <panto@intracom.gr>
   6  *
   7  * 2005 (c) MontaVista Software, Inc.
   8  * Vitaly Bordug <vbordug@ru.mvista.com>
   9  *
  10  * Heavily based on original FEC driver by Dan Malek <dan@embeddededge.com>
  11  * and modifications by Joakim Tjernlund <joakim.tjernlund@lumentis.se>
  12  *
  13  * This file is licensed under the terms of the GNU General Public License
  14  * version 2. This program is licensed "as is" without any warranty of any
  15  * kind, whether express or implied.
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/types.h>
  21 #include <linux/string.h>
  22 #include <linux/ptrace.h>
  23 #include <linux/errno.h>
  24 #include <linux/ioport.h>
  25 #include <linux/slab.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/init.h>
  28 #include <linux/delay.h>
  29 #include <linux/netdevice.h>
  30 #include <linux/etherdevice.h>
  31 #include <linux/skbuff.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/mii.h>
  34 #include <linux/ethtool.h>
  35 #include <linux/bitops.h>
  36 #include <linux/fs.h>
  37 #include <linux/platform_device.h>
  38 #include <linux/phy.h>
  39 #include <linux/of.h>
  40 #include <linux/of_mdio.h>
  41 #include <linux/of_platform.h>
  42 #include <linux/of_gpio.h>
  43 #include <linux/of_net.h>
  44
  45 #include <linux/vmalloc.h>
  46 #include <asm/pgtable.h>
  47 #include <asm/irq.h>
  48 #include <asm/uaccess.h>
  49
  50 #include "fs_enet.h"
  51
  52 /*************************************************/
  53
  54 MODULE_AUTHOR("Pantelis Antoniou <panto@intracom.gr>");
  55 MODULE_DESCRIPTION("Freescale Ethernet Driver");
  56 MODULE_LICENSE("GPL");
  57 MODULE_VERSION(DRV_MODULE_VERSION);
  58
  59 static int fs_enet_debug = -1; /* -1 == use FS_ENET_DEF_MSG_ENABLE as value */
  60 module_param(fs_enet_debug, int, 0);
  61 MODULE_PARM_DESC(fs_enet_debug,
  62                  "Freescale bitmapped debugging message enable value");
  63
  64 #ifdef CONFIG_NET_POLL_CONTROLLER
  65 static void fs_enet_netpoll(struct net_device *dev);
  66 #endif
  67
  68 static void fs_set_multicast_list(struct net_device *dev)
  69 {
  70         struct fs_enet_private *fep = netdev_priv(dev);
  71
  72         (*fep->ops->set_multicast_list)(dev);
  73 }
  74
  75 static void skb_align(struct sk_buff *skb, int align)
  76 {
  77         int off = ((unsigned long)skb->data) & (align - 1);
  78
  79         if (off)
  80                 skb_reserve(skb, align - off);
  81 }
  82
  83 /* NAPI receive function */
  84 static int fs_enet_rx_napi(struct napi_struct *napi, int budget)
  85 {
  86         struct fs_enet_private *fep = container_of(napi, struct fs_enet_private, napi);
  87         struct net_device *dev = fep->ndev;
  88         const struct fs_platform_info *fpi = fep->fpi;
  89         cbd_t __iomem *bdp;
  90         struct sk_buff *skb, *skbn, *skbt;
  91         int received = 0;
  92         u16 pkt_len, sc;
  93         int curidx;
  94
  95         /*
  96          * First, grab all of the stats for the incoming packet.
  97          * These get messed up if we get called due to a busy condition.
  98          */
  99         bdp = fep->cur_rx;
 100
 101         /* clear RX status bits for napi*/
 102         (*fep->ops->napi_clear_rx_event)(dev);
 103
 104         while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0) {
 105                 curidx = bdp - fep->rx_bd_base;
 106
 107                 /*
 108                  * Since we have allocated space to hold a complete frame,
 109                  * the last indicator should be set.
 110                  */
 111                 if ((sc & BD_ENET_RX_LAST) == 0)
 112                         dev_warn(fep->dev, "rcv is not +last\n");
 113
 114                 /*
 115                  * Check for errors.
 116                  */
 117                 if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_CL |
 118                           BD_ENET_RX_NO | BD_ENET_RX_CR | BD_ENET_RX_OV)) {
 119                         fep->stats.rx_errors++;
 120                         /* Frame too long or too short. */
 121                         if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH))
 122                                 fep->stats.rx_length_errors++;
 123                         /* Frame alignment */
 124                         if (sc & (BD_ENET_RX_NO | BD_ENET_RX_CL))
 125                                 fep->stats.rx_frame_errors++;
 126                         /* CRC Error */
 127                         if (sc & BD_ENET_RX_CR)
 128                                 fep->stats.rx_crc_errors++;
 129                         /* FIFO overrun */
 130                         if (sc & BD_ENET_RX_OV)
 131                                 fep->stats.rx_crc_errors++;
 132
 133                         skb = fep->rx_skbuff[curidx];
 134
 135                         dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
 136                                 L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
 137                                 DMA_FROM_DEVICE);
 138
 139                         skbn = skb;
 140
 141                 } else {
 142                         skb = fep->rx_skbuff[curidx];
 143
 144                         dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
 145                                 L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
 146                                 DMA_FROM_DEVICE);
 147
 148                         /*
 149                          * Process the incoming frame.
 150                          */
 151                         fep->stats.rx_packets++;
 152                         pkt_len = CBDR_DATLEN(bdp) - 4; /* remove CRC */
 153                         fep->stats.rx_bytes += pkt_len + 4;
 154
 155                         if (pkt_len <= fpi->rx_copybreak) {
 156                                 /* +2 to make IP header L1 cache aligned */
 157                                 skbn = netdev_alloc_skb(dev, pkt_len + 2);
 158                                 if (skbn != NULL) {
 159                                         skb_reserve(skbn, 2);   /* align IP header */
 160                                         skb_copy_from_linear_data(skb,
 161                                                       skbn->data, pkt_len);
 162                                         /* swap */
 163                                         skbt = skb;
 164                                         skb = skbn;
 165                                         skbn = skbt;
 166                                 }
 167                         } else {
 168                                 skbn = netdev_alloc_skb(dev, ENET_RX_FRSIZE);
 169
 170                                 if (skbn)
 171                                         skb_align(skbn, ENET_RX_ALIGN);
 172                         }
 173
 174                         if (skbn != NULL) {
 175                                 skb_put(skb, pkt_len);  /* Make room */
 176                                 skb->protocol = eth_type_trans(skb, dev);
 177                                 received++;
 178                                 netif_receive_skb(skb);
 179                         } else {
 180                                 fep->stats.rx_dropped++;
 181                                 skbn = skb;
 182                         }
 183                 }
 184
 185                 fep->rx_skbuff[curidx] = skbn;
 186                 CBDW_BUFADDR(bdp, dma_map_single(fep->dev, skbn->data,
 187                              L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
 188                              DMA_FROM_DEVICE));
 189                 CBDW_DATLEN(bdp, 0);
 190                 CBDW_SC(bdp, (sc & ~BD_ENET_RX_STATS) | BD_ENET_RX_EMPTY);
 191
 192                 /*
 193                  * Update BD pointer to next entry.
 194                  */
 195                 if ((sc & BD_ENET_RX_WRAP) == 0)
 196                         bdp++;
 197                 else
 198                         bdp = fep->rx_bd_base;
 199
 200                 (*fep->ops->rx_bd_done)(dev);
 201
 202                 if (received >= budget)
 203                         break;
 204         }
 205
 206         fep->cur_rx = bdp;
 207
 208         if (received < budget) {
 209                 /* done */
 210                 napi_complete(napi);
 211                 (*fep->ops->napi_enable_rx)(dev);
 212         }
 213         return received;
 214 }
 215
 216 /* non NAPI receive function */
 217 static int fs_enet_rx_non_napi(struct net_device *dev)
 218 {
 219         struct fs_enet_private *fep = netdev_priv(dev);
 220         const struct fs_platform_info *fpi = fep->fpi;
 221         cbd_t __iomem *bdp;
 222         struct sk_buff *skb, *skbn, *skbt;
 223         int received = 0;
 224         u16 pkt_len, sc;
 225         int curidx;
 226         /*
 227          * First, grab all of the stats for the incoming packet.
 228          * These get messed up if we get called due to a busy condition.
 229          */
 230         bdp = fep->cur_rx;
 231
 232         while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0) {
 233
 234                 curidx = bdp - fep->rx_bd_base;
 235
 236                 /*
 237                  * Since we have allocated space to hold a complete frame,
 238                  * the last indicator should be set.
 239                  */
 240                 if ((sc & BD_ENET_RX_LAST) == 0)
 241                         dev_warn(fep->dev, "rcv is not +last\n");
 242
 243                 /*
 244                  * Check for errors.
 245                  */
 246                 if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_CL |
 247                           BD_ENET_RX_NO | BD_ENET_RX_CR | BD_ENET_RX_OV)) {
 248                         fep->stats.rx_errors++;
 249                         /* Frame too long or too short. */
 250                         if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH))
 251                                 fep->stats.rx_length_errors++;
 252                         /* Frame alignment */
 253                         if (sc & (BD_ENET_RX_NO | BD_ENET_RX_CL))
 254                                 fep->stats.rx_frame_errors++;
 255                         /* CRC Error */
 256                         if (sc & BD_ENET_RX_CR)
 257                                 fep->stats.rx_crc_errors++;
 258                         /* FIFO overrun */
 259                         if (sc & BD_ENET_RX_OV)
 260                                 fep->stats.rx_crc_errors++;
 261
 262                         skb = fep->rx_skbuff[curidx];
 263
 264                         dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
 265                                 L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
 266                                 DMA_FROM_DEVICE);
 267
 268                         skbn = skb;
 269
 270                 } else {
 271
 272                         skb = fep->rx_skbuff[curidx];
 273
 274                         dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
 275                                 L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
 276                                 DMA_FROM_DEVICE);
 277
 278                         /*
 279                          * Process the incoming frame.
 280                          */
 281                         fep->stats.rx_packets++;
 282                         pkt_len = CBDR_DATLEN(bdp) - 4; /* remove CRC */
 283                         fep->stats.rx_bytes += pkt_len + 4;
 284
 285                         if (pkt_len <= fpi->rx_copybreak) {
 286                                 /* +2 to make IP header L1 cache aligned */
 287                                 skbn = netdev_alloc_skb(dev, pkt_len + 2);
 288                                 if (skbn != NULL) {
 289                                         skb_reserve(skbn, 2);   /* align IP header */
 290                                         skb_copy_from_linear_data(skb,
 291                                                       skbn->data, pkt_len);
 292                                         /* swap */
 293                                         skbt = skb;
 294                                         skb = skbn;
 295                                         skbn = skbt;
 296                                 }
 297                         } else {
 298                                 skbn = netdev_alloc_skb(dev, ENET_RX_FRSIZE);
 299
 300                                 if (skbn)
 301                                         skb_align(skbn, ENET_RX_ALIGN);
 302                         }
 303
 304                         if (skbn != NULL) {
 305                                 skb_put(skb, pkt_len);  /* Make room */
 306                                 skb->protocol = eth_type_trans(skb, dev);
 307                                 received++;
 308                                 netif_rx(skb);
 309                         } else {
 310                                 fep->stats.rx_dropped++;
 311                                 skbn = skb;
 312                         }
 313                 }
 314
 315                 fep->rx_skbuff[curidx] = skbn;
 316                 CBDW_BUFADDR(bdp, dma_map_single(fep->dev, skbn->data,
 317                              L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
 318                              DMA_FROM_DEVICE));
 319                 CBDW_DATLEN(bdp, 0);
 320                 CBDW_SC(bdp, (sc & ~BD_ENET_RX_STATS) | BD_ENET_RX_EMPTY);
 321
 322                 /*
 323                  * Update BD pointer to next entry.
 324                  */
 325                 if ((sc & BD_ENET_RX_WRAP) == 0)
 326                         bdp++;
 327                 else
 328                         bdp = fep->rx_bd_base;
 329
 330                 (*fep->ops->rx_bd_done)(dev);
 331         }
 332
 333         fep->cur_rx = bdp;
 334
 335         return 0;
 336 }
 337
 338 static void fs_enet_tx(struct net_device *dev)
 339 {
 340         struct fs_enet_private *fep = netdev_priv(dev);
 341         cbd_t __iomem *bdp;
 342         struct sk_buff *skb;
 343         int dirtyidx, do_wake, do_restart;
 344         u16 sc;
 345
 346         spin_lock(&fep->tx_lock);
 347         bdp = fep->dirty_tx;
 348
 349         do_wake = do_restart = 0;
 350         while (((sc = CBDR_SC(bdp)) & BD_ENET_TX_READY) == 0) {
 351                 dirtyidx = bdp - fep->tx_bd_base;
 352
 353                 if (fep->tx_free == fep->tx_ring)
 354                         break;
 355
 356                 skb = fep->tx_skbuff[dirtyidx];
 357
 358                 /*
 359                  * Check for errors.
 360                  */
 361                 if (sc & (BD_ENET_TX_HB | BD_ENET_TX_LC |
 362                           BD_ENET_TX_RL | BD_ENET_TX_UN | BD_ENET_TX_CSL)) {
 363
 364                         if (sc & BD_ENET_TX_HB) /* No heartbeat */
 365                                 fep->stats.tx_heartbeat_errors++;
 366                         if (sc & BD_ENET_TX_LC) /* Late collision */
 367                                 fep->stats.tx_window_errors++;
 368                         if (sc & BD_ENET_TX_RL) /* Retrans limit */
 369                                 fep->stats.tx_aborted_errors++;
 370                         if (sc & BD_ENET_TX_UN) /* Underrun */
 371                                 fep->stats.tx_fifo_errors++;
 372                         if (sc & BD_ENET_TX_CSL)        /* Carrier lost */
 373                                 fep->stats.tx_carrier_errors++;
 374
 375                         if (sc & (BD_ENET_TX_LC | BD_ENET_TX_RL | BD_ENET_TX_UN)) {
 376                                 fep->stats.tx_errors++;
 377                                 do_restart = 1;
 378                         }
 379                 } else
 380                         fep->stats.tx_packets++;
 381
 382                 if (sc & BD_ENET_TX_READY) {
 383                         dev_warn(fep->dev,
 384                                  "HEY! Enet xmit interrupt and TX_READY.\n");
 385                 }
 386
 387                 /*
 388                  * Deferred means some collisions occurred during transmit,
 389                  * but we eventually sent the packet OK.
 390                  */
 391                 if (sc & BD_ENET_TX_DEF)
 392                         fep->stats.collisions++;
 393
 394                 /* unmap */
 395                 dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
 396                                 skb->len, DMA_TO_DEVICE);
 397
 398                 /*
 399                  * Free the sk buffer associated with this last transmit.
 400                  */
 401                 dev_kfree_skb_irq(skb);
 402                 fep->tx_skbuff[dirtyidx] = NULL;
 403
 404                 /*
 405                  * Update pointer to next buffer descriptor to be transmitted.
 406                  */
 407                 if ((sc & BD_ENET_TX_WRAP) == 0)
 408                         bdp++;
 409                 else
 410                         bdp = fep->tx_bd_base;
 411
 412                 /*
 413                  * Since we have freed up a buffer, the ring is no longer
 414                  * full.
 415                  */
 416                 if (!fep->tx_free++)
 417                         do_wake = 1;
 418         }
 419
 420         fep->dirty_tx = bdp;
 421
 422         if (do_restart)
 423                 (*fep->ops->tx_restart)(dev);
 424
 425         spin_unlock(&fep->tx_lock);
 426
 427         if (do_wake)
 428                 netif_wake_queue(dev);
 429 }
 430
 431 /*
 432  * The interrupt handler.
 433  * This is called from the MPC core interrupt.
 434  */
 435 static irqreturn_t
 436 fs_enet_interrupt(int irq, void *dev_id)
 437 {
 438         struct net_device *dev = dev_id;
 439         struct fs_enet_private *fep;
 440         const struct fs_platform_info *fpi;
 441         u32 int_events;
 442         u32 int_clr_events;
 443         int nr, napi_ok;
 444         int handled;
 445
 446         fep = netdev_priv(dev);
 447         fpi = fep->fpi;
 448
 449         nr = 0;
 450         while ((int_events = (*fep->ops->get_int_events)(dev)) != 0) {
 451                 nr++;
 452
 453                 int_clr_events = int_events;
 454                 if (fpi->use_napi)
 455                         int_clr_events &= ~fep->ev_napi_rx;
 456
 457                 (*fep->ops->clear_int_events)(dev, int_clr_events);
 458
 459                 if (int_events & fep->ev_err)
 460                         (*fep->ops->ev_error)(dev, int_events);
 461
 462                 if (int_events & fep->ev_rx) {
 463                         if (!fpi->use_napi)
 464                                 fs_enet_rx_non_napi(dev);
 465                         else {
 466                                 napi_ok = napi_schedule_prep(&fep->napi);
 467
 468                                 (*fep->ops->napi_disable_rx)(dev);
 469                                 (*fep->ops->clear_int_events)(dev, fep->ev_napi_rx);
 470
 471                                 /* NOTE: it is possible for FCCs in NAPI mode    */
 472                                 /* to submit a spurious interrupt while in poll  */
 473                                 if (napi_ok)
 474                                         __napi_schedule(&fep->napi);
 475                         }
 476                 }
 477
 478                 if (int_events & fep->ev_tx)
 479                         fs_enet_tx(dev);
 480         }
 481
 482         handled = nr > 0;
 483         return IRQ_RETVAL(handled);
 484 }
 485
 486 void fs_init_bds(struct net_device *dev)
 487 {
 488         struct fs_enet_private *fep = netdev_priv(dev);
 489         cbd_t __iomem *bdp;
 490         struct sk_buff *skb;
 491         int i;
 492
 493         fs_cleanup_bds(dev);
 494
 495         fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
 496         fep->tx_free = fep->tx_ring;
 497         fep->cur_rx = fep->rx_bd_base;
 498
 499         /*
 500          * Initialize the receive buffer descriptors.
 501          */
 502         for (i = 0, bdp = fep->rx_bd_base; i < fep->rx_ring; i++, bdp++) {
 503                 skb = netdev_alloc_skb(dev, ENET_RX_FRSIZE);
 504                 if (skb == NULL)
 505                         break;
 506
 507                 skb_align(skb, ENET_RX_ALIGN);
 508                 fep->rx_skbuff[i] = skb;
 509                 CBDW_BUFADDR(bdp,
 510                         dma_map_single(fep->dev, skb->data,
 511                                 L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
 512                                 DMA_FROM_DEVICE));
 513                 CBDW_DATLEN(bdp, 0);    /* zero */
 514                 CBDW_SC(bdp, BD_ENET_RX_EMPTY |
 515                         ((i < fep->rx_ring - 1) ? 0 : BD_SC_WRAP));
 516         }
 517         /*
 518          * if we failed, fillup remainder
 519          */
 520         for (; i < fep->rx_ring; i++, bdp++) {
 521                 fep->rx_skbuff[i] = NULL;
 522                 CBDW_SC(bdp, (i < fep->rx_ring - 1) ? 0 : BD_SC_WRAP);
 523         }
 524
 525         /*
 526          * ...and the same for transmit.
 527          */
 528         for (i = 0, bdp = fep->tx_bd_base; i < fep->tx_ring; i++, bdp++) {
 529                 fep->tx_skbuff[i] = NULL;
 530                 CBDW_BUFADDR(bdp, 0);
 531                 CBDW_DATLEN(bdp, 0);
 532                 CBDW_SC(bdp, (i < fep->tx_ring - 1) ? 0 : BD_SC_WRAP);
 533         }
 534 }
 535
 536 void fs_cleanup_bds(struct net_device *dev)
 537 {
 538         struct fs_enet_private *fep = netdev_priv(dev);
 539         struct sk_buff *skb;
 540         cbd_t __iomem *bdp;
 541         int i;
 542
 543         /*
 544          * Reset SKB transmit buffers.
 545          */
 546         for (i = 0, bdp = fep->tx_bd_base; i < fep->tx_ring; i++, bdp++) {
 547                 if ((skb = fep->tx_skbuff[i]) == NULL)
 548                         continue;
 549
 550                 /* unmap */
 551                 dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
 552                                 skb->len, DMA_TO_DEVICE);
 553
 554                 fep->tx_skbuff[i] = NULL;
 555                 dev_kfree_skb(skb);
 556         }
 557
 558         /*
 559          * Reset SKB receive buffers
 560          */
 561         for (i = 0, bdp = fep->rx_bd_base; i < fep->rx_ring; i++, bdp++) {
 562                 if ((skb = fep->rx_skbuff[i]) == NULL)
 563                         continue;
 564
 565                 /* unmap */
 566                 dma_unmap_single(fep->dev, CBDR_BUFADDR(bdp),
 567                         L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
 568                         DMA_FROM_DEVICE);
 569
 570                 fep->rx_skbuff[i] = NULL;
 571
 572                 dev_kfree_skb(skb);
 573         }
 574 }
 575
 576 /**********************************************************************************/
 577
 578 #ifdef CONFIG_FS_ENET_MPC5121_FEC
 579 /*
 580  * MPC5121 FEC requeries 4-byte alignment for TX data buffer!
 581  */
 582 static struct sk_buff *tx_skb_align_workaround(struct net_device *dev,
 583                                                struct sk_buff *skb)
 584 {
 585         struct sk_buff *new_skb;
 586         struct fs_enet_private *fep = netdev_priv(dev);
 587
 588         /* Alloc new skb */
 589         new_skb = netdev_alloc_skb(dev, skb->len + 4);
 590         if (!new_skb)
 591                 return NULL;
 592
 593         /* Make sure new skb is properly aligned */
 594         skb_align(new_skb, 4);
 595
 596         /* Copy data to new skb ... */
 597         skb_copy_from_linear_data(skb, new_skb->data, skb->len);
 598         skb_put(new_skb, skb->len);
 599
 600         /* ... and free an old one */
 601         dev_kfree_skb_any(skb);
 602
 603         return new_skb;
 604 }
 605 #endif
 606
 607 static int fs_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
 608 {
 609         struct fs_enet_private *fep = netdev_priv(dev);
 610         cbd_t __iomem *bdp;
 611         int curidx;
 612         u16 sc;
 613         unsigned long flags;
 614
 615 #ifdef CONFIG_FS_ENET_MPC5121_FEC
 616         if (((unsigned long)skb->data) & 0x3) {
 617                 skb = tx_skb_align_workaround(dev, skb);
 618                 if (!skb) {
 619                         /*
 620                          * We have lost packet due to memory allocation error
 621                          * in tx_skb_align_workaround(). Hopefully original
 622                          * skb is still valid, so try transmit it later.
 623                          */
 624                         return NETDEV_TX_BUSY;
 625                 }
 626         }
 627 #endif
 628         spin_lock_irqsave(&fep->tx_lock, flags);
 629
 630         /*
 631          * Fill in a Tx ring entry
 632          */
 633         bdp = fep->cur_tx;
 634
 635         if (!fep->tx_free || (CBDR_SC(bdp) & BD_ENET_TX_READY)) {
 636                 netif_stop_queue(dev);
 637                 spin_unlock_irqrestore(&fep->tx_lock, flags);
 638
 639                 /*
 640                  * Ooops.  All transmit buffers are full.  Bail out.
 641                  * This should not happen, since the tx queue should be stopped.
 642                  */
 643                 dev_warn(fep->dev, "tx queue full!.\n");
 644                 return NETDEV_TX_BUSY;
 645         }
 646
 647         curidx = bdp - fep->tx_bd_base;
 648         /*
 649          * Clear all of the status flags.
 650          */
 651         CBDC_SC(bdp, BD_ENET_TX_STATS);
 652
 653         /*
 654          * Save skb pointer.
 655          */
 656         fep->tx_skbuff[curidx] = skb;
 657
 658         fep->stats.tx_bytes += skb->len;
 659
 660         /*
 661          * Push the data cache so the CPM does not get stale memory data.
 662          */
 663         CBDW_BUFADDR(bdp, dma_map_single(fep->dev,
 664                                 skb->data, skb->len, DMA_TO_DEVICE));
 665         CBDW_DATLEN(bdp, skb->len);
 666
 667         /*
 668          * If this was the last BD in the ring, start at the beginning again.
 669          */
 670         if ((CBDR_SC(bdp) & BD_ENET_TX_WRAP) == 0)
 671                 fep->cur_tx++;
 672         else
 673                 fep->cur_tx = fep->tx_bd_base;
 674
 675         if (!--fep->tx_free)
 676                 netif_stop_queue(dev);
 677
 678         /* Trigger transmission start */
 679         sc = BD_ENET_TX_READY | BD_ENET_TX_INTR |
 680              BD_ENET_TX_LAST | BD_ENET_TX_TC;
 681
 682         /* note that while FEC does not have this bit
 683          * it marks it as available for software use
 684          * yay for hw reuse :) */
 685         if (skb->len <= 60)
 686                 sc |= BD_ENET_TX_PAD;
 687         CBDS_SC(bdp, sc);
 688
 689         skb_tx_timestamp(skb);
 690
 691         (*fep->ops->tx_kickstart)(dev);
 692
 693         spin_unlock_irqrestore(&fep->tx_lock, flags);
 694
 695         return NETDEV_TX_OK;
 696 }
 697
 698 static void fs_timeout(struct net_device *dev)
 699 {
 700         struct fs_enet_private *fep = netdev_priv(dev);
 701         unsigned long flags;
 702         int wake = 0;
 703
 704         fep->stats.tx_errors++;
 705
 706         spin_lock_irqsave(&fep->lock, flags);
 707
 708         if (dev->flags & IFF_UP) {
 709                 phy_stop(fep->phydev);
 710                 (*fep->ops->stop)(dev);
 711                 (*fep->ops->restart)(dev);
 712                 phy_start(fep->phydev);
 713         }
 714
 715         phy_start(fep->phydev);
 716         wake = fep->tx_free && !(CBDR_SC(fep->cur_tx) & BD_ENET_TX_READY);
 717         spin_unlock_irqrestore(&fep->lock, flags);
 718
 719         if (wake)
 720                 netif_wake_queue(dev);
 721 }
 722
 723 /*-----------------------------------------------------------------------------
 724  *  generic link-change handler - should be sufficient for most cases
 725  *-----------------------------------------------------------------------------*/
 726 static void generic_adjust_link(struct  net_device *dev)
 727 {
 728         struct fs_enet_private *fep = netdev_priv(dev);
 729         struct phy_device *phydev = fep->phydev;
 730         int new_state = 0;
 731
 732         if (phydev->link) {
 733                 /* adjust to duplex mode */
 734                 if (phydev->duplex != fep->oldduplex) {
 735                         new_state = 1;
 736                         fep->oldduplex = phydev->duplex;
 737                 }
 738
 739                 if (phydev->speed != fep->oldspeed) {
 740                         new_state = 1;
 741                         fep->oldspeed = phydev->speed;
 742                 }
 743
 744                 if (!fep->oldlink) {
 745                         new_state = 1;
 746                         fep->oldlink = 1;
 747                 }
 748
 749                 if (new_state)
 750                         fep->ops->restart(dev);
 751         } else if (fep->oldlink) {
 752                 new_state = 1;
 753                 fep->oldlink = 0;
 754                 fep->oldspeed = 0;
 755                 fep->oldduplex = -1;
 756         }
 757
 758         if (new_state && netif_msg_link(fep))
 759                 phy_print_status(phydev);
 760 }
 761
 762
 763 static void fs_adjust_link(struct net_device *dev)
 764 {
 765         struct fs_enet_private *fep = netdev_priv(dev);
 766         unsigned long flags;
 767
 768         spin_lock_irqsave(&fep->lock, flags);
 769
 770         if(fep->ops->adjust_link)
 771                 fep->ops->adjust_link(dev);
 772         else
 773                 generic_adjust_link(dev);
 774
 775         spin_unlock_irqrestore(&fep->lock, flags);
 776 }
 777
 778 static int fs_init_phy(struct net_device *dev)
 779 {
 780         struct fs_enet_private *fep = netdev_priv(dev);
 781         struct phy_device *phydev;
 782         phy_interface_t iface;
 783
 784         fep->oldlink = 0;
 785         fep->oldspeed = 0;
 786         fep->oldduplex = -1;
 787
 788         iface = fep->fpi->use_rmii ?
 789                 PHY_INTERFACE_MODE_RMII : PHY_INTERFACE_MODE_MII;
 790
 791         phydev = of_phy_connect(dev, fep->fpi->phy_node, &fs_adjust_link, 0,
 792                                 iface);
 793         if (!phydev) {
 794                 phydev = of_phy_connect_fixed_link(dev, &fs_adjust_link,
 795                                                    iface);
 796         }
 797         if (!phydev) {
 798                 dev_err(&dev->dev, "Could not attach to PHY\n");
 799                 return -ENODEV;
 800         }
 801
 802         fep->phydev = phydev;
 803
 804         return 0;
 805 }
 806
 807 static int fs_enet_open(struct net_device *dev)
 808 {
 809         struct fs_enet_private *fep = netdev_priv(dev);
 810         int r;
 811         int err;
 812
 813         /* to initialize the fep->cur_rx,... */
 814         /* not doing this, will cause a crash in fs_enet_rx_napi */
 815         fs_init_bds(fep->ndev);
 816
 817         if (fep->fpi->use_napi)
 818                 napi_enable(&fep->napi);
 819
 820         /* Install our interrupt handler. */
 821         r = request_irq(fep->interrupt, fs_enet_interrupt, IRQF_SHARED,
 822                         "fs_enet-mac", dev);
 823         if (r != 0) {
 824                 dev_err(fep->dev, "Could not allocate FS_ENET IRQ!");
 825                 if (fep->fpi->use_napi)
 826                         napi_disable(&fep->napi);
 827                 return -EINVAL;
 828         }
 829
 830         err = fs_init_phy(dev);
 831         if (err) {
 832                 free_irq(fep->interrupt, dev);
 833                 if (fep->fpi->use_napi)
 834                         napi_disable(&fep->napi);
 835                 return err;
 836         }
 837         phy_start(fep->phydev);
 838
 839         netif_start_queue(dev);
 840
 841         return 0;
 842 }
 843
 844 static int fs_enet_close(struct net_device *dev)
 845 {
 846         struct fs_enet_private *fep = netdev_priv(dev);
 847         unsigned long flags;
 848
 849         netif_stop_queue(dev);
 850         netif_carrier_off(dev);
 851         if (fep->fpi->use_napi)
 852                 napi_disable(&fep->napi);
 853         phy_stop(fep->phydev);
 854
 855         spin_lock_irqsave(&fep->lock, flags);
 856         spin_lock(&fep->tx_lock);
 857         (*fep->ops->stop)(dev);
 858         spin_unlock(&fep->tx_lock);
 859         spin_unlock_irqrestore(&fep->lock, flags);
 860
 861         /* release any irqs */
 862         phy_disconnect(fep->phydev);
 863         fep->phydev = NULL;
 864         free_irq(fep->interrupt, dev);
 865
 866         return 0;
 867 }
 868
 869 static struct net_device_stats *fs_enet_get_stats(struct net_device *dev)
 870 {
 871         struct fs_enet_private *fep = netdev_priv(dev);
 872         return &fep->stats;
 873 }
 874
 875 /*************************************************************************/
 876
 877 static void fs_get_drvinfo(struct net_device *dev,
 878                             struct ethtool_drvinfo *info)
 879 {
 880         strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
 881         strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
 882 }
 883
 884 static int fs_get_regs_len(struct net_device *dev)
 885 {
 886         struct fs_enet_private *fep = netdev_priv(dev);
 887
 888         return (*fep->ops->get_regs_len)(dev);
 889 }
 890
 891 static void fs_get_regs(struct net_device *dev, struct ethtool_regs *regs,
 892                          void *p)
 893 {
 894         struct fs_enet_private *fep = netdev_priv(dev);
 895         unsigned long flags;
 896         int r, len;
 897
 898         len = regs->len;
 899
 900         spin_lock_irqsave(&fep->lock, flags);
 901         r = (*fep->ops->get_regs)(dev, p, &len);
 902         spin_unlock_irqrestore(&fep->lock, flags);
 903
 904         if (r == 0)
 905                 regs->version = 0;
 906 }
 907
 908 static int fs_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 909 {
 910         struct fs_enet_private *fep = netdev_priv(dev);
 911
 912         if (!fep->phydev)
 913                 return -ENODEV;
 914
 915         return phy_ethtool_gset(fep->phydev, cmd);
 916 }
 917
 918 static int fs_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 919 {
 920         struct fs_enet_private *fep = netdev_priv(dev);
 921
 922         if (!fep->phydev)
 923                 return -ENODEV;
 924
 925         return phy_ethtool_sset(fep->phydev, cmd);
 926 }
 927
 928 static int fs_nway_reset(struct net_device *dev)
 929 {
 930         return 0;
 931 }
 932
 933 static u32 fs_get_msglevel(struct net_device *dev)
 934 {
 935         struct fs_enet_private *fep = netdev_priv(dev);
 936         return fep->msg_enable;
 937 }
 938
 939 static void fs_set_msglevel(struct net_device *dev, u32 value)
 940 {
 941         struct fs_enet_private *fep = netdev_priv(dev);
 942         fep->msg_enable = value;
 943 }
 944
 945 static const struct ethtool_ops fs_ethtool_ops = {
 946         .get_drvinfo = fs_get_drvinfo,
 947         .get_regs_len = fs_get_regs_len,
 948         .get_settings = fs_get_settings,
 949         .set_settings = fs_set_settings,
 950         .nway_reset = fs_nway_reset,
 951         .get_link = ethtool_op_get_link,
 952         .get_msglevel = fs_get_msglevel,
 953         .set_msglevel = fs_set_msglevel,
 954         .get_regs = fs_get_regs,
 955         .get_ts_info = ethtool_op_get_ts_info,
 956 };
 957
 958 static int fs_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 959 {
 960         struct fs_enet_private *fep = netdev_priv(dev);
 961
 962         if (!netif_running(dev))
 963                 return -EINVAL;
 964
 965         return phy_mii_ioctl(fep->phydev, rq, cmd);
 966 }
 967
 968 extern int fs_mii_connect(struct net_device *dev);
 969 extern void fs_mii_disconnect(struct net_device *dev);
 970
 971 /**************************************************************************************/
 972
 973 #ifdef CONFIG_FS_ENET_HAS_FEC
 974 #define IS_FEC(match) ((match)->data == &fs_fec_ops)
 975 #else
 976 #define IS_FEC(match) 0
 977 #endif
 978
 979 static const struct net_device_ops fs_enet_netdev_ops = {
 980         .ndo_open               = fs_enet_open,
 981         .ndo_stop               = fs_enet_close,
 982         .ndo_get_stats          = fs_enet_get_stats,
 983         .ndo_start_xmit         = fs_enet_start_xmit,
 984         .ndo_tx_timeout         = fs_timeout,
 985         .ndo_set_rx_mode        = fs_set_multicast_list,
 986         .ndo_do_ioctl           = fs_ioctl,
 987         .ndo_validate_addr      = eth_validate_addr,
 988         .ndo_set_mac_address    = eth_mac_addr,
 989         .ndo_change_mtu         = eth_change_mtu,
 990 #ifdef CONFIG_NET_POLL_CONTROLLER
 991         .ndo_poll_controller    = fs_enet_netpoll,
 992 #endif
 993 };
 994
 995 static struct of_device_id fs_enet_match[];
 996 static int fs_enet_probe(struct platform_device *ofdev)
 997 {
 998         const struct of_device_id *match;
 999         struct net_device *ndev;
1000         struct fs_enet_private *fep;
1001         struct fs_platform_info *fpi;
1002         const u32 *data;
1003         const u8 *mac_addr;
1004         const char *phy_connection_type;
1005         int privsize, len, ret = -ENODEV;
1006
1007         match = of_match_device(fs_enet_match, &ofdev->dev);
1008         if (!match)
1009                 return -EINVAL;
1010
1011         fpi = kzalloc(sizeof(*fpi), GFP_KERNEL);
1012         if (!fpi)
1013                 return -ENOMEM;
1014
1015         if (!IS_FEC(match)) {
1016                 data = of_get_property(ofdev->dev.of_node, "fsl,cpm-command", &len);
1017                 if (!data || len != 4)
1018                         goto out_free_fpi;
1019
1020                 fpi->cp_command = *data;
1021         }
1022
1023         fpi->rx_ring = 32;
1024         fpi->tx_ring = 32;
1025         fpi->rx_copybreak = 240;
1026         fpi->use_napi = 1;
1027         fpi->napi_weight = 17;
1028         fpi->phy_node = of_parse_phandle(ofdev->dev.of_node, "phy-handle", 0);
1029         if ((!fpi->phy_node) && (!of_get_property(ofdev->dev.of_node, "fixed-link",
1030                                                   NULL)))
1031                 goto out_free_fpi;
1032
1033         if (of_device_is_compatible(ofdev->dev.of_node, "fsl,mpc5125-fec")) {
1034                 phy_connection_type = of_get_property(ofdev->dev.of_node,
1035                                                 "phy-connection-type", NULL);
1036                 if (phy_connection_type && !strcmp("rmii", phy_connection_type))
1037                         fpi->use_rmii = 1;
1038         }
1039
1040         privsize = sizeof(*fep) +
1041                    sizeof(struct sk_buff **) *
1042                    (fpi->rx_ring + fpi->tx_ring);
1043
1044         ndev = alloc_etherdev(privsize);
1045         if (!ndev) {
1046                 ret = -ENOMEM;
1047                 goto out_put;
1048         }
1049
1050         SET_NETDEV_DEV(ndev, &ofdev->dev);
1051         dev_set_drvdata(&ofdev->dev, ndev);
1052
1053         fep = netdev_priv(ndev);
1054         fep->dev = &ofdev->dev;
1055         fep->ndev = ndev;
1056         fep->fpi = fpi;
1057         fep->ops = match->data;
1058
1059         ret = fep->ops->setup_data(ndev);
1060         if (ret)
1061                 goto out_free_dev;
1062
1063         fep->rx_skbuff = (struct sk_buff **)&fep[1];
1064         fep->tx_skbuff = fep->rx_skbuff + fpi->rx_ring;
1065
1066         spin_lock_init(&fep->lock);
1067         spin_lock_init(&fep->tx_lock);
1068
1069         mac_addr = of_get_mac_address(ofdev->dev.of_node);
1070         if (mac_addr)
1071                 memcpy(ndev->dev_addr, mac_addr, 6);
1072
1073         ret = fep->ops->allocate_bd(ndev);
1074         if (ret)
1075                 goto out_cleanup_data;
1076
1077         fep->rx_bd_base = fep->ring_base;
1078         fep->tx_bd_base = fep->rx_bd_base + fpi->rx_ring;
1079
1080         fep->tx_ring = fpi->tx_ring;
1081         fep->rx_ring = fpi->rx_ring;
1082
1083         ndev->netdev_ops = &fs_enet_netdev_ops;
1084         ndev->watchdog_timeo = 2 * HZ;
1085         if (fpi->use_napi)
1086                 netif_napi_add(ndev, &fep->napi, fs_enet_rx_napi,
1087                                fpi->napi_weight);
1088
1089         ndev->ethtool_ops = &fs_ethtool_ops;
1090
1091         init_timer(&fep->phy_timer_list);
1092
1093         netif_carrier_off(ndev);
1094
1095         ret = register_netdev(ndev);
1096         if (ret)
1097                 goto out_free_bd;
1098
1099         pr_info("%s: fs_enet: %pM\n", ndev->name, ndev->dev_addr);
1100
1101         return 0;
1102
1103 out_free_bd:
1104         fep->ops->free_bd(ndev);
1105 out_cleanup_data:
1106         fep->ops->cleanup_data(ndev);
1107 out_free_dev:
1108         free_netdev(ndev);
1109         dev_set_drvdata(&ofdev->dev, NULL);
1110 out_put:
1111         of_node_put(fpi->phy_node);
1112 out_free_fpi:
1113         kfree(fpi);
1114         return ret;
1115 }
1116
1117 static int fs_enet_remove(struct platform_device *ofdev)
1118 {
1119         struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
1120         struct fs_enet_private *fep = netdev_priv(ndev);
1121
1122         unregister_netdev(ndev);
1123
1124         fep->ops->free_bd(ndev);
1125         fep->ops->cleanup_data(ndev);
1126         dev_set_drvdata(fep->dev, NULL);
1127         of_node_put(fep->fpi->phy_node);
1128         free_netdev(ndev);
1129         return 0;
1130 }
1131
1132 static struct of_device_id fs_enet_match[] = {
1133 #ifdef CONFIG_FS_ENET_HAS_SCC
1134         {
1135                 .compatible = "fsl,cpm1-scc-enet",
1136                 .data = (void *)&fs_scc_ops,
1137         },
1138         {
1139                 .compatible = "fsl,cpm2-scc-enet",
1140                 .data = (void *)&fs_scc_ops,
1141         },
1142 #endif
1143 #ifdef CONFIG_FS_ENET_HAS_FCC
1144         {
1145                 .compatible = "fsl,cpm2-fcc-enet",
1146                 .data = (void *)&fs_fcc_ops,
1147         },
1148 #endif
1149 #ifdef CONFIG_FS_ENET_HAS_FEC
1150 #ifdef CONFIG_FS_ENET_MPC5121_FEC
1151         {
1152                 .compatible = "fsl,mpc5121-fec",
1153                 .data = (void *)&fs_fec_ops,
1154         },
1155         {
1156                 .compatible = "fsl,mpc5125-fec",
1157                 .data = (void *)&fs_fec_ops,
1158         },
1159 #else
1160         {
1161                 .compatible = "fsl,pq1-fec-enet",
1162                 .data = (void *)&fs_fec_ops,
1163         },
1164 #endif
1165 #endif
1166         {}
1167 };
1168 MODULE_DEVICE_TABLE(of, fs_enet_match);
1169
1170 static struct platform_driver fs_enet_driver = {
1171         .driver = {
1172                 .owner = THIS_MODULE,
1173                 .name = "fs_enet",
1174                 .of_match_table = fs_enet_match,
1175         },
1176         .probe = fs_enet_probe,
1177         .remove = fs_enet_remove,
1178 };
1179
1180 #ifdef CONFIG_NET_POLL_CONTROLLER
1181 static void fs_enet_netpoll(struct net_device *dev)
1182 {
1183        disable_irq(dev->irq);
1184        fs_enet_interrupt(dev->irq, dev);
1185        enable_irq(dev->irq);
1186 }
1187 #endif
1188
1189 module_platform_driver(fs_enet_driver);