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