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                 free_irq(fep->interrupt, dev);
 799                 if (fep->fpi->use_napi)
 800                         napi_disable(&fep->napi);
 801                 return err;
 802         }
 803         phy_start(fep->phydev);
 804
 805         netif_start_queue(dev);
 806
 807         return 0;
 808 }
 809
 810 static int fs_enet_close(struct net_device *dev)
 811 {
 812         struct fs_enet_private *fep = netdev_priv(dev);
 813         unsigned long flags;
 814
 815         netif_stop_queue(dev);
 816         netif_carrier_off(dev);
 817         if (fep->fpi->use_napi)
 818                 napi_disable(&fep->napi);
 819         phy_stop(fep->phydev);
 820
 821         spin_lock_irqsave(&fep->lock, flags);
 822         spin_lock(&fep->tx_lock);
 823         (*fep->ops->stop)(dev);
 824         spin_unlock(&fep->tx_lock);
 825         spin_unlock_irqrestore(&fep->lock, flags);
 826
 827         /* release any irqs */
 828         phy_disconnect(fep->phydev);
 829         fep->phydev = NULL;
 830         free_irq(fep->interrupt, dev);
 831
 832         return 0;
 833 }
 834
 835 static struct net_device_stats *fs_enet_get_stats(struct net_device *dev)
 836 {
 837         struct fs_enet_private *fep = netdev_priv(dev);
 838         return &fep->stats;
 839 }
 840
 841 /*************************************************************************/
 842
 843 static void fs_get_drvinfo(struct net_device *dev,
 844                             struct ethtool_drvinfo *info)
 845 {
 846         strcpy(info->driver, DRV_MODULE_NAME);
 847         strcpy(info->version, DRV_MODULE_VERSION);
 848 }
 849
 850 static int fs_get_regs_len(struct net_device *dev)
 851 {
 852         struct fs_enet_private *fep = netdev_priv(dev);
 853
 854         return (*fep->ops->get_regs_len)(dev);
 855 }
 856
 857 static void fs_get_regs(struct net_device *dev, struct ethtool_regs *regs,
 858                          void *p)
 859 {
 860         struct fs_enet_private *fep = netdev_priv(dev);
 861         unsigned long flags;
 862         int r, len;
 863
 864         len = regs->len;
 865
 866         spin_lock_irqsave(&fep->lock, flags);
 867         r = (*fep->ops->get_regs)(dev, p, &len);
 868         spin_unlock_irqrestore(&fep->lock, flags);
 869
 870         if (r == 0)
 871                 regs->version = 0;
 872 }
 873
 874 static int fs_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 875 {
 876         struct fs_enet_private *fep = netdev_priv(dev);
 877
 878         if (!fep->phydev)
 879                 return -ENODEV;
 880
 881         return phy_ethtool_gset(fep->phydev, cmd);
 882 }
 883
 884 static int fs_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 885 {
 886         struct fs_enet_private *fep = netdev_priv(dev);
 887
 888         if (!fep->phydev)
 889                 return -ENODEV;
 890
 891         return phy_ethtool_sset(fep->phydev, cmd);
 892 }
 893
 894 static int fs_nway_reset(struct net_device *dev)
 895 {
 896         return 0;
 897 }
 898
 899 static u32 fs_get_msglevel(struct net_device *dev)
 900 {
 901         struct fs_enet_private *fep = netdev_priv(dev);
 902         return fep->msg_enable;
 903 }
 904
 905 static void fs_set_msglevel(struct net_device *dev, u32 value)
 906 {
 907         struct fs_enet_private *fep = netdev_priv(dev);
 908         fep->msg_enable = value;
 909 }
 910
 911 static const struct ethtool_ops fs_ethtool_ops = {
 912         .get_drvinfo = fs_get_drvinfo,
 913         .get_regs_len = fs_get_regs_len,
 914         .get_settings = fs_get_settings,
 915         .set_settings = fs_set_settings,
 916         .nway_reset = fs_nway_reset,
 917         .get_link = ethtool_op_get_link,
 918         .get_msglevel = fs_get_msglevel,
 919         .set_msglevel = fs_set_msglevel,
 920         .set_tx_csum = ethtool_op_set_tx_csum,  /* local! */
 921         .set_sg = ethtool_op_set_sg,
 922         .get_regs = fs_get_regs,
 923 };
 924
 925 static int fs_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 926 {
 927         struct fs_enet_private *fep = netdev_priv(dev);
 928         struct mii_ioctl_data *mii = (struct mii_ioctl_data *)&rq->ifr_data;
 929
 930         if (!netif_running(dev))
 931                 return -EINVAL;
 932
 933         return phy_mii_ioctl(fep->phydev, mii, cmd);
 934 }
 935
 936 extern int fs_mii_connect(struct net_device *dev);
 937 extern void fs_mii_disconnect(struct net_device *dev);
 938
 939 /**************************************************************************************/
 940
 941 /* handy pointer to the immap */
 942 void __iomem *fs_enet_immap = NULL;
 943
 944 static int setup_immap(void)
 945 {
 946 #ifdef CONFIG_CPM1
 947         fs_enet_immap = ioremap(IMAP_ADDR, 0x4000);
 948         WARN_ON(!fs_enet_immap);
 949 #elif defined(CONFIG_CPM2)
 950         fs_enet_immap = cpm2_immr;
 951 #endif
 952
 953         return 0;
 954 }
 955
 956 static void cleanup_immap(void)
 957 {
 958 #if defined(CONFIG_CPM1)
 959         iounmap(fs_enet_immap);
 960 #endif
 961 }
 962
 963 /**************************************************************************************/
 964
 965 static int __devinit find_phy(struct device_node *np,
 966                               struct fs_platform_info *fpi)
 967 {
 968         struct device_node *phynode, *mdionode;
 969         int ret = 0, len, bus_id;
 970         const u32 *data;
 971
 972         data  = of_get_property(np, "fixed-link", NULL);
 973         if (data) {
 974                 snprintf(fpi->bus_id, 16, "%x:%02x", 0, *data);
 975                 return 0;
 976         }
 977
 978         data = of_get_property(np, "phy-handle", &len);
 979         if (!data || len != 4)
 980                 return -EINVAL;
 981
 982         phynode = of_find_node_by_phandle(*data);
 983         if (!phynode)
 984                 return -EINVAL;
 985
 986         data = of_get_property(phynode, "reg", &len);
 987         if (!data || len != 4) {
 988                 ret = -EINVAL;
 989                 goto out_put_phy;
 990         }
 991
 992         mdionode = of_get_parent(phynode);
 993         if (!mdionode) {
 994                 ret = -EINVAL;
 995                 goto out_put_phy;
 996         }
 997
 998         bus_id = of_get_gpio(mdionode, 0);
 999         if (bus_id < 0) {
1000                 struct resource res;
1001                 ret = of_address_to_resource(mdionode, 0, &res);
1002                 if (ret)
1003                         goto out_put_mdio;
1004                 bus_id = res.start;
1005         }
1006
1007         snprintf(fpi->bus_id, 16, "%x:%02x", bus_id, *data);
1008
1009 out_put_mdio:
1010         of_node_put(mdionode);
1011 out_put_phy:
1012         of_node_put(phynode);
1013         return ret;
1014 }
1015
1016 #ifdef CONFIG_FS_ENET_HAS_FEC
1017 #define IS_FEC(match) ((match)->data == &fs_fec_ops)
1018 #else
1019 #define IS_FEC(match) 0
1020 #endif
1021
1022 static int __devinit fs_enet_probe(struct of_device *ofdev,
1023                                    const struct of_device_id *match)
1024 {
1025         struct net_device *ndev;
1026         struct fs_enet_private *fep;
1027         struct fs_platform_info *fpi;
1028         const u32 *data;
1029         const u8 *mac_addr;
1030         int privsize, len, ret = -ENODEV;
1031
1032         fpi = kzalloc(sizeof(*fpi), GFP_KERNEL);
1033         if (!fpi)
1034                 return -ENOMEM;
1035
1036         if (!IS_FEC(match)) {
1037                 data = of_get_property(ofdev->node, "fsl,cpm-command", &len);
1038                 if (!data || len != 4)
1039                         goto out_free_fpi;
1040
1041                 fpi->cp_command = *data;
1042         }
1043
1044         fpi->rx_ring = 32;
1045         fpi->tx_ring = 32;
1046         fpi->rx_copybreak = 240;
1047         fpi->use_napi = 1;
1048         fpi->napi_weight = 17;
1049
1050         ret = find_phy(ofdev->node, fpi);
1051         if (ret)
1052                 goto out_free_fpi;
1053
1054         privsize = sizeof(*fep) +
1055                    sizeof(struct sk_buff **) *
1056                    (fpi->rx_ring + fpi->tx_ring);
1057
1058         ndev = alloc_etherdev(privsize);
1059         if (!ndev) {
1060                 ret = -ENOMEM;
1061                 goto out_free_fpi;
1062         }
1063
1064         dev_set_drvdata(&ofdev->dev, ndev);
1065
1066         fep = netdev_priv(ndev);
1067         fep->dev = &ofdev->dev;
1068         fep->ndev = ndev;
1069         fep->fpi = fpi;
1070         fep->ops = match->data;
1071
1072         ret = fep->ops->setup_data(ndev);
1073         if (ret)
1074                 goto out_free_dev;
1075
1076         fep->rx_skbuff = (struct sk_buff **)&fep[1];
1077         fep->tx_skbuff = fep->rx_skbuff + fpi->rx_ring;
1078
1079         spin_lock_init(&fep->lock);
1080         spin_lock_init(&fep->tx_lock);
1081
1082         mac_addr = of_get_mac_address(ofdev->node);
1083         if (mac_addr)
1084                 memcpy(ndev->dev_addr, mac_addr, 6);
1085
1086         ret = fep->ops->allocate_bd(ndev);
1087         if (ret)
1088                 goto out_cleanup_data;
1089
1090         fep->rx_bd_base = fep->ring_base;
1091         fep->tx_bd_base = fep->rx_bd_base + fpi->rx_ring;
1092
1093         fep->tx_ring = fpi->tx_ring;
1094         fep->rx_ring = fpi->rx_ring;
1095
1096         ndev->open = fs_enet_open;
1097         ndev->hard_start_xmit = fs_enet_start_xmit;
1098         ndev->tx_timeout = fs_timeout;
1099         ndev->watchdog_timeo = 2 * HZ;
1100         ndev->stop = fs_enet_close;
1101         ndev->get_stats = fs_enet_get_stats;
1102         ndev->set_multicast_list = fs_set_multicast_list;
1103 #ifdef CONFIG_NET_POLL_CONTROLLER
1104         ndev->poll_controller = fs_enet_netpoll;
1105 #endif
1106         if (fpi->use_napi)
1107                 netif_napi_add(ndev, &fep->napi, fs_enet_rx_napi,
1108                                fpi->napi_weight);
1109
1110         ndev->ethtool_ops = &fs_ethtool_ops;
1111         ndev->do_ioctl = fs_ioctl;
1112
1113         init_timer(&fep->phy_timer_list);
1114
1115         netif_carrier_off(ndev);
1116
1117         ret = register_netdev(ndev);
1118         if (ret)
1119                 goto out_free_bd;
1120
1121         printk(KERN_INFO "%s: fs_enet: %pM\n", ndev->name, ndev->dev_addr);
1122
1123         return 0;
1124
1125 out_free_bd:
1126         fep->ops->free_bd(ndev);
1127 out_cleanup_data:
1128         fep->ops->cleanup_data(ndev);
1129 out_free_dev:
1130         free_netdev(ndev);
1131         dev_set_drvdata(&ofdev->dev, NULL);
1132 out_free_fpi:
1133         kfree(fpi);
1134         return ret;
1135 }
1136
1137 static int fs_enet_remove(struct of_device *ofdev)
1138 {
1139         struct net_device *ndev = dev_get_drvdata(&ofdev->dev);
1140         struct fs_enet_private *fep = netdev_priv(ndev);
1141
1142         unregister_netdev(ndev);
1143
1144         fep->ops->free_bd(ndev);
1145         fep->ops->cleanup_data(ndev);
1146         dev_set_drvdata(fep->dev, NULL);
1147
1148         free_netdev(ndev);
1149         return 0;
1150 }
1151
1152 static struct of_device_id fs_enet_match[] = {
1153 #ifdef CONFIG_FS_ENET_HAS_SCC
1154         {
1155                 .compatible = "fsl,cpm1-scc-enet",
1156                 .data = (void *)&fs_scc_ops,
1157         },
1158         {
1159                 .compatible = "fsl,cpm2-scc-enet",
1160                 .data = (void *)&fs_scc_ops,
1161         },
1162 #endif
1163 #ifdef CONFIG_FS_ENET_HAS_FCC
1164         {
1165                 .compatible = "fsl,cpm2-fcc-enet",
1166                 .data = (void *)&fs_fcc_ops,
1167         },
1168 #endif
1169 #ifdef CONFIG_FS_ENET_HAS_FEC
1170         {
1171                 .compatible = "fsl,pq1-fec-enet",
1172                 .data = (void *)&fs_fec_ops,
1173         },
1174 #endif
1175         {}
1176 };
1177
1178 static struct of_platform_driver fs_enet_driver = {
1179         .name   = "fs_enet",
1180         .match_table = fs_enet_match,
1181         .probe = fs_enet_probe,
1182         .remove = fs_enet_remove,
1183 };
1184
1185 static int __init fs_init(void)
1186 {
1187         int r = setup_immap();
1188         if (r != 0)
1189                 return r;
1190
1191         r = of_register_platform_driver(&fs_enet_driver);
1192         if (r != 0)
1193                 goto out;
1194
1195         return 0;
1196
1197 out:
1198         cleanup_immap();
1199         return r;
1200 }
1201
1202 static void __exit fs_cleanup(void)
1203 {
1204         of_unregister_platform_driver(&fs_enet_driver);
1205         cleanup_immap();
1206 }
1207
1208 #ifdef CONFIG_NET_POLL_CONTROLLER
1209 static void fs_enet_netpoll(struct net_device *dev)
1210 {
1211        disable_irq(dev->irq);
1212        fs_enet_interrupt(dev->irq, dev);
1213        enable_irq(dev->irq);
1214 }
1215 #endif
1216
1217 /**************************************************************************************/
1218
1219 module_init(fs_init);
1220 module_exit(fs_cleanup);