drivers/net/tulip/winbond-840.c

   1 /* winbond-840.c: A Linux PCI network adapter device driver. */
   2 /*
   3         Written 1998-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         The author may be reached as becker@scyld.com, or C/O
  13         Scyld Computing Corporation
  14         410 Severn Ave., Suite 210
  15         Annapolis MD 21403
  16
  17         Support and updates available at
  18         http://www.scyld.com/network/drivers.html
  19
  20         Do not remove the copyright information.
  21         Do not change the version information unless an improvement has been made.
  22         Merely removing my name, as Compex has done in the past, does not count
  23         as an improvement.
  24
  25         Changelog:
  26         * ported to 2.4
  27                 ???
  28         * spin lock update, memory barriers, new style dma mappings
  29                 limit each tx buffer to < 1024 bytes
  30                 remove DescIntr from Rx descriptors (that's an Tx flag)
  31                 remove next pointer from Tx descriptors
  32                 synchronize tx_q_bytes
  33                 software reset in tx_timeout
  34                         Copyright (C) 2000 Manfred Spraul
  35         * further cleanups
  36                 power management.
  37                 support for big endian descriptors
  38                         Copyright (C) 2001 Manfred Spraul
  39         * ethtool support (jgarzik)
  40         * Replace some MII-related magic numbers with constants (jgarzik)
  41
  42         TODO:
  43         * enable pci_power_off
  44         * Wake-On-LAN
  45 */
  46
  47 #define DRV_NAME        "winbond-840"
  48 #define DRV_VERSION     "1.01-e"
  49 #define DRV_RELDATE     "Sep-11-2006"
  50
  51
  52 /* Automatically extracted configuration info:
  53 probe-func: winbond840_probe
  54 config-in: tristate 'Winbond W89c840 Ethernet support' CONFIG_WINBOND_840
  55
  56 c-help-name: Winbond W89c840 PCI Ethernet support
  57 c-help-symbol: CONFIG_WINBOND_840
  58 c-help: This driver is for the Winbond W89c840 chip.  It also works with
  59 c-help: the TX9882 chip on the Compex RL100-ATX board.
  60 c-help: More specific information and updates are available from
  61 c-help: http://www.scyld.com/network/drivers.html
  62 */
  63
  64 /* The user-configurable values.
  65    These may be modified when a driver module is loaded.*/
  66
  67 static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */
  68 static int max_interrupt_work = 20;
  69 /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
  70    The '840 uses a 64 element hash table based on the Ethernet CRC.  */
  71 static int multicast_filter_limit = 32;
  72
  73 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  74    Setting to > 1518 effectively disables this feature. */
  75 static int rx_copybreak;
  76
  77 /* Used to pass the media type, etc.
  78    Both 'options[]' and 'full_duplex[]' should exist for driver
  79    interoperability.
  80    The media type is usually passed in 'options[]'.
  81 */
  82 #define MAX_UNITS 8             /* More are supported, limit only on options */
  83 static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
  84 static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
  85
  86 /* Operational parameters that are set at compile time. */
  87
  88 /* Keep the ring sizes a power of two for compile efficiency.
  89    The compiler will convert <unsigned>'%'<2^N> into a bit mask.
  90    Making the Tx ring too large decreases the effectiveness of channel
  91    bonding and packet priority.
  92    There are no ill effects from too-large receive rings. */
  93 #define TX_QUEUE_LEN    10              /* Limit ring entries actually used.  */
  94 #define TX_QUEUE_LEN_RESTART    5
  95
  96 #define TX_BUFLIMIT     (1024-128)
  97
  98 /* The presumed FIFO size for working around the Tx-FIFO-overflow bug.
  99    To avoid overflowing we don't queue again until we have room for a
 100    full-size packet.
 101  */
 102 #define TX_FIFO_SIZE (2048)
 103 #define TX_BUG_FIFO_LIMIT (TX_FIFO_SIZE-1514-16)
 104
 105
 106 /* Operational parameters that usually are not changed. */
 107 /* Time in jiffies before concluding the transmitter is hung. */
 108 #define TX_TIMEOUT  (2*HZ)
 109
 110 /* Include files, designed to support most kernel versions 2.0.0 and later. */
 111 #include <linux/module.h>
 112 #include <linux/kernel.h>
 113 #include <linux/string.h>
 114 #include <linux/timer.h>
 115 #include <linux/errno.h>
 116 #include <linux/ioport.h>
 117 #include <linux/interrupt.h>
 118 #include <linux/pci.h>
 119 #include <linux/dma-mapping.h>
 120 #include <linux/netdevice.h>
 121 #include <linux/etherdevice.h>
 122 #include <linux/skbuff.h>
 123 #include <linux/init.h>
 124 #include <linux/delay.h>
 125 #include <linux/ethtool.h>
 126 #include <linux/mii.h>
 127 #include <linux/rtnetlink.h>
 128 #include <linux/crc32.h>
 129 #include <linux/bitops.h>
 130 #include <asm/uaccess.h>
 131 #include <asm/processor.h>              /* Processor type for cache alignment. */
 132 #include <asm/io.h>
 133 #include <asm/irq.h>
 134
 135 #include "tulip.h"
 136
 137 #undef PKT_BUF_SZ                       /* tulip.h also defines this */
 138 #define PKT_BUF_SZ              1536    /* Size of each temporary Rx buffer.*/
 139
 140 /* These identify the driver base version and may not be removed. */
 141 static const char version[] __initconst =
 142         KERN_INFO DRV_NAME ".c:v" DRV_VERSION " (2.4 port) "
 143         DRV_RELDATE "  Donald Becker <becker@scyld.com>\n"
 144         "  http://www.scyld.com/network/drivers.html\n";
 145
 146 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 147 MODULE_DESCRIPTION("Winbond W89c840 Ethernet driver");
 148 MODULE_LICENSE("GPL");
 149 MODULE_VERSION(DRV_VERSION);
 150
 151 module_param(max_interrupt_work, int, 0);
 152 module_param(debug, int, 0);
 153 module_param(rx_copybreak, int, 0);
 154 module_param(multicast_filter_limit, int, 0);
 155 module_param_array(options, int, NULL, 0);
 156 module_param_array(full_duplex, int, NULL, 0);
 157 MODULE_PARM_DESC(max_interrupt_work, "winbond-840 maximum events handled per interrupt");
 158 MODULE_PARM_DESC(debug, "winbond-840 debug level (0-6)");
 159 MODULE_PARM_DESC(rx_copybreak, "winbond-840 copy breakpoint for copy-only-tiny-frames");
 160 MODULE_PARM_DESC(multicast_filter_limit, "winbond-840 maximum number of filtered multicast addresses");
 161 MODULE_PARM_DESC(options, "winbond-840: Bits 0-3: media type, bit 17: full duplex");
 162 MODULE_PARM_DESC(full_duplex, "winbond-840 full duplex setting(s) (1)");
 163
 164 /*
 165                                 Theory of Operation
 166
 167 I. Board Compatibility
 168
 169 This driver is for the Winbond w89c840 chip.
 170
 171 II. Board-specific settings
 172
 173 None.
 174
 175 III. Driver operation
 176
 177 This chip is very similar to the Digital 21*4* "Tulip" family.  The first
 178 twelve registers and the descriptor format are nearly identical.  Read a
 179 Tulip manual for operational details.
 180
 181 A significant difference is that the multicast filter and station address are
 182 stored in registers rather than loaded through a pseudo-transmit packet.
 183
 184 Unlike the Tulip, transmit buffers are limited to 1KB.  To transmit a
 185 full-sized packet we must use both data buffers in a descriptor.  Thus the
 186 driver uses ring mode where descriptors are implicitly sequential in memory,
 187 rather than using the second descriptor address as a chain pointer to
 188 subsequent descriptors.
 189
 190 IV. Notes
 191
 192 If you are going to almost clone a Tulip, why not go all the way and avoid
 193 the need for a new driver?
 194
 195 IVb. References
 196
 197 http://www.scyld.com/expert/100mbps.html
 198 http://www.scyld.com/expert/NWay.html
 199 http://www.winbond.com.tw/
 200
 201 IVc. Errata
 202
 203 A horrible bug exists in the transmit FIFO.  Apparently the chip doesn't
 204 correctly detect a full FIFO, and queuing more than 2048 bytes may result in
 205 silent data corruption.
 206
 207 Test with 'ping -s 10000' on a fast computer.
 208
 209 */
 210
 211
 212
 213 /*
 214   PCI probe table.
 215 */
 216 enum chip_capability_flags {
 217         CanHaveMII=1, HasBrokenTx=2, AlwaysFDX=4, FDXOnNoMII=8,
 218 };
 219
 220 static DEFINE_PCI_DEVICE_TABLE(w840_pci_tbl) = {
 221         { 0x1050, 0x0840, PCI_ANY_ID, 0x8153,     0, 0, 0 },
 222         { 0x1050, 0x0840, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
 223         { 0x11f6, 0x2011, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
 224         { }
 225 };
 226 MODULE_DEVICE_TABLE(pci, w840_pci_tbl);
 227
 228 enum {
 229         netdev_res_size         = 128,  /* size of PCI BAR resource */
 230 };
 231
 232 struct pci_id_info {
 233         const char *name;
 234         int drv_flags;          /* Driver use, intended as capability flags. */
 235 };
 236
 237 static const struct pci_id_info pci_id_tbl[] __devinitdata = {
 238         {                               /* Sometime a Level-One switch card. */
 239           "Winbond W89c840",    CanHaveMII | HasBrokenTx | FDXOnNoMII},
 240         { "Winbond W89c840",    CanHaveMII | HasBrokenTx},
 241         { "Compex RL100-ATX",   CanHaveMII | HasBrokenTx},
 242         { }     /* terminate list. */
 243 };
 244
 245 /* This driver was written to use PCI memory space, however some x86 systems
 246    work only with I/O space accesses. See CONFIG_TULIP_MMIO in .config
 247 */
 248
 249 /* Offsets to the Command and Status Registers, "CSRs".
 250    While similar to the Tulip, these registers are longword aligned.
 251    Note: It's not useful to define symbolic names for every register bit in
 252    the device.  The name can only partially document the semantics and make
 253    the driver longer and more difficult to read.
 254 */
 255 enum w840_offsets {
 256         PCIBusCfg=0x00, TxStartDemand=0x04, RxStartDemand=0x08,
 257         RxRingPtr=0x0C, TxRingPtr=0x10,
 258         IntrStatus=0x14, NetworkConfig=0x18, IntrEnable=0x1C,
 259         RxMissed=0x20, EECtrl=0x24, MIICtrl=0x24, BootRom=0x28, GPTimer=0x2C,
 260         CurRxDescAddr=0x30, CurRxBufAddr=0x34,                  /* Debug use */
 261         MulticastFilter0=0x38, MulticastFilter1=0x3C, StationAddr=0x40,
 262         CurTxDescAddr=0x4C, CurTxBufAddr=0x50,
 263 };
 264
 265 /* Bits in the NetworkConfig register. */
 266 enum rx_mode_bits {
 267         AcceptErr=0x80,
 268         RxAcceptBroadcast=0x20, AcceptMulticast=0x10,
 269         RxAcceptAllPhys=0x08, AcceptMyPhys=0x02,
 270 };
 271
 272 enum mii_reg_bits {
 273         MDIO_ShiftClk=0x10000, MDIO_DataIn=0x80000, MDIO_DataOut=0x20000,
 274         MDIO_EnbOutput=0x40000, MDIO_EnbIn = 0x00000,
 275 };
 276
 277 /* The Tulip Rx and Tx buffer descriptors. */
 278 struct w840_rx_desc {
 279         s32 status;
 280         s32 length;
 281         u32 buffer1;
 282         u32 buffer2;
 283 };
 284
 285 struct w840_tx_desc {
 286         s32 status;
 287         s32 length;
 288         u32 buffer1, buffer2;
 289 };
 290
 291 #define MII_CNT         1 /* winbond only supports one MII */
 292 struct netdev_private {
 293         struct w840_rx_desc *rx_ring;
 294         dma_addr_t      rx_addr[RX_RING_SIZE];
 295         struct w840_tx_desc *tx_ring;
 296         dma_addr_t      tx_addr[TX_RING_SIZE];
 297         dma_addr_t ring_dma_addr;
 298         /* The addresses of receive-in-place skbuffs. */
 299         struct sk_buff* rx_skbuff[RX_RING_SIZE];
 300         /* The saved address of a sent-in-place packet/buffer, for later free(). */
 301         struct sk_buff* tx_skbuff[TX_RING_SIZE];
 302         struct net_device_stats stats;
 303         struct timer_list timer;        /* Media monitoring timer. */
 304         /* Frequently used values: keep some adjacent for cache effect. */
 305         spinlock_t lock;
 306         int chip_id, drv_flags;
 307         struct pci_dev *pci_dev;
 308         int csr6;
 309         struct w840_rx_desc *rx_head_desc;
 310         unsigned int cur_rx, dirty_rx;          /* Producer/consumer ring indices */
 311         unsigned int rx_buf_sz;                         /* Based on MTU+slack. */
 312         unsigned int cur_tx, dirty_tx;
 313         unsigned int tx_q_bytes;
 314         unsigned int tx_full;                           /* The Tx queue is full. */
 315         /* MII transceiver section. */
 316         int mii_cnt;                                            /* MII device addresses. */
 317         unsigned char phys[MII_CNT];            /* MII device addresses, but only the first is used */
 318         u32 mii;
 319         struct mii_if_info mii_if;
 320         void __iomem *base_addr;
 321 };
 322
 323 static int  eeprom_read(void __iomem *ioaddr, int location);
 324 static int  mdio_read(struct net_device *dev, int phy_id, int location);
 325 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
 326 static int  netdev_open(struct net_device *dev);
 327 static int  update_link(struct net_device *dev);
 328 static void netdev_timer(unsigned long data);
 329 static void init_rxtx_rings(struct net_device *dev);
 330 static void free_rxtx_rings(struct netdev_private *np);
 331 static void init_registers(struct net_device *dev);
 332 static void tx_timeout(struct net_device *dev);
 333 static int alloc_ringdesc(struct net_device *dev);
 334 static void free_ringdesc(struct netdev_private *np);
 335 static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev);
 336 static irqreturn_t intr_handler(int irq, void *dev_instance);
 337 static void netdev_error(struct net_device *dev, int intr_status);
 338 static int  netdev_rx(struct net_device *dev);
 339 static u32 __set_rx_mode(struct net_device *dev);
 340 static void set_rx_mode(struct net_device *dev);
 341 static struct net_device_stats *get_stats(struct net_device *dev);
 342 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 343 static const struct ethtool_ops netdev_ethtool_ops;
 344 static int  netdev_close(struct net_device *dev);
 345
 346 static const struct net_device_ops netdev_ops = {
 347         .ndo_open               = netdev_open,
 348         .ndo_stop               = netdev_close,
 349         .ndo_start_xmit         = start_tx,
 350         .ndo_get_stats          = get_stats,
 351         .ndo_set_multicast_list = set_rx_mode,
 352         .ndo_do_ioctl           = netdev_ioctl,
 353         .ndo_tx_timeout         = tx_timeout,
 354         .ndo_change_mtu         = eth_change_mtu,
 355         .ndo_set_mac_address    = eth_mac_addr,
 356         .ndo_validate_addr      = eth_validate_addr,
 357 };
 358
 359 static int __devinit w840_probe1 (struct pci_dev *pdev,
 360                                   const struct pci_device_id *ent)
 361 {
 362         struct net_device *dev;
 363         struct netdev_private *np;
 364         static int find_cnt;
 365         int chip_idx = ent->driver_data;
 366         int irq;
 367         int i, option = find_cnt < MAX_UNITS ? options[find_cnt] : 0;
 368         void __iomem *ioaddr;
 369
 370         i = pci_enable_device(pdev);
 371         if (i) return i;
 372
 373         pci_set_master(pdev);
 374
 375         irq = pdev->irq;
 376
 377         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
 378                 pr_warning("Winbond-840: Device %s disabled due to DMA limitations\n",
 379                            pci_name(pdev));
 380                 return -EIO;
 381         }
 382         dev = alloc_etherdev(sizeof(*np));
 383         if (!dev)
 384                 return -ENOMEM;
 385         SET_NETDEV_DEV(dev, &pdev->dev);
 386
 387         if (pci_request_regions(pdev, DRV_NAME))
 388                 goto err_out_netdev;
 389
 390         ioaddr = pci_iomap(pdev, TULIP_BAR, netdev_res_size);
 391         if (!ioaddr)
 392                 goto err_out_free_res;
 393
 394         for (i = 0; i < 3; i++)
 395                 ((__le16 *)dev->dev_addr)[i] = cpu_to_le16(eeprom_read(ioaddr, i));
 396
 397         /* Reset the chip to erase previous misconfiguration.
 398            No hold time required! */
 399         iowrite32(0x00000001, ioaddr + PCIBusCfg);
 400
 401         dev->base_addr = (unsigned long)ioaddr;
 402         dev->irq = irq;
 403
 404         np = netdev_priv(dev);
 405         np->pci_dev = pdev;
 406         np->chip_id = chip_idx;
 407         np->drv_flags = pci_id_tbl[chip_idx].drv_flags;
 408         spin_lock_init(&np->lock);
 409         np->mii_if.dev = dev;
 410         np->mii_if.mdio_read = mdio_read;
 411         np->mii_if.mdio_write = mdio_write;
 412         np->base_addr = ioaddr;
 413
 414         pci_set_drvdata(pdev, dev);
 415
 416         if (dev->mem_start)
 417                 option = dev->mem_start;
 418
 419         /* The lower four bits are the media type. */
 420         if (option > 0) {
 421                 if (option & 0x200)
 422                         np->mii_if.full_duplex = 1;
 423                 if (option & 15)
 424                         dev_info(&dev->dev,
 425                                  "ignoring user supplied media type %d",
 426                                  option & 15);
 427         }
 428         if (find_cnt < MAX_UNITS  &&  full_duplex[find_cnt] > 0)
 429                 np->mii_if.full_duplex = 1;
 430
 431         if (np->mii_if.full_duplex)
 432                 np->mii_if.force_media = 1;
 433
 434         /* The chip-specific entries in the device structure. */
 435         dev->netdev_ops = &netdev_ops;
 436         dev->ethtool_ops = &netdev_ethtool_ops;
 437         dev->watchdog_timeo = TX_TIMEOUT;
 438
 439         i = register_netdev(dev);
 440         if (i)
 441                 goto err_out_cleardev;
 442
 443         dev_info(&dev->dev, "%s at %p, %pM, IRQ %d\n",
 444                  pci_id_tbl[chip_idx].name, ioaddr, dev->dev_addr, irq);
 445
 446         if (np->drv_flags & CanHaveMII) {
 447                 int phy, phy_idx = 0;
 448                 for (phy = 1; phy < 32 && phy_idx < MII_CNT; phy++) {
 449                         int mii_status = mdio_read(dev, phy, MII_BMSR);
 450                         if (mii_status != 0xffff  &&  mii_status != 0x0000) {
 451                                 np->phys[phy_idx++] = phy;
 452                                 np->mii_if.advertising = mdio_read(dev, phy, MII_ADVERTISE);
 453                                 np->mii = (mdio_read(dev, phy, MII_PHYSID1) << 16)+
 454                                                 mdio_read(dev, phy, MII_PHYSID2);
 455                                 dev_info(&dev->dev,
 456                                          "MII PHY %08xh found at address %d, status 0x%04x advertising %04x\n",
 457                                          np->mii, phy, mii_status,
 458                                          np->mii_if.advertising);
 459                         }
 460                 }
 461                 np->mii_cnt = phy_idx;
 462                 np->mii_if.phy_id = np->phys[0];
 463                 if (phy_idx == 0) {
 464                         dev_warn(&dev->dev,
 465                                  "MII PHY not found -- this device may not operate correctly\n");
 466                 }
 467         }
 468
 469         find_cnt++;
 470         return 0;
 471
 472 err_out_cleardev:
 473         pci_set_drvdata(pdev, NULL);
 474         pci_iounmap(pdev, ioaddr);
 475 err_out_free_res:
 476         pci_release_regions(pdev);
 477 err_out_netdev:
 478         free_netdev (dev);
 479         return -ENODEV;
 480 }
 481
 482
 483 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces.  These are
 484    often serial bit streams generated by the host processor.
 485    The example below is for the common 93c46 EEPROM, 64 16 bit words. */
 486
 487 /* Delay between EEPROM clock transitions.
 488    No extra delay is needed with 33Mhz PCI, but future 66Mhz access may need
 489    a delay.  Note that pre-2.0.34 kernels had a cache-alignment bug that
 490    made udelay() unreliable.
 491    The old method of using an ISA access as a delay, __SLOW_DOWN_IO__, is
 492    deprecated.
 493 */
 494 #define eeprom_delay(ee_addr)   ioread32(ee_addr)
 495
 496 enum EEPROM_Ctrl_Bits {
 497         EE_ShiftClk=0x02, EE_Write0=0x801, EE_Write1=0x805,
 498         EE_ChipSelect=0x801, EE_DataIn=0x08,
 499 };
 500
 501 /* The EEPROM commands include the alway-set leading bit. */
 502 enum EEPROM_Cmds {
 503         EE_WriteCmd=(5 << 6), EE_ReadCmd=(6 << 6), EE_EraseCmd=(7 << 6),
 504 };
 505
 506 static int eeprom_read(void __iomem *addr, int location)
 507 {
 508         int i;
 509         int retval = 0;
 510         void __iomem *ee_addr = addr + EECtrl;
 511         int read_cmd = location | EE_ReadCmd;
 512         iowrite32(EE_ChipSelect, ee_addr);
 513
 514         /* Shift the read command bits out. */
 515         for (i = 10; i >= 0; i--) {
 516                 short dataval = (read_cmd & (1 << i)) ? EE_Write1 : EE_Write0;
 517                 iowrite32(dataval, ee_addr);
 518                 eeprom_delay(ee_addr);
 519                 iowrite32(dataval | EE_ShiftClk, ee_addr);
 520                 eeprom_delay(ee_addr);
 521         }
 522         iowrite32(EE_ChipSelect, ee_addr);
 523         eeprom_delay(ee_addr);
 524
 525         for (i = 16; i > 0; i--) {
 526                 iowrite32(EE_ChipSelect | EE_ShiftClk, ee_addr);
 527                 eeprom_delay(ee_addr);
 528                 retval = (retval << 1) | ((ioread32(ee_addr) & EE_DataIn) ? 1 : 0);
 529                 iowrite32(EE_ChipSelect, ee_addr);
 530                 eeprom_delay(ee_addr);
 531         }
 532
 533         /* Terminate the EEPROM access. */
 534         iowrite32(0, ee_addr);
 535         return retval;
 536 }
 537
 538 /*  MII transceiver control section.
 539         Read and write the MII registers using software-generated serial
 540         MDIO protocol.  See the MII specifications or DP83840A data sheet
 541         for details.
 542
 543         The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
 544         met by back-to-back 33Mhz PCI cycles. */
 545 #define mdio_delay(mdio_addr) ioread32(mdio_addr)
 546
 547 /* Set iff a MII transceiver on any interface requires mdio preamble.
 548    This only set with older transceivers, so the extra
 549    code size of a per-interface flag is not worthwhile. */
 550 static char mii_preamble_required = 1;
 551
 552 #define MDIO_WRITE0 (MDIO_EnbOutput)
 553 #define MDIO_WRITE1 (MDIO_DataOut | MDIO_EnbOutput)
 554
 555 /* Generate the preamble required for initial synchronization and
 556    a few older transceivers. */
 557 static void mdio_sync(void __iomem *mdio_addr)
 558 {
 559         int bits = 32;
 560
 561         /* Establish sync by sending at least 32 logic ones. */
 562         while (--bits >= 0) {
 563                 iowrite32(MDIO_WRITE1, mdio_addr);
 564                 mdio_delay(mdio_addr);
 565                 iowrite32(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
 566                 mdio_delay(mdio_addr);
 567         }
 568 }
 569
 570 static int mdio_read(struct net_device *dev, int phy_id, int location)
 571 {
 572         struct netdev_private *np = netdev_priv(dev);
 573         void __iomem *mdio_addr = np->base_addr + MIICtrl;
 574         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
 575         int i, retval = 0;
 576
 577         if (mii_preamble_required)
 578                 mdio_sync(mdio_addr);
 579
 580         /* Shift the read command bits out. */
 581         for (i = 15; i >= 0; i--) {
 582                 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
 583
 584                 iowrite32(dataval, mdio_addr);
 585                 mdio_delay(mdio_addr);
 586                 iowrite32(dataval | MDIO_ShiftClk, mdio_addr);
 587                 mdio_delay(mdio_addr);
 588         }
 589         /* Read the two transition, 16 data, and wire-idle bits. */
 590         for (i = 20; i > 0; i--) {
 591                 iowrite32(MDIO_EnbIn, mdio_addr);
 592                 mdio_delay(mdio_addr);
 593                 retval = (retval << 1) | ((ioread32(mdio_addr) & MDIO_DataIn) ? 1 : 0);
 594                 iowrite32(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
 595                 mdio_delay(mdio_addr);
 596         }
 597         return (retval>>1) & 0xffff;
 598 }
 599
 600 static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
 601 {
 602         struct netdev_private *np = netdev_priv(dev);
 603         void __iomem *mdio_addr = np->base_addr + MIICtrl;
 604         int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
 605         int i;
 606
 607         if (location == 4  &&  phy_id == np->phys[0])
 608                 np->mii_if.advertising = value;
 609
 610         if (mii_preamble_required)
 611                 mdio_sync(mdio_addr);
 612
 613         /* Shift the command bits out. */
 614         for (i = 31; i >= 0; i--) {
 615                 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
 616
 617                 iowrite32(dataval, mdio_addr);
 618                 mdio_delay(mdio_addr);
 619                 iowrite32(dataval | MDIO_ShiftClk, mdio_addr);
 620                 mdio_delay(mdio_addr);
 621         }
 622         /* Clear out extra bits. */
 623         for (i = 2; i > 0; i--) {
 624                 iowrite32(MDIO_EnbIn, mdio_addr);
 625                 mdio_delay(mdio_addr);
 626                 iowrite32(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
 627                 mdio_delay(mdio_addr);
 628         }
 629 }
 630
 631
 632 static int netdev_open(struct net_device *dev)
 633 {
 634         struct netdev_private *np = netdev_priv(dev);
 635         void __iomem *ioaddr = np->base_addr;
 636         int i;
 637
 638         iowrite32(0x00000001, ioaddr + PCIBusCfg);              /* Reset */
 639
 640         netif_device_detach(dev);
 641         i = request_irq(dev->irq, intr_handler, IRQF_SHARED, dev->name, dev);
 642         if (i)
 643                 goto out_err;
 644
 645         if (debug > 1)
 646                 printk(KERN_DEBUG "%s: w89c840_open() irq %d\n",
 647                        dev->name, dev->irq);
 648
 649         if((i=alloc_ringdesc(dev)))
 650                 goto out_err;
 651
 652         spin_lock_irq(&np->lock);
 653         netif_device_attach(dev);
 654         init_registers(dev);
 655         spin_unlock_irq(&np->lock);
 656
 657         netif_start_queue(dev);
 658         if (debug > 2)
 659                 printk(KERN_DEBUG "%s: Done netdev_open()\n", dev->name);
 660
 661         /* Set the timer to check for link beat. */
 662         init_timer(&np->timer);
 663         np->timer.expires = jiffies + 1*HZ;
 664         np->timer.data = (unsigned long)dev;
 665         np->timer.function = &netdev_timer;                             /* timer handler */
 666         add_timer(&np->timer);
 667         return 0;
 668 out_err:
 669         netif_device_attach(dev);
 670         return i;
 671 }
 672
 673 #define MII_DAVICOM_DM9101      0x0181b800
 674
 675 static int update_link(struct net_device *dev)
 676 {
 677         struct netdev_private *np = netdev_priv(dev);
 678         int duplex, fasteth, result, mii_reg;
 679
 680         /* BSMR */
 681         mii_reg = mdio_read(dev, np->phys[0], MII_BMSR);
 682
 683         if (mii_reg == 0xffff)
 684                 return np->csr6;
 685         /* reread: the link status bit is sticky */
 686         mii_reg = mdio_read(dev, np->phys[0], MII_BMSR);
 687         if (!(mii_reg & 0x4)) {
 688                 if (netif_carrier_ok(dev)) {
 689                         if (debug)
 690                                 dev_info(&dev->dev,
 691                                          "MII #%d reports no link. Disabling watchdog\n",
 692                                          np->phys[0]);
 693                         netif_carrier_off(dev);
 694                 }
 695                 return np->csr6;
 696         }
 697         if (!netif_carrier_ok(dev)) {
 698                 if (debug)
 699                         dev_info(&dev->dev,
 700                                  "MII #%d link is back. Enabling watchdog\n",
 701                                  np->phys[0]);
 702                 netif_carrier_on(dev);
 703         }
 704
 705         if ((np->mii & ~0xf) == MII_DAVICOM_DM9101) {
 706                 /* If the link partner doesn't support autonegotiation
 707                  * the MII detects it's abilities with the "parallel detection".
 708                  * Some MIIs update the LPA register to the result of the parallel
 709                  * detection, some don't.
 710                  * The Davicom PHY [at least 0181b800] doesn't.
 711                  * Instead bit 9 and 13 of the BMCR are updated to the result
 712                  * of the negotiation..
 713                  */
 714                 mii_reg = mdio_read(dev, np->phys[0], MII_BMCR);
 715                 duplex = mii_reg & BMCR_FULLDPLX;
 716                 fasteth = mii_reg & BMCR_SPEED100;
 717         } else {
 718                 int negotiated;
 719                 mii_reg = mdio_read(dev, np->phys[0], MII_LPA);
 720                 negotiated = mii_reg & np->mii_if.advertising;
 721
 722                 duplex = (negotiated & LPA_100FULL) || ((negotiated & 0x02C0) == LPA_10FULL);
 723                 fasteth = negotiated & 0x380;
 724         }
 725         duplex |= np->mii_if.force_media;
 726         /* remove fastether and fullduplex */
 727         result = np->csr6 & ~0x20000200;
 728         if (duplex)
 729                 result |= 0x200;
 730         if (fasteth)
 731                 result |= 0x20000000;
 732         if (result != np->csr6 && debug)
 733                 dev_info(&dev->dev,
 734                          "Setting %dMBit-%s-duplex based on MII#%d\n",
 735                          fasteth ? 100 : 10, duplex ? "full" : "half",
 736                          np->phys[0]);
 737         return result;
 738 }
 739
 740 #define RXTX_TIMEOUT    2000
 741 static inline void update_csr6(struct net_device *dev, int new)
 742 {
 743         struct netdev_private *np = netdev_priv(dev);
 744         void __iomem *ioaddr = np->base_addr;
 745         int limit = RXTX_TIMEOUT;
 746
 747         if (!netif_device_present(dev))
 748                 new = 0;
 749         if (new==np->csr6)
 750                 return;
 751         /* stop both Tx and Rx processes */
 752         iowrite32(np->csr6 & ~0x2002, ioaddr + NetworkConfig);
 753         /* wait until they have really stopped */
 754         for (;;) {
 755                 int csr5 = ioread32(ioaddr + IntrStatus);
 756                 int t;
 757
 758                 t = (csr5 >> 17) & 0x07;
 759                 if (t==0||t==1) {
 760                         /* rx stopped */
 761                         t = (csr5 >> 20) & 0x07;
 762                         if (t==0||t==1)
 763                                 break;
 764                 }
 765
 766                 limit--;
 767                 if(!limit) {
 768                         dev_info(&dev->dev,
 769                                  "couldn't stop rxtx, IntrStatus %xh\n", csr5);
 770                         break;
 771                 }
 772                 udelay(1);
 773         }
 774         np->csr6 = new;
 775         /* and restart them with the new configuration */
 776         iowrite32(np->csr6, ioaddr + NetworkConfig);
 777         if (new & 0x200)
 778                 np->mii_if.full_duplex = 1;
 779 }
 780
 781 static void netdev_timer(unsigned long data)
 782 {
 783         struct net_device *dev = (struct net_device *)data;
 784         struct netdev_private *np = netdev_priv(dev);
 785         void __iomem *ioaddr = np->base_addr;
 786
 787         if (debug > 2)
 788                 printk(KERN_DEBUG "%s: Media selection timer tick, status %08x config %08x\n",
 789                        dev->name, ioread32(ioaddr + IntrStatus),
 790                        ioread32(ioaddr + NetworkConfig));
 791         spin_lock_irq(&np->lock);
 792         update_csr6(dev, update_link(dev));
 793         spin_unlock_irq(&np->lock);
 794         np->timer.expires = jiffies + 10*HZ;
 795         add_timer(&np->timer);
 796 }
 797
 798 static void init_rxtx_rings(struct net_device *dev)
 799 {
 800         struct netdev_private *np = netdev_priv(dev);
 801         int i;
 802
 803         np->rx_head_desc = &np->rx_ring[0];
 804         np->tx_ring = (struct w840_tx_desc*)&np->rx_ring[RX_RING_SIZE];
 805
 806         /* Initial all Rx descriptors. */
 807         for (i = 0; i < RX_RING_SIZE; i++) {
 808                 np->rx_ring[i].length = np->rx_buf_sz;
 809                 np->rx_ring[i].status = 0;
 810                 np->rx_skbuff[i] = NULL;
 811         }
 812         /* Mark the last entry as wrapping the ring. */
 813         np->rx_ring[i-1].length |= DescEndRing;
 814
 815         /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
 816         for (i = 0; i < RX_RING_SIZE; i++) {
 817                 struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz);
 818                 np->rx_skbuff[i] = skb;
 819                 if (skb == NULL)
 820                         break;
 821                 np->rx_addr[i] = pci_map_single(np->pci_dev,skb->data,
 822                                         np->rx_buf_sz,PCI_DMA_FROMDEVICE);
 823
 824                 np->rx_ring[i].buffer1 = np->rx_addr[i];
 825                 np->rx_ring[i].status = DescOwned;
 826         }
 827
 828         np->cur_rx = 0;
 829         np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
 830
 831         /* Initialize the Tx descriptors */
 832         for (i = 0; i < TX_RING_SIZE; i++) {
 833                 np->tx_skbuff[i] = NULL;
 834                 np->tx_ring[i].status = 0;
 835         }
 836         np->tx_full = 0;
 837         np->tx_q_bytes = np->dirty_tx = np->cur_tx = 0;
 838
 839         iowrite32(np->ring_dma_addr, np->base_addr + RxRingPtr);
 840         iowrite32(np->ring_dma_addr+sizeof(struct w840_rx_desc)*RX_RING_SIZE,
 841                 np->base_addr + TxRingPtr);
 842
 843 }
 844
 845 static void free_rxtx_rings(struct netdev_private* np)
 846 {
 847         int i;
 848         /* Free all the skbuffs in the Rx queue. */
 849         for (i = 0; i < RX_RING_SIZE; i++) {
 850                 np->rx_ring[i].status = 0;
 851                 if (np->rx_skbuff[i]) {
 852                         pci_unmap_single(np->pci_dev,
 853                                                 np->rx_addr[i],
 854                                                 np->rx_skbuff[i]->len,
 855                                                 PCI_DMA_FROMDEVICE);
 856                         dev_kfree_skb(np->rx_skbuff[i]);
 857                 }
 858                 np->rx_skbuff[i] = NULL;
 859         }
 860         for (i = 0; i < TX_RING_SIZE; i++) {
 861                 if (np->tx_skbuff[i]) {
 862                         pci_unmap_single(np->pci_dev,
 863                                                 np->tx_addr[i],
 864                                                 np->tx_skbuff[i]->len,
 865                                                 PCI_DMA_TODEVICE);
 866                         dev_kfree_skb(np->tx_skbuff[i]);
 867                 }
 868                 np->tx_skbuff[i] = NULL;
 869         }
 870 }
 871
 872 static void init_registers(struct net_device *dev)
 873 {
 874         struct netdev_private *np = netdev_priv(dev);
 875         void __iomem *ioaddr = np->base_addr;
 876         int i;
 877
 878         for (i = 0; i < 6; i++)
 879                 iowrite8(dev->dev_addr[i], ioaddr + StationAddr + i);
 880
 881         /* Initialize other registers. */
 882 #ifdef __BIG_ENDIAN
 883         i = (1<<20);    /* Big-endian descriptors */
 884 #else
 885         i = 0;
 886 #endif
 887         i |= (0x04<<2);         /* skip length 4 u32 */
 888         i |= 0x02;              /* give Rx priority */
 889
 890         /* Configure the PCI bus bursts and FIFO thresholds.
 891            486: Set 8 longword cache alignment, 8 longword burst.
 892            586: Set 16 longword cache alignment, no burst limit.
 893            Cache alignment bits 15:14        Burst length 13:8
 894                 0000    <not allowed>           0000 align to cache     0800 8 longwords
 895                 4000    8  longwords            0100 1 longword         1000 16 longwords
 896                 8000    16 longwords            0200 2 longwords        2000 32 longwords
 897                 C000    32  longwords           0400 4 longwords */
 898
 899 #if defined (__i386__) && !defined(MODULE)
 900         /* When not a module we can work around broken '486 PCI boards. */
 901         if (boot_cpu_data.x86 <= 4) {
 902                 i |= 0x4800;
 903                 dev_info(&dev->dev,
 904                          "This is a 386/486 PCI system, setting cache alignment to 8 longwords\n");
 905         } else {
 906                 i |= 0xE000;
 907         }
 908 #elif defined(__powerpc__) || defined(__i386__) || defined(__alpha__) || defined(__ia64__) || defined(__x86_64__)
 909         i |= 0xE000;
 910 #elif defined(CONFIG_SPARC) || defined (CONFIG_PARISC)
 911         i |= 0x4800;
 912 #else
 913 #warning Processor architecture undefined
 914         i |= 0x4800;
 915 #endif
 916         iowrite32(i, ioaddr + PCIBusCfg);
 917
 918         np->csr6 = 0;
 919         /* 128 byte Tx threshold;
 920                 Transmit on; Receive on; */
 921         update_csr6(dev, 0x00022002 | update_link(dev) | __set_rx_mode(dev));
 922
 923         /* Clear and Enable interrupts by setting the interrupt mask. */
 924         iowrite32(0x1A0F5, ioaddr + IntrStatus);
 925         iowrite32(0x1A0F5, ioaddr + IntrEnable);
 926
 927         iowrite32(0, ioaddr + RxStartDemand);
 928 }
 929
 930 static void tx_timeout(struct net_device *dev)
 931 {
 932         struct netdev_private *np = netdev_priv(dev);
 933         void __iomem *ioaddr = np->base_addr;
 934
 935         dev_warn(&dev->dev, "Transmit timed out, status %08x, resetting...\n",
 936                  ioread32(ioaddr + IntrStatus));
 937
 938         {
 939                 int i;
 940                 printk(KERN_DEBUG "  Rx ring %p: ", np->rx_ring);
 941                 for (i = 0; i < RX_RING_SIZE; i++)
 942                         printk(KERN_CONT " %08x", (unsigned int)np->rx_ring[i].status);
 943                 printk(KERN_CONT "\n");
 944                 printk(KERN_DEBUG "  Tx ring %p: ", np->tx_ring);
 945                 for (i = 0; i < TX_RING_SIZE; i++)
 946                         printk(KERN_CONT " %08x", np->tx_ring[i].status);
 947                 printk(KERN_CONT "\n");
 948         }
 949         printk(KERN_DEBUG "Tx cur %d Tx dirty %d Tx Full %d, q bytes %d\n",
 950                np->cur_tx, np->dirty_tx, np->tx_full, np->tx_q_bytes);
 951         printk(KERN_DEBUG "Tx Descriptor addr %xh\n", ioread32(ioaddr+0x4C));
 952
 953         disable_irq(dev->irq);
 954         spin_lock_irq(&np->lock);
 955         /*
 956          * Under high load dirty_tx and the internal tx descriptor pointer
 957          * come out of sync, thus perform a software reset and reinitialize
 958          * everything.
 959          */
 960
 961         iowrite32(1, np->base_addr+PCIBusCfg);
 962         udelay(1);
 963
 964         free_rxtx_rings(np);
 965         init_rxtx_rings(dev);
 966         init_registers(dev);
 967         spin_unlock_irq(&np->lock);
 968         enable_irq(dev->irq);
 969
 970         netif_wake_queue(dev);
 971         dev->trans_start = jiffies; /* prevent tx timeout */
 972         np->stats.tx_errors++;
 973 }
 974
 975 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
 976 static int alloc_ringdesc(struct net_device *dev)
 977 {
 978         struct netdev_private *np = netdev_priv(dev);
 979
 980         np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
 981
 982         np->rx_ring = pci_alloc_consistent(np->pci_dev,
 983                         sizeof(struct w840_rx_desc)*RX_RING_SIZE +
 984                         sizeof(struct w840_tx_desc)*TX_RING_SIZE,
 985                         &np->ring_dma_addr);
 986         if(!np->rx_ring)
 987                 return -ENOMEM;
 988         init_rxtx_rings(dev);
 989         return 0;
 990 }
 991
 992 static void free_ringdesc(struct netdev_private *np)
 993 {
 994         pci_free_consistent(np->pci_dev,
 995                         sizeof(struct w840_rx_desc)*RX_RING_SIZE +
 996                         sizeof(struct w840_tx_desc)*TX_RING_SIZE,
 997                         np->rx_ring, np->ring_dma_addr);
 998
 999 }
1000
1001 static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev)
1002 {
1003         struct netdev_private *np = netdev_priv(dev);
1004         unsigned entry;
1005
1006         /* Caution: the write order is important here, set the field
1007            with the "ownership" bits last. */
1008
1009         /* Calculate the next Tx descriptor entry. */
1010         entry = np->cur_tx % TX_RING_SIZE;
1011
1012         np->tx_addr[entry] = pci_map_single(np->pci_dev,
1013                                 skb->data,skb->len, PCI_DMA_TODEVICE);
1014         np->tx_skbuff[entry] = skb;
1015
1016         np->tx_ring[entry].buffer1 = np->tx_addr[entry];
1017         if (skb->len < TX_BUFLIMIT) {
1018                 np->tx_ring[entry].length = DescWholePkt | skb->len;
1019         } else {
1020                 int len = skb->len - TX_BUFLIMIT;
1021
1022                 np->tx_ring[entry].buffer2 = np->tx_addr[entry]+TX_BUFLIMIT;
1023                 np->tx_ring[entry].length = DescWholePkt | (len << 11) | TX_BUFLIMIT;
1024         }
1025         if(entry == TX_RING_SIZE-1)
1026                 np->tx_ring[entry].length |= DescEndRing;
1027
1028         /* Now acquire the irq spinlock.
1029          * The difficult race is the ordering between
1030          * increasing np->cur_tx and setting DescOwned:
1031          * - if np->cur_tx is increased first the interrupt
1032          *   handler could consider the packet as transmitted
1033          *   since DescOwned is cleared.
1034          * - If DescOwned is set first the NIC could report the
1035          *   packet as sent, but the interrupt handler would ignore it
1036          *   since the np->cur_tx was not yet increased.
1037          */
1038         spin_lock_irq(&np->lock);
1039         np->cur_tx++;
1040
1041         wmb(); /* flush length, buffer1, buffer2 */
1042         np->tx_ring[entry].status = DescOwned;
1043         wmb(); /* flush status and kick the hardware */
1044         iowrite32(0, np->base_addr + TxStartDemand);
1045         np->tx_q_bytes += skb->len;
1046         /* Work around horrible bug in the chip by marking the queue as full
1047            when we do not have FIFO room for a maximum sized packet. */
1048         if (np->cur_tx - np->dirty_tx > TX_QUEUE_LEN ||
1049                 ((np->drv_flags & HasBrokenTx) && np->tx_q_bytes > TX_BUG_FIFO_LIMIT)) {
1050                 netif_stop_queue(dev);
1051                 wmb();
1052                 np->tx_full = 1;
1053         }
1054         spin_unlock_irq(&np->lock);
1055
1056         if (debug > 4) {
1057                 printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d\n",
1058                        dev->name, np->cur_tx, entry);
1059         }
1060         return NETDEV_TX_OK;
1061 }
1062
1063 static void netdev_tx_done(struct net_device *dev)
1064 {
1065         struct netdev_private *np = netdev_priv(dev);
1066         for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1067                 int entry = np->dirty_tx % TX_RING_SIZE;
1068                 int tx_status = np->tx_ring[entry].status;
1069
1070                 if (tx_status < 0)
1071                         break;
1072                 if (tx_status & 0x8000) {       /* There was an error, log it. */
1073 #ifndef final_version
1074                         if (debug > 1)
1075                                 printk(KERN_DEBUG "%s: Transmit error, Tx status %08x\n",
1076                                        dev->name, tx_status);
1077 #endif
1078                         np->stats.tx_errors++;
1079                         if (tx_status & 0x0104) np->stats.tx_aborted_errors++;
1080                         if (tx_status & 0x0C80) np->stats.tx_carrier_errors++;
1081                         if (tx_status & 0x0200) np->stats.tx_window_errors++;
1082                         if (tx_status & 0x0002) np->stats.tx_fifo_errors++;
1083                         if ((tx_status & 0x0080) && np->mii_if.full_duplex == 0)
1084                                 np->stats.tx_heartbeat_errors++;
1085                 } else {
1086 #ifndef final_version
1087                         if (debug > 3)
1088                                 printk(KERN_DEBUG "%s: Transmit slot %d ok, Tx status %08x\n",
1089                                        dev->name, entry, tx_status);
1090 #endif
1091                         np->stats.tx_bytes += np->tx_skbuff[entry]->len;
1092                         np->stats.collisions += (tx_status >> 3) & 15;
1093                         np->stats.tx_packets++;
1094                 }
1095                 /* Free the original skb. */
1096                 pci_unmap_single(np->pci_dev,np->tx_addr[entry],
1097                                         np->tx_skbuff[entry]->len,
1098                                         PCI_DMA_TODEVICE);
1099                 np->tx_q_bytes -= np->tx_skbuff[entry]->len;
1100                 dev_kfree_skb_irq(np->tx_skbuff[entry]);
1101                 np->tx_skbuff[entry] = NULL;
1102         }
1103         if (np->tx_full &&
1104                 np->cur_tx - np->dirty_tx < TX_QUEUE_LEN_RESTART &&
1105                 np->tx_q_bytes < TX_BUG_FIFO_LIMIT) {
1106                 /* The ring is no longer full, clear tbusy. */
1107                 np->tx_full = 0;
1108                 wmb();
1109                 netif_wake_queue(dev);
1110         }
1111 }
1112
1113 /* The interrupt handler does all of the Rx thread work and cleans up
1114    after the Tx thread. */
1115 static irqreturn_t intr_handler(int irq, void *dev_instance)
1116 {
1117         struct net_device *dev = (struct net_device *)dev_instance;
1118         struct netdev_private *np = netdev_priv(dev);
1119         void __iomem *ioaddr = np->base_addr;
1120         int work_limit = max_interrupt_work;
1121         int handled = 0;
1122
1123         if (!netif_device_present(dev))
1124                 return IRQ_NONE;
1125         do {
1126                 u32 intr_status = ioread32(ioaddr + IntrStatus);
1127
1128                 /* Acknowledge all of the current interrupt sources ASAP. */
1129                 iowrite32(intr_status & 0x001ffff, ioaddr + IntrStatus);
1130
1131                 if (debug > 4)
1132                         printk(KERN_DEBUG "%s: Interrupt, status %04x\n",
1133                                dev->name, intr_status);
1134
1135                 if ((intr_status & (NormalIntr|AbnormalIntr)) == 0)
1136                         break;
1137
1138                 handled = 1;
1139
1140                 if (intr_status & (RxIntr | RxNoBuf))
1141                         netdev_rx(dev);
1142                 if (intr_status & RxNoBuf)
1143                         iowrite32(0, ioaddr + RxStartDemand);
1144
1145                 if (intr_status & (TxNoBuf | TxIntr) &&
1146                         np->cur_tx != np->dirty_tx) {
1147                         spin_lock(&np->lock);
1148                         netdev_tx_done(dev);
1149                         spin_unlock(&np->lock);
1150                 }
1151
1152                 /* Abnormal error summary/uncommon events handlers. */
1153                 if (intr_status & (AbnormalIntr | TxFIFOUnderflow | SystemError |
1154                                                    TimerInt | TxDied))
1155                         netdev_error(dev, intr_status);
1156
1157                 if (--work_limit < 0) {
1158                         dev_warn(&dev->dev,
1159                                  "Too much work at interrupt, status=0x%04x\n",
1160                                  intr_status);
1161                         /* Set the timer to re-enable the other interrupts after
1162                            10*82usec ticks. */
1163                         spin_lock(&np->lock);
1164                         if (netif_device_present(dev)) {
1165                                 iowrite32(AbnormalIntr | TimerInt, ioaddr + IntrEnable);
1166                                 iowrite32(10, ioaddr + GPTimer);
1167                         }
1168                         spin_unlock(&np->lock);
1169                         break;
1170                 }
1171         } while (1);
1172
1173         if (debug > 3)
1174                 printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x\n",
1175                        dev->name, ioread32(ioaddr + IntrStatus));
1176         return IRQ_RETVAL(handled);
1177 }
1178
1179 /* This routine is logically part of the interrupt handler, but separated
1180    for clarity and better register allocation. */
1181 static int netdev_rx(struct net_device *dev)
1182 {
1183         struct netdev_private *np = netdev_priv(dev);
1184         int entry = np->cur_rx % RX_RING_SIZE;
1185         int work_limit = np->dirty_rx + RX_RING_SIZE - np->cur_rx;
1186
1187         if (debug > 4) {
1188                 printk(KERN_DEBUG " In netdev_rx(), entry %d status %04x\n",
1189                        entry, np->rx_ring[entry].status);
1190         }
1191
1192         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1193         while (--work_limit >= 0) {
1194                 struct w840_rx_desc *desc = np->rx_head_desc;
1195                 s32 status = desc->status;
1196
1197                 if (debug > 4)
1198                         printk(KERN_DEBUG "  netdev_rx() status was %08x\n",
1199                                status);
1200                 if (status < 0)
1201                         break;
1202                 if ((status & 0x38008300) != 0x0300) {
1203                         if ((status & 0x38000300) != 0x0300) {
1204                                 /* Ingore earlier buffers. */
1205                                 if ((status & 0xffff) != 0x7fff) {
1206                                         dev_warn(&dev->dev,
1207                                                  "Oversized Ethernet frame spanned multiple buffers, entry %#x status %04x!\n",
1208                                                  np->cur_rx, status);
1209                                         np->stats.rx_length_errors++;
1210                                 }
1211                         } else if (status & 0x8000) {
1212                                 /* There was a fatal error. */
1213                                 if (debug > 2)
1214                                         printk(KERN_DEBUG "%s: Receive error, Rx status %08x\n",
1215                                                dev->name, status);
1216                                 np->stats.rx_errors++; /* end of a packet.*/
1217                                 if (status & 0x0890) np->stats.rx_length_errors++;
1218                                 if (status & 0x004C) np->stats.rx_frame_errors++;
1219                                 if (status & 0x0002) np->stats.rx_crc_errors++;
1220                         }
1221                 } else {
1222                         struct sk_buff *skb;
1223                         /* Omit the four octet CRC from the length. */
1224                         int pkt_len = ((status >> 16) & 0x7ff) - 4;
1225
1226 #ifndef final_version
1227                         if (debug > 4)
1228                                 printk(KERN_DEBUG "  netdev_rx() normal Rx pkt length %d status %x\n",
1229                                        pkt_len, status);
1230 #endif
1231                         /* Check if the packet is long enough to accept without copying
1232                            to a minimally-sized skbuff. */
1233                         if (pkt_len < rx_copybreak &&
1234                             (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1235                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
1236                                 pci_dma_sync_single_for_cpu(np->pci_dev,np->rx_addr[entry],
1237                                                             np->rx_skbuff[entry]->len,
1238                                                             PCI_DMA_FROMDEVICE);
1239                                 skb_copy_to_linear_data(skb, np->rx_skbuff[entry]->data, pkt_len);
1240                                 skb_put(skb, pkt_len);
1241                                 pci_dma_sync_single_for_device(np->pci_dev,np->rx_addr[entry],
1242                                                                np->rx_skbuff[entry]->len,
1243                                                                PCI_DMA_FROMDEVICE);
1244                         } else {
1245                                 pci_unmap_single(np->pci_dev,np->rx_addr[entry],
1246                                                         np->rx_skbuff[entry]->len,
1247                                                         PCI_DMA_FROMDEVICE);
1248                                 skb_put(skb = np->rx_skbuff[entry], pkt_len);
1249                                 np->rx_skbuff[entry] = NULL;
1250                         }
1251 #ifndef final_version                           /* Remove after testing. */
1252                         /* You will want this info for the initial debug. */
1253                         if (debug > 5)
1254                                 printk(KERN_DEBUG "  Rx data %pM %pM %02x%02x %pI4\n",
1255                                        &skb->data[0], &skb->data[6],
1256                                        skb->data[12], skb->data[13],
1257                                        &skb->data[14]);
1258 #endif
1259                         skb->protocol = eth_type_trans(skb, dev);
1260                         netif_rx(skb);
1261                         np->stats.rx_packets++;
1262                         np->stats.rx_bytes += pkt_len;
1263                 }
1264                 entry = (++np->cur_rx) % RX_RING_SIZE;
1265                 np->rx_head_desc = &np->rx_ring[entry];
1266         }
1267
1268         /* Refill the Rx ring buffers. */
1269         for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) {
1270                 struct sk_buff *skb;
1271                 entry = np->dirty_rx % RX_RING_SIZE;
1272                 if (np->rx_skbuff[entry] == NULL) {
1273                         skb = dev_alloc_skb(np->rx_buf_sz);
1274                         np->rx_skbuff[entry] = skb;
1275                         if (skb == NULL)
1276                                 break;                  /* Better luck next round. */
1277                         np->rx_addr[entry] = pci_map_single(np->pci_dev,
1278                                                         skb->data,
1279                                                         np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1280                         np->rx_ring[entry].buffer1 = np->rx_addr[entry];
1281                 }
1282                 wmb();
1283                 np->rx_ring[entry].status = DescOwned;
1284         }
1285
1286         return 0;
1287 }
1288
1289 static void netdev_error(struct net_device *dev, int intr_status)
1290 {
1291         struct netdev_private *np = netdev_priv(dev);
1292         void __iomem *ioaddr = np->base_addr;
1293
1294         if (debug > 2)
1295                 printk(KERN_DEBUG "%s: Abnormal event, %08x\n",
1296                        dev->name, intr_status);
1297         if (intr_status == 0xffffffff)
1298                 return;
1299         spin_lock(&np->lock);
1300         if (intr_status & TxFIFOUnderflow) {
1301                 int new;
1302                 /* Bump up the Tx threshold */
1303 #if 0
1304                 /* This causes lots of dropped packets,
1305                  * and under high load even tx_timeouts
1306                  */
1307                 new = np->csr6 + 0x4000;
1308 #else
1309                 new = (np->csr6 >> 14)&0x7f;
1310                 if (new < 64)
1311                         new *= 2;
1312                  else
1313                         new = 127; /* load full packet before starting */
1314                 new = (np->csr6 & ~(0x7F << 14)) | (new<<14);
1315 #endif
1316                 printk(KERN_DEBUG "%s: Tx underflow, new csr6 %08x\n",
1317                        dev->name, new);
1318                 update_csr6(dev, new);
1319         }
1320         if (intr_status & RxDied) {             /* Missed a Rx frame. */
1321                 np->stats.rx_errors++;
1322         }
1323         if (intr_status & TimerInt) {
1324                 /* Re-enable other interrupts. */
1325                 if (netif_device_present(dev))
1326                         iowrite32(0x1A0F5, ioaddr + IntrEnable);
1327         }
1328         np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;
1329         iowrite32(0, ioaddr + RxStartDemand);
1330         spin_unlock(&np->lock);
1331 }
1332
1333 static struct net_device_stats *get_stats(struct net_device *dev)
1334 {
1335         struct netdev_private *np = netdev_priv(dev);
1336         void __iomem *ioaddr = np->base_addr;
1337
1338         /* The chip only need report frame silently dropped. */
1339         spin_lock_irq(&np->lock);
1340         if (netif_running(dev) && netif_device_present(dev))
1341                 np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;
1342         spin_unlock_irq(&np->lock);
1343
1344         return &np->stats;
1345 }
1346
1347
1348 static u32 __set_rx_mode(struct net_device *dev)
1349 {
1350         struct netdev_private *np = netdev_priv(dev);
1351         void __iomem *ioaddr = np->base_addr;
1352         u32 mc_filter[2];                       /* Multicast hash filter */
1353         u32 rx_mode;
1354
1355         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
1356                 memset(mc_filter, 0xff, sizeof(mc_filter));
1357                 rx_mode = RxAcceptBroadcast | AcceptMulticast | RxAcceptAllPhys
1358                         | AcceptMyPhys;
1359         } else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
1360                    (dev->flags & IFF_ALLMULTI)) {
1361                 /* Too many to match, or accept all multicasts. */
1362                 memset(mc_filter, 0xff, sizeof(mc_filter));
1363                 rx_mode = RxAcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1364         } else {
1365                 struct netdev_hw_addr *ha;
1366
1367                 memset(mc_filter, 0, sizeof(mc_filter));
1368                 netdev_for_each_mc_addr(ha, dev) {
1369                         int filbit;
1370
1371                         filbit = (ether_crc(ETH_ALEN, ha->addr) >> 26) ^ 0x3F;
1372                         filbit &= 0x3f;
1373                         mc_filter[filbit >> 5] |= 1 << (filbit & 31);
1374                 }
1375                 rx_mode = RxAcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1376         }
1377         iowrite32(mc_filter[0], ioaddr + MulticastFilter0);
1378         iowrite32(mc_filter[1], ioaddr + MulticastFilter1);
1379         return rx_mode;
1380 }
1381
1382 static void set_rx_mode(struct net_device *dev)
1383 {
1384         struct netdev_private *np = netdev_priv(dev);
1385         u32 rx_mode = __set_rx_mode(dev);
1386         spin_lock_irq(&np->lock);
1387         update_csr6(dev, (np->csr6 & ~0x00F8) | rx_mode);
1388         spin_unlock_irq(&np->lock);
1389 }
1390
1391 static void netdev_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info)
1392 {
1393         struct netdev_private *np = netdev_priv(dev);
1394
1395         strcpy (info->driver, DRV_NAME);
1396         strcpy (info->version, DRV_VERSION);
1397         strcpy (info->bus_info, pci_name(np->pci_dev));
1398 }
1399
1400 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1401 {
1402         struct netdev_private *np = netdev_priv(dev);
1403         int rc;
1404
1405         spin_lock_irq(&np->lock);
1406         rc = mii_ethtool_gset(&np->mii_if, cmd);
1407         spin_unlock_irq(&np->lock);
1408
1409         return rc;
1410 }
1411
1412 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1413 {
1414         struct netdev_private *np = netdev_priv(dev);
1415         int rc;
1416
1417         spin_lock_irq(&np->lock);
1418         rc = mii_ethtool_sset(&np->mii_if, cmd);
1419         spin_unlock_irq(&np->lock);
1420
1421         return rc;
1422 }
1423
1424 static int netdev_nway_reset(struct net_device *dev)
1425 {
1426         struct netdev_private *np = netdev_priv(dev);
1427         return mii_nway_restart(&np->mii_if);
1428 }
1429
1430 static u32 netdev_get_link(struct net_device *dev)
1431 {
1432         struct netdev_private *np = netdev_priv(dev);
1433         return mii_link_ok(&np->mii_if);
1434 }
1435
1436 static u32 netdev_get_msglevel(struct net_device *dev)
1437 {
1438         return debug;
1439 }
1440
1441 static void netdev_set_msglevel(struct net_device *dev, u32 value)
1442 {
1443         debug = value;
1444 }
1445
1446 static const struct ethtool_ops netdev_ethtool_ops = {
1447         .get_drvinfo            = netdev_get_drvinfo,
1448         .get_settings           = netdev_get_settings,
1449         .set_settings           = netdev_set_settings,
1450         .nway_reset             = netdev_nway_reset,
1451         .get_link               = netdev_get_link,
1452         .get_msglevel           = netdev_get_msglevel,
1453         .set_msglevel           = netdev_set_msglevel,
1454 };
1455
1456 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1457 {
1458         struct mii_ioctl_data *data = if_mii(rq);
1459         struct netdev_private *np = netdev_priv(dev);
1460
1461         switch(cmd) {
1462         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
1463                 data->phy_id = ((struct netdev_private *)netdev_priv(dev))->phys[0] & 0x1f;
1464                 /* Fall Through */
1465
1466         case SIOCGMIIREG:               /* Read MII PHY register. */
1467                 spin_lock_irq(&np->lock);
1468                 data->val_out = mdio_read(dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
1469                 spin_unlock_irq(&np->lock);
1470                 return 0;
1471
1472         case SIOCSMIIREG:               /* Write MII PHY register. */
1473                 spin_lock_irq(&np->lock);
1474                 mdio_write(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1475                 spin_unlock_irq(&np->lock);
1476                 return 0;
1477         default:
1478                 return -EOPNOTSUPP;
1479         }
1480 }
1481
1482 static int netdev_close(struct net_device *dev)
1483 {
1484         struct netdev_private *np = netdev_priv(dev);
1485         void __iomem *ioaddr = np->base_addr;
1486
1487         netif_stop_queue(dev);
1488
1489         if (debug > 1) {
1490                 printk(KERN_DEBUG "%s: Shutting down ethercard, status was %08x Config %08x\n",
1491                        dev->name, ioread32(ioaddr + IntrStatus),
1492                        ioread32(ioaddr + NetworkConfig));
1493                 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d,  Rx %d / %d\n",
1494                        dev->name,
1495                        np->cur_tx, np->dirty_tx,
1496                        np->cur_rx, np->dirty_rx);
1497         }
1498
1499         /* Stop the chip's Tx and Rx processes. */
1500         spin_lock_irq(&np->lock);
1501         netif_device_detach(dev);
1502         update_csr6(dev, 0);
1503         iowrite32(0x0000, ioaddr + IntrEnable);
1504         spin_unlock_irq(&np->lock);
1505
1506         free_irq(dev->irq, dev);
1507         wmb();
1508         netif_device_attach(dev);
1509
1510         if (ioread32(ioaddr + NetworkConfig) != 0xffffffff)
1511                 np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;
1512
1513 #ifdef __i386__
1514         if (debug > 2) {
1515                 int i;
1516
1517                 printk(KERN_DEBUG"  Tx ring at %p:\n", np->tx_ring);
1518                 for (i = 0; i < TX_RING_SIZE; i++)
1519                         printk(KERN_DEBUG " #%d desc. %04x %04x %08x\n",
1520                                i, np->tx_ring[i].length,
1521                                np->tx_ring[i].status, np->tx_ring[i].buffer1);
1522                 printk(KERN_DEBUG "  Rx ring %p:\n", np->rx_ring);
1523                 for (i = 0; i < RX_RING_SIZE; i++) {
1524                         printk(KERN_DEBUG " #%d desc. %04x %04x %08x\n",
1525                                i, np->rx_ring[i].length,
1526                                np->rx_ring[i].status, np->rx_ring[i].buffer1);
1527                 }
1528         }
1529 #endif /* __i386__ debugging only */
1530
1531         del_timer_sync(&np->timer);
1532
1533         free_rxtx_rings(np);
1534         free_ringdesc(np);
1535
1536         return 0;
1537 }
1538
1539 static void __devexit w840_remove1 (struct pci_dev *pdev)
1540 {
1541         struct net_device *dev = pci_get_drvdata(pdev);
1542
1543         if (dev) {
1544                 struct netdev_private *np = netdev_priv(dev);
1545                 unregister_netdev(dev);
1546                 pci_release_regions(pdev);
1547                 pci_iounmap(pdev, np->base_addr);
1548                 free_netdev(dev);
1549         }
1550
1551         pci_set_drvdata(pdev, NULL);
1552 }
1553
1554 #ifdef CONFIG_PM
1555
1556 /*
1557  * suspend/resume synchronization:
1558  * - open, close, do_ioctl:
1559  *      rtnl_lock, & netif_device_detach after the rtnl_unlock.
1560  * - get_stats:
1561  *      spin_lock_irq(np->lock), doesn't touch hw if not present
1562  * - start_xmit:
1563  *      synchronize_irq + netif_tx_disable;
1564  * - tx_timeout:
1565  *      netif_device_detach + netif_tx_disable;
1566  * - set_multicast_list
1567  *      netif_device_detach + netif_tx_disable;
1568  * - interrupt handler
1569  *      doesn't touch hw if not present, synchronize_irq waits for
1570  *      running instances of the interrupt handler.
1571  *
1572  * Disabling hw requires clearing csr6 & IntrEnable.
1573  * update_csr6 & all function that write IntrEnable check netif_device_present
1574  * before settings any bits.
1575  *
1576  * Detach must occur under spin_unlock_irq(), interrupts from a detached
1577  * device would cause an irq storm.
1578  */
1579 static int w840_suspend (struct pci_dev *pdev, pm_message_t state)
1580 {
1581         struct net_device *dev = pci_get_drvdata (pdev);
1582         struct netdev_private *np = netdev_priv(dev);
1583         void __iomem *ioaddr = np->base_addr;
1584
1585         rtnl_lock();
1586         if (netif_running (dev)) {
1587                 del_timer_sync(&np->timer);
1588
1589                 spin_lock_irq(&np->lock);
1590                 netif_device_detach(dev);
1591                 update_csr6(dev, 0);
1592                 iowrite32(0, ioaddr + IntrEnable);
1593                 spin_unlock_irq(&np->lock);
1594
1595                 synchronize_irq(dev->irq);
1596                 netif_tx_disable(dev);
1597
1598                 np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;
1599
1600                 /* no more hardware accesses behind this line. */
1601
1602                 BUG_ON(np->csr6 || ioread32(ioaddr + IntrEnable));
1603
1604                 /* pci_power_off(pdev, -1); */
1605
1606                 free_rxtx_rings(np);
1607         } else {
1608                 netif_device_detach(dev);
1609         }
1610         rtnl_unlock();
1611         return 0;
1612 }
1613
1614 static int w840_resume (struct pci_dev *pdev)
1615 {
1616         struct net_device *dev = pci_get_drvdata (pdev);
1617         struct netdev_private *np = netdev_priv(dev);
1618         int retval = 0;
1619
1620         rtnl_lock();
1621         if (netif_device_present(dev))
1622                 goto out; /* device not suspended */
1623         if (netif_running(dev)) {
1624                 if ((retval = pci_enable_device(pdev))) {
1625                         dev_err(&dev->dev,
1626                                 "pci_enable_device failed in resume\n");
1627                         goto out;
1628                 }
1629                 spin_lock_irq(&np->lock);
1630                 iowrite32(1, np->base_addr+PCIBusCfg);
1631                 ioread32(np->base_addr+PCIBusCfg);
1632                 udelay(1);
1633                 netif_device_attach(dev);
1634                 init_rxtx_rings(dev);
1635                 init_registers(dev);
1636                 spin_unlock_irq(&np->lock);
1637
1638                 netif_wake_queue(dev);
1639
1640                 mod_timer(&np->timer, jiffies + 1*HZ);
1641         } else {
1642                 netif_device_attach(dev);
1643         }
1644 out:
1645         rtnl_unlock();
1646         return retval;
1647 }
1648 #endif
1649
1650 static struct pci_driver w840_driver = {
1651         .name           = DRV_NAME,
1652         .id_table       = w840_pci_tbl,
1653         .probe          = w840_probe1,
1654         .remove         = __devexit_p(w840_remove1),
1655 #ifdef CONFIG_PM
1656         .suspend        = w840_suspend,
1657         .resume         = w840_resume,
1658 #endif
1659 };
1660
1661 static int __init w840_init(void)
1662 {
1663         printk(version);
1664         return pci_register_driver(&w840_driver);
1665 }
1666
1667 static void __exit w840_exit(void)
1668 {
1669         pci_unregister_driver(&w840_driver);
1670 }
1671
1672 module_init(w840_init);
1673 module_exit(w840_exit);