drivers/net/sundance.c

   1 /* sundance.c: A Linux device driver for the Sundance ST201 "Alta". */
   2 /*
   3         Written 1999-2000 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/sundance.html
  19         [link no longer provides useful info -jgarzik]
  20         Archives of the mailing list are still available at
  21         http://www.beowulf.org/pipermail/netdrivers/
  22
  23 */
  24
  25 #define DRV_NAME        "sundance"
  26 #define DRV_VERSION     "1.2"
  27 #define DRV_RELDATE     "11-Sep-2006"
  28
  29
  30 /* The user-configurable values.
  31    These may be modified when a driver module is loaded.*/
  32 static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */
  33 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
  34    Typical is a 64 element hash table based on the Ethernet CRC.  */
  35 static const int multicast_filter_limit = 32;
  36
  37 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  38    Setting to > 1518 effectively disables this feature.
  39    This chip can receive into offset buffers, so the Alpha does not
  40    need a copy-align. */
  41 static int rx_copybreak;
  42 static int flowctrl=1;
  43
  44 /* media[] specifies the media type the NIC operates at.
  45                  autosense      Autosensing active media.
  46                  10mbps_hd      10Mbps half duplex.
  47                  10mbps_fd      10Mbps full duplex.
  48                  100mbps_hd     100Mbps half duplex.
  49                  100mbps_fd     100Mbps full duplex.
  50                  0              Autosensing active media.
  51                  1              10Mbps half duplex.
  52                  2              10Mbps full duplex.
  53                  3              100Mbps half duplex.
  54                  4              100Mbps full duplex.
  55 */
  56 #define MAX_UNITS 8
  57 static char *media[MAX_UNITS];
  58
  59
  60 /* Operational parameters that are set at compile time. */
  61
  62 /* Keep the ring sizes a power of two for compile efficiency.
  63    The compiler will convert <unsigned>'%'<2^N> into a bit mask.
  64    Making the Tx ring too large decreases the effectiveness of channel
  65    bonding and packet priority, and more than 128 requires modifying the
  66    Tx error recovery.
  67    Large receive rings merely waste memory. */
  68 #define TX_RING_SIZE    32
  69 #define TX_QUEUE_LEN    (TX_RING_SIZE - 1) /* Limit ring entries actually used.  */
  70 #define RX_RING_SIZE    64
  71 #define RX_BUDGET       32
  72 #define TX_TOTAL_SIZE   TX_RING_SIZE*sizeof(struct netdev_desc)
  73 #define RX_TOTAL_SIZE   RX_RING_SIZE*sizeof(struct netdev_desc)
  74
  75 /* Operational parameters that usually are not changed. */
  76 /* Time in jiffies before concluding the transmitter is hung. */
  77 #define TX_TIMEOUT  (4*HZ)
  78 #define PKT_BUF_SZ              1536    /* Size of each temporary Rx buffer.*/
  79
  80 /* Include files, designed to support most kernel versions 2.0.0 and later. */
  81 #include <linux/module.h>
  82 #include <linux/kernel.h>
  83 #include <linux/string.h>
  84 #include <linux/timer.h>
  85 #include <linux/errno.h>
  86 #include <linux/ioport.h>
  87 #include <linux/slab.h>
  88 #include <linux/interrupt.h>
  89 #include <linux/pci.h>
  90 #include <linux/netdevice.h>
  91 #include <linux/etherdevice.h>
  92 #include <linux/skbuff.h>
  93 #include <linux/init.h>
  94 #include <linux/bitops.h>
  95 #include <asm/uaccess.h>
  96 #include <asm/processor.h>              /* Processor type for cache alignment. */
  97 #include <asm/io.h>
  98 #include <linux/delay.h>
  99 #include <linux/spinlock.h>
 100 #ifndef _COMPAT_WITH_OLD_KERNEL
 101 #include <linux/crc32.h>
 102 #include <linux/ethtool.h>
 103 #include <linux/mii.h>
 104 #else
 105 #include "crc32.h"
 106 #include "ethtool.h"
 107 #include "mii.h"
 108 #include "compat.h"
 109 #endif
 110
 111 /* These identify the driver base version and may not be removed. */
 112 static char version[] =
 113 KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE "  Written by Donald Becker\n";
 114
 115 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 116 MODULE_DESCRIPTION("Sundance Alta Ethernet driver");
 117 MODULE_LICENSE("GPL");
 118
 119 module_param(debug, int, 0);
 120 module_param(rx_copybreak, int, 0);
 121 module_param_array(media, charp, NULL, 0);
 122 module_param(flowctrl, int, 0);
 123 MODULE_PARM_DESC(debug, "Sundance Alta debug level (0-5)");
 124 MODULE_PARM_DESC(rx_copybreak, "Sundance Alta copy breakpoint for copy-only-tiny-frames");
 125 MODULE_PARM_DESC(flowctrl, "Sundance Alta flow control [0|1]");
 126
 127 /*
 128                                 Theory of Operation
 129
 130 I. Board Compatibility
 131
 132 This driver is designed for the Sundance Technologies "Alta" ST201 chip.
 133
 134 II. Board-specific settings
 135
 136 III. Driver operation
 137
 138 IIIa. Ring buffers
 139
 140 This driver uses two statically allocated fixed-size descriptor lists
 141 formed into rings by a branch from the final descriptor to the beginning of
 142 the list.  The ring sizes are set at compile time by RX/TX_RING_SIZE.
 143 Some chips explicitly use only 2^N sized rings, while others use a
 144 'next descriptor' pointer that the driver forms into rings.
 145
 146 IIIb/c. Transmit/Receive Structure
 147
 148 This driver uses a zero-copy receive and transmit scheme.
 149 The driver allocates full frame size skbuffs for the Rx ring buffers at
 150 open() time and passes the skb->data field to the chip as receive data
 151 buffers.  When an incoming frame is less than RX_COPYBREAK bytes long,
 152 a fresh skbuff is allocated and the frame is copied to the new skbuff.
 153 When the incoming frame is larger, the skbuff is passed directly up the
 154 protocol stack.  Buffers consumed this way are replaced by newly allocated
 155 skbuffs in a later phase of receives.
 156
 157 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
 158 using a full-sized skbuff for small frames vs. the copying costs of larger
 159 frames.  New boards are typically used in generously configured machines
 160 and the underfilled buffers have negligible impact compared to the benefit of
 161 a single allocation size, so the default value of zero results in never
 162 copying packets.  When copying is done, the cost is usually mitigated by using
 163 a combined copy/checksum routine.  Copying also preloads the cache, which is
 164 most useful with small frames.
 165
 166 A subtle aspect of the operation is that the IP header at offset 14 in an
 167 ethernet frame isn't longword aligned for further processing.
 168 Unaligned buffers are permitted by the Sundance hardware, so
 169 frames are received into the skbuff at an offset of "+2", 16-byte aligning
 170 the IP header.
 171
 172 IIId. Synchronization
 173
 174 The driver runs as two independent, single-threaded flows of control.  One
 175 is the send-packet routine, which enforces single-threaded use by the
 176 dev->tbusy flag.  The other thread is the interrupt handler, which is single
 177 threaded by the hardware and interrupt handling software.
 178
 179 The send packet thread has partial control over the Tx ring and 'dev->tbusy'
 180 flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
 181 queue slot is empty, it clears the tbusy flag when finished otherwise it sets
 182 the 'lp->tx_full' flag.
 183
 184 The interrupt handler has exclusive control over the Rx ring and records stats
 185 from the Tx ring.  After reaping the stats, it marks the Tx queue entry as
 186 empty by incrementing the dirty_tx mark. Iff the 'lp->tx_full' flag is set, it
 187 clears both the tx_full and tbusy flags.
 188
 189 IV. Notes
 190
 191 IVb. References
 192
 193 The Sundance ST201 datasheet, preliminary version.
 194 The Kendin KS8723 datasheet, preliminary version.
 195 The ICplus IP100 datasheet, preliminary version.
 196 http://www.scyld.com/expert/100mbps.html
 197 http://www.scyld.com/expert/NWay.html
 198
 199 IVc. Errata
 200
 201 */
 202
 203 /* Work-around for Kendin chip bugs. */
 204 #ifndef CONFIG_SUNDANCE_MMIO
 205 #define USE_IO_OPS 1
 206 #endif
 207
 208 static const struct pci_device_id sundance_pci_tbl[] = {
 209         { 0x1186, 0x1002, 0x1186, 0x1002, 0, 0, 0 },
 210         { 0x1186, 0x1002, 0x1186, 0x1003, 0, 0, 1 },
 211         { 0x1186, 0x1002, 0x1186, 0x1012, 0, 0, 2 },
 212         { 0x1186, 0x1002, 0x1186, 0x1040, 0, 0, 3 },
 213         { 0x1186, 0x1002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
 214         { 0x13F0, 0x0201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
 215         { 0x13F0, 0x0200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
 216         { }
 217 };
 218 MODULE_DEVICE_TABLE(pci, sundance_pci_tbl);
 219
 220 enum {
 221         netdev_io_size = 128
 222 };
 223
 224 struct pci_id_info {
 225         const char *name;
 226 };
 227 static const struct pci_id_info pci_id_tbl[] __devinitdata = {
 228         {"D-Link DFE-550TX FAST Ethernet Adapter"},
 229         {"D-Link DFE-550FX 100Mbps Fiber-optics Adapter"},
 230         {"D-Link DFE-580TX 4 port Server Adapter"},
 231         {"D-Link DFE-530TXS FAST Ethernet Adapter"},
 232         {"D-Link DL10050-based FAST Ethernet Adapter"},
 233         {"Sundance Technology Alta"},
 234         {"IC Plus Corporation IP100A FAST Ethernet Adapter"},
 235         { }     /* terminate list. */
 236 };
 237
 238 /* This driver was written to use PCI memory space, however x86-oriented
 239    hardware often uses I/O space accesses. */
 240
 241 /* Offsets to the device registers.
 242    Unlike software-only systems, device drivers interact with complex hardware.
 243    It's not useful to define symbolic names for every register bit in the
 244    device.  The name can only partially document the semantics and make
 245    the driver longer and more difficult to read.
 246    In general, only the important configuration values or bits changed
 247    multiple times should be defined symbolically.
 248 */
 249 enum alta_offsets {
 250         DMACtrl = 0x00,
 251         TxListPtr = 0x04,
 252         TxDMABurstThresh = 0x08,
 253         TxDMAUrgentThresh = 0x09,
 254         TxDMAPollPeriod = 0x0a,
 255         RxDMAStatus = 0x0c,
 256         RxListPtr = 0x10,
 257         DebugCtrl0 = 0x1a,
 258         DebugCtrl1 = 0x1c,
 259         RxDMABurstThresh = 0x14,
 260         RxDMAUrgentThresh = 0x15,
 261         RxDMAPollPeriod = 0x16,
 262         LEDCtrl = 0x1a,
 263         ASICCtrl = 0x30,
 264         EEData = 0x34,
 265         EECtrl = 0x36,
 266         FlashAddr = 0x40,
 267         FlashData = 0x44,
 268         TxStatus = 0x46,
 269         TxFrameId = 0x47,
 270         DownCounter = 0x18,
 271         IntrClear = 0x4a,
 272         IntrEnable = 0x4c,
 273         IntrStatus = 0x4e,
 274         MACCtrl0 = 0x50,
 275         MACCtrl1 = 0x52,
 276         StationAddr = 0x54,
 277         MaxFrameSize = 0x5A,
 278         RxMode = 0x5c,
 279         MIICtrl = 0x5e,
 280         MulticastFilter0 = 0x60,
 281         MulticastFilter1 = 0x64,
 282         RxOctetsLow = 0x68,
 283         RxOctetsHigh = 0x6a,
 284         TxOctetsLow = 0x6c,
 285         TxOctetsHigh = 0x6e,
 286         TxFramesOK = 0x70,
 287         RxFramesOK = 0x72,
 288         StatsCarrierError = 0x74,
 289         StatsLateColl = 0x75,
 290         StatsMultiColl = 0x76,
 291         StatsOneColl = 0x77,
 292         StatsTxDefer = 0x78,
 293         RxMissed = 0x79,
 294         StatsTxXSDefer = 0x7a,
 295         StatsTxAbort = 0x7b,
 296         StatsBcastTx = 0x7c,
 297         StatsBcastRx = 0x7d,
 298         StatsMcastTx = 0x7e,
 299         StatsMcastRx = 0x7f,
 300         /* Aliased and bogus values! */
 301         RxStatus = 0x0c,
 302 };
 303 enum ASICCtrl_HiWord_bit {
 304         GlobalReset = 0x0001,
 305         RxReset = 0x0002,
 306         TxReset = 0x0004,
 307         DMAReset = 0x0008,
 308         FIFOReset = 0x0010,
 309         NetworkReset = 0x0020,
 310         HostReset = 0x0040,
 311         ResetBusy = 0x0400,
 312 };
 313
 314 /* Bits in the interrupt status/mask registers. */
 315 enum intr_status_bits {
 316         IntrSummary=0x0001, IntrPCIErr=0x0002, IntrMACCtrl=0x0008,
 317         IntrTxDone=0x0004, IntrRxDone=0x0010, IntrRxStart=0x0020,
 318         IntrDrvRqst=0x0040,
 319         StatsMax=0x0080, LinkChange=0x0100,
 320         IntrTxDMADone=0x0200, IntrRxDMADone=0x0400,
 321 };
 322
 323 /* Bits in the RxMode register. */
 324 enum rx_mode_bits {
 325         AcceptAllIPMulti=0x20, AcceptMultiHash=0x10, AcceptAll=0x08,
 326         AcceptBroadcast=0x04, AcceptMulticast=0x02, AcceptMyPhys=0x01,
 327 };
 328 /* Bits in MACCtrl. */
 329 enum mac_ctrl0_bits {
 330         EnbFullDuplex=0x20, EnbRcvLargeFrame=0x40,
 331         EnbFlowCtrl=0x100, EnbPassRxCRC=0x200,
 332 };
 333 enum mac_ctrl1_bits {
 334         StatsEnable=0x0020,     StatsDisable=0x0040, StatsEnabled=0x0080,
 335         TxEnable=0x0100, TxDisable=0x0200, TxEnabled=0x0400,
 336         RxEnable=0x0800, RxDisable=0x1000, RxEnabled=0x2000,
 337 };
 338
 339 /* The Rx and Tx buffer descriptors. */
 340 /* Note that using only 32 bit fields simplifies conversion to big-endian
 341    architectures. */
 342 struct netdev_desc {
 343         u32 next_desc;
 344         u32 status;
 345         struct desc_frag { u32 addr, length; } frag[1];
 346 };
 347
 348 /* Bits in netdev_desc.status */
 349 enum desc_status_bits {
 350         DescOwn=0x8000,
 351         DescEndPacket=0x4000,
 352         DescEndRing=0x2000,
 353         LastFrag=0x80000000,
 354         DescIntrOnTx=0x8000,
 355         DescIntrOnDMADone=0x80000000,
 356         DisableAlign = 0x00000001,
 357 };
 358
 359 #define PRIV_ALIGN      15      /* Required alignment mask */
 360 /* Use  __attribute__((aligned (L1_CACHE_BYTES)))  to maintain alignment
 361    within the structure. */
 362 #define MII_CNT         4
 363 struct netdev_private {
 364         /* Descriptor rings first for alignment. */
 365         struct netdev_desc *rx_ring;
 366         struct netdev_desc *tx_ring;
 367         struct sk_buff* rx_skbuff[RX_RING_SIZE];
 368         struct sk_buff* tx_skbuff[TX_RING_SIZE];
 369         dma_addr_t tx_ring_dma;
 370         dma_addr_t rx_ring_dma;
 371         struct net_device_stats stats;
 372         struct timer_list timer;                /* Media monitoring timer. */
 373         /* Frequently used values: keep some adjacent for cache effect. */
 374         spinlock_t lock;
 375         spinlock_t rx_lock;                     /* Group with Tx control cache line. */
 376         int msg_enable;
 377         int chip_id;
 378         unsigned int cur_rx, dirty_rx;          /* Producer/consumer ring indices */
 379         unsigned int rx_buf_sz;                 /* Based on MTU+slack. */
 380         struct netdev_desc *last_tx;            /* Last Tx descriptor used. */
 381         unsigned int cur_tx, dirty_tx;
 382         /* These values are keep track of the transceiver/media in use. */
 383         unsigned int flowctrl:1;
 384         unsigned int default_port:4;            /* Last dev->if_port value. */
 385         unsigned int an_enable:1;
 386         unsigned int speed;
 387         struct tasklet_struct rx_tasklet;
 388         struct tasklet_struct tx_tasklet;
 389         int budget;
 390         int cur_task;
 391         /* Multicast and receive mode. */
 392         spinlock_t mcastlock;                   /* SMP lock multicast updates. */
 393         u16 mcast_filter[4];
 394         /* MII transceiver section. */
 395         struct mii_if_info mii_if;
 396         int mii_preamble_required;
 397         unsigned char phys[MII_CNT];            /* MII device addresses, only first one used. */
 398         struct pci_dev *pci_dev;
 399         void __iomem *base;
 400 };
 401
 402 /* The station address location in the EEPROM. */
 403 #define EEPROM_SA_OFFSET        0x10
 404 #define DEFAULT_INTR (IntrRxDMADone | IntrPCIErr | \
 405                         IntrDrvRqst | IntrTxDone | StatsMax | \
 406                         LinkChange)
 407
 408 static int  change_mtu(struct net_device *dev, int new_mtu);
 409 static int  eeprom_read(void __iomem *ioaddr, int location);
 410 static int  mdio_read(struct net_device *dev, int phy_id, int location);
 411 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
 412 static int  netdev_open(struct net_device *dev);
 413 static void check_duplex(struct net_device *dev);
 414 static void netdev_timer(unsigned long data);
 415 static void tx_timeout(struct net_device *dev);
 416 static void init_ring(struct net_device *dev);
 417 static int  start_tx(struct sk_buff *skb, struct net_device *dev);
 418 static int reset_tx (struct net_device *dev);
 419 static irqreturn_t intr_handler(int irq, void *dev_instance);
 420 static void rx_poll(unsigned long data);
 421 static void tx_poll(unsigned long data);
 422 static void refill_rx (struct net_device *dev);
 423 static void netdev_error(struct net_device *dev, int intr_status);
 424 static void netdev_error(struct net_device *dev, int intr_status);
 425 static void set_rx_mode(struct net_device *dev);
 426 static int __set_mac_addr(struct net_device *dev);
 427 static struct net_device_stats *get_stats(struct net_device *dev);
 428 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 429 static int  netdev_close(struct net_device *dev);
 430 static const struct ethtool_ops ethtool_ops;
 431
 432 static void sundance_reset(struct net_device *dev, unsigned long reset_cmd)
 433 {
 434         struct netdev_private *np = netdev_priv(dev);
 435         void __iomem *ioaddr = np->base + ASICCtrl;
 436         int countdown;
 437
 438         /* ST201 documentation states ASICCtrl is a 32bit register */
 439         iowrite32 (reset_cmd | ioread32 (ioaddr), ioaddr);
 440         /* ST201 documentation states reset can take up to 1 ms */
 441         countdown = 10 + 1;
 442         while (ioread32 (ioaddr) & (ResetBusy << 16)) {
 443                 if (--countdown == 0) {
 444                         printk(KERN_WARNING "%s : reset not completed !!\n", dev->name);
 445                         break;
 446                 }
 447                 udelay(100);
 448         }
 449 }
 450
 451 static int __devinit sundance_probe1 (struct pci_dev *pdev,
 452                                       const struct pci_device_id *ent)
 453 {
 454         struct net_device *dev;
 455         struct netdev_private *np;
 456         static int card_idx;
 457         int chip_idx = ent->driver_data;
 458         int irq;
 459         int i;
 460         void __iomem *ioaddr;
 461         u16 mii_ctl;
 462         void *ring_space;
 463         dma_addr_t ring_dma;
 464 #ifdef USE_IO_OPS
 465         int bar = 0;
 466 #else
 467         int bar = 1;
 468 #endif
 469         int phy, phy_idx = 0;
 470
 471
 472 /* when built into the kernel, we only print version if device is found */
 473 #ifndef MODULE
 474         static int printed_version;
 475         if (!printed_version++)
 476                 printk(version);
 477 #endif
 478
 479         if (pci_enable_device(pdev))
 480                 return -EIO;
 481         pci_set_master(pdev);
 482
 483         irq = pdev->irq;
 484
 485         dev = alloc_etherdev(sizeof(*np));
 486         if (!dev)
 487                 return -ENOMEM;
 488         SET_NETDEV_DEV(dev, &pdev->dev);
 489
 490         if (pci_request_regions(pdev, DRV_NAME))
 491                 goto err_out_netdev;
 492
 493         ioaddr = pci_iomap(pdev, bar, netdev_io_size);
 494         if (!ioaddr)
 495                 goto err_out_res;
 496
 497         for (i = 0; i < 3; i++)
 498                 ((u16 *)dev->dev_addr)[i] =
 499                         le16_to_cpu(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET));
 500         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 501
 502         dev->base_addr = (unsigned long)ioaddr;
 503         dev->irq = irq;
 504
 505         np = netdev_priv(dev);
 506         np->base = ioaddr;
 507         np->pci_dev = pdev;
 508         np->chip_id = chip_idx;
 509         np->msg_enable = (1 << debug) - 1;
 510         spin_lock_init(&np->lock);
 511         tasklet_init(&np->rx_tasklet, rx_poll, (unsigned long)dev);
 512         tasklet_init(&np->tx_tasklet, tx_poll, (unsigned long)dev);
 513
 514         ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
 515         if (!ring_space)
 516                 goto err_out_cleardev;
 517         np->tx_ring = (struct netdev_desc *)ring_space;
 518         np->tx_ring_dma = ring_dma;
 519
 520         ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
 521         if (!ring_space)
 522                 goto err_out_unmap_tx;
 523         np->rx_ring = (struct netdev_desc *)ring_space;
 524         np->rx_ring_dma = ring_dma;
 525
 526         np->mii_if.dev = dev;
 527         np->mii_if.mdio_read = mdio_read;
 528         np->mii_if.mdio_write = mdio_write;
 529         np->mii_if.phy_id_mask = 0x1f;
 530         np->mii_if.reg_num_mask = 0x1f;
 531
 532         /* The chip-specific entries in the device structure. */
 533         dev->open = &netdev_open;
 534         dev->hard_start_xmit = &start_tx;
 535         dev->stop = &netdev_close;
 536         dev->get_stats = &get_stats;
 537         dev->set_multicast_list = &set_rx_mode;
 538         dev->do_ioctl = &netdev_ioctl;
 539         SET_ETHTOOL_OPS(dev, &ethtool_ops);
 540         dev->tx_timeout = &tx_timeout;
 541         dev->watchdog_timeo = TX_TIMEOUT;
 542         dev->change_mtu = &change_mtu;
 543         pci_set_drvdata(pdev, dev);
 544
 545         i = register_netdev(dev);
 546         if (i)
 547                 goto err_out_unmap_rx;
 548
 549         printk(KERN_INFO "%s: %s at %p, ",
 550                    dev->name, pci_id_tbl[chip_idx].name, ioaddr);
 551         for (i = 0; i < 5; i++)
 552                         printk("%2.2x:", dev->dev_addr[i]);
 553         printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], irq);
 554
 555         np->phys[0] = 1;                /* Default setting */
 556         np->mii_preamble_required++;
 557         /*
 558          * It seems some phys doesn't deal well with address 0 being accessed
 559          * first, so leave address zero to the end of the loop (32 & 31).
 560          */
 561         for (phy = 1; phy <= 32 && phy_idx < MII_CNT; phy++) {
 562                 int phyx = phy & 0x1f;
 563                 int mii_status = mdio_read(dev, phyx, MII_BMSR);
 564                 if (mii_status != 0xffff  &&  mii_status != 0x0000) {
 565                         np->phys[phy_idx++] = phyx;
 566                         np->mii_if.advertising = mdio_read(dev, phyx, MII_ADVERTISE);
 567                         if ((mii_status & 0x0040) == 0)
 568                                 np->mii_preamble_required++;
 569                         printk(KERN_INFO "%s: MII PHY found at address %d, status "
 570                                    "0x%4.4x advertising %4.4x.\n",
 571                                    dev->name, phyx, mii_status, np->mii_if.advertising);
 572                 }
 573         }
 574         np->mii_preamble_required--;
 575
 576         if (phy_idx == 0) {
 577                 printk(KERN_INFO "%s: No MII transceiver found, aborting.  ASIC status %x\n",
 578                            dev->name, ioread32(ioaddr + ASICCtrl));
 579                 goto err_out_unregister;
 580         }
 581
 582         np->mii_if.phy_id = np->phys[0];
 583
 584         /* Parse override configuration */
 585         np->an_enable = 1;
 586         if (card_idx < MAX_UNITS) {
 587                 if (media[card_idx] != NULL) {
 588                         np->an_enable = 0;
 589                         if (strcmp (media[card_idx], "100mbps_fd") == 0 ||
 590                             strcmp (media[card_idx], "4") == 0) {
 591                                 np->speed = 100;
 592                                 np->mii_if.full_duplex = 1;
 593                         } else if (strcmp (media[card_idx], "100mbps_hd") == 0
 594                                    || strcmp (media[card_idx], "3") == 0) {
 595                                 np->speed = 100;
 596                                 np->mii_if.full_duplex = 0;
 597                         } else if (strcmp (media[card_idx], "10mbps_fd") == 0 ||
 598                                    strcmp (media[card_idx], "2") == 0) {
 599                                 np->speed = 10;
 600                                 np->mii_if.full_duplex = 1;
 601                         } else if (strcmp (media[card_idx], "10mbps_hd") == 0 ||
 602                                    strcmp (media[card_idx], "1") == 0) {
 603                                 np->speed = 10;
 604                                 np->mii_if.full_duplex = 0;
 605                         } else {
 606                                 np->an_enable = 1;
 607                         }
 608                 }
 609                 if (flowctrl == 1)
 610                         np->flowctrl = 1;
 611         }
 612
 613         /* Fibre PHY? */
 614         if (ioread32 (ioaddr + ASICCtrl) & 0x80) {
 615                 /* Default 100Mbps Full */
 616                 if (np->an_enable) {
 617                         np->speed = 100;
 618                         np->mii_if.full_duplex = 1;
 619                         np->an_enable = 0;
 620                 }
 621         }
 622         /* Reset PHY */
 623         mdio_write (dev, np->phys[0], MII_BMCR, BMCR_RESET);
 624         mdelay (300);
 625         /* If flow control enabled, we need to advertise it.*/
 626         if (np->flowctrl)
 627                 mdio_write (dev, np->phys[0], MII_ADVERTISE, np->mii_if.advertising | 0x0400);
 628         mdio_write (dev, np->phys[0], MII_BMCR, BMCR_ANENABLE|BMCR_ANRESTART);
 629         /* Force media type */
 630         if (!np->an_enable) {
 631                 mii_ctl = 0;
 632                 mii_ctl |= (np->speed == 100) ? BMCR_SPEED100 : 0;
 633                 mii_ctl |= (np->mii_if.full_duplex) ? BMCR_FULLDPLX : 0;
 634                 mdio_write (dev, np->phys[0], MII_BMCR, mii_ctl);
 635                 printk (KERN_INFO "Override speed=%d, %s duplex\n",
 636                         np->speed, np->mii_if.full_duplex ? "Full" : "Half");
 637
 638         }
 639
 640         /* Perhaps move the reset here? */
 641         /* Reset the chip to erase previous misconfiguration. */
 642         if (netif_msg_hw(np))
 643                 printk("ASIC Control is %x.\n", ioread32(ioaddr + ASICCtrl));
 644         sundance_reset(dev, 0x00ff << 16);
 645         if (netif_msg_hw(np))
 646                 printk("ASIC Control is now %x.\n", ioread32(ioaddr + ASICCtrl));
 647
 648         card_idx++;
 649         return 0;
 650
 651 err_out_unregister:
 652         unregister_netdev(dev);
 653 err_out_unmap_rx:
 654         pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
 655 err_out_unmap_tx:
 656         pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma);
 657 err_out_cleardev:
 658         pci_set_drvdata(pdev, NULL);
 659         pci_iounmap(pdev, ioaddr);
 660 err_out_res:
 661         pci_release_regions(pdev);
 662 err_out_netdev:
 663         free_netdev (dev);
 664         return -ENODEV;
 665 }
 666
 667 static int change_mtu(struct net_device *dev, int new_mtu)
 668 {
 669         if ((new_mtu < 68) || (new_mtu > 8191)) /* Set by RxDMAFrameLen */
 670                 return -EINVAL;
 671         if (netif_running(dev))
 672                 return -EBUSY;
 673         dev->mtu = new_mtu;
 674         return 0;
 675 }
 676
 677 #define eeprom_delay(ee_addr)   ioread32(ee_addr)
 678 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. */
 679 static int __devinit eeprom_read(void __iomem *ioaddr, int location)
 680 {
 681         int boguscnt = 10000;           /* Typical 1900 ticks. */
 682         iowrite16(0x0200 | (location & 0xff), ioaddr + EECtrl);
 683         do {
 684                 eeprom_delay(ioaddr + EECtrl);
 685                 if (! (ioread16(ioaddr + EECtrl) & 0x8000)) {
 686                         return ioread16(ioaddr + EEData);
 687                 }
 688         } while (--boguscnt > 0);
 689         return 0;
 690 }
 691
 692 /*  MII transceiver control section.
 693         Read and write the MII registers using software-generated serial
 694         MDIO protocol.  See the MII specifications or DP83840A data sheet
 695         for details.
 696
 697         The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
 698         met by back-to-back 33Mhz PCI cycles. */
 699 #define mdio_delay() ioread8(mdio_addr)
 700
 701 enum mii_reg_bits {
 702         MDIO_ShiftClk=0x0001, MDIO_Data=0x0002, MDIO_EnbOutput=0x0004,
 703 };
 704 #define MDIO_EnbIn  (0)
 705 #define MDIO_WRITE0 (MDIO_EnbOutput)
 706 #define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput)
 707
 708 /* Generate the preamble required for initial synchronization and
 709    a few older transceivers. */
 710 static void mdio_sync(void __iomem *mdio_addr)
 711 {
 712         int bits = 32;
 713
 714         /* Establish sync by sending at least 32 logic ones. */
 715         while (--bits >= 0) {
 716                 iowrite8(MDIO_WRITE1, mdio_addr);
 717                 mdio_delay();
 718                 iowrite8(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
 719                 mdio_delay();
 720         }
 721 }
 722
 723 static int mdio_read(struct net_device *dev, int phy_id, int location)
 724 {
 725         struct netdev_private *np = netdev_priv(dev);
 726         void __iomem *mdio_addr = np->base + MIICtrl;
 727         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
 728         int i, retval = 0;
 729
 730         if (np->mii_preamble_required)
 731                 mdio_sync(mdio_addr);
 732
 733         /* Shift the read command bits out. */
 734         for (i = 15; i >= 0; i--) {
 735                 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
 736
 737                 iowrite8(dataval, mdio_addr);
 738                 mdio_delay();
 739                 iowrite8(dataval | MDIO_ShiftClk, mdio_addr);
 740                 mdio_delay();
 741         }
 742         /* Read the two transition, 16 data, and wire-idle bits. */
 743         for (i = 19; i > 0; i--) {
 744                 iowrite8(MDIO_EnbIn, mdio_addr);
 745                 mdio_delay();
 746                 retval = (retval << 1) | ((ioread8(mdio_addr) & MDIO_Data) ? 1 : 0);
 747                 iowrite8(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
 748                 mdio_delay();
 749         }
 750         return (retval>>1) & 0xffff;
 751 }
 752
 753 static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
 754 {
 755         struct netdev_private *np = netdev_priv(dev);
 756         void __iomem *mdio_addr = np->base + MIICtrl;
 757         int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
 758         int i;
 759
 760         if (np->mii_preamble_required)
 761                 mdio_sync(mdio_addr);
 762
 763         /* Shift the command bits out. */
 764         for (i = 31; i >= 0; i--) {
 765                 int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
 766
 767                 iowrite8(dataval, mdio_addr);
 768                 mdio_delay();
 769                 iowrite8(dataval | MDIO_ShiftClk, mdio_addr);
 770                 mdio_delay();
 771         }
 772         /* Clear out extra bits. */
 773         for (i = 2; i > 0; i--) {
 774                 iowrite8(MDIO_EnbIn, mdio_addr);
 775                 mdio_delay();
 776                 iowrite8(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
 777                 mdio_delay();
 778         }
 779         return;
 780 }
 781
 782 static int netdev_open(struct net_device *dev)
 783 {
 784         struct netdev_private *np = netdev_priv(dev);
 785         void __iomem *ioaddr = np->base;
 786         unsigned long flags;
 787         int i;
 788
 789         /* Do we need to reset the chip??? */
 790
 791         i = request_irq(dev->irq, &intr_handler, IRQF_SHARED, dev->name, dev);
 792         if (i)
 793                 return i;
 794
 795         if (netif_msg_ifup(np))
 796                 printk(KERN_DEBUG "%s: netdev_open() irq %d.\n",
 797                            dev->name, dev->irq);
 798         init_ring(dev);
 799
 800         iowrite32(np->rx_ring_dma, ioaddr + RxListPtr);
 801         /* The Tx list pointer is written as packets are queued. */
 802
 803         /* Initialize other registers. */
 804         __set_mac_addr(dev);
 805 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
 806         iowrite16(dev->mtu + 18, ioaddr + MaxFrameSize);
 807 #else
 808         iowrite16(dev->mtu + 14, ioaddr + MaxFrameSize);
 809 #endif
 810         if (dev->mtu > 2047)
 811                 iowrite32(ioread32(ioaddr + ASICCtrl) | 0x0C, ioaddr + ASICCtrl);
 812
 813         /* Configure the PCI bus bursts and FIFO thresholds. */
 814
 815         if (dev->if_port == 0)
 816                 dev->if_port = np->default_port;
 817
 818         spin_lock_init(&np->mcastlock);
 819
 820         set_rx_mode(dev);
 821         iowrite16(0, ioaddr + IntrEnable);
 822         iowrite16(0, ioaddr + DownCounter);
 823         /* Set the chip to poll every N*320nsec. */
 824         iowrite8(100, ioaddr + RxDMAPollPeriod);
 825         iowrite8(127, ioaddr + TxDMAPollPeriod);
 826         /* Fix DFE-580TX packet drop issue */
 827         if (np->pci_dev->revision >= 0x14)
 828                 iowrite8(0x01, ioaddr + DebugCtrl1);
 829         netif_start_queue(dev);
 830
 831         spin_lock_irqsave(&np->lock, flags);
 832         reset_tx(dev);
 833         spin_unlock_irqrestore(&np->lock, flags);
 834
 835         iowrite16 (StatsEnable | RxEnable | TxEnable, ioaddr + MACCtrl1);
 836
 837         if (netif_msg_ifup(np))
 838                 printk(KERN_DEBUG "%s: Done netdev_open(), status: Rx %x Tx %x "
 839                            "MAC Control %x, %4.4x %4.4x.\n",
 840                            dev->name, ioread32(ioaddr + RxStatus), ioread8(ioaddr + TxStatus),
 841                            ioread32(ioaddr + MACCtrl0),
 842                            ioread16(ioaddr + MACCtrl1), ioread16(ioaddr + MACCtrl0));
 843
 844         /* Set the timer to check for link beat. */
 845         init_timer(&np->timer);
 846         np->timer.expires = jiffies + 3*HZ;
 847         np->timer.data = (unsigned long)dev;
 848         np->timer.function = &netdev_timer;                             /* timer handler */
 849         add_timer(&np->timer);
 850
 851         /* Enable interrupts by setting the interrupt mask. */
 852         iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
 853
 854         return 0;
 855 }
 856
 857 static void check_duplex(struct net_device *dev)
 858 {
 859         struct netdev_private *np = netdev_priv(dev);
 860         void __iomem *ioaddr = np->base;
 861         int mii_lpa = mdio_read(dev, np->phys[0], MII_LPA);
 862         int negotiated = mii_lpa & np->mii_if.advertising;
 863         int duplex;
 864
 865         /* Force media */
 866         if (!np->an_enable || mii_lpa == 0xffff) {
 867                 if (np->mii_if.full_duplex)
 868                         iowrite16 (ioread16 (ioaddr + MACCtrl0) | EnbFullDuplex,
 869                                 ioaddr + MACCtrl0);
 870                 return;
 871         }
 872
 873         /* Autonegotiation */
 874         duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
 875         if (np->mii_if.full_duplex != duplex) {
 876                 np->mii_if.full_duplex = duplex;
 877                 if (netif_msg_link(np))
 878                         printk(KERN_INFO "%s: Setting %s-duplex based on MII #%d "
 879                                    "negotiated capability %4.4x.\n", dev->name,
 880                                    duplex ? "full" : "half", np->phys[0], negotiated);
 881                 iowrite16(ioread16(ioaddr + MACCtrl0) | duplex ? 0x20 : 0, ioaddr + MACCtrl0);
 882         }
 883 }
 884
 885 static void netdev_timer(unsigned long data)
 886 {
 887         struct net_device *dev = (struct net_device *)data;
 888         struct netdev_private *np = netdev_priv(dev);
 889         void __iomem *ioaddr = np->base;
 890         int next_tick = 10*HZ;
 891
 892         if (netif_msg_timer(np)) {
 893                 printk(KERN_DEBUG "%s: Media selection timer tick, intr status %4.4x, "
 894                            "Tx %x Rx %x.\n",
 895                            dev->name, ioread16(ioaddr + IntrEnable),
 896                            ioread8(ioaddr + TxStatus), ioread32(ioaddr + RxStatus));
 897         }
 898         check_duplex(dev);
 899         np->timer.expires = jiffies + next_tick;
 900         add_timer(&np->timer);
 901 }
 902
 903 static void tx_timeout(struct net_device *dev)
 904 {
 905         struct netdev_private *np = netdev_priv(dev);
 906         void __iomem *ioaddr = np->base;
 907         unsigned long flag;
 908
 909         netif_stop_queue(dev);
 910         tasklet_disable(&np->tx_tasklet);
 911         iowrite16(0, ioaddr + IntrEnable);
 912         printk(KERN_WARNING "%s: Transmit timed out, TxStatus %2.2x "
 913                    "TxFrameId %2.2x,"
 914                    " resetting...\n", dev->name, ioread8(ioaddr + TxStatus),
 915                    ioread8(ioaddr + TxFrameId));
 916
 917         {
 918                 int i;
 919                 for (i=0; i<TX_RING_SIZE; i++) {
 920                         printk(KERN_DEBUG "%02x %08llx %08x %08x(%02x) %08x %08x\n", i,
 921                                 (unsigned long long)(np->tx_ring_dma + i*sizeof(*np->tx_ring)),
 922                                 le32_to_cpu(np->tx_ring[i].next_desc),
 923                                 le32_to_cpu(np->tx_ring[i].status),
 924                                 (le32_to_cpu(np->tx_ring[i].status) >> 2) & 0xff,
 925                                 le32_to_cpu(np->tx_ring[i].frag[0].addr),
 926                                 le32_to_cpu(np->tx_ring[i].frag[0].length));
 927                 }
 928                 printk(KERN_DEBUG "TxListPtr=%08x netif_queue_stopped=%d\n",
 929                         ioread32(np->base + TxListPtr),
 930                         netif_queue_stopped(dev));
 931                 printk(KERN_DEBUG "cur_tx=%d(%02x) dirty_tx=%d(%02x)\n",
 932                         np->cur_tx, np->cur_tx % TX_RING_SIZE,
 933                         np->dirty_tx, np->dirty_tx % TX_RING_SIZE);
 934                 printk(KERN_DEBUG "cur_rx=%d dirty_rx=%d\n", np->cur_rx, np->dirty_rx);
 935                 printk(KERN_DEBUG "cur_task=%d\n", np->cur_task);
 936         }
 937         spin_lock_irqsave(&np->lock, flag);
 938
 939         /* Stop and restart the chip's Tx processes . */
 940         reset_tx(dev);
 941         spin_unlock_irqrestore(&np->lock, flag);
 942
 943         dev->if_port = 0;
 944
 945         dev->trans_start = jiffies;
 946         np->stats.tx_errors++;
 947         if (np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) {
 948                 netif_wake_queue(dev);
 949         }
 950         iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
 951         tasklet_enable(&np->tx_tasklet);
 952 }
 953
 954
 955 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
 956 static void init_ring(struct net_device *dev)
 957 {
 958         struct netdev_private *np = netdev_priv(dev);
 959         int i;
 960
 961         np->cur_rx = np->cur_tx = 0;
 962         np->dirty_rx = np->dirty_tx = 0;
 963         np->cur_task = 0;
 964
 965         np->rx_buf_sz = (dev->mtu <= 1520 ? PKT_BUF_SZ : dev->mtu + 16);
 966
 967         /* Initialize all Rx descriptors. */
 968         for (i = 0; i < RX_RING_SIZE; i++) {
 969                 np->rx_ring[i].next_desc = cpu_to_le32(np->rx_ring_dma +
 970                         ((i+1)%RX_RING_SIZE)*sizeof(*np->rx_ring));
 971                 np->rx_ring[i].status = 0;
 972                 np->rx_ring[i].frag[0].length = 0;
 973                 np->rx_skbuff[i] = NULL;
 974         }
 975
 976         /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
 977         for (i = 0; i < RX_RING_SIZE; i++) {
 978                 struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz);
 979                 np->rx_skbuff[i] = skb;
 980                 if (skb == NULL)
 981                         break;
 982                 skb->dev = dev;         /* Mark as being used by this device. */
 983                 skb_reserve(skb, 2);    /* 16 byte align the IP header. */
 984                 np->rx_ring[i].frag[0].addr = cpu_to_le32(
 985                         pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz,
 986                                 PCI_DMA_FROMDEVICE));
 987                 np->rx_ring[i].frag[0].length = cpu_to_le32(np->rx_buf_sz | LastFrag);
 988         }
 989         np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
 990
 991         for (i = 0; i < TX_RING_SIZE; i++) {
 992                 np->tx_skbuff[i] = NULL;
 993                 np->tx_ring[i].status = 0;
 994         }
 995         return;
 996 }
 997
 998 static void tx_poll (unsigned long data)
 999 {
1000         struct net_device *dev = (struct net_device *)data;
1001         struct netdev_private *np = netdev_priv(dev);
1002         unsigned head = np->cur_task % TX_RING_SIZE;
1003         struct netdev_desc *txdesc =
1004                 &np->tx_ring[(np->cur_tx - 1) % TX_RING_SIZE];
1005
1006         /* Chain the next pointer */
1007         for (; np->cur_tx - np->cur_task > 0; np->cur_task++) {
1008                 int entry = np->cur_task % TX_RING_SIZE;
1009                 txdesc = &np->tx_ring[entry];
1010                 if (np->last_tx) {
1011                         np->last_tx->next_desc = cpu_to_le32(np->tx_ring_dma +
1012                                 entry*sizeof(struct netdev_desc));
1013                 }
1014                 np->last_tx = txdesc;
1015         }
1016         /* Indicate the latest descriptor of tx ring */
1017         txdesc->status |= cpu_to_le32(DescIntrOnTx);
1018
1019         if (ioread32 (np->base + TxListPtr) == 0)
1020                 iowrite32 (np->tx_ring_dma + head * sizeof(struct netdev_desc),
1021                         np->base + TxListPtr);
1022         return;
1023 }
1024
1025 static int
1026 start_tx (struct sk_buff *skb, struct net_device *dev)
1027 {
1028         struct netdev_private *np = netdev_priv(dev);
1029         struct netdev_desc *txdesc;
1030         unsigned entry;
1031
1032         /* Calculate the next Tx descriptor entry. */
1033         entry = np->cur_tx % TX_RING_SIZE;
1034         np->tx_skbuff[entry] = skb;
1035         txdesc = &np->tx_ring[entry];
1036
1037         txdesc->next_desc = 0;
1038         txdesc->status = cpu_to_le32 ((entry << 2) | DisableAlign);
1039         txdesc->frag[0].addr = cpu_to_le32 (pci_map_single (np->pci_dev, skb->data,
1040                                                         skb->len,
1041                                                         PCI_DMA_TODEVICE));
1042         txdesc->frag[0].length = cpu_to_le32 (skb->len | LastFrag);
1043
1044         /* Increment cur_tx before tasklet_schedule() */
1045         np->cur_tx++;
1046         mb();
1047         /* Schedule a tx_poll() task */
1048         tasklet_schedule(&np->tx_tasklet);
1049
1050         /* On some architectures: explicitly flush cache lines here. */
1051         if (np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 1
1052                         && !netif_queue_stopped(dev)) {
1053                 /* do nothing */
1054         } else {
1055                 netif_stop_queue (dev);
1056         }
1057         dev->trans_start = jiffies;
1058         if (netif_msg_tx_queued(np)) {
1059                 printk (KERN_DEBUG
1060                         "%s: Transmit frame #%d queued in slot %d.\n",
1061                         dev->name, np->cur_tx, entry);
1062         }
1063         return 0;
1064 }
1065
1066 /* Reset hardware tx and free all of tx buffers */
1067 static int
1068 reset_tx (struct net_device *dev)
1069 {
1070         struct netdev_private *np = netdev_priv(dev);
1071         void __iomem *ioaddr = np->base;
1072         struct sk_buff *skb;
1073         int i;
1074         int irq = in_interrupt();
1075
1076         /* Reset tx logic, TxListPtr will be cleaned */
1077         iowrite16 (TxDisable, ioaddr + MACCtrl1);
1078         sundance_reset(dev, (NetworkReset|FIFOReset|DMAReset|TxReset) << 16);
1079
1080         /* free all tx skbuff */
1081         for (i = 0; i < TX_RING_SIZE; i++) {
1082                 np->tx_ring[i].next_desc = 0;
1083
1084                 skb = np->tx_skbuff[i];
1085                 if (skb) {
1086                         pci_unmap_single(np->pci_dev,
1087                                 np->tx_ring[i].frag[0].addr, skb->len,
1088                                 PCI_DMA_TODEVICE);
1089                         if (irq)
1090                                 dev_kfree_skb_irq (skb);
1091                         else
1092                                 dev_kfree_skb (skb);
1093                         np->tx_skbuff[i] = NULL;
1094                         np->stats.tx_dropped++;
1095                 }
1096         }
1097         np->cur_tx = np->dirty_tx = 0;
1098         np->cur_task = 0;
1099
1100         np->last_tx = NULL;
1101         iowrite8(127, ioaddr + TxDMAPollPeriod);
1102
1103         iowrite16 (StatsEnable | RxEnable | TxEnable, ioaddr + MACCtrl1);
1104         return 0;
1105 }
1106
1107 /* The interrupt handler cleans up after the Tx thread,
1108    and schedule a Rx thread work */
1109 static irqreturn_t intr_handler(int irq, void *dev_instance)
1110 {
1111         struct net_device *dev = (struct net_device *)dev_instance;
1112         struct netdev_private *np = netdev_priv(dev);
1113         void __iomem *ioaddr = np->base;
1114         int hw_frame_id;
1115         int tx_cnt;
1116         int tx_status;
1117         int handled = 0;
1118         int i;
1119
1120
1121         do {
1122                 int intr_status = ioread16(ioaddr + IntrStatus);
1123                 iowrite16(intr_status, ioaddr + IntrStatus);
1124
1125                 if (netif_msg_intr(np))
1126                         printk(KERN_DEBUG "%s: Interrupt, status %4.4x.\n",
1127                                    dev->name, intr_status);
1128
1129                 if (!(intr_status & DEFAULT_INTR))
1130                         break;
1131
1132                 handled = 1;
1133
1134                 if (intr_status & (IntrRxDMADone)) {
1135                         iowrite16(DEFAULT_INTR & ~(IntrRxDone|IntrRxDMADone),
1136                                         ioaddr + IntrEnable);
1137                         if (np->budget < 0)
1138                                 np->budget = RX_BUDGET;
1139                         tasklet_schedule(&np->rx_tasklet);
1140                 }
1141                 if (intr_status & (IntrTxDone | IntrDrvRqst)) {
1142                         tx_status = ioread16 (ioaddr + TxStatus);
1143                         for (tx_cnt=32; tx_status & 0x80; --tx_cnt) {
1144                                 if (netif_msg_tx_done(np))
1145                                         printk
1146                                             ("%s: Transmit status is %2.2x.\n",
1147                                         dev->name, tx_status);
1148                                 if (tx_status & 0x1e) {
1149                                         if (netif_msg_tx_err(np))
1150                                                 printk("%s: Transmit error status %4.4x.\n",
1151                                                            dev->name, tx_status);
1152                                         np->stats.tx_errors++;
1153                                         if (tx_status & 0x10)
1154                                                 np->stats.tx_fifo_errors++;
1155                                         if (tx_status & 0x08)
1156                                                 np->stats.collisions++;
1157                                         if (tx_status & 0x04)
1158                                                 np->stats.tx_fifo_errors++;
1159                                         if (tx_status & 0x02)
1160                                                 np->stats.tx_window_errors++;
1161
1162                                         /*
1163                                         ** This reset has been verified on
1164                                         ** DFE-580TX boards ! phdm@macqel.be.
1165                                         */
1166                                         if (tx_status & 0x10) { /* TxUnderrun */
1167                                                 /* Restart Tx FIFO and transmitter */
1168                                                 sundance_reset(dev, (NetworkReset|FIFOReset|TxReset) << 16);
1169                                                 /* No need to reset the Tx pointer here */
1170                                         }
1171                                         /* Restart the Tx. Need to make sure tx enabled */
1172                                         i = 10;
1173                                         do {
1174                                                 iowrite16(ioread16(ioaddr + MACCtrl1) | TxEnable, ioaddr + MACCtrl1);
1175                                                 if (ioread16(ioaddr + MACCtrl1) & TxEnabled)
1176                                                         break;
1177                                                 mdelay(1);
1178                                         } while (--i);
1179                                 }
1180                                 /* Yup, this is a documentation bug.  It cost me *hours*. */
1181                                 iowrite16 (0, ioaddr + TxStatus);
1182                                 if (tx_cnt < 0) {
1183                                         iowrite32(5000, ioaddr + DownCounter);
1184                                         break;
1185                                 }
1186                                 tx_status = ioread16 (ioaddr + TxStatus);
1187                         }
1188                         hw_frame_id = (tx_status >> 8) & 0xff;
1189                 } else  {
1190                         hw_frame_id = ioread8(ioaddr + TxFrameId);
1191                 }
1192
1193                 if (np->pci_dev->revision >= 0x14) {
1194                         spin_lock(&np->lock);
1195                         for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1196                                 int entry = np->dirty_tx % TX_RING_SIZE;
1197                                 struct sk_buff *skb;
1198                                 int sw_frame_id;
1199                                 sw_frame_id = (le32_to_cpu(
1200                                         np->tx_ring[entry].status) >> 2) & 0xff;
1201                                 if (sw_frame_id == hw_frame_id &&
1202                                         !(le32_to_cpu(np->tx_ring[entry].status)
1203                                         & 0x00010000))
1204                                                 break;
1205                                 if (sw_frame_id == (hw_frame_id + 1) %
1206                                         TX_RING_SIZE)
1207                                                 break;
1208                                 skb = np->tx_skbuff[entry];
1209                                 /* Free the original skb. */
1210                                 pci_unmap_single(np->pci_dev,
1211                                         np->tx_ring[entry].frag[0].addr,
1212                                         skb->len, PCI_DMA_TODEVICE);
1213                                 dev_kfree_skb_irq (np->tx_skbuff[entry]);
1214                                 np->tx_skbuff[entry] = NULL;
1215                                 np->tx_ring[entry].frag[0].addr = 0;
1216                                 np->tx_ring[entry].frag[0].length = 0;
1217                         }
1218                         spin_unlock(&np->lock);
1219                 } else {
1220                         spin_lock(&np->lock);
1221                         for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1222                                 int entry = np->dirty_tx % TX_RING_SIZE;
1223                                 struct sk_buff *skb;
1224                                 if (!(le32_to_cpu(np->tx_ring[entry].status)
1225                                                         & 0x00010000))
1226                                         break;
1227                                 skb = np->tx_skbuff[entry];
1228                                 /* Free the original skb. */
1229                                 pci_unmap_single(np->pci_dev,
1230                                         np->tx_ring[entry].frag[0].addr,
1231                                         skb->len, PCI_DMA_TODEVICE);
1232                                 dev_kfree_skb_irq (np->tx_skbuff[entry]);
1233                                 np->tx_skbuff[entry] = NULL;
1234                                 np->tx_ring[entry].frag[0].addr = 0;
1235                                 np->tx_ring[entry].frag[0].length = 0;
1236                         }
1237                         spin_unlock(&np->lock);
1238                 }
1239
1240                 if (netif_queue_stopped(dev) &&
1241                         np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) {
1242                         /* The ring is no longer full, clear busy flag. */
1243                         netif_wake_queue (dev);
1244                 }
1245                 /* Abnormal error summary/uncommon events handlers. */
1246                 if (intr_status & (IntrPCIErr | LinkChange | StatsMax))
1247                         netdev_error(dev, intr_status);
1248         } while (0);
1249         if (netif_msg_intr(np))
1250                 printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",
1251                            dev->name, ioread16(ioaddr + IntrStatus));
1252         return IRQ_RETVAL(handled);
1253 }
1254
1255 static void rx_poll(unsigned long data)
1256 {
1257         struct net_device *dev = (struct net_device *)data;
1258         struct netdev_private *np = netdev_priv(dev);
1259         int entry = np->cur_rx % RX_RING_SIZE;
1260         int boguscnt = np->budget;
1261         void __iomem *ioaddr = np->base;
1262         int received = 0;
1263
1264         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1265         while (1) {
1266                 struct netdev_desc *desc = &(np->rx_ring[entry]);
1267                 u32 frame_status = le32_to_cpu(desc->status);
1268                 int pkt_len;
1269
1270                 if (--boguscnt < 0) {
1271                         goto not_done;
1272                 }
1273                 if (!(frame_status & DescOwn))
1274                         break;
1275                 pkt_len = frame_status & 0x1fff;        /* Chip omits the CRC. */
1276                 if (netif_msg_rx_status(np))
1277                         printk(KERN_DEBUG "  netdev_rx() status was %8.8x.\n",
1278                                    frame_status);
1279                 if (frame_status & 0x001f4000) {
1280                         /* There was a error. */
1281                         if (netif_msg_rx_err(np))
1282                                 printk(KERN_DEBUG "  netdev_rx() Rx error was %8.8x.\n",
1283                                            frame_status);
1284                         np->stats.rx_errors++;
1285                         if (frame_status & 0x00100000) np->stats.rx_length_errors++;
1286                         if (frame_status & 0x00010000) np->stats.rx_fifo_errors++;
1287                         if (frame_status & 0x00060000) np->stats.rx_frame_errors++;
1288                         if (frame_status & 0x00080000) np->stats.rx_crc_errors++;
1289                         if (frame_status & 0x00100000) {
1290                                 printk(KERN_WARNING "%s: Oversized Ethernet frame,"
1291                                            " status %8.8x.\n",
1292                                            dev->name, frame_status);
1293                         }
1294                 } else {
1295                         struct sk_buff *skb;
1296 #ifndef final_version
1297                         if (netif_msg_rx_status(np))
1298                                 printk(KERN_DEBUG "  netdev_rx() normal Rx pkt length %d"
1299                                            ", bogus_cnt %d.\n",
1300                                            pkt_len, boguscnt);
1301 #endif
1302                         /* Check if the packet is long enough to accept without copying
1303                            to a minimally-sized skbuff. */
1304                         if (pkt_len < rx_copybreak
1305                                 && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1306                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
1307                                 pci_dma_sync_single_for_cpu(np->pci_dev,
1308                                                             desc->frag[0].addr,
1309                                                             np->rx_buf_sz,
1310                                                             PCI_DMA_FROMDEVICE);
1311
1312                                 skb_copy_to_linear_data(skb, np->rx_skbuff[entry]->data, pkt_len);
1313                                 pci_dma_sync_single_for_device(np->pci_dev,
1314                                                                desc->frag[0].addr,
1315                                                                np->rx_buf_sz,
1316                                                                PCI_DMA_FROMDEVICE);
1317                                 skb_put(skb, pkt_len);
1318                         } else {
1319                                 pci_unmap_single(np->pci_dev,
1320                                         desc->frag[0].addr,
1321                                         np->rx_buf_sz,
1322                                         PCI_DMA_FROMDEVICE);
1323                                 skb_put(skb = np->rx_skbuff[entry], pkt_len);
1324                                 np->rx_skbuff[entry] = NULL;
1325                         }
1326                         skb->protocol = eth_type_trans(skb, dev);
1327                         /* Note: checksum -> skb->ip_summed = CHECKSUM_UNNECESSARY; */
1328                         netif_rx(skb);
1329                         dev->last_rx = jiffies;
1330                 }
1331                 entry = (entry + 1) % RX_RING_SIZE;
1332                 received++;
1333         }
1334         np->cur_rx = entry;
1335         refill_rx (dev);
1336         np->budget -= received;
1337         iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
1338         return;
1339
1340 not_done:
1341         np->cur_rx = entry;
1342         refill_rx (dev);
1343         if (!received)
1344                 received = 1;
1345         np->budget -= received;
1346         if (np->budget <= 0)
1347                 np->budget = RX_BUDGET;
1348         tasklet_schedule(&np->rx_tasklet);
1349         return;
1350 }
1351
1352 static void refill_rx (struct net_device *dev)
1353 {
1354         struct netdev_private *np = netdev_priv(dev);
1355         int entry;
1356         int cnt = 0;
1357
1358         /* Refill the Rx ring buffers. */
1359         for (;(np->cur_rx - np->dirty_rx + RX_RING_SIZE) % RX_RING_SIZE > 0;
1360                 np->dirty_rx = (np->dirty_rx + 1) % RX_RING_SIZE) {
1361                 struct sk_buff *skb;
1362                 entry = np->dirty_rx % RX_RING_SIZE;
1363                 if (np->rx_skbuff[entry] == NULL) {
1364                         skb = dev_alloc_skb(np->rx_buf_sz);
1365                         np->rx_skbuff[entry] = skb;
1366                         if (skb == NULL)
1367                                 break;          /* Better luck next round. */
1368                         skb->dev = dev;         /* Mark as being used by this device. */
1369                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1370                         np->rx_ring[entry].frag[0].addr = cpu_to_le32(
1371                                 pci_map_single(np->pci_dev, skb->data,
1372                                         np->rx_buf_sz, PCI_DMA_FROMDEVICE));
1373                 }
1374                 /* Perhaps we need not reset this field. */
1375                 np->rx_ring[entry].frag[0].length =
1376                         cpu_to_le32(np->rx_buf_sz | LastFrag);
1377                 np->rx_ring[entry].status = 0;
1378                 cnt++;
1379         }
1380         return;
1381 }
1382 static void netdev_error(struct net_device *dev, int intr_status)
1383 {
1384         struct netdev_private *np = netdev_priv(dev);
1385         void __iomem *ioaddr = np->base;
1386         u16 mii_ctl, mii_advertise, mii_lpa;
1387         int speed;
1388
1389         if (intr_status & LinkChange) {
1390                 if (np->an_enable) {
1391                         mii_advertise = mdio_read (dev, np->phys[0], MII_ADVERTISE);
1392                         mii_lpa= mdio_read (dev, np->phys[0], MII_LPA);
1393                         mii_advertise &= mii_lpa;
1394                         printk (KERN_INFO "%s: Link changed: ", dev->name);
1395                         if (mii_advertise & ADVERTISE_100FULL) {
1396                                 np->speed = 100;
1397                                 printk ("100Mbps, full duplex\n");
1398                         } else if (mii_advertise & ADVERTISE_100HALF) {
1399                                 np->speed = 100;
1400                                 printk ("100Mbps, half duplex\n");
1401                         } else if (mii_advertise & ADVERTISE_10FULL) {
1402                                 np->speed = 10;
1403                                 printk ("10Mbps, full duplex\n");
1404                         } else if (mii_advertise & ADVERTISE_10HALF) {
1405                                 np->speed = 10;
1406                                 printk ("10Mbps, half duplex\n");
1407                         } else
1408                                 printk ("\n");
1409
1410                 } else {
1411                         mii_ctl = mdio_read (dev, np->phys[0], MII_BMCR);
1412                         speed = (mii_ctl & BMCR_SPEED100) ? 100 : 10;
1413                         np->speed = speed;
1414                         printk (KERN_INFO "%s: Link changed: %dMbps ,",
1415                                 dev->name, speed);
1416                         printk ("%s duplex.\n", (mii_ctl & BMCR_FULLDPLX) ?
1417                                 "full" : "half");
1418                 }
1419                 check_duplex (dev);
1420                 if (np->flowctrl && np->mii_if.full_duplex) {
1421                         iowrite16(ioread16(ioaddr + MulticastFilter1+2) | 0x0200,
1422                                 ioaddr + MulticastFilter1+2);
1423                         iowrite16(ioread16(ioaddr + MACCtrl0) | EnbFlowCtrl,
1424                                 ioaddr + MACCtrl0);
1425                 }
1426         }
1427         if (intr_status & StatsMax) {
1428                 get_stats(dev);
1429         }
1430         if (intr_status & IntrPCIErr) {
1431                 printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n",
1432                            dev->name, intr_status);
1433                 /* We must do a global reset of DMA to continue. */
1434         }
1435 }
1436
1437 static struct net_device_stats *get_stats(struct net_device *dev)
1438 {
1439         struct netdev_private *np = netdev_priv(dev);
1440         void __iomem *ioaddr = np->base;
1441         int i;
1442
1443         /* We should lock this segment of code for SMP eventually, although
1444            the vulnerability window is very small and statistics are
1445            non-critical. */
1446         /* The chip only need report frame silently dropped. */
1447         np->stats.rx_missed_errors      += ioread8(ioaddr + RxMissed);
1448         np->stats.tx_packets += ioread16(ioaddr + TxFramesOK);
1449         np->stats.rx_packets += ioread16(ioaddr + RxFramesOK);
1450         np->stats.collisions += ioread8(ioaddr + StatsLateColl);
1451         np->stats.collisions += ioread8(ioaddr + StatsMultiColl);
1452         np->stats.collisions += ioread8(ioaddr + StatsOneColl);
1453         np->stats.tx_carrier_errors += ioread8(ioaddr + StatsCarrierError);
1454         ioread8(ioaddr + StatsTxDefer);
1455         for (i = StatsTxDefer; i <= StatsMcastRx; i++)
1456                 ioread8(ioaddr + i);
1457         np->stats.tx_bytes += ioread16(ioaddr + TxOctetsLow);
1458         np->stats.tx_bytes += ioread16(ioaddr + TxOctetsHigh) << 16;
1459         np->stats.rx_bytes += ioread16(ioaddr + RxOctetsLow);
1460         np->stats.rx_bytes += ioread16(ioaddr + RxOctetsHigh) << 16;
1461
1462         return &np->stats;
1463 }
1464
1465 static void set_rx_mode(struct net_device *dev)
1466 {
1467         struct netdev_private *np = netdev_priv(dev);
1468         void __iomem *ioaddr = np->base;
1469         u16 mc_filter[4];                       /* Multicast hash filter */
1470         u32 rx_mode;
1471         int i;
1472
1473         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
1474                 memset(mc_filter, 0xff, sizeof(mc_filter));
1475                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptAll | AcceptMyPhys;
1476         } else if ((dev->mc_count > multicast_filter_limit)
1477                            ||  (dev->flags & IFF_ALLMULTI)) {
1478                 /* Too many to match, or accept all multicasts. */
1479                 memset(mc_filter, 0xff, sizeof(mc_filter));
1480                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1481         } else if (dev->mc_count) {
1482                 struct dev_mc_list *mclist;
1483                 int bit;
1484                 int index;
1485                 int crc;
1486                 memset (mc_filter, 0, sizeof (mc_filter));
1487                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1488                      i++, mclist = mclist->next) {
1489                         crc = ether_crc_le (ETH_ALEN, mclist->dmi_addr);
1490                         for (index=0, bit=0; bit < 6; bit++, crc <<= 1)
1491                                 if (crc & 0x80000000) index |= 1 << bit;
1492                         mc_filter[index/16] |= (1 << (index % 16));
1493                 }
1494                 rx_mode = AcceptBroadcast | AcceptMultiHash | AcceptMyPhys;
1495         } else {
1496                 iowrite8(AcceptBroadcast | AcceptMyPhys, ioaddr + RxMode);
1497                 return;
1498         }
1499         if (np->mii_if.full_duplex && np->flowctrl)
1500                 mc_filter[3] |= 0x0200;
1501
1502         for (i = 0; i < 4; i++)
1503                 iowrite16(mc_filter[i], ioaddr + MulticastFilter0 + i*2);
1504         iowrite8(rx_mode, ioaddr + RxMode);
1505 }
1506
1507 static int __set_mac_addr(struct net_device *dev)
1508 {
1509         struct netdev_private *np = netdev_priv(dev);
1510         u16 addr16;
1511
1512         addr16 = (dev->dev_addr[0] | (dev->dev_addr[1] << 8));
1513         iowrite16(addr16, np->base + StationAddr);
1514         addr16 = (dev->dev_addr[2] | (dev->dev_addr[3] << 8));
1515         iowrite16(addr16, np->base + StationAddr+2);
1516         addr16 = (dev->dev_addr[4] | (dev->dev_addr[5] << 8));
1517         iowrite16(addr16, np->base + StationAddr+4);
1518         return 0;
1519 }
1520
1521 static int check_if_running(struct net_device *dev)
1522 {
1523         if (!netif_running(dev))
1524                 return -EINVAL;
1525         return 0;
1526 }
1527
1528 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1529 {
1530         struct netdev_private *np = netdev_priv(dev);
1531         strcpy(info->driver, DRV_NAME);
1532         strcpy(info->version, DRV_VERSION);
1533         strcpy(info->bus_info, pci_name(np->pci_dev));
1534 }
1535
1536 static int get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1537 {
1538         struct netdev_private *np = netdev_priv(dev);
1539         spin_lock_irq(&np->lock);
1540         mii_ethtool_gset(&np->mii_if, ecmd);
1541         spin_unlock_irq(&np->lock);
1542         return 0;
1543 }
1544
1545 static int set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1546 {
1547         struct netdev_private *np = netdev_priv(dev);
1548         int res;
1549         spin_lock_irq(&np->lock);
1550         res = mii_ethtool_sset(&np->mii_if, ecmd);
1551         spin_unlock_irq(&np->lock);
1552         return res;
1553 }
1554
1555 static int nway_reset(struct net_device *dev)
1556 {
1557         struct netdev_private *np = netdev_priv(dev);
1558         return mii_nway_restart(&np->mii_if);
1559 }
1560
1561 static u32 get_link(struct net_device *dev)
1562 {
1563         struct netdev_private *np = netdev_priv(dev);
1564         return mii_link_ok(&np->mii_if);
1565 }
1566
1567 static u32 get_msglevel(struct net_device *dev)
1568 {
1569         struct netdev_private *np = netdev_priv(dev);
1570         return np->msg_enable;
1571 }
1572
1573 static void set_msglevel(struct net_device *dev, u32 val)
1574 {
1575         struct netdev_private *np = netdev_priv(dev);
1576         np->msg_enable = val;
1577 }
1578
1579 static const struct ethtool_ops ethtool_ops = {
1580         .begin = check_if_running,
1581         .get_drvinfo = get_drvinfo,
1582         .get_settings = get_settings,
1583         .set_settings = set_settings,
1584         .nway_reset = nway_reset,
1585         .get_link = get_link,
1586         .get_msglevel = get_msglevel,
1587         .set_msglevel = set_msglevel,
1588 };
1589
1590 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1591 {
1592         struct netdev_private *np = netdev_priv(dev);
1593         void __iomem *ioaddr = np->base;
1594         int rc;
1595         int i;
1596
1597         if (!netif_running(dev))
1598                 return -EINVAL;
1599
1600         spin_lock_irq(&np->lock);
1601         rc = generic_mii_ioctl(&np->mii_if, if_mii(rq), cmd, NULL);
1602         spin_unlock_irq(&np->lock);
1603         switch (cmd) {
1604                 case SIOCDEVPRIVATE:
1605                 for (i=0; i<TX_RING_SIZE; i++) {
1606                         printk(KERN_DEBUG "%02x %08llx %08x %08x(%02x) %08x %08x\n", i,
1607                                 (unsigned long long)(np->tx_ring_dma + i*sizeof(*np->tx_ring)),
1608                                 le32_to_cpu(np->tx_ring[i].next_desc),
1609                                 le32_to_cpu(np->tx_ring[i].status),
1610                                 (le32_to_cpu(np->tx_ring[i].status) >> 2)
1611                                         & 0xff,
1612                                 le32_to_cpu(np->tx_ring[i].frag[0].addr),
1613                                 le32_to_cpu(np->tx_ring[i].frag[0].length));
1614                 }
1615                 printk(KERN_DEBUG "TxListPtr=%08x netif_queue_stopped=%d\n",
1616                         ioread32(np->base + TxListPtr),
1617                         netif_queue_stopped(dev));
1618                 printk(KERN_DEBUG "cur_tx=%d(%02x) dirty_tx=%d(%02x)\n",
1619                         np->cur_tx, np->cur_tx % TX_RING_SIZE,
1620                         np->dirty_tx, np->dirty_tx % TX_RING_SIZE);
1621                 printk(KERN_DEBUG "cur_rx=%d dirty_rx=%d\n", np->cur_rx, np->dirty_rx);
1622                 printk(KERN_DEBUG "cur_task=%d\n", np->cur_task);
1623                 printk(KERN_DEBUG "TxStatus=%04x\n", ioread16(ioaddr + TxStatus));
1624                         return 0;
1625         }
1626
1627
1628         return rc;
1629 }
1630
1631 static int netdev_close(struct net_device *dev)
1632 {
1633         struct netdev_private *np = netdev_priv(dev);
1634         void __iomem *ioaddr = np->base;
1635         struct sk_buff *skb;
1636         int i;
1637
1638         /* Wait and kill tasklet */
1639         tasklet_kill(&np->rx_tasklet);
1640         tasklet_kill(&np->tx_tasklet);
1641         np->cur_tx = 0;
1642         np->dirty_tx = 0;
1643         np->cur_task = 0;
1644         np->last_tx = NULL;
1645
1646         netif_stop_queue(dev);
1647
1648         if (netif_msg_ifdown(np)) {
1649                 printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %2.2x "
1650                            "Rx %4.4x Int %2.2x.\n",
1651                            dev->name, ioread8(ioaddr + TxStatus),
1652                            ioread32(ioaddr + RxStatus), ioread16(ioaddr + IntrStatus));
1653                 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d,  Rx %d / %d.\n",
1654                            dev->name, np->cur_tx, np->dirty_tx, np->cur_rx, np->dirty_rx);
1655         }
1656
1657         /* Disable interrupts by clearing the interrupt mask. */
1658         iowrite16(0x0000, ioaddr + IntrEnable);
1659
1660         /* Disable Rx and Tx DMA for safely release resource */
1661         iowrite32(0x500, ioaddr + DMACtrl);
1662
1663         /* Stop the chip's Tx and Rx processes. */
1664         iowrite16(TxDisable | RxDisable | StatsDisable, ioaddr + MACCtrl1);
1665
1666         for (i = 2000; i > 0; i--) {
1667                 if ((ioread32(ioaddr + DMACtrl) & 0xc000) == 0)
1668                         break;
1669                 mdelay(1);
1670         }
1671
1672         iowrite16(GlobalReset | DMAReset | FIFOReset | NetworkReset,
1673                         ioaddr +ASICCtrl + 2);
1674
1675         for (i = 2000; i > 0; i--) {
1676                 if ((ioread16(ioaddr + ASICCtrl +2) & ResetBusy) == 0)
1677                         break;
1678                 mdelay(1);
1679         }
1680
1681 #ifdef __i386__
1682         if (netif_msg_hw(np)) {
1683                 printk("\n"KERN_DEBUG"  Tx ring at %8.8x:\n",
1684                            (int)(np->tx_ring_dma));
1685                 for (i = 0; i < TX_RING_SIZE; i++)
1686                         printk(" #%d desc. %4.4x %8.8x %8.8x.\n",
1687                                    i, np->tx_ring[i].status, np->tx_ring[i].frag[0].addr,
1688                                    np->tx_ring[i].frag[0].length);
1689                 printk("\n"KERN_DEBUG "  Rx ring %8.8x:\n",
1690                            (int)(np->rx_ring_dma));
1691                 for (i = 0; i < /*RX_RING_SIZE*/4 ; i++) {
1692                         printk(KERN_DEBUG " #%d desc. %4.4x %4.4x %8.8x\n",
1693                                    i, np->rx_ring[i].status, np->rx_ring[i].frag[0].addr,
1694                                    np->rx_ring[i].frag[0].length);
1695                 }
1696         }
1697 #endif /* __i386__ debugging only */
1698
1699         free_irq(dev->irq, dev);
1700
1701         del_timer_sync(&np->timer);
1702
1703         /* Free all the skbuffs in the Rx queue. */
1704         for (i = 0; i < RX_RING_SIZE; i++) {
1705                 np->rx_ring[i].status = 0;
1706                 np->rx_ring[i].frag[0].addr = 0xBADF00D0; /* An invalid address. */
1707                 skb = np->rx_skbuff[i];
1708                 if (skb) {
1709                         pci_unmap_single(np->pci_dev,
1710                                 np->rx_ring[i].frag[0].addr, np->rx_buf_sz,
1711                                 PCI_DMA_FROMDEVICE);
1712                         dev_kfree_skb(skb);
1713                         np->rx_skbuff[i] = NULL;
1714                 }
1715         }
1716         for (i = 0; i < TX_RING_SIZE; i++) {
1717                 np->tx_ring[i].next_desc = 0;
1718                 skb = np->tx_skbuff[i];
1719                 if (skb) {
1720                         pci_unmap_single(np->pci_dev,
1721                                 np->tx_ring[i].frag[0].addr, skb->len,
1722                                 PCI_DMA_TODEVICE);
1723                         dev_kfree_skb(skb);
1724                         np->tx_skbuff[i] = NULL;
1725                 }
1726         }
1727
1728         return 0;
1729 }
1730
1731 static void __devexit sundance_remove1 (struct pci_dev *pdev)
1732 {
1733         struct net_device *dev = pci_get_drvdata(pdev);
1734
1735         if (dev) {
1736                 struct netdev_private *np = netdev_priv(dev);
1737
1738                 unregister_netdev(dev);
1739                 pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring,
1740                         np->rx_ring_dma);
1741                 pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring,
1742                         np->tx_ring_dma);
1743                 pci_iounmap(pdev, np->base);
1744                 pci_release_regions(pdev);
1745                 free_netdev(dev);
1746                 pci_set_drvdata(pdev, NULL);
1747         }
1748 }
1749
1750 static struct pci_driver sundance_driver = {
1751         .name           = DRV_NAME,
1752         .id_table       = sundance_pci_tbl,
1753         .probe          = sundance_probe1,
1754         .remove         = __devexit_p(sundance_remove1),
1755 };
1756
1757 static int __init sundance_init(void)
1758 {
1759 /* when a module, this is printed whether or not devices are found in probe */
1760 #ifdef MODULE
1761         printk(version);
1762 #endif
1763         return pci_register_driver(&sundance_driver);
1764 }
1765
1766 static void __exit sundance_exit(void)
1767 {
1768         pci_unregister_driver(&sundance_driver);
1769 }
1770
1771 module_init(sundance_init);
1772 module_exit(sundance_exit);
1773
1774