drivers/net/epic100.c

   1 /* epic100.c: A SMC 83c170 EPIC/100 Fast Ethernet driver for Linux. */
   2 /*
   3         Written/copyright 1997-2001 by Donald Becker.
   4
   5         This software may be used and distributed according to the terms of
   6         the GNU General Public License (GPL), incorporated herein by reference.
   7         Drivers based on or derived from this code fall under the GPL and must
   8         retain the authorship, copyright and license notice.  This file is not
   9         a complete program and may only be used when the entire operating
  10         system is licensed under the GPL.
  11
  12         This driver is for the SMC83c170/175 "EPIC" series, as used on the
  13         SMC EtherPower II 9432 PCI adapter, and several CardBus cards.
  14
  15         The author may be reached as becker@scyld.com, or C/O
  16         Scyld Computing Corporation
  17         410 Severn Ave., Suite 210
  18         Annapolis MD 21403
  19
  20         Information and updates available at
  21         http://www.scyld.com/network/epic100.html
  22         [this link no longer provides anything useful -jgarzik]
  23
  24         ---------------------------------------------------------------------
  25
  26 */
  27
  28 #define DRV_NAME        "epic100"
  29 #define DRV_VERSION     "2.1"
  30 #define DRV_RELDATE     "Sept 11, 2006"
  31
  32 /* The user-configurable values.
  33    These may be modified when a driver module is loaded.*/
  34
  35 static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */
  36
  37 /* Used to pass the full-duplex flag, etc. */
  38 #define MAX_UNITS 8             /* More are supported, limit only on options */
  39 static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
  40 static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
  41
  42 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  43    Setting to > 1518 effectively disables this feature. */
  44 static int rx_copybreak;
  45
  46 /* Operational parameters that are set at compile time. */
  47
  48 /* Keep the ring sizes a power of two for operational efficiency.
  49    The compiler will convert <unsigned>'%'<2^N> into a bit mask.
  50    Making the Tx ring too large decreases the effectiveness of channel
  51    bonding and packet priority.
  52    There are no ill effects from too-large receive rings. */
  53 #define TX_RING_SIZE    256
  54 #define TX_QUEUE_LEN    240             /* Limit ring entries actually used.  */
  55 #define RX_RING_SIZE    256
  56 #define TX_TOTAL_SIZE   TX_RING_SIZE*sizeof(struct epic_tx_desc)
  57 #define RX_TOTAL_SIZE   RX_RING_SIZE*sizeof(struct epic_rx_desc)
  58
  59 /* Operational parameters that usually are not changed. */
  60 /* Time in jiffies before concluding the transmitter is hung. */
  61 #define TX_TIMEOUT  (2*HZ)
  62
  63 #define PKT_BUF_SZ              1536                    /* Size of each temporary Rx buffer.*/
  64
  65 /* Bytes transferred to chip before transmission starts. */
  66 /* Initial threshold, increased on underflow, rounded down to 4 byte units. */
  67 #define TX_FIFO_THRESH 256
  68 #define RX_FIFO_THRESH 1                /* 0-3, 0==32, 64,96, or 3==128 bytes  */
  69
  70 #include <linux/module.h>
  71 #include <linux/kernel.h>
  72 #include <linux/string.h>
  73 #include <linux/timer.h>
  74 #include <linux/errno.h>
  75 #include <linux/ioport.h>
  76 #include <linux/interrupt.h>
  77 #include <linux/pci.h>
  78 #include <linux/delay.h>
  79 #include <linux/netdevice.h>
  80 #include <linux/etherdevice.h>
  81 #include <linux/skbuff.h>
  82 #include <linux/init.h>
  83 #include <linux/spinlock.h>
  84 #include <linux/ethtool.h>
  85 #include <linux/mii.h>
  86 #include <linux/crc32.h>
  87 #include <linux/bitops.h>
  88 #include <asm/io.h>
  89 #include <asm/uaccess.h>
  90
  91 /* These identify the driver base version and may not be removed. */
  92 static char version[] __devinitdata =
  93 DRV_NAME ".c:v1.11 1/7/2001 Written by Donald Becker <becker@scyld.com>\n";
  94 static char version2[] __devinitdata =
  95 "  (unofficial 2.4.x kernel port, version " DRV_VERSION ", " DRV_RELDATE ")\n";
  96
  97 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
  98 MODULE_DESCRIPTION("SMC 83c170 EPIC series Ethernet driver");
  99 MODULE_LICENSE("GPL");
 100
 101 module_param(debug, int, 0);
 102 module_param(rx_copybreak, int, 0);
 103 module_param_array(options, int, NULL, 0);
 104 module_param_array(full_duplex, int, NULL, 0);
 105 MODULE_PARM_DESC(debug, "EPIC/100 debug level (0-5)");
 106 MODULE_PARM_DESC(options, "EPIC/100: Bits 0-3: media type, bit 4: full duplex");
 107 MODULE_PARM_DESC(rx_copybreak, "EPIC/100 copy breakpoint for copy-only-tiny-frames");
 108 MODULE_PARM_DESC(full_duplex, "EPIC/100 full duplex setting(s) (1)");
 109
 110 /*
 111                                 Theory of Operation
 112
 113 I. Board Compatibility
 114
 115 This device driver is designed for the SMC "EPIC/100", the SMC
 116 single-chip Ethernet controllers for PCI.  This chip is used on
 117 the SMC EtherPower II boards.
 118
 119 II. Board-specific settings
 120
 121 PCI bus devices are configured by the system at boot time, so no jumpers
 122 need to be set on the board.  The system BIOS will assign the
 123 PCI INTA signal to a (preferably otherwise unused) system IRQ line.
 124 Note: Kernel versions earlier than 1.3.73 do not support shared PCI
 125 interrupt lines.
 126
 127 III. Driver operation
 128
 129 IIIa. Ring buffers
 130
 131 IVb. References
 132
 133 http://www.smsc.com/main/tools/discontinued/83c171.pdf
 134 http://www.smsc.com/main/tools/discontinued/83c175.pdf
 135 http://scyld.com/expert/NWay.html
 136 http://www.national.com/pf/DP/DP83840A.html
 137
 138 IVc. Errata
 139
 140 */
 141
 142
 143 enum chip_capability_flags { MII_PWRDWN=1, TYPE2_INTR=2, NO_MII=4 };
 144
 145 #define EPIC_TOTAL_SIZE 0x100
 146 #define USE_IO_OPS 1
 147
 148 typedef enum {
 149         SMSC_83C170_0,
 150         SMSC_83C170,
 151         SMSC_83C175,
 152 } chip_t;
 153
 154
 155 struct epic_chip_info {
 156         const char *name;
 157         int drv_flags;                          /* Driver use, intended as capability flags. */
 158 };
 159
 160
 161 /* indexed by chip_t */
 162 static const struct epic_chip_info pci_id_tbl[] = {
 163         { "SMSC EPIC/100 83c170",       TYPE2_INTR | NO_MII | MII_PWRDWN },
 164         { "SMSC EPIC/100 83c170",       TYPE2_INTR },
 165         { "SMSC EPIC/C 83c175",         TYPE2_INTR | MII_PWRDWN },
 166 };
 167
 168
 169 static DEFINE_PCI_DEVICE_TABLE(epic_pci_tbl) = {
 170         { 0x10B8, 0x0005, 0x1092, 0x0AB4, 0, 0, SMSC_83C170_0 },
 171         { 0x10B8, 0x0005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SMSC_83C170 },
 172         { 0x10B8, 0x0006, PCI_ANY_ID, PCI_ANY_ID,
 173           PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, SMSC_83C175 },
 174         { 0,}
 175 };
 176 MODULE_DEVICE_TABLE (pci, epic_pci_tbl);
 177
 178
 179 #ifndef USE_IO_OPS
 180 #undef inb
 181 #undef inw
 182 #undef inl
 183 #undef outb
 184 #undef outw
 185 #undef outl
 186 #define inb readb
 187 #define inw readw
 188 #define inl readl
 189 #define outb writeb
 190 #define outw writew
 191 #define outl writel
 192 #endif
 193
 194 /* Offsets to registers, using the (ugh) SMC names. */
 195 enum epic_registers {
 196   COMMAND=0, INTSTAT=4, INTMASK=8, GENCTL=0x0C, NVCTL=0x10, EECTL=0x14,
 197   PCIBurstCnt=0x18,
 198   TEST1=0x1C, CRCCNT=0x20, ALICNT=0x24, MPCNT=0x28,     /* Rx error counters. */
 199   MIICtrl=0x30, MIIData=0x34, MIICfg=0x38,
 200   LAN0=64,                                              /* MAC address. */
 201   MC0=80,                                               /* Multicast filter table. */
 202   RxCtrl=96, TxCtrl=112, TxSTAT=0x74,
 203   PRxCDAR=0x84, RxSTAT=0xA4, EarlyRx=0xB0, PTxCDAR=0xC4, TxThresh=0xDC,
 204 };
 205
 206 /* Interrupt register bits, using my own meaningful names. */
 207 enum IntrStatus {
 208         TxIdle=0x40000, RxIdle=0x20000, IntrSummary=0x010000,
 209         PCIBusErr170=0x7000, PCIBusErr175=0x1000, PhyEvent175=0x8000,
 210         RxStarted=0x0800, RxEarlyWarn=0x0400, CntFull=0x0200, TxUnderrun=0x0100,
 211         TxEmpty=0x0080, TxDone=0x0020, RxError=0x0010,
 212         RxOverflow=0x0008, RxFull=0x0004, RxHeader=0x0002, RxDone=0x0001,
 213 };
 214 enum CommandBits {
 215         StopRx=1, StartRx=2, TxQueued=4, RxQueued=8,
 216         StopTxDMA=0x20, StopRxDMA=0x40, RestartTx=0x80,
 217 };
 218
 219 #define EpicRemoved     0xffffffff      /* Chip failed or removed (CardBus) */
 220
 221 #define EpicNapiEvent   (TxEmpty | TxDone | \
 222                          RxDone | RxStarted | RxEarlyWarn | RxOverflow | RxFull)
 223 #define EpicNormalEvent (0x0000ffff & ~EpicNapiEvent)
 224
 225 static const u16 media2miictl[16] = {
 226         0, 0x0C00, 0x0C00, 0x2000,  0x0100, 0x2100, 0, 0,
 227         0, 0, 0, 0,  0, 0, 0, 0 };
 228
 229 /*
 230  * The EPIC100 Rx and Tx buffer descriptors.  Note that these
 231  * really ARE host-endian; it's not a misannotation.  We tell
 232  * the card to byteswap them internally on big-endian hosts -
 233  * look for #ifdef CONFIG_BIG_ENDIAN in epic_open().
 234  */
 235
 236 struct epic_tx_desc {
 237         u32 txstatus;
 238         u32 bufaddr;
 239         u32 buflength;
 240         u32 next;
 241 };
 242
 243 struct epic_rx_desc {
 244         u32 rxstatus;
 245         u32 bufaddr;
 246         u32 buflength;
 247         u32 next;
 248 };
 249
 250 enum desc_status_bits {
 251         DescOwn=0x8000,
 252 };
 253
 254 #define PRIV_ALIGN      15      /* Required alignment mask */
 255 struct epic_private {
 256         struct epic_rx_desc *rx_ring;
 257         struct epic_tx_desc *tx_ring;
 258         /* The saved address of a sent-in-place packet/buffer, for skfree(). */
 259         struct sk_buff* tx_skbuff[TX_RING_SIZE];
 260         /* The addresses of receive-in-place skbuffs. */
 261         struct sk_buff* rx_skbuff[RX_RING_SIZE];
 262
 263         dma_addr_t tx_ring_dma;
 264         dma_addr_t rx_ring_dma;
 265
 266         /* Ring pointers. */
 267         spinlock_t lock;                                /* Group with Tx control cache line. */
 268         spinlock_t napi_lock;
 269         struct napi_struct napi;
 270         unsigned int reschedule_in_poll;
 271         unsigned int cur_tx, dirty_tx;
 272
 273         unsigned int cur_rx, dirty_rx;
 274         u32 irq_mask;
 275         unsigned int rx_buf_sz;                         /* Based on MTU+slack. */
 276
 277         struct pci_dev *pci_dev;                        /* PCI bus location. */
 278         int chip_id, chip_flags;
 279
 280         struct net_device_stats stats;
 281         struct timer_list timer;                        /* Media selection timer. */
 282         int tx_threshold;
 283         unsigned char mc_filter[8];
 284         signed char phys[4];                            /* MII device addresses. */
 285         u16 advertising;                                        /* NWay media advertisement */
 286         int mii_phy_cnt;
 287         struct mii_if_info mii;
 288         unsigned int tx_full:1;                         /* The Tx queue is full. */
 289         unsigned int default_port:4;            /* Last dev->if_port value. */
 290 };
 291
 292 static int epic_open(struct net_device *dev);
 293 static int read_eeprom(long ioaddr, int location);
 294 static int mdio_read(struct net_device *dev, int phy_id, int location);
 295 static void mdio_write(struct net_device *dev, int phy_id, int loc, int val);
 296 static void epic_restart(struct net_device *dev);
 297 static void epic_timer(unsigned long data);
 298 static void epic_tx_timeout(struct net_device *dev);
 299 static void epic_init_ring(struct net_device *dev);
 300 static netdev_tx_t epic_start_xmit(struct sk_buff *skb,
 301                                    struct net_device *dev);
 302 static int epic_rx(struct net_device *dev, int budget);
 303 static int epic_poll(struct napi_struct *napi, int budget);
 304 static irqreturn_t epic_interrupt(int irq, void *dev_instance);
 305 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 306 static const struct ethtool_ops netdev_ethtool_ops;
 307 static int epic_close(struct net_device *dev);
 308 static struct net_device_stats *epic_get_stats(struct net_device *dev);
 309 static void set_rx_mode(struct net_device *dev);
 310
 311 static const struct net_device_ops epic_netdev_ops = {
 312         .ndo_open               = epic_open,
 313         .ndo_stop               = epic_close,
 314         .ndo_start_xmit         = epic_start_xmit,
 315         .ndo_tx_timeout         = epic_tx_timeout,
 316         .ndo_get_stats          = epic_get_stats,
 317         .ndo_set_multicast_list = set_rx_mode,
 318         .ndo_do_ioctl           = netdev_ioctl,
 319         .ndo_change_mtu         = eth_change_mtu,
 320         .ndo_set_mac_address    = eth_mac_addr,
 321         .ndo_validate_addr      = eth_validate_addr,
 322 };
 323
 324 static int __devinit epic_init_one (struct pci_dev *pdev,
 325                                     const struct pci_device_id *ent)
 326 {
 327         static int card_idx = -1;
 328         long ioaddr;
 329         int chip_idx = (int) ent->driver_data;
 330         int irq;
 331         struct net_device *dev;
 332         struct epic_private *ep;
 333         int i, ret, option = 0, duplex = 0;
 334         void *ring_space;
 335         dma_addr_t ring_dma;
 336
 337 /* when built into the kernel, we only print version if device is found */
 338 #ifndef MODULE
 339         static int printed_version;
 340         if (!printed_version++)
 341                 printk(KERN_INFO "%s%s", version, version2);
 342 #endif
 343
 344         card_idx++;
 345
 346         ret = pci_enable_device(pdev);
 347         if (ret)
 348                 goto out;
 349         irq = pdev->irq;
 350
 351         if (pci_resource_len(pdev, 0) < EPIC_TOTAL_SIZE) {
 352                 dev_err(&pdev->dev, "no PCI region space\n");
 353                 ret = -ENODEV;
 354                 goto err_out_disable;
 355         }
 356
 357         pci_set_master(pdev);
 358
 359         ret = pci_request_regions(pdev, DRV_NAME);
 360         if (ret < 0)
 361                 goto err_out_disable;
 362
 363         ret = -ENOMEM;
 364
 365         dev = alloc_etherdev(sizeof (*ep));
 366         if (!dev) {
 367                 dev_err(&pdev->dev, "no memory for eth device\n");
 368                 goto err_out_free_res;
 369         }
 370         SET_NETDEV_DEV(dev, &pdev->dev);
 371
 372 #ifdef USE_IO_OPS
 373         ioaddr = pci_resource_start (pdev, 0);
 374 #else
 375         ioaddr = pci_resource_start (pdev, 1);
 376         ioaddr = (long) pci_ioremap_bar(pdev, 1);
 377         if (!ioaddr) {
 378                 dev_err(&pdev->dev, "ioremap failed\n");
 379                 goto err_out_free_netdev;
 380         }
 381 #endif
 382
 383         pci_set_drvdata(pdev, dev);
 384         ep = netdev_priv(dev);
 385         ep->mii.dev = dev;
 386         ep->mii.mdio_read = mdio_read;
 387         ep->mii.mdio_write = mdio_write;
 388         ep->mii.phy_id_mask = 0x1f;
 389         ep->mii.reg_num_mask = 0x1f;
 390
 391         ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
 392         if (!ring_space)
 393                 goto err_out_iounmap;
 394         ep->tx_ring = (struct epic_tx_desc *)ring_space;
 395         ep->tx_ring_dma = ring_dma;
 396
 397         ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
 398         if (!ring_space)
 399                 goto err_out_unmap_tx;
 400         ep->rx_ring = (struct epic_rx_desc *)ring_space;
 401         ep->rx_ring_dma = ring_dma;
 402
 403         if (dev->mem_start) {
 404                 option = dev->mem_start;
 405                 duplex = (dev->mem_start & 16) ? 1 : 0;
 406         } else if (card_idx >= 0  &&  card_idx < MAX_UNITS) {
 407                 if (options[card_idx] >= 0)
 408                         option = options[card_idx];
 409                 if (full_duplex[card_idx] >= 0)
 410                         duplex = full_duplex[card_idx];
 411         }
 412
 413         dev->base_addr = ioaddr;
 414         dev->irq = irq;
 415
 416         spin_lock_init(&ep->lock);
 417         spin_lock_init(&ep->napi_lock);
 418         ep->reschedule_in_poll = 0;
 419
 420         /* Bring the chip out of low-power mode. */
 421         outl(0x4200, ioaddr + GENCTL);
 422         /* Magic?!  If we don't set this bit the MII interface won't work. */
 423         /* This magic is documented in SMSC app note 7.15 */
 424         for (i = 16; i > 0; i--)
 425                 outl(0x0008, ioaddr + TEST1);
 426
 427         /* Turn on the MII transceiver. */
 428         outl(0x12, ioaddr + MIICfg);
 429         if (chip_idx == 1)
 430                 outl((inl(ioaddr + NVCTL) & ~0x003C) | 0x4800, ioaddr + NVCTL);
 431         outl(0x0200, ioaddr + GENCTL);
 432
 433         /* Note: the '175 does not have a serial EEPROM. */
 434         for (i = 0; i < 3; i++)
 435                 ((__le16 *)dev->dev_addr)[i] = cpu_to_le16(inw(ioaddr + LAN0 + i*4));
 436
 437         if (debug > 2) {
 438                 dev_printk(KERN_DEBUG, &pdev->dev, "EEPROM contents:\n");
 439                 for (i = 0; i < 64; i++)
 440                         printk(" %4.4x%s", read_eeprom(ioaddr, i),
 441                                    i % 16 == 15 ? "\n" : "");
 442         }
 443
 444         ep->pci_dev = pdev;
 445         ep->chip_id = chip_idx;
 446         ep->chip_flags = pci_id_tbl[chip_idx].drv_flags;
 447         ep->irq_mask =
 448                 (ep->chip_flags & TYPE2_INTR ?  PCIBusErr175 : PCIBusErr170)
 449                  | CntFull | TxUnderrun | EpicNapiEvent;
 450
 451         /* Find the connected MII xcvrs.
 452            Doing this in open() would allow detecting external xcvrs later, but
 453            takes much time and no cards have external MII. */
 454         {
 455                 int phy, phy_idx = 0;
 456                 for (phy = 1; phy < 32 && phy_idx < sizeof(ep->phys); phy++) {
 457                         int mii_status = mdio_read(dev, phy, MII_BMSR);
 458                         if (mii_status != 0xffff  &&  mii_status != 0x0000) {
 459                                 ep->phys[phy_idx++] = phy;
 460                                 dev_info(&pdev->dev,
 461                                         "MII transceiver #%d control "
 462                                         "%4.4x status %4.4x.\n",
 463                                         phy, mdio_read(dev, phy, 0), mii_status);
 464                         }
 465                 }
 466                 ep->mii_phy_cnt = phy_idx;
 467                 if (phy_idx != 0) {
 468                         phy = ep->phys[0];
 469                         ep->mii.advertising = mdio_read(dev, phy, MII_ADVERTISE);
 470                         dev_info(&pdev->dev,
 471                                 "Autonegotiation advertising %4.4x link "
 472                                    "partner %4.4x.\n",
 473                                    ep->mii.advertising, mdio_read(dev, phy, 5));
 474                 } else if ( ! (ep->chip_flags & NO_MII)) {
 475                         dev_warn(&pdev->dev,
 476                                 "***WARNING***: No MII transceiver found!\n");
 477                         /* Use the known PHY address of the EPII. */
 478                         ep->phys[0] = 3;
 479                 }
 480                 ep->mii.phy_id = ep->phys[0];
 481         }
 482
 483         /* Turn off the MII xcvr (175 only!), leave the chip in low-power mode. */
 484         if (ep->chip_flags & MII_PWRDWN)
 485                 outl(inl(ioaddr + NVCTL) & ~0x483C, ioaddr + NVCTL);
 486         outl(0x0008, ioaddr + GENCTL);
 487
 488         /* The lower four bits are the media type. */
 489         if (duplex) {
 490                 ep->mii.force_media = ep->mii.full_duplex = 1;
 491                 dev_info(&pdev->dev, "Forced full duplex requested.\n");
 492         }
 493         dev->if_port = ep->default_port = option;
 494
 495         /* The Epic-specific entries in the device structure. */
 496         dev->netdev_ops = &epic_netdev_ops;
 497         dev->ethtool_ops = &netdev_ethtool_ops;
 498         dev->watchdog_timeo = TX_TIMEOUT;
 499         netif_napi_add(dev, &ep->napi, epic_poll, 64);
 500
 501         ret = register_netdev(dev);
 502         if (ret < 0)
 503                 goto err_out_unmap_rx;
 504
 505         printk(KERN_INFO "%s: %s at %#lx, IRQ %d, %pM\n",
 506                dev->name, pci_id_tbl[chip_idx].name, ioaddr, dev->irq,
 507                dev->dev_addr);
 508
 509 out:
 510         return ret;
 511
 512 err_out_unmap_rx:
 513         pci_free_consistent(pdev, RX_TOTAL_SIZE, ep->rx_ring, ep->rx_ring_dma);
 514 err_out_unmap_tx:
 515         pci_free_consistent(pdev, TX_TOTAL_SIZE, ep->tx_ring, ep->tx_ring_dma);
 516 err_out_iounmap:
 517 #ifndef USE_IO_OPS
 518         iounmap(ioaddr);
 519 err_out_free_netdev:
 520 #endif
 521         free_netdev(dev);
 522 err_out_free_res:
 523         pci_release_regions(pdev);
 524 err_out_disable:
 525         pci_disable_device(pdev);
 526         goto out;
 527 }
 528
 529 /* Serial EEPROM section. */
 530
 531 /*  EEPROM_Ctrl bits. */
 532 #define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
 533 #define EE_CS                   0x02    /* EEPROM chip select. */
 534 #define EE_DATA_WRITE   0x08    /* EEPROM chip data in. */
 535 #define EE_WRITE_0              0x01
 536 #define EE_WRITE_1              0x09
 537 #define EE_DATA_READ    0x10    /* EEPROM chip data out. */
 538 #define EE_ENB                  (0x0001 | EE_CS)
 539
 540 /* Delay between EEPROM clock transitions.
 541    This serves to flush the operation to the PCI bus.
 542  */
 543
 544 #define eeprom_delay()  inl(ee_addr)
 545
 546 /* The EEPROM commands include the alway-set leading bit. */
 547 #define EE_WRITE_CMD    (5 << 6)
 548 #define EE_READ64_CMD   (6 << 6)
 549 #define EE_READ256_CMD  (6 << 8)
 550 #define EE_ERASE_CMD    (7 << 6)
 551
 552 static void epic_disable_int(struct net_device *dev, struct epic_private *ep)
 553 {
 554         long ioaddr = dev->base_addr;
 555
 556         outl(0x00000000, ioaddr + INTMASK);
 557 }
 558
 559 static inline void __epic_pci_commit(long ioaddr)
 560 {
 561 #ifndef USE_IO_OPS
 562         inl(ioaddr + INTMASK);
 563 #endif
 564 }
 565
 566 static inline void epic_napi_irq_off(struct net_device *dev,
 567                                      struct epic_private *ep)
 568 {
 569         long ioaddr = dev->base_addr;
 570
 571         outl(ep->irq_mask & ~EpicNapiEvent, ioaddr + INTMASK);
 572         __epic_pci_commit(ioaddr);
 573 }
 574
 575 static inline void epic_napi_irq_on(struct net_device *dev,
 576                                     struct epic_private *ep)
 577 {
 578         long ioaddr = dev->base_addr;
 579
 580         /* No need to commit possible posted write */
 581         outl(ep->irq_mask | EpicNapiEvent, ioaddr + INTMASK);
 582 }
 583
 584 static int __devinit read_eeprom(long ioaddr, int location)
 585 {
 586         int i;
 587         int retval = 0;
 588         long ee_addr = ioaddr + EECTL;
 589         int read_cmd = location |
 590                 (inl(ee_addr) & 0x40 ? EE_READ64_CMD : EE_READ256_CMD);
 591
 592         outl(EE_ENB & ~EE_CS, ee_addr);
 593         outl(EE_ENB, ee_addr);
 594
 595         /* Shift the read command bits out. */
 596         for (i = 12; i >= 0; i--) {
 597                 short dataval = (read_cmd & (1 << i)) ? EE_WRITE_1 : EE_WRITE_0;
 598                 outl(EE_ENB | dataval, ee_addr);
 599                 eeprom_delay();
 600                 outl(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
 601                 eeprom_delay();
 602         }
 603         outl(EE_ENB, ee_addr);
 604
 605         for (i = 16; i > 0; i--) {
 606                 outl(EE_ENB | EE_SHIFT_CLK, ee_addr);
 607                 eeprom_delay();
 608                 retval = (retval << 1) | ((inl(ee_addr) & EE_DATA_READ) ? 1 : 0);
 609                 outl(EE_ENB, ee_addr);
 610                 eeprom_delay();
 611         }
 612
 613         /* Terminate the EEPROM access. */
 614         outl(EE_ENB & ~EE_CS, ee_addr);
 615         return retval;
 616 }
 617
 618 #define MII_READOP              1
 619 #define MII_WRITEOP             2
 620 static int mdio_read(struct net_device *dev, int phy_id, int location)
 621 {
 622         long ioaddr = dev->base_addr;
 623         int read_cmd = (phy_id << 9) | (location << 4) | MII_READOP;
 624         int i;
 625
 626         outl(read_cmd, ioaddr + MIICtrl);
 627         /* Typical operation takes 25 loops. */
 628         for (i = 400; i > 0; i--) {
 629                 barrier();
 630                 if ((inl(ioaddr + MIICtrl) & MII_READOP) == 0) {
 631                         /* Work around read failure bug. */
 632                         if (phy_id == 1 && location < 6 &&
 633                             inw(ioaddr + MIIData) == 0xffff) {
 634                                 outl(read_cmd, ioaddr + MIICtrl);
 635                                 continue;
 636                         }
 637                         return inw(ioaddr + MIIData);
 638                 }
 639         }
 640         return 0xffff;
 641 }
 642
 643 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value)
 644 {
 645         long ioaddr = dev->base_addr;
 646         int i;
 647
 648         outw(value, ioaddr + MIIData);
 649         outl((phy_id << 9) | (loc << 4) | MII_WRITEOP, ioaddr + MIICtrl);
 650         for (i = 10000; i > 0; i--) {
 651                 barrier();
 652                 if ((inl(ioaddr + MIICtrl) & MII_WRITEOP) == 0)
 653                         break;
 654         }
 655 }
 656
 657
 658 static int epic_open(struct net_device *dev)
 659 {
 660         struct epic_private *ep = netdev_priv(dev);
 661         long ioaddr = dev->base_addr;
 662         int i;
 663         int retval;
 664
 665         /* Soft reset the chip. */
 666         outl(0x4001, ioaddr + GENCTL);
 667
 668         napi_enable(&ep->napi);
 669         if ((retval = request_irq(dev->irq, epic_interrupt, IRQF_SHARED, dev->name, dev))) {
 670                 napi_disable(&ep->napi);
 671                 return retval;
 672         }
 673
 674         epic_init_ring(dev);
 675
 676         outl(0x4000, ioaddr + GENCTL);
 677         /* This magic is documented in SMSC app note 7.15 */
 678         for (i = 16; i > 0; i--)
 679                 outl(0x0008, ioaddr + TEST1);
 680
 681         /* Pull the chip out of low-power mode, enable interrupts, and set for
 682            PCI read multiple.  The MIIcfg setting and strange write order are
 683            required by the details of which bits are reset and the transceiver
 684            wiring on the Ositech CardBus card.
 685         */
 686 #if 0
 687         outl(dev->if_port == 1 ? 0x13 : 0x12, ioaddr + MIICfg);
 688 #endif
 689         if (ep->chip_flags & MII_PWRDWN)
 690                 outl((inl(ioaddr + NVCTL) & ~0x003C) | 0x4800, ioaddr + NVCTL);
 691
 692         /* Tell the chip to byteswap descriptors on big-endian hosts */
 693 #ifdef CONFIG_BIG_ENDIAN
 694         outl(0x4432 | (RX_FIFO_THRESH<<8), ioaddr + GENCTL);
 695         inl(ioaddr + GENCTL);
 696         outl(0x0432 | (RX_FIFO_THRESH<<8), ioaddr + GENCTL);
 697 #else
 698         outl(0x4412 | (RX_FIFO_THRESH<<8), ioaddr + GENCTL);
 699         inl(ioaddr + GENCTL);
 700         outl(0x0412 | (RX_FIFO_THRESH<<8), ioaddr + GENCTL);
 701 #endif
 702
 703         udelay(20); /* Looks like EPII needs that if you want reliable RX init. FIXME: pci posting bug? */
 704
 705         for (i = 0; i < 3; i++)
 706                 outl(le16_to_cpu(((__le16*)dev->dev_addr)[i]), ioaddr + LAN0 + i*4);
 707
 708         ep->tx_threshold = TX_FIFO_THRESH;
 709         outl(ep->tx_threshold, ioaddr + TxThresh);
 710
 711         if (media2miictl[dev->if_port & 15]) {
 712                 if (ep->mii_phy_cnt)
 713                         mdio_write(dev, ep->phys[0], MII_BMCR, media2miictl[dev->if_port&15]);
 714                 if (dev->if_port == 1) {
 715                         if (debug > 1)
 716                                 printk(KERN_INFO "%s: Using the 10base2 transceiver, MII "
 717                                            "status %4.4x.\n",
 718                                            dev->name, mdio_read(dev, ep->phys[0], MII_BMSR));
 719                 }
 720         } else {
 721                 int mii_lpa = mdio_read(dev, ep->phys[0], MII_LPA);
 722                 if (mii_lpa != 0xffff) {
 723                         if ((mii_lpa & LPA_100FULL) || (mii_lpa & 0x01C0) == LPA_10FULL)
 724                                 ep->mii.full_duplex = 1;
 725                         else if (! (mii_lpa & LPA_LPACK))
 726                                 mdio_write(dev, ep->phys[0], MII_BMCR, BMCR_ANENABLE|BMCR_ANRESTART);
 727                         if (debug > 1)
 728                                 printk(KERN_INFO "%s: Setting %s-duplex based on MII xcvr %d"
 729                                            " register read of %4.4x.\n", dev->name,
 730                                            ep->mii.full_duplex ? "full" : "half",
 731                                            ep->phys[0], mii_lpa);
 732                 }
 733         }
 734
 735         outl(ep->mii.full_duplex ? 0x7F : 0x79, ioaddr + TxCtrl);
 736         outl(ep->rx_ring_dma, ioaddr + PRxCDAR);
 737         outl(ep->tx_ring_dma, ioaddr + PTxCDAR);
 738
 739         /* Start the chip's Rx process. */
 740         set_rx_mode(dev);
 741         outl(StartRx | RxQueued, ioaddr + COMMAND);
 742
 743         netif_start_queue(dev);
 744
 745         /* Enable interrupts by setting the interrupt mask. */
 746         outl((ep->chip_flags & TYPE2_INTR ? PCIBusErr175 : PCIBusErr170)
 747                  | CntFull | TxUnderrun
 748                  | RxError | RxHeader | EpicNapiEvent, ioaddr + INTMASK);
 749
 750         if (debug > 1)
 751                 printk(KERN_DEBUG "%s: epic_open() ioaddr %lx IRQ %d status %4.4x "
 752                            "%s-duplex.\n",
 753                            dev->name, ioaddr, dev->irq, (int)inl(ioaddr + GENCTL),
 754                            ep->mii.full_duplex ? "full" : "half");
 755
 756         /* Set the timer to switch to check for link beat and perhaps switch
 757            to an alternate media type. */
 758         init_timer(&ep->timer);
 759         ep->timer.expires = jiffies + 3*HZ;
 760         ep->timer.data = (unsigned long)dev;
 761         ep->timer.function = &epic_timer;                               /* timer handler */
 762         add_timer(&ep->timer);
 763
 764         return 0;
 765 }
 766
 767 /* Reset the chip to recover from a PCI transaction error.
 768    This may occur at interrupt time. */
 769 static void epic_pause(struct net_device *dev)
 770 {
 771         long ioaddr = dev->base_addr;
 772         struct epic_private *ep = netdev_priv(dev);
 773
 774         netif_stop_queue (dev);
 775
 776         /* Disable interrupts by clearing the interrupt mask. */
 777         outl(0x00000000, ioaddr + INTMASK);
 778         /* Stop the chip's Tx and Rx DMA processes. */
 779         outw(StopRx | StopTxDMA | StopRxDMA, ioaddr + COMMAND);
 780
 781         /* Update the error counts. */
 782         if (inw(ioaddr + COMMAND) != 0xffff) {
 783                 ep->stats.rx_missed_errors += inb(ioaddr + MPCNT);
 784                 ep->stats.rx_frame_errors += inb(ioaddr + ALICNT);
 785                 ep->stats.rx_crc_errors += inb(ioaddr + CRCCNT);
 786         }
 787
 788         /* Remove the packets on the Rx queue. */
 789         epic_rx(dev, RX_RING_SIZE);
 790 }
 791
 792 static void epic_restart(struct net_device *dev)
 793 {
 794         long ioaddr = dev->base_addr;
 795         struct epic_private *ep = netdev_priv(dev);
 796         int i;
 797
 798         /* Soft reset the chip. */
 799         outl(0x4001, ioaddr + GENCTL);
 800
 801         printk(KERN_DEBUG "%s: Restarting the EPIC chip, Rx %d/%d Tx %d/%d.\n",
 802                    dev->name, ep->cur_rx, ep->dirty_rx, ep->dirty_tx, ep->cur_tx);
 803         udelay(1);
 804
 805         /* This magic is documented in SMSC app note 7.15 */
 806         for (i = 16; i > 0; i--)
 807                 outl(0x0008, ioaddr + TEST1);
 808
 809 #ifdef CONFIG_BIG_ENDIAN
 810         outl(0x0432 | (RX_FIFO_THRESH<<8), ioaddr + GENCTL);
 811 #else
 812         outl(0x0412 | (RX_FIFO_THRESH<<8), ioaddr + GENCTL);
 813 #endif
 814         outl(dev->if_port == 1 ? 0x13 : 0x12, ioaddr + MIICfg);
 815         if (ep->chip_flags & MII_PWRDWN)
 816                 outl((inl(ioaddr + NVCTL) & ~0x003C) | 0x4800, ioaddr + NVCTL);
 817
 818         for (i = 0; i < 3; i++)
 819                 outl(le16_to_cpu(((__le16*)dev->dev_addr)[i]), ioaddr + LAN0 + i*4);
 820
 821         ep->tx_threshold = TX_FIFO_THRESH;
 822         outl(ep->tx_threshold, ioaddr + TxThresh);
 823         outl(ep->mii.full_duplex ? 0x7F : 0x79, ioaddr + TxCtrl);
 824         outl(ep->rx_ring_dma + (ep->cur_rx%RX_RING_SIZE)*
 825                 sizeof(struct epic_rx_desc), ioaddr + PRxCDAR);
 826         outl(ep->tx_ring_dma + (ep->dirty_tx%TX_RING_SIZE)*
 827                  sizeof(struct epic_tx_desc), ioaddr + PTxCDAR);
 828
 829         /* Start the chip's Rx process. */
 830         set_rx_mode(dev);
 831         outl(StartRx | RxQueued, ioaddr + COMMAND);
 832
 833         /* Enable interrupts by setting the interrupt mask. */
 834         outl((ep->chip_flags & TYPE2_INTR ? PCIBusErr175 : PCIBusErr170)
 835                  | CntFull | TxUnderrun
 836                  | RxError | RxHeader | EpicNapiEvent, ioaddr + INTMASK);
 837
 838         printk(KERN_DEBUG "%s: epic_restart() done, cmd status %4.4x, ctl %4.4x"
 839                    " interrupt %4.4x.\n",
 840                    dev->name, (int)inl(ioaddr + COMMAND), (int)inl(ioaddr + GENCTL),
 841                    (int)inl(ioaddr + INTSTAT));
 842 }
 843
 844 static void check_media(struct net_device *dev)
 845 {
 846         struct epic_private *ep = netdev_priv(dev);
 847         long ioaddr = dev->base_addr;
 848         int mii_lpa = ep->mii_phy_cnt ? mdio_read(dev, ep->phys[0], MII_LPA) : 0;
 849         int negotiated = mii_lpa & ep->mii.advertising;
 850         int duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
 851
 852         if (ep->mii.force_media)
 853                 return;
 854         if (mii_lpa == 0xffff)          /* Bogus read */
 855                 return;
 856         if (ep->mii.full_duplex != duplex) {
 857                 ep->mii.full_duplex = duplex;
 858                 printk(KERN_INFO "%s: Setting %s-duplex based on MII #%d link"
 859                            " partner capability of %4.4x.\n", dev->name,
 860                            ep->mii.full_duplex ? "full" : "half", ep->phys[0], mii_lpa);
 861                 outl(ep->mii.full_duplex ? 0x7F : 0x79, ioaddr + TxCtrl);
 862         }
 863 }
 864
 865 static void epic_timer(unsigned long data)
 866 {
 867         struct net_device *dev = (struct net_device *)data;
 868         struct epic_private *ep = netdev_priv(dev);
 869         long ioaddr = dev->base_addr;
 870         int next_tick = 5*HZ;
 871
 872         if (debug > 3) {
 873                 printk(KERN_DEBUG "%s: Media monitor tick, Tx status %8.8x.\n",
 874                            dev->name, (int)inl(ioaddr + TxSTAT));
 875                 printk(KERN_DEBUG "%s: Other registers are IntMask %4.4x "
 876                            "IntStatus %4.4x RxStatus %4.4x.\n",
 877                            dev->name, (int)inl(ioaddr + INTMASK),
 878                            (int)inl(ioaddr + INTSTAT), (int)inl(ioaddr + RxSTAT));
 879         }
 880
 881         check_media(dev);
 882
 883         ep->timer.expires = jiffies + next_tick;
 884         add_timer(&ep->timer);
 885 }
 886
 887 static void epic_tx_timeout(struct net_device *dev)
 888 {
 889         struct epic_private *ep = netdev_priv(dev);
 890         long ioaddr = dev->base_addr;
 891
 892         if (debug > 0) {
 893                 printk(KERN_WARNING "%s: Transmit timeout using MII device, "
 894                            "Tx status %4.4x.\n",
 895                            dev->name, (int)inw(ioaddr + TxSTAT));
 896                 if (debug > 1) {
 897                         printk(KERN_DEBUG "%s: Tx indices: dirty_tx %d, cur_tx %d.\n",
 898                                    dev->name, ep->dirty_tx, ep->cur_tx);
 899                 }
 900         }
 901         if (inw(ioaddr + TxSTAT) & 0x10) {              /* Tx FIFO underflow. */
 902                 ep->stats.tx_fifo_errors++;
 903                 outl(RestartTx, ioaddr + COMMAND);
 904         } else {
 905                 epic_restart(dev);
 906                 outl(TxQueued, dev->base_addr + COMMAND);
 907         }
 908
 909         dev->trans_start = jiffies; /* prevent tx timeout */
 910         ep->stats.tx_errors++;
 911         if (!ep->tx_full)
 912                 netif_wake_queue(dev);
 913 }
 914
 915 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
 916 static void epic_init_ring(struct net_device *dev)
 917 {
 918         struct epic_private *ep = netdev_priv(dev);
 919         int i;
 920
 921         ep->tx_full = 0;
 922         ep->dirty_tx = ep->cur_tx = 0;
 923         ep->cur_rx = ep->dirty_rx = 0;
 924         ep->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
 925
 926         /* Initialize all Rx descriptors. */
 927         for (i = 0; i < RX_RING_SIZE; i++) {
 928                 ep->rx_ring[i].rxstatus = 0;
 929                 ep->rx_ring[i].buflength = ep->rx_buf_sz;
 930                 ep->rx_ring[i].next = ep->rx_ring_dma +
 931                                       (i+1)*sizeof(struct epic_rx_desc);
 932                 ep->rx_skbuff[i] = NULL;
 933         }
 934         /* Mark the last entry as wrapping the ring. */
 935         ep->rx_ring[i-1].next = ep->rx_ring_dma;
 936
 937         /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
 938         for (i = 0; i < RX_RING_SIZE; i++) {
 939                 struct sk_buff *skb = dev_alloc_skb(ep->rx_buf_sz);
 940                 ep->rx_skbuff[i] = skb;
 941                 if (skb == NULL)
 942                         break;
 943                 skb_reserve(skb, 2);    /* 16 byte align the IP header. */
 944                 ep->rx_ring[i].bufaddr = pci_map_single(ep->pci_dev,
 945                         skb->data, ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
 946                 ep->rx_ring[i].rxstatus = DescOwn;
 947         }
 948         ep->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
 949
 950         /* The Tx buffer descriptor is filled in as needed, but we
 951            do need to clear the ownership bit. */
 952         for (i = 0; i < TX_RING_SIZE; i++) {
 953                 ep->tx_skbuff[i] = NULL;
 954                 ep->tx_ring[i].txstatus = 0x0000;
 955                 ep->tx_ring[i].next = ep->tx_ring_dma +
 956                         (i+1)*sizeof(struct epic_tx_desc);
 957         }
 958         ep->tx_ring[i-1].next = ep->tx_ring_dma;
 959 }
 960
 961 static netdev_tx_t epic_start_xmit(struct sk_buff *skb, struct net_device *dev)
 962 {
 963         struct epic_private *ep = netdev_priv(dev);
 964         int entry, free_count;
 965         u32 ctrl_word;
 966         unsigned long flags;
 967
 968         if (skb_padto(skb, ETH_ZLEN))
 969                 return NETDEV_TX_OK;
 970
 971         /* Caution: the write order is important here, set the field with the
 972            "ownership" bit last. */
 973
 974         /* Calculate the next Tx descriptor entry. */
 975         spin_lock_irqsave(&ep->lock, flags);
 976         free_count = ep->cur_tx - ep->dirty_tx;
 977         entry = ep->cur_tx % TX_RING_SIZE;
 978
 979         ep->tx_skbuff[entry] = skb;
 980         ep->tx_ring[entry].bufaddr = pci_map_single(ep->pci_dev, skb->data,
 981                                                     skb->len, PCI_DMA_TODEVICE);
 982         if (free_count < TX_QUEUE_LEN/2) {/* Typical path */
 983                 ctrl_word = 0x100000; /* No interrupt */
 984         } else if (free_count == TX_QUEUE_LEN/2) {
 985                 ctrl_word = 0x140000; /* Tx-done intr. */
 986         } else if (free_count < TX_QUEUE_LEN - 1) {
 987                 ctrl_word = 0x100000; /* No Tx-done intr. */
 988         } else {
 989                 /* Leave room for an additional entry. */
 990                 ctrl_word = 0x140000; /* Tx-done intr. */
 991                 ep->tx_full = 1;
 992         }
 993         ep->tx_ring[entry].buflength = ctrl_word | skb->len;
 994         ep->tx_ring[entry].txstatus =
 995                 ((skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN) << 16)
 996                             | DescOwn;
 997
 998         ep->cur_tx++;
 999         if (ep->tx_full)
1000                 netif_stop_queue(dev);
1001
1002         spin_unlock_irqrestore(&ep->lock, flags);
1003         /* Trigger an immediate transmit demand. */
1004         outl(TxQueued, dev->base_addr + COMMAND);
1005
1006         if (debug > 4)
1007                 printk(KERN_DEBUG "%s: Queued Tx packet size %d to slot %d, "
1008                            "flag %2.2x Tx status %8.8x.\n",
1009                            dev->name, (int)skb->len, entry, ctrl_word,
1010                            (int)inl(dev->base_addr + TxSTAT));
1011
1012         return NETDEV_TX_OK;
1013 }
1014
1015 static void epic_tx_error(struct net_device *dev, struct epic_private *ep,
1016                           int status)
1017 {
1018         struct net_device_stats *stats = &ep->stats;
1019
1020 #ifndef final_version
1021         /* There was an major error, log it. */
1022         if (debug > 1)
1023                 printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n",
1024                        dev->name, status);
1025 #endif
1026         stats->tx_errors++;
1027         if (status & 0x1050)
1028                 stats->tx_aborted_errors++;
1029         if (status & 0x0008)
1030                 stats->tx_carrier_errors++;
1031         if (status & 0x0040)
1032                 stats->tx_window_errors++;
1033         if (status & 0x0010)
1034                 stats->tx_fifo_errors++;
1035 }
1036
1037 static void epic_tx(struct net_device *dev, struct epic_private *ep)
1038 {
1039         unsigned int dirty_tx, cur_tx;
1040
1041         /*
1042          * Note: if this lock becomes a problem we can narrow the locked
1043          * region at the cost of occasionally grabbing the lock more times.
1044          */
1045         cur_tx = ep->cur_tx;
1046         for (dirty_tx = ep->dirty_tx; cur_tx - dirty_tx > 0; dirty_tx++) {
1047                 struct sk_buff *skb;
1048                 int entry = dirty_tx % TX_RING_SIZE;
1049                 int txstatus = ep->tx_ring[entry].txstatus;
1050
1051                 if (txstatus & DescOwn)
1052                         break;  /* It still hasn't been Txed */
1053
1054                 if (likely(txstatus & 0x0001)) {
1055                         ep->stats.collisions += (txstatus >> 8) & 15;
1056                         ep->stats.tx_packets++;
1057                         ep->stats.tx_bytes += ep->tx_skbuff[entry]->len;
1058                 } else
1059                         epic_tx_error(dev, ep, txstatus);
1060
1061                 /* Free the original skb. */
1062                 skb = ep->tx_skbuff[entry];
1063                 pci_unmap_single(ep->pci_dev, ep->tx_ring[entry].bufaddr,
1064                                  skb->len, PCI_DMA_TODEVICE);
1065                 dev_kfree_skb_irq(skb);
1066                 ep->tx_skbuff[entry] = NULL;
1067         }
1068
1069 #ifndef final_version
1070         if (cur_tx - dirty_tx > TX_RING_SIZE) {
1071                 printk(KERN_WARNING
1072                        "%s: Out-of-sync dirty pointer, %d vs. %d, full=%d.\n",
1073                        dev->name, dirty_tx, cur_tx, ep->tx_full);
1074                 dirty_tx += TX_RING_SIZE;
1075         }
1076 #endif
1077         ep->dirty_tx = dirty_tx;
1078         if (ep->tx_full && cur_tx - dirty_tx < TX_QUEUE_LEN - 4) {
1079                 /* The ring is no longer full, allow new TX entries. */
1080                 ep->tx_full = 0;
1081                 netif_wake_queue(dev);
1082         }
1083 }
1084
1085 /* The interrupt handler does all of the Rx thread work and cleans up
1086    after the Tx thread. */
1087 static irqreturn_t epic_interrupt(int irq, void *dev_instance)
1088 {
1089         struct net_device *dev = dev_instance;
1090         struct epic_private *ep = netdev_priv(dev);
1091         long ioaddr = dev->base_addr;
1092         unsigned int handled = 0;
1093         int status;
1094
1095         status = inl(ioaddr + INTSTAT);
1096         /* Acknowledge all of the current interrupt sources ASAP. */
1097         outl(status & EpicNormalEvent, ioaddr + INTSTAT);
1098
1099         if (debug > 4) {
1100                 printk(KERN_DEBUG "%s: Interrupt, status=%#8.8x new "
1101                                    "intstat=%#8.8x.\n", dev->name, status,
1102                                    (int)inl(ioaddr + INTSTAT));
1103         }
1104
1105         if ((status & IntrSummary) == 0)
1106                 goto out;
1107
1108         handled = 1;
1109
1110         if ((status & EpicNapiEvent) && !ep->reschedule_in_poll) {
1111                 spin_lock(&ep->napi_lock);
1112                 if (napi_schedule_prep(&ep->napi)) {
1113                         epic_napi_irq_off(dev, ep);
1114                         __napi_schedule(&ep->napi);
1115                 } else
1116                         ep->reschedule_in_poll++;
1117                 spin_unlock(&ep->napi_lock);
1118         }
1119         status &= ~EpicNapiEvent;
1120
1121         /* Check uncommon events all at once. */
1122         if (status & (CntFull | TxUnderrun | PCIBusErr170 | PCIBusErr175)) {
1123                 if (status == EpicRemoved)
1124                         goto out;
1125
1126                 /* Always update the error counts to avoid overhead later. */
1127                 ep->stats.rx_missed_errors += inb(ioaddr + MPCNT);
1128                 ep->stats.rx_frame_errors += inb(ioaddr + ALICNT);
1129                 ep->stats.rx_crc_errors += inb(ioaddr + CRCCNT);
1130
1131                 if (status & TxUnderrun) { /* Tx FIFO underflow. */
1132                         ep->stats.tx_fifo_errors++;
1133                         outl(ep->tx_threshold += 128, ioaddr + TxThresh);
1134                         /* Restart the transmit process. */
1135                         outl(RestartTx, ioaddr + COMMAND);
1136                 }
1137                 if (status & PCIBusErr170) {
1138                         printk(KERN_ERR "%s: PCI Bus Error! status %4.4x.\n",
1139                                          dev->name, status);
1140                         epic_pause(dev);
1141                         epic_restart(dev);
1142                 }
1143                 /* Clear all error sources. */
1144                 outl(status & 0x7f18, ioaddr + INTSTAT);
1145         }
1146
1147 out:
1148         if (debug > 3) {
1149                 printk(KERN_DEBUG "%s: exit interrupt, intr_status=%#4.4x.\n",
1150                                    dev->name, status);
1151         }
1152
1153         return IRQ_RETVAL(handled);
1154 }
1155
1156 static int epic_rx(struct net_device *dev, int budget)
1157 {
1158         struct epic_private *ep = netdev_priv(dev);
1159         int entry = ep->cur_rx % RX_RING_SIZE;
1160         int rx_work_limit = ep->dirty_rx + RX_RING_SIZE - ep->cur_rx;
1161         int work_done = 0;
1162
1163         if (debug > 4)
1164                 printk(KERN_DEBUG " In epic_rx(), entry %d %8.8x.\n", entry,
1165                            ep->rx_ring[entry].rxstatus);
1166
1167         if (rx_work_limit > budget)
1168                 rx_work_limit = budget;
1169
1170         /* If we own the next entry, it's a new packet. Send it up. */
1171         while ((ep->rx_ring[entry].rxstatus & DescOwn) == 0) {
1172                 int status = ep->rx_ring[entry].rxstatus;
1173
1174                 if (debug > 4)
1175                         printk(KERN_DEBUG "  epic_rx() status was %8.8x.\n", status);
1176                 if (--rx_work_limit < 0)
1177                         break;
1178                 if (status & 0x2006) {
1179                         if (debug > 2)
1180                                 printk(KERN_DEBUG "%s: epic_rx() error status was %8.8x.\n",
1181                                            dev->name, status);
1182                         if (status & 0x2000) {
1183                                 printk(KERN_WARNING "%s: Oversized Ethernet frame spanned "
1184                                            "multiple buffers, status %4.4x!\n", dev->name, status);
1185                                 ep->stats.rx_length_errors++;
1186                         } else if (status & 0x0006)
1187                                 /* Rx Frame errors are counted in hardware. */
1188                                 ep->stats.rx_errors++;
1189                 } else {
1190                         /* Malloc up new buffer, compatible with net-2e. */
1191                         /* Omit the four octet CRC from the length. */
1192                         short pkt_len = (status >> 16) - 4;
1193                         struct sk_buff *skb;
1194
1195                         if (pkt_len > PKT_BUF_SZ - 4) {
1196                                 printk(KERN_ERR "%s: Oversized Ethernet frame, status %x "
1197                                            "%d bytes.\n",
1198                                            dev->name, status, pkt_len);
1199                                 pkt_len = 1514;
1200                         }
1201                         /* Check if the packet is long enough to accept without copying
1202                            to a minimally-sized skbuff. */
1203                         if (pkt_len < rx_copybreak &&
1204                             (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1205                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
1206                                 pci_dma_sync_single_for_cpu(ep->pci_dev,
1207                                                             ep->rx_ring[entry].bufaddr,
1208                                                             ep->rx_buf_sz,
1209                                                             PCI_DMA_FROMDEVICE);
1210                                 skb_copy_to_linear_data(skb, ep->rx_skbuff[entry]->data, pkt_len);
1211                                 skb_put(skb, pkt_len);
1212                                 pci_dma_sync_single_for_device(ep->pci_dev,
1213                                                                ep->rx_ring[entry].bufaddr,
1214                                                                ep->rx_buf_sz,
1215                                                                PCI_DMA_FROMDEVICE);
1216                         } else {
1217                                 pci_unmap_single(ep->pci_dev,
1218                                         ep->rx_ring[entry].bufaddr,
1219                                         ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
1220                                 skb_put(skb = ep->rx_skbuff[entry], pkt_len);
1221                                 ep->rx_skbuff[entry] = NULL;
1222                         }
1223                         skb->protocol = eth_type_trans(skb, dev);
1224                         netif_receive_skb(skb);
1225                         ep->stats.rx_packets++;
1226                         ep->stats.rx_bytes += pkt_len;
1227                 }
1228                 work_done++;
1229                 entry = (++ep->cur_rx) % RX_RING_SIZE;
1230         }
1231
1232         /* Refill the Rx ring buffers. */
1233         for (; ep->cur_rx - ep->dirty_rx > 0; ep->dirty_rx++) {
1234                 entry = ep->dirty_rx % RX_RING_SIZE;
1235                 if (ep->rx_skbuff[entry] == NULL) {
1236                         struct sk_buff *skb;
1237                         skb = ep->rx_skbuff[entry] = dev_alloc_skb(ep->rx_buf_sz);
1238                         if (skb == NULL)
1239                                 break;
1240                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1241                         ep->rx_ring[entry].bufaddr = pci_map_single(ep->pci_dev,
1242                                 skb->data, ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
1243                         work_done++;
1244                 }
1245                 /* AV: shouldn't we add a barrier here? */
1246                 ep->rx_ring[entry].rxstatus = DescOwn;
1247         }
1248         return work_done;
1249 }
1250
1251 static void epic_rx_err(struct net_device *dev, struct epic_private *ep)
1252 {
1253         long ioaddr = dev->base_addr;
1254         int status;
1255
1256         status = inl(ioaddr + INTSTAT);
1257
1258         if (status == EpicRemoved)
1259                 return;
1260         if (status & RxOverflow)        /* Missed a Rx frame. */
1261                 ep->stats.rx_errors++;
1262         if (status & (RxOverflow | RxFull))
1263                 outw(RxQueued, ioaddr + COMMAND);
1264 }
1265
1266 static int epic_poll(struct napi_struct *napi, int budget)
1267 {
1268         struct epic_private *ep = container_of(napi, struct epic_private, napi);
1269         struct net_device *dev = ep->mii.dev;
1270         int work_done = 0;
1271         long ioaddr = dev->base_addr;
1272
1273 rx_action:
1274
1275         epic_tx(dev, ep);
1276
1277         work_done += epic_rx(dev, budget);
1278
1279         epic_rx_err(dev, ep);
1280
1281         if (work_done < budget) {
1282                 unsigned long flags;
1283                 int more;
1284
1285                 /* A bit baroque but it avoids a (space hungry) spin_unlock */
1286
1287                 spin_lock_irqsave(&ep->napi_lock, flags);
1288
1289                 more = ep->reschedule_in_poll;
1290                 if (!more) {
1291                         __napi_complete(napi);
1292                         outl(EpicNapiEvent, ioaddr + INTSTAT);
1293                         epic_napi_irq_on(dev, ep);
1294                 } else
1295                         ep->reschedule_in_poll--;
1296
1297                 spin_unlock_irqrestore(&ep->napi_lock, flags);
1298
1299                 if (more)
1300                         goto rx_action;
1301         }
1302
1303         return work_done;
1304 }
1305
1306 static int epic_close(struct net_device *dev)
1307 {
1308         long ioaddr = dev->base_addr;
1309         struct epic_private *ep = netdev_priv(dev);
1310         struct sk_buff *skb;
1311         int i;
1312
1313         netif_stop_queue(dev);
1314         napi_disable(&ep->napi);
1315
1316         if (debug > 1)
1317                 printk(KERN_DEBUG "%s: Shutting down ethercard, status was %2.2x.\n",
1318                            dev->name, (int)inl(ioaddr + INTSTAT));
1319
1320         del_timer_sync(&ep->timer);
1321
1322         epic_disable_int(dev, ep);
1323
1324         free_irq(dev->irq, dev);
1325
1326         epic_pause(dev);
1327
1328         /* Free all the skbuffs in the Rx queue. */
1329         for (i = 0; i < RX_RING_SIZE; i++) {
1330                 skb = ep->rx_skbuff[i];
1331                 ep->rx_skbuff[i] = NULL;
1332                 ep->rx_ring[i].rxstatus = 0;            /* Not owned by Epic chip. */
1333                 ep->rx_ring[i].buflength = 0;
1334                 if (skb) {
1335                         pci_unmap_single(ep->pci_dev, ep->rx_ring[i].bufaddr,
1336                                          ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
1337                         dev_kfree_skb(skb);
1338                 }
1339                 ep->rx_ring[i].bufaddr = 0xBADF00D0; /* An invalid address. */
1340         }
1341         for (i = 0; i < TX_RING_SIZE; i++) {
1342                 skb = ep->tx_skbuff[i];
1343                 ep->tx_skbuff[i] = NULL;
1344                 if (!skb)
1345                         continue;
1346                 pci_unmap_single(ep->pci_dev, ep->tx_ring[i].bufaddr,
1347                                  skb->len, PCI_DMA_TODEVICE);
1348                 dev_kfree_skb(skb);
1349         }
1350
1351         /* Green! Leave the chip in low-power mode. */
1352         outl(0x0008, ioaddr + GENCTL);
1353
1354         return 0;
1355 }
1356
1357 static struct net_device_stats *epic_get_stats(struct net_device *dev)
1358 {
1359         struct epic_private *ep = netdev_priv(dev);
1360         long ioaddr = dev->base_addr;
1361
1362         if (netif_running(dev)) {
1363                 /* Update the error counts. */
1364                 ep->stats.rx_missed_errors += inb(ioaddr + MPCNT);
1365                 ep->stats.rx_frame_errors += inb(ioaddr + ALICNT);
1366                 ep->stats.rx_crc_errors += inb(ioaddr + CRCCNT);
1367         }
1368
1369         return &ep->stats;
1370 }
1371
1372 /* Set or clear the multicast filter for this adaptor.
1373    Note that we only use exclusion around actually queueing the
1374    new frame, not around filling ep->setup_frame.  This is non-deterministic
1375    when re-entered but still correct. */
1376
1377 static void set_rx_mode(struct net_device *dev)
1378 {
1379         long ioaddr = dev->base_addr;
1380         struct epic_private *ep = netdev_priv(dev);
1381         unsigned char mc_filter[8];              /* Multicast hash filter */
1382         int i;
1383
1384         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
1385                 outl(0x002C, ioaddr + RxCtrl);
1386                 /* Unconditionally log net taps. */
1387                 memset(mc_filter, 0xff, sizeof(mc_filter));
1388         } else if ((!netdev_mc_empty(dev)) || (dev->flags & IFF_ALLMULTI)) {
1389                 /* There is apparently a chip bug, so the multicast filter
1390                    is never enabled. */
1391                 /* Too many to filter perfectly -- accept all multicasts. */
1392                 memset(mc_filter, 0xff, sizeof(mc_filter));
1393                 outl(0x000C, ioaddr + RxCtrl);
1394         } else if (netdev_mc_empty(dev)) {
1395                 outl(0x0004, ioaddr + RxCtrl);
1396                 return;
1397         } else {                                        /* Never executed, for now. */
1398                 struct netdev_hw_addr *ha;
1399
1400                 memset(mc_filter, 0, sizeof(mc_filter));
1401                 netdev_for_each_mc_addr(ha, dev) {
1402                         unsigned int bit_nr =
1403                                 ether_crc_le(ETH_ALEN, ha->addr) & 0x3f;
1404                         mc_filter[bit_nr >> 3] |= (1 << bit_nr);
1405                 }
1406         }
1407         /* ToDo: perhaps we need to stop the Tx and Rx process here? */
1408         if (memcmp(mc_filter, ep->mc_filter, sizeof(mc_filter))) {
1409                 for (i = 0; i < 4; i++)
1410                         outw(((u16 *)mc_filter)[i], ioaddr + MC0 + i*4);
1411                 memcpy(ep->mc_filter, mc_filter, sizeof(mc_filter));
1412         }
1413 }
1414
1415 static void netdev_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info)
1416 {
1417         struct epic_private *np = netdev_priv(dev);
1418
1419         strcpy (info->driver, DRV_NAME);
1420         strcpy (info->version, DRV_VERSION);
1421         strcpy (info->bus_info, pci_name(np->pci_dev));
1422 }
1423
1424 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1425 {
1426         struct epic_private *np = netdev_priv(dev);
1427         int rc;
1428
1429         spin_lock_irq(&np->lock);
1430         rc = mii_ethtool_gset(&np->mii, cmd);
1431         spin_unlock_irq(&np->lock);
1432
1433         return rc;
1434 }
1435
1436 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1437 {
1438         struct epic_private *np = netdev_priv(dev);
1439         int rc;
1440
1441         spin_lock_irq(&np->lock);
1442         rc = mii_ethtool_sset(&np->mii, cmd);
1443         spin_unlock_irq(&np->lock);
1444
1445         return rc;
1446 }
1447
1448 static int netdev_nway_reset(struct net_device *dev)
1449 {
1450         struct epic_private *np = netdev_priv(dev);
1451         return mii_nway_restart(&np->mii);
1452 }
1453
1454 static u32 netdev_get_link(struct net_device *dev)
1455 {
1456         struct epic_private *np = netdev_priv(dev);
1457         return mii_link_ok(&np->mii);
1458 }
1459
1460 static u32 netdev_get_msglevel(struct net_device *dev)
1461 {
1462         return debug;
1463 }
1464
1465 static void netdev_set_msglevel(struct net_device *dev, u32 value)
1466 {
1467         debug = value;
1468 }
1469
1470 static int ethtool_begin(struct net_device *dev)
1471 {
1472         unsigned long ioaddr = dev->base_addr;
1473         /* power-up, if interface is down */
1474         if (! netif_running(dev)) {
1475                 outl(0x0200, ioaddr + GENCTL);
1476                 outl((inl(ioaddr + NVCTL) & ~0x003C) | 0x4800, ioaddr + NVCTL);
1477         }
1478         return 0;
1479 }
1480
1481 static void ethtool_complete(struct net_device *dev)
1482 {
1483         unsigned long ioaddr = dev->base_addr;
1484         /* power-down, if interface is down */
1485         if (! netif_running(dev)) {
1486                 outl(0x0008, ioaddr + GENCTL);
1487                 outl((inl(ioaddr + NVCTL) & ~0x483C) | 0x0000, ioaddr + NVCTL);
1488         }
1489 }
1490
1491 static const struct ethtool_ops netdev_ethtool_ops = {
1492         .get_drvinfo            = netdev_get_drvinfo,
1493         .get_settings           = netdev_get_settings,
1494         .set_settings           = netdev_set_settings,
1495         .nway_reset             = netdev_nway_reset,
1496         .get_link               = netdev_get_link,
1497         .get_msglevel           = netdev_get_msglevel,
1498         .set_msglevel           = netdev_set_msglevel,
1499         .begin                  = ethtool_begin,
1500         .complete               = ethtool_complete
1501 };
1502
1503 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1504 {
1505         struct epic_private *np = netdev_priv(dev);
1506         long ioaddr = dev->base_addr;
1507         struct mii_ioctl_data *data = if_mii(rq);
1508         int rc;
1509
1510         /* power-up, if interface is down */
1511         if (! netif_running(dev)) {
1512                 outl(0x0200, ioaddr + GENCTL);
1513                 outl((inl(ioaddr + NVCTL) & ~0x003C) | 0x4800, ioaddr + NVCTL);
1514         }
1515
1516         /* all non-ethtool ioctls (the SIOC[GS]MIIxxx ioctls) */
1517         spin_lock_irq(&np->lock);
1518         rc = generic_mii_ioctl(&np->mii, data, cmd, NULL);
1519         spin_unlock_irq(&np->lock);
1520
1521         /* power-down, if interface is down */
1522         if (! netif_running(dev)) {
1523                 outl(0x0008, ioaddr + GENCTL);
1524                 outl((inl(ioaddr + NVCTL) & ~0x483C) | 0x0000, ioaddr + NVCTL);
1525         }
1526         return rc;
1527 }
1528
1529
1530 static void __devexit epic_remove_one (struct pci_dev *pdev)
1531 {
1532         struct net_device *dev = pci_get_drvdata(pdev);
1533         struct epic_private *ep = netdev_priv(dev);
1534
1535         pci_free_consistent(pdev, TX_TOTAL_SIZE, ep->tx_ring, ep->tx_ring_dma);
1536         pci_free_consistent(pdev, RX_TOTAL_SIZE, ep->rx_ring, ep->rx_ring_dma);
1537         unregister_netdev(dev);
1538 #ifndef USE_IO_OPS
1539         iounmap((void*) dev->base_addr);
1540 #endif
1541         pci_release_regions(pdev);
1542         free_netdev(dev);
1543         pci_disable_device(pdev);
1544         pci_set_drvdata(pdev, NULL);
1545         /* pci_power_off(pdev, -1); */
1546 }
1547
1548
1549 #ifdef CONFIG_PM
1550
1551 static int epic_suspend (struct pci_dev *pdev, pm_message_t state)
1552 {
1553         struct net_device *dev = pci_get_drvdata(pdev);
1554         long ioaddr = dev->base_addr;
1555
1556         if (!netif_running(dev))
1557                 return 0;
1558         epic_pause(dev);
1559         /* Put the chip into low-power mode. */
1560         outl(0x0008, ioaddr + GENCTL);
1561         /* pci_power_off(pdev, -1); */
1562         return 0;
1563 }
1564
1565
1566 static int epic_resume (struct pci_dev *pdev)
1567 {
1568         struct net_device *dev = pci_get_drvdata(pdev);
1569
1570         if (!netif_running(dev))
1571                 return 0;
1572         epic_restart(dev);
1573         /* pci_power_on(pdev); */
1574         return 0;
1575 }
1576
1577 #endif /* CONFIG_PM */
1578
1579
1580 static struct pci_driver epic_driver = {
1581         .name           = DRV_NAME,
1582         .id_table       = epic_pci_tbl,
1583         .probe          = epic_init_one,
1584         .remove         = __devexit_p(epic_remove_one),
1585 #ifdef CONFIG_PM
1586         .suspend        = epic_suspend,
1587         .resume         = epic_resume,
1588 #endif /* CONFIG_PM */
1589 };
1590
1591
1592 static int __init epic_init (void)
1593 {
1594 /* when a module, this is printed whether or not devices are found in probe */
1595 #ifdef MODULE
1596         printk (KERN_INFO "%s%s",
1597                 version, version2);
1598 #endif
1599
1600         return pci_register_driver(&epic_driver);
1601 }
1602
1603
1604 static void __exit epic_cleanup (void)
1605 {
1606         pci_unregister_driver (&epic_driver);
1607 }
1608
1609
1610 module_init(epic_init);
1611 module_exit(epic_cleanup);