Create platform_device.h to contain all the platform device details.
[linux-2.6.git] / 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         int phy, phy_idx = 0;
522
523
524 /* when built into the kernel, we only print version if device is found */
525 #ifndef MODULE
526         static int printed_version;
527         if (!printed_version++)
528                 printk(version);
529 #endif
530
531         if (pci_enable_device(pdev))
532                 return -EIO;
533         pci_set_master(pdev);
534
535         irq = pdev->irq;
536
537         dev = alloc_etherdev(sizeof(*np));
538         if (!dev)
539                 return -ENOMEM;
540         SET_MODULE_OWNER(dev);
541         SET_NETDEV_DEV(dev, &pdev->dev);
542
543         if (pci_request_regions(pdev, DRV_NAME))
544                 goto err_out_netdev;
545
546         ioaddr = pci_iomap(pdev, bar, netdev_io_size);
547         if (!ioaddr)
548                 goto err_out_res;
549
550         for (i = 0; i < 3; i++)
551                 ((u16 *)dev->dev_addr)[i] =
552                         le16_to_cpu(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET));
553         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
554
555         dev->base_addr = (unsigned long)ioaddr;
556         dev->irq = irq;
557
558         np = netdev_priv(dev);
559         np->base = ioaddr;
560         np->pci_dev = pdev;
561         np->chip_id = chip_idx;
562         np->msg_enable = (1 << debug) - 1;
563         spin_lock_init(&np->lock);
564         tasklet_init(&np->rx_tasklet, rx_poll, (unsigned long)dev);
565         tasklet_init(&np->tx_tasklet, tx_poll, (unsigned long)dev);
566
567         ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
568         if (!ring_space)
569                 goto err_out_cleardev;
570         np->tx_ring = (struct netdev_desc *)ring_space;
571         np->tx_ring_dma = ring_dma;
572
573         ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
574         if (!ring_space)
575                 goto err_out_unmap_tx;
576         np->rx_ring = (struct netdev_desc *)ring_space;
577         np->rx_ring_dma = ring_dma;
578
579         np->mii_if.dev = dev;
580         np->mii_if.mdio_read = mdio_read;
581         np->mii_if.mdio_write = mdio_write;
582         np->mii_if.phy_id_mask = 0x1f;
583         np->mii_if.reg_num_mask = 0x1f;
584
585         /* The chip-specific entries in the device structure. */
586         dev->open = &netdev_open;
587         dev->hard_start_xmit = &start_tx;
588         dev->stop = &netdev_close;
589         dev->get_stats = &get_stats;
590         dev->set_multicast_list = &set_rx_mode;
591         dev->do_ioctl = &netdev_ioctl;
592         SET_ETHTOOL_OPS(dev, &ethtool_ops);
593         dev->tx_timeout = &tx_timeout;
594         dev->watchdog_timeo = TX_TIMEOUT;
595         dev->change_mtu = &change_mtu;
596         pci_set_drvdata(pdev, dev);
597
598         pci_read_config_byte(pdev, PCI_REVISION_ID, &np->pci_rev_id);
599
600         i = register_netdev(dev);
601         if (i)
602                 goto err_out_unmap_rx;
603
604         printk(KERN_INFO "%s: %s at %p, ",
605                    dev->name, pci_id_tbl[chip_idx].name, ioaddr);
606         for (i = 0; i < 5; i++)
607                         printk("%2.2x:", dev->dev_addr[i]);
608         printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], irq);
609
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                 int phyx = phy & 0x1f;
615                 if (mii_status != 0xffff  &&  mii_status != 0x0000) {
616                         np->phys[phy_idx++] = phyx;
617                         np->mii_if.advertising = mdio_read(dev, phyx, MII_ADVERTISE);
618                         if ((mii_status & 0x0040) == 0)
619                                 np->mii_preamble_required++;
620                         printk(KERN_INFO "%s: MII PHY found at address %d, status "
621                                    "0x%4.4x advertising %4.4x.\n",
622                                    dev->name, phyx, mii_status, np->mii_if.advertising);
623                 }
624         }
625         np->mii_preamble_required--;
626
627         if (phy_idx == 0) {
628                 printk(KERN_INFO "%s: No MII transceiver found, aborting.  ASIC status %x\n",
629                            dev->name, ioread32(ioaddr + ASICCtrl));
630                 goto err_out_unregister;
631         }
632
633         np->mii_if.phy_id = np->phys[0];
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(0x00ff, 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->data, 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                                 if (tx_cnt < 0) {
1214                                         iowrite32(5000, ioaddr + DownCounter);
1215                                         break;
1216                                 }
1217                                 tx_status = ioread16 (ioaddr + TxStatus);
1218                         }
1219                         hw_frame_id = (tx_status >> 8) & 0xff;
1220                 } else  {
1221                         hw_frame_id = ioread8(ioaddr + TxFrameId);
1222                 }
1223                         
1224                 if (np->pci_rev_id >= 0x14) {   
1225                         spin_lock(&np->lock);
1226                         for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1227                                 int entry = np->dirty_tx % TX_RING_SIZE;
1228                                 struct sk_buff *skb;
1229                                 int sw_frame_id;
1230                                 sw_frame_id = (le32_to_cpu(
1231                                         np->tx_ring[entry].status) >> 2) & 0xff;
1232                                 if (sw_frame_id == hw_frame_id &&
1233                                         !(le32_to_cpu(np->tx_ring[entry].status)
1234                                         & 0x00010000))
1235                                                 break;
1236                                 if (sw_frame_id == (hw_frame_id + 1) % 
1237                                         TX_RING_SIZE)
1238                                                 break;
1239                                 skb = np->tx_skbuff[entry];
1240                                 /* Free the original skb. */
1241                                 pci_unmap_single(np->pci_dev,
1242                                         np->tx_ring[entry].frag[0].addr,
1243                                         skb->len, PCI_DMA_TODEVICE);
1244                                 dev_kfree_skb_irq (np->tx_skbuff[entry]);
1245                                 np->tx_skbuff[entry] = NULL;
1246                                 np->tx_ring[entry].frag[0].addr = 0;
1247                                 np->tx_ring[entry].frag[0].length = 0;
1248                         }
1249                         spin_unlock(&np->lock);
1250                 } else {
1251                         spin_lock(&np->lock);
1252                         for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1253                                 int entry = np->dirty_tx % TX_RING_SIZE;
1254                                 struct sk_buff *skb;
1255                                 if (!(le32_to_cpu(np->tx_ring[entry].status) 
1256                                                         & 0x00010000))
1257                                         break;
1258                                 skb = np->tx_skbuff[entry];
1259                                 /* Free the original skb. */
1260                                 pci_unmap_single(np->pci_dev,
1261                                         np->tx_ring[entry].frag[0].addr,
1262                                         skb->len, PCI_DMA_TODEVICE);
1263                                 dev_kfree_skb_irq (np->tx_skbuff[entry]);
1264                                 np->tx_skbuff[entry] = NULL;
1265                                 np->tx_ring[entry].frag[0].addr = 0;
1266                                 np->tx_ring[entry].frag[0].length = 0;
1267                         }
1268                         spin_unlock(&np->lock);
1269                 }
1270                 
1271                 if (netif_queue_stopped(dev) &&
1272                         np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) {
1273                         /* The ring is no longer full, clear busy flag. */
1274                         netif_wake_queue (dev);
1275                 }
1276                 /* Abnormal error summary/uncommon events handlers. */
1277                 if (intr_status & (IntrPCIErr | LinkChange | StatsMax))
1278                         netdev_error(dev, intr_status);
1279         } while (0);
1280         if (netif_msg_intr(np))
1281                 printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",
1282                            dev->name, ioread16(ioaddr + IntrStatus));
1283         return IRQ_RETVAL(handled);
1284 }
1285
1286 static void rx_poll(unsigned long data)
1287 {
1288         struct net_device *dev = (struct net_device *)data;
1289         struct netdev_private *np = netdev_priv(dev);
1290         int entry = np->cur_rx % RX_RING_SIZE;
1291         int boguscnt = np->budget;
1292         void __iomem *ioaddr = np->base;
1293         int received = 0;
1294
1295         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1296         while (1) {
1297                 struct netdev_desc *desc = &(np->rx_ring[entry]);
1298                 u32 frame_status = le32_to_cpu(desc->status);
1299                 int pkt_len;
1300
1301                 if (--boguscnt < 0) {
1302                         goto not_done;
1303                 }
1304                 if (!(frame_status & DescOwn))
1305                         break;
1306                 pkt_len = frame_status & 0x1fff;        /* Chip omits the CRC. */
1307                 if (netif_msg_rx_status(np))
1308                         printk(KERN_DEBUG "  netdev_rx() status was %8.8x.\n",
1309                                    frame_status);
1310                 if (frame_status & 0x001f4000) {
1311                         /* There was a error. */
1312                         if (netif_msg_rx_err(np))
1313                                 printk(KERN_DEBUG "  netdev_rx() Rx error was %8.8x.\n",
1314                                            frame_status);
1315                         np->stats.rx_errors++;
1316                         if (frame_status & 0x00100000) np->stats.rx_length_errors++;
1317                         if (frame_status & 0x00010000) np->stats.rx_fifo_errors++;
1318                         if (frame_status & 0x00060000) np->stats.rx_frame_errors++;
1319                         if (frame_status & 0x00080000) np->stats.rx_crc_errors++;
1320                         if (frame_status & 0x00100000) {
1321                                 printk(KERN_WARNING "%s: Oversized Ethernet frame,"
1322                                            " status %8.8x.\n",
1323                                            dev->name, frame_status);
1324                         }
1325                 } else {
1326                         struct sk_buff *skb;
1327 #ifndef final_version
1328                         if (netif_msg_rx_status(np))
1329                                 printk(KERN_DEBUG "  netdev_rx() normal Rx pkt length %d"
1330                                            ", bogus_cnt %d.\n",
1331                                            pkt_len, boguscnt);
1332 #endif
1333                         /* Check if the packet is long enough to accept without copying
1334                            to a minimally-sized skbuff. */
1335                         if (pkt_len < rx_copybreak
1336                                 && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1337                                 skb->dev = dev;
1338                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
1339                                 pci_dma_sync_single_for_cpu(np->pci_dev,
1340                                                             desc->frag[0].addr,
1341                                                             np->rx_buf_sz,
1342                                                             PCI_DMA_FROMDEVICE);
1343
1344                                 eth_copy_and_sum(skb, np->rx_skbuff[entry]->data, pkt_len, 0);
1345                                 pci_dma_sync_single_for_device(np->pci_dev,
1346                                                                desc->frag[0].addr,
1347                                                                np->rx_buf_sz,
1348                                                                PCI_DMA_FROMDEVICE);
1349                                 skb_put(skb, pkt_len);
1350                         } else {
1351                                 pci_unmap_single(np->pci_dev,
1352                                         desc->frag[0].addr,
1353                                         np->rx_buf_sz,
1354                                         PCI_DMA_FROMDEVICE);
1355                                 skb_put(skb = np->rx_skbuff[entry], pkt_len);
1356                                 np->rx_skbuff[entry] = NULL;
1357                         }
1358                         skb->protocol = eth_type_trans(skb, dev);
1359                         /* Note: checksum -> skb->ip_summed = CHECKSUM_UNNECESSARY; */
1360                         netif_rx(skb);
1361                         dev->last_rx = jiffies;
1362                 }
1363                 entry = (entry + 1) % RX_RING_SIZE;
1364                 received++;
1365         }
1366         np->cur_rx = entry;
1367         refill_rx (dev);
1368         np->budget -= received;
1369         iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
1370         return;
1371
1372 not_done:
1373         np->cur_rx = entry;
1374         refill_rx (dev);
1375         if (!received)
1376                 received = 1;
1377         np->budget -= received;
1378         if (np->budget <= 0)
1379                 np->budget = RX_BUDGET;
1380         tasklet_schedule(&np->rx_tasklet);
1381         return;
1382 }
1383
1384 static void refill_rx (struct net_device *dev)
1385 {
1386         struct netdev_private *np = netdev_priv(dev);
1387         int entry;
1388         int cnt = 0;
1389
1390         /* Refill the Rx ring buffers. */
1391         for (;(np->cur_rx - np->dirty_rx + RX_RING_SIZE) % RX_RING_SIZE > 0;
1392                 np->dirty_rx = (np->dirty_rx + 1) % RX_RING_SIZE) {
1393                 struct sk_buff *skb;
1394                 entry = np->dirty_rx % RX_RING_SIZE;
1395                 if (np->rx_skbuff[entry] == NULL) {
1396                         skb = dev_alloc_skb(np->rx_buf_sz);
1397                         np->rx_skbuff[entry] = skb;
1398                         if (skb == NULL)
1399                                 break;          /* Better luck next round. */
1400                         skb->dev = dev;         /* Mark as being used by this device. */
1401                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1402                         np->rx_ring[entry].frag[0].addr = cpu_to_le32(
1403                                 pci_map_single(np->pci_dev, skb->data,
1404                                         np->rx_buf_sz, PCI_DMA_FROMDEVICE));
1405                 }
1406                 /* Perhaps we need not reset this field. */
1407                 np->rx_ring[entry].frag[0].length =
1408                         cpu_to_le32(np->rx_buf_sz | LastFrag);
1409                 np->rx_ring[entry].status = 0;
1410                 cnt++;
1411         }
1412         return;
1413 }
1414 static void netdev_error(struct net_device *dev, int intr_status)
1415 {
1416         struct netdev_private *np = netdev_priv(dev);
1417         void __iomem *ioaddr = np->base;
1418         u16 mii_ctl, mii_advertise, mii_lpa;
1419         int speed;
1420
1421         if (intr_status & LinkChange) {
1422                 if (np->an_enable) {
1423                         mii_advertise = mdio_read (dev, np->phys[0], MII_ADVERTISE);
1424                         mii_lpa= mdio_read (dev, np->phys[0], MII_LPA);
1425                         mii_advertise &= mii_lpa;
1426                         printk (KERN_INFO "%s: Link changed: ", dev->name);
1427                         if (mii_advertise & ADVERTISE_100FULL) {
1428                                 np->speed = 100;
1429                                 printk ("100Mbps, full duplex\n");
1430                         } else if (mii_advertise & ADVERTISE_100HALF) {
1431                                 np->speed = 100;
1432                                 printk ("100Mbps, half duplex\n");
1433                         } else if (mii_advertise & ADVERTISE_10FULL) {
1434                                 np->speed = 10;
1435                                 printk ("10Mbps, full duplex\n");
1436                         } else if (mii_advertise & ADVERTISE_10HALF) {
1437                                 np->speed = 10;
1438                                 printk ("10Mbps, half duplex\n");
1439                         } else
1440                                 printk ("\n");
1441
1442                 } else {
1443                         mii_ctl = mdio_read (dev, np->phys[0], MII_BMCR);
1444                         speed = (mii_ctl & BMCR_SPEED100) ? 100 : 10;
1445                         np->speed = speed;
1446                         printk (KERN_INFO "%s: Link changed: %dMbps ,",
1447                                 dev->name, speed);
1448                         printk ("%s duplex.\n", (mii_ctl & BMCR_FULLDPLX) ?
1449                                 "full" : "half");
1450                 }
1451                 check_duplex (dev);
1452                 if (np->flowctrl && np->mii_if.full_duplex) {
1453                         iowrite16(ioread16(ioaddr + MulticastFilter1+2) | 0x0200,
1454                                 ioaddr + MulticastFilter1+2);
1455                         iowrite16(ioread16(ioaddr + MACCtrl0) | EnbFlowCtrl,
1456                                 ioaddr + MACCtrl0);
1457                 }
1458         }
1459         if (intr_status & StatsMax) {
1460                 get_stats(dev);
1461         }
1462         if (intr_status & IntrPCIErr) {
1463                 printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n",
1464                            dev->name, intr_status);
1465                 /* We must do a global reset of DMA to continue. */
1466         }
1467 }
1468
1469 static struct net_device_stats *get_stats(struct net_device *dev)
1470 {
1471         struct netdev_private *np = netdev_priv(dev);
1472         void __iomem *ioaddr = np->base;
1473         int i;
1474
1475         /* We should lock this segment of code for SMP eventually, although
1476            the vulnerability window is very small and statistics are
1477            non-critical. */
1478         /* The chip only need report frame silently dropped. */
1479         np->stats.rx_missed_errors      += ioread8(ioaddr + RxMissed);
1480         np->stats.tx_packets += ioread16(ioaddr + TxFramesOK);
1481         np->stats.rx_packets += ioread16(ioaddr + RxFramesOK);
1482         np->stats.collisions += ioread8(ioaddr + StatsLateColl);
1483         np->stats.collisions += ioread8(ioaddr + StatsMultiColl);
1484         np->stats.collisions += ioread8(ioaddr + StatsOneColl);
1485         np->stats.tx_carrier_errors += ioread8(ioaddr + StatsCarrierError);
1486         ioread8(ioaddr + StatsTxDefer);
1487         for (i = StatsTxDefer; i <= StatsMcastRx; i++)
1488                 ioread8(ioaddr + i);
1489         np->stats.tx_bytes += ioread16(ioaddr + TxOctetsLow);
1490         np->stats.tx_bytes += ioread16(ioaddr + TxOctetsHigh) << 16;
1491         np->stats.rx_bytes += ioread16(ioaddr + RxOctetsLow);
1492         np->stats.rx_bytes += ioread16(ioaddr + RxOctetsHigh) << 16;
1493
1494         return &np->stats;
1495 }
1496
1497 static void set_rx_mode(struct net_device *dev)
1498 {
1499         struct netdev_private *np = netdev_priv(dev);
1500         void __iomem *ioaddr = np->base;
1501         u16 mc_filter[4];                       /* Multicast hash filter */
1502         u32 rx_mode;
1503         int i;
1504
1505         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
1506                 /* Unconditionally log net taps. */
1507                 printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1508                 memset(mc_filter, 0xff, sizeof(mc_filter));
1509                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptAll | AcceptMyPhys;
1510         } else if ((dev->mc_count > multicast_filter_limit)
1511                            ||  (dev->flags & IFF_ALLMULTI)) {
1512                 /* Too many to match, or accept all multicasts. */
1513                 memset(mc_filter, 0xff, sizeof(mc_filter));
1514                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1515         } else if (dev->mc_count) {
1516                 struct dev_mc_list *mclist;
1517                 int bit;
1518                 int index;
1519                 int crc;
1520                 memset (mc_filter, 0, sizeof (mc_filter));
1521                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1522                      i++, mclist = mclist->next) {
1523                         crc = ether_crc_le (ETH_ALEN, mclist->dmi_addr);
1524                         for (index=0, bit=0; bit < 6; bit++, crc <<= 1)
1525                                 if (crc & 0x80000000) index |= 1 << bit;
1526                         mc_filter[index/16] |= (1 << (index % 16));
1527                 }
1528                 rx_mode = AcceptBroadcast | AcceptMultiHash | AcceptMyPhys;
1529         } else {
1530                 iowrite8(AcceptBroadcast | AcceptMyPhys, ioaddr + RxMode);
1531                 return;
1532         }
1533         if (np->mii_if.full_duplex && np->flowctrl)
1534                 mc_filter[3] |= 0x0200;
1535
1536         for (i = 0; i < 4; i++)
1537                 iowrite16(mc_filter[i], ioaddr + MulticastFilter0 + i*2);
1538         iowrite8(rx_mode, ioaddr + RxMode);
1539 }
1540
1541 static int __set_mac_addr(struct net_device *dev)
1542 {
1543         struct netdev_private *np = netdev_priv(dev);
1544         u16 addr16;
1545
1546         addr16 = (dev->dev_addr[0] | (dev->dev_addr[1] << 8));
1547         iowrite16(addr16, np->base + StationAddr);
1548         addr16 = (dev->dev_addr[2] | (dev->dev_addr[3] << 8));
1549         iowrite16(addr16, np->base + StationAddr+2);
1550         addr16 = (dev->dev_addr[4] | (dev->dev_addr[5] << 8));
1551         iowrite16(addr16, np->base + StationAddr+4);
1552         return 0;
1553 }
1554
1555 static int check_if_running(struct net_device *dev)
1556 {
1557         if (!netif_running(dev))
1558                 return -EINVAL;
1559         return 0;
1560 }
1561
1562 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1563 {
1564         struct netdev_private *np = netdev_priv(dev);
1565         strcpy(info->driver, DRV_NAME);
1566         strcpy(info->version, DRV_VERSION);
1567         strcpy(info->bus_info, pci_name(np->pci_dev));
1568 }
1569
1570 static int get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1571 {
1572         struct netdev_private *np = netdev_priv(dev);
1573         spin_lock_irq(&np->lock);
1574         mii_ethtool_gset(&np->mii_if, ecmd);
1575         spin_unlock_irq(&np->lock);
1576         return 0;
1577 }
1578
1579 static int set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1580 {
1581         struct netdev_private *np = netdev_priv(dev);
1582         int res;
1583         spin_lock_irq(&np->lock);
1584         res = mii_ethtool_sset(&np->mii_if, ecmd);
1585         spin_unlock_irq(&np->lock);
1586         return res;
1587 }
1588
1589 static int nway_reset(struct net_device *dev)
1590 {
1591         struct netdev_private *np = netdev_priv(dev);
1592         return mii_nway_restart(&np->mii_if);
1593 }
1594
1595 static u32 get_link(struct net_device *dev)
1596 {
1597         struct netdev_private *np = netdev_priv(dev);
1598         return mii_link_ok(&np->mii_if);
1599 }
1600
1601 static u32 get_msglevel(struct net_device *dev)
1602 {
1603         struct netdev_private *np = netdev_priv(dev);
1604         return np->msg_enable;
1605 }
1606
1607 static void set_msglevel(struct net_device *dev, u32 val)
1608 {
1609         struct netdev_private *np = netdev_priv(dev);
1610         np->msg_enable = val;
1611 }
1612
1613 static struct ethtool_ops ethtool_ops = {
1614         .begin = check_if_running,
1615         .get_drvinfo = get_drvinfo,
1616         .get_settings = get_settings,
1617         .set_settings = set_settings,
1618         .nway_reset = nway_reset,
1619         .get_link = get_link,
1620         .get_msglevel = get_msglevel,
1621         .set_msglevel = set_msglevel,
1622         .get_perm_addr = ethtool_op_get_perm_addr,
1623 };
1624
1625 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1626 {
1627         struct netdev_private *np = netdev_priv(dev);
1628         void __iomem *ioaddr = np->base;
1629         int rc;
1630         int i;
1631
1632         if (!netif_running(dev))
1633                 return -EINVAL;
1634
1635         spin_lock_irq(&np->lock);
1636         rc = generic_mii_ioctl(&np->mii_if, if_mii(rq), cmd, NULL);
1637         spin_unlock_irq(&np->lock);
1638         switch (cmd) {
1639                 case SIOCDEVPRIVATE:
1640                 for (i=0; i<TX_RING_SIZE; i++) {
1641                         printk(KERN_DEBUG "%02x %08llx %08x %08x(%02x) %08x %08x\n", i,
1642                                 (unsigned long long)(np->tx_ring_dma + i*sizeof(*np->tx_ring)), 
1643                                 le32_to_cpu(np->tx_ring[i].next_desc),
1644                                 le32_to_cpu(np->tx_ring[i].status),
1645                                 (le32_to_cpu(np->tx_ring[i].status) >> 2) 
1646                                         & 0xff,
1647                                 le32_to_cpu(np->tx_ring[i].frag[0].addr), 
1648                                 le32_to_cpu(np->tx_ring[i].frag[0].length));
1649                 }
1650                 printk(KERN_DEBUG "TxListPtr=%08x netif_queue_stopped=%d\n", 
1651                         ioread32(np->base + TxListPtr), 
1652                         netif_queue_stopped(dev));
1653                 printk(KERN_DEBUG "cur_tx=%d(%02x) dirty_tx=%d(%02x)\n", 
1654                         np->cur_tx, np->cur_tx % TX_RING_SIZE,
1655                         np->dirty_tx, np->dirty_tx % TX_RING_SIZE);
1656                 printk(KERN_DEBUG "cur_rx=%d dirty_rx=%d\n", np->cur_rx, np->dirty_rx);
1657                 printk(KERN_DEBUG "cur_task=%d\n", np->cur_task);
1658                 printk(KERN_DEBUG "TxStatus=%04x\n", ioread16(ioaddr + TxStatus));
1659                         return 0;
1660         }
1661                                 
1662
1663         return rc;
1664 }
1665
1666 static int netdev_close(struct net_device *dev)
1667 {
1668         struct netdev_private *np = netdev_priv(dev);
1669         void __iomem *ioaddr = np->base;
1670         struct sk_buff *skb;
1671         int i;
1672
1673         netif_stop_queue(dev);
1674
1675         if (netif_msg_ifdown(np)) {
1676                 printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %2.2x "
1677                            "Rx %4.4x Int %2.2x.\n",
1678                            dev->name, ioread8(ioaddr + TxStatus),
1679                            ioread32(ioaddr + RxStatus), ioread16(ioaddr + IntrStatus));
1680                 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d,  Rx %d / %d.\n",
1681                            dev->name, np->cur_tx, np->dirty_tx, np->cur_rx, np->dirty_rx);
1682         }
1683
1684         /* Disable interrupts by clearing the interrupt mask. */
1685         iowrite16(0x0000, ioaddr + IntrEnable);
1686
1687         /* Stop the chip's Tx and Rx processes. */
1688         iowrite16(TxDisable | RxDisable | StatsDisable, ioaddr + MACCtrl1);
1689
1690         /* Wait and kill tasklet */
1691         tasklet_kill(&np->rx_tasklet);
1692         tasklet_kill(&np->tx_tasklet);
1693
1694 #ifdef __i386__
1695         if (netif_msg_hw(np)) {
1696                 printk("\n"KERN_DEBUG"  Tx ring at %8.8x:\n",
1697                            (int)(np->tx_ring_dma));
1698                 for (i = 0; i < TX_RING_SIZE; i++)
1699                         printk(" #%d desc. %4.4x %8.8x %8.8x.\n",
1700                                    i, np->tx_ring[i].status, np->tx_ring[i].frag[0].addr,
1701                                    np->tx_ring[i].frag[0].length);
1702                 printk("\n"KERN_DEBUG "  Rx ring %8.8x:\n",
1703                            (int)(np->rx_ring_dma));
1704                 for (i = 0; i < /*RX_RING_SIZE*/4 ; i++) {
1705                         printk(KERN_DEBUG " #%d desc. %4.4x %4.4x %8.8x\n",
1706                                    i, np->rx_ring[i].status, np->rx_ring[i].frag[0].addr,
1707                                    np->rx_ring[i].frag[0].length);
1708                 }
1709         }
1710 #endif /* __i386__ debugging only */
1711
1712         free_irq(dev->irq, dev);
1713
1714         del_timer_sync(&np->timer);
1715
1716         /* Free all the skbuffs in the Rx queue. */
1717         for (i = 0; i < RX_RING_SIZE; i++) {
1718                 np->rx_ring[i].status = 0;
1719                 np->rx_ring[i].frag[0].addr = 0xBADF00D0; /* An invalid address. */
1720                 skb = np->rx_skbuff[i];
1721                 if (skb) {
1722                         pci_unmap_single(np->pci_dev,
1723                                 np->rx_ring[i].frag[0].addr, np->rx_buf_sz,
1724                                 PCI_DMA_FROMDEVICE);
1725                         dev_kfree_skb(skb);
1726                         np->rx_skbuff[i] = NULL;
1727                 }
1728         }
1729         for (i = 0; i < TX_RING_SIZE; i++) {
1730                 skb = np->tx_skbuff[i];
1731                 if (skb) {
1732                         pci_unmap_single(np->pci_dev,
1733                                 np->tx_ring[i].frag[0].addr, skb->len,
1734                                 PCI_DMA_TODEVICE);
1735                         dev_kfree_skb(skb);
1736                         np->tx_skbuff[i] = NULL;
1737                 }
1738         }
1739
1740         return 0;
1741 }
1742
1743 static void __devexit sundance_remove1 (struct pci_dev *pdev)
1744 {
1745         struct net_device *dev = pci_get_drvdata(pdev);
1746
1747         if (dev) {
1748                 struct netdev_private *np = netdev_priv(dev);
1749
1750                 unregister_netdev(dev);
1751                 pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring,
1752                         np->rx_ring_dma);
1753                 pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring,
1754                         np->tx_ring_dma);
1755                 pci_iounmap(pdev, np->base);
1756                 pci_release_regions(pdev);
1757                 free_netdev(dev);
1758                 pci_set_drvdata(pdev, NULL);
1759         }
1760 }
1761
1762 static struct pci_driver sundance_driver = {
1763         .name           = DRV_NAME,
1764         .id_table       = sundance_pci_tbl,
1765         .probe          = sundance_probe1,
1766         .remove         = __devexit_p(sundance_remove1),
1767 };
1768
1769 static int __init sundance_init(void)
1770 {
1771 /* when a module, this is printed whether or not devices are found in probe */
1772 #ifdef MODULE
1773         printk(version);
1774 #endif
1775         return pci_module_init(&sundance_driver);
1776 }
1777
1778 static void __exit sundance_exit(void)
1779 {
1780         pci_unregister_driver(&sundance_driver);
1781 }
1782
1783 module_init(sundance_init);
1784 module_exit(sundance_exit);
1785
1786