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