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