net: convert print_mac to %pM
[linux-2.6.git] / drivers / net / 3c515.c
1 /*
2         Written 1997-1998 by Donald Becker.
3
4         This software may be used and distributed according to the terms
5         of the GNU General Public License, incorporated herein by reference.
6
7         This driver is for the 3Com ISA EtherLink XL "Corkscrew" 3c515 ethercard.
8
9         The author may be reached as becker@scyld.com, or C/O
10         Scyld Computing Corporation
11         410 Severn Ave., Suite 210
12         Annapolis MD 21403
13
14
15         2000/2/2- Added support for kernel-level ISAPnP
16                 by Stephen Frost <sfrost@snowman.net> and Alessandro Zummo
17         Cleaned up for 2.3.x/softnet by Jeff Garzik and Alan Cox.
18
19         2001/11/17 - Added ethtool support (jgarzik)
20
21         2002/10/28 - Locking updates for 2.5 (alan@lxorguk.ukuu.org.uk)
22
23 */
24
25 #define DRV_NAME                "3c515"
26 #define DRV_VERSION             "0.99t-ac"
27 #define DRV_RELDATE             "28-Oct-2002"
28
29 static char *version =
30 DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " becker@scyld.com and others\n";
31
32 #define CORKSCREW 1
33
34 /* "Knobs" that adjust features and parameters. */
35 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
36    Setting to > 1512 effectively disables this feature. */
37 static int rx_copybreak = 200;
38
39 /* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */
40 static const int mtu = 1500;
41
42 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
43 static int max_interrupt_work = 20;
44
45 /* Enable the automatic media selection code -- usually set. */
46 #define AUTOMEDIA 1
47
48 /* Allow the use of fragment bus master transfers instead of only
49    programmed-I/O for Vortex cards.  Full-bus-master transfers are always
50    enabled by default on Boomerang cards.  If VORTEX_BUS_MASTER is defined,
51    the feature may be turned on using 'options'. */
52 #define VORTEX_BUS_MASTER
53
54 /* A few values that may be tweaked. */
55 /* Keep the ring sizes a power of two for efficiency. */
56 #define TX_RING_SIZE    16
57 #define RX_RING_SIZE    16
58 #define PKT_BUF_SZ              1536    /* Size of each temporary Rx buffer. */
59
60 #include <linux/module.h>
61 #include <linux/isapnp.h>
62 #include <linux/kernel.h>
63 #include <linux/netdevice.h>
64 #include <linux/string.h>
65 #include <linux/errno.h>
66 #include <linux/in.h>
67 #include <linux/ioport.h>
68 #include <linux/slab.h>
69 #include <linux/skbuff.h>
70 #include <linux/etherdevice.h>
71 #include <linux/interrupt.h>
72 #include <linux/timer.h>
73 #include <linux/ethtool.h>
74 #include <linux/bitops.h>
75
76 #include <asm/uaccess.h>
77 #include <asm/io.h>
78 #include <asm/dma.h>
79
80 #define NEW_MULTICAST
81 #include <linux/delay.h>
82
83 #define MAX_UNITS 8
84
85 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
86 MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
87 MODULE_LICENSE("GPL");
88 MODULE_VERSION(DRV_VERSION);
89
90 /* "Knobs" for adjusting internal parameters. */
91 /* Put out somewhat more debugging messages. (0 - no msg, 1 minimal msgs). */
92 #define DRIVER_DEBUG 1
93 /* Some values here only for performance evaluation and path-coverage
94    debugging. */
95 static int rx_nocopy, rx_copy, queued_packet;
96
97 /* Number of times to check to see if the Tx FIFO has space, used in some
98    limited cases. */
99 #define WAIT_TX_AVAIL 200
100
101 /* Operational parameter that usually are not changed. */
102 #define TX_TIMEOUT  40          /* Time in jiffies before concluding Tx hung */
103
104 /* The size here is somewhat misleading: the Corkscrew also uses the ISA
105    aliased registers at <base>+0x400.
106    */
107 #define CORKSCREW_TOTAL_SIZE 0x20
108
109 #ifdef DRIVER_DEBUG
110 static int corkscrew_debug = DRIVER_DEBUG;
111 #else
112 static int corkscrew_debug = 1;
113 #endif
114
115 #define CORKSCREW_ID 10
116
117 /*
118                                 Theory of Operation
119
120 I. Board Compatibility
121
122 This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL,
123 3Com's ISA bus adapter for Fast Ethernet.  Due to the unique I/O port layout,
124 it's not practical to integrate this driver with the other EtherLink drivers.
125
126 II. Board-specific settings
127
128 The Corkscrew has an EEPROM for configuration, but no special settings are
129 needed for Linux.
130
131 III. Driver operation
132
133 The 3c515 series use an interface that's very similar to the 3c900 "Boomerang"
134 PCI cards, with the bus master interface extensively modified to work with
135 the ISA bus.
136
137 The card is capable of full-bus-master transfers with separate
138 lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
139 DEC Tulip and Intel Speedo3.
140
141 This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate
142 receive buffer.  This scheme allocates full-sized skbuffs as receive
143 buffers.  The value RX_COPYBREAK is used as the copying breakpoint: it is
144 chosen to trade-off the memory wasted by passing the full-sized skbuff to
145 the queue layer for all frames vs. the copying cost of copying a frame to a
146 correctly-sized skbuff.
147
148
149 IIIC. Synchronization
150 The driver runs as two independent, single-threaded flows of control.  One
151 is the send-packet routine, which enforces single-threaded use by the netif
152 layer.  The other thread is the interrupt handler, which is single
153 threaded by the hardware and other software.
154
155 IV. Notes
156
157 Thanks to Terry Murphy of 3Com for providing documentation and a development
158 board.
159
160 The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com
161 project names.  I use these names to eliminate confusion -- 3Com product
162 numbers and names are very similar and often confused.
163
164 The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes!
165 This driver only supports ethernet frames because of the recent MTU limit
166 of 1.5K, but the changes to support 4.5K are minimal.
167 */
168
169 /* Operational definitions.
170    These are not used by other compilation units and thus are not
171    exported in a ".h" file.
172
173    First the windows.  There are eight register windows, with the command
174    and status registers available in each.
175    */
176 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
177 #define EL3_CMD 0x0e
178 #define EL3_STATUS 0x0e
179
180 /* The top five bits written to EL3_CMD are a command, the lower
181    11 bits are the parameter, if applicable.
182    Note that 11 parameters bits was fine for ethernet, but the new chips
183    can handle FDDI length frames (~4500 octets) and now parameters count
184    32-bit 'Dwords' rather than octets. */
185
186 enum corkscrew_cmd {
187         TotalReset = 0 << 11, SelectWindow = 1 << 11, StartCoax = 2 << 11,
188         RxDisable = 3 << 11, RxEnable = 4 << 11, RxReset = 5 << 11,
189         UpStall = 6 << 11, UpUnstall = (6 << 11) + 1, DownStall = (6 << 11) + 2,
190         DownUnstall = (6 << 11) + 3, RxDiscard = 8 << 11, TxEnable = 9 << 11,
191         TxDisable = 10 << 11, TxReset = 11 << 11, FakeIntr = 12 << 11,
192         AckIntr = 13 << 11, SetIntrEnb = 14 << 11, SetStatusEnb = 15 << 11,
193         SetRxFilter = 16 << 11, SetRxThreshold = 17 << 11,
194         SetTxThreshold = 18 << 11, SetTxStart = 19 << 11, StartDMAUp = 20 << 11,
195         StartDMADown = (20 << 11) + 1, StatsEnable = 21 << 11,
196         StatsDisable = 22 << 11, StopCoax = 23 << 11,
197 };
198
199 /* The SetRxFilter command accepts the following classes: */
200 enum RxFilter {
201         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
202 };
203
204 /* Bits in the general status register. */
205 enum corkscrew_status {
206         IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
207         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
208         IntReq = 0x0040, StatsFull = 0x0080,
209         DMADone = 1 << 8, DownComplete = 1 << 9, UpComplete = 1 << 10,
210         DMAInProgress = 1 << 11,        /* DMA controller is still busy. */
211         CmdInProgress = 1 << 12,        /* EL3_CMD is still busy. */
212 };
213
214 /* Register window 1 offsets, the window used in normal operation.
215    On the Corkscrew this window is always mapped at offsets 0x10-0x1f. */
216 enum Window1 {
217         TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
218         RxStatus = 0x18, Timer = 0x1A, TxStatus = 0x1B,
219         TxFree = 0x1C,          /* Remaining free bytes in Tx buffer. */
220 };
221 enum Window0 {
222         Wn0IRQ = 0x08,
223 #if defined(CORKSCREW)
224         Wn0EepromCmd = 0x200A,  /* Corkscrew EEPROM command register. */
225         Wn0EepromData = 0x200C, /* Corkscrew EEPROM results register. */
226 #else
227         Wn0EepromCmd = 10,      /* Window 0: EEPROM command register. */
228         Wn0EepromData = 12,     /* Window 0: EEPROM results register. */
229 #endif
230 };
231 enum Win0_EEPROM_bits {
232         EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
233         EEPROM_EWENB = 0x30,    /* Enable erasing/writing for 10 msec. */
234         EEPROM_EWDIS = 0x00,    /* Disable EWENB before 10 msec timeout. */
235 };
236
237 /* EEPROM locations. */
238 enum eeprom_offset {
239         PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3,
240         EtherLink3ID = 7,
241 };
242
243 enum Window3 {                  /* Window 3: MAC/config bits. */
244         Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8,
245 };
246 enum wn3_config {
247         Ram_size = 7,
248         Ram_width = 8,
249         Ram_speed = 0x30,
250         Rom_size = 0xc0,
251         Ram_split_shift = 16,
252         Ram_split = 3 << Ram_split_shift,
253         Xcvr_shift = 20,
254         Xcvr = 7 << Xcvr_shift,
255         Autoselect = 0x1000000,
256 };
257
258 enum Window4 {
259         Wn4_NetDiag = 6, Wn4_Media = 10,        /* Window 4: Xcvr/media bits. */
260 };
261 enum Win4_Media_bits {
262         Media_SQE = 0x0008,     /* Enable SQE error counting for AUI. */
263         Media_10TP = 0x00C0,    /* Enable link beat and jabber for 10baseT. */
264         Media_Lnk = 0x0080,     /* Enable just link beat for 100TX/100FX. */
265         Media_LnkBeat = 0x0800,
266 };
267 enum Window7 {                  /* Window 7: Bus Master control. */
268         Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
269 };
270
271 /* Boomerang-style bus master control registers.  Note ISA aliases! */
272 enum MasterCtrl {
273         PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
274             0x40c,
275         TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
276 };
277
278 /* The Rx and Tx descriptor lists.
279    Caution Alpha hackers: these types are 32 bits!  Note also the 8 byte
280    alignment contraint on tx_ring[] and rx_ring[]. */
281 struct boom_rx_desc {
282         u32 next;
283         s32 status;
284         u32 addr;
285         s32 length;
286 };
287
288 /* Values for the Rx status entry. */
289 enum rx_desc_status {
290         RxDComplete = 0x00008000, RxDError = 0x4000,
291         /* See boomerang_rx() for actual error bits */
292 };
293
294 struct boom_tx_desc {
295         u32 next;
296         s32 status;
297         u32 addr;
298         s32 length;
299 };
300
301 struct corkscrew_private {
302         const char *product_name;
303         struct list_head list;
304         struct net_device *our_dev;
305         /* The Rx and Tx rings are here to keep them quad-word-aligned. */
306         struct boom_rx_desc rx_ring[RX_RING_SIZE];
307         struct boom_tx_desc tx_ring[TX_RING_SIZE];
308         /* The addresses of transmit- and receive-in-place skbuffs. */
309         struct sk_buff *rx_skbuff[RX_RING_SIZE];
310         struct sk_buff *tx_skbuff[TX_RING_SIZE];
311         unsigned int cur_rx, cur_tx;    /* The next free ring entry */
312         unsigned int dirty_rx, dirty_tx;/* The ring entries to be free()ed. */
313         struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl.  */
314         struct timer_list timer;        /* Media selection timer. */
315         int capabilities        ;       /* Adapter capabilities word. */
316         int options;                    /* User-settable misc. driver options. */
317         int last_rx_packets;            /* For media autoselection. */
318         unsigned int available_media:8, /* From Wn3_Options */
319                 media_override:3,       /* Passed-in media type. */
320                 default_media:3,        /* Read from the EEPROM. */
321                 full_duplex:1, autoselect:1, bus_master:1,      /* Vortex can only do a fragment bus-m. */
322                 full_bus_master_tx:1, full_bus_master_rx:1,     /* Boomerang  */
323                 tx_full:1;
324         spinlock_t lock;
325         struct device *dev;
326 };
327
328 /* The action to take with a media selection timer tick.
329    Note that we deviate from the 3Com order by checking 10base2 before AUI.
330  */
331 enum xcvr_types {
332         XCVR_10baseT = 0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
333         XCVR_100baseFx, XCVR_MII = 6, XCVR_Default = 8,
334 };
335
336 static struct media_table {
337         char *name;
338         unsigned int media_bits:16,     /* Bits to set in Wn4_Media register. */
339                 mask:8,                 /* The transceiver-present bit in Wn3_Config. */
340                 next:8;                 /* The media type to try next. */
341         short wait;                     /* Time before we check media status. */
342 } media_tbl[] = {
343         { "10baseT", Media_10TP, 0x08, XCVR_10base2, (14 * HZ) / 10 },
344         { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1 * HZ) / 10},
345         { "undefined", 0, 0x80, XCVR_10baseT, 10000},
346         { "10base2", 0, 0x10, XCVR_AUI, (1 * HZ) / 10},
347         { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14 * HZ) / 10},
348         { "100baseFX", Media_Lnk, 0x04, XCVR_MII, (14 * HZ) / 10},
349         { "MII", 0, 0x40, XCVR_10baseT, 3 * HZ},
350         { "undefined", 0, 0x01, XCVR_10baseT, 10000},
351         { "Default", 0, 0xFF, XCVR_10baseT, 10000},
352 };
353
354 #ifdef __ISAPNP__
355 static struct isapnp_device_id corkscrew_isapnp_adapters[] = {
356         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
357                 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5051),
358                 (long) "3Com Fast EtherLink ISA" },
359         { }     /* terminate list */
360 };
361
362 MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
363
364 static int nopnp;
365 #endif /* __ISAPNP__ */
366
367 static struct net_device *corkscrew_scan(int unit);
368 static int corkscrew_setup(struct net_device *dev, int ioaddr,
369                             struct pnp_dev *idev, int card_number);
370 static int corkscrew_open(struct net_device *dev);
371 static void corkscrew_timer(unsigned long arg);
372 static int corkscrew_start_xmit(struct sk_buff *skb,
373                                 struct net_device *dev);
374 static int corkscrew_rx(struct net_device *dev);
375 static void corkscrew_timeout(struct net_device *dev);
376 static int boomerang_rx(struct net_device *dev);
377 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id);
378 static int corkscrew_close(struct net_device *dev);
379 static void update_stats(int addr, struct net_device *dev);
380 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev);
381 static void set_rx_mode(struct net_device *dev);
382 static const struct ethtool_ops netdev_ethtool_ops;
383
384
385 /*
386    Unfortunately maximizing the shared code between the integrated and
387    module version of the driver results in a complicated set of initialization
388    procedures.
389    init_module() -- modules /  tc59x_init()  -- built-in
390                 The wrappers for corkscrew_scan()
391    corkscrew_scan()              The common routine that scans for PCI and EISA cards
392    corkscrew_found_device() Allocate a device structure when we find a card.
393                                         Different versions exist for modules and built-in.
394    corkscrew_probe1()           Fill in the device structure -- this is separated
395                                         so that the modules code can put it in dev->init.
396 */
397 /* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
398 /* Note: this is the only limit on the number of cards supported!! */
399 static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, };
400
401 #ifdef MODULE
402 static int debug = -1;
403
404 module_param(debug, int, 0);
405 module_param_array(options, int, NULL, 0);
406 module_param(rx_copybreak, int, 0);
407 module_param(max_interrupt_work, int, 0);
408 MODULE_PARM_DESC(debug, "3c515 debug level (0-6)");
409 MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering");
410 MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames");
411 MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt");
412
413 /* A list of all installed Vortex devices, for removing the driver module. */
414 /* we will need locking (and refcounting) if we ever use it for more */
415 static LIST_HEAD(root_corkscrew_dev);
416
417 int init_module(void)
418 {
419         int found = 0;
420         if (debug >= 0)
421                 corkscrew_debug = debug;
422         if (corkscrew_debug)
423                 printk(version);
424         while (corkscrew_scan(-1))
425                 found++;
426         return found ? 0 : -ENODEV;
427 }
428
429 #else
430 struct net_device *tc515_probe(int unit)
431 {
432         struct net_device *dev = corkscrew_scan(unit);
433         static int printed;
434
435         if (!dev)
436                 return ERR_PTR(-ENODEV);
437
438         if (corkscrew_debug > 0 && !printed) {
439                 printed = 1;
440                 printk(version);
441         }
442
443         return dev;
444 }
445 #endif                          /* not MODULE */
446
447 static int check_device(unsigned ioaddr)
448 {
449         int timer;
450
451         if (!request_region(ioaddr, CORKSCREW_TOTAL_SIZE, "3c515"))
452                 return 0;
453         /* Check the resource configuration for a matching ioaddr. */
454         if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0)) {
455                 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
456                 return 0;
457         }
458         /* Verify by reading the device ID from the EEPROM. */
459         outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd);
460         /* Pause for at least 162 us. for the read to take place. */
461         for (timer = 4; timer >= 0; timer--) {
462                 udelay(162);
463                 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
464                         break;
465         }
466         if (inw(ioaddr + Wn0EepromData) != 0x6d50) {
467                 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
468                 return 0;
469         }
470         return 1;
471 }
472
473 static void cleanup_card(struct net_device *dev)
474 {
475         struct corkscrew_private *vp = netdev_priv(dev);
476         list_del_init(&vp->list);
477         if (dev->dma)
478                 free_dma(dev->dma);
479         outw(TotalReset, dev->base_addr + EL3_CMD);
480         release_region(dev->base_addr, CORKSCREW_TOTAL_SIZE);
481         if (vp->dev)
482                 pnp_device_detach(to_pnp_dev(vp->dev));
483 }
484
485 static struct net_device *corkscrew_scan(int unit)
486 {
487         struct net_device *dev;
488         static int cards_found = 0;
489         static int ioaddr;
490         int err;
491 #ifdef __ISAPNP__
492         short i;
493         static int pnp_cards;
494 #endif
495
496         dev = alloc_etherdev(sizeof(struct corkscrew_private));
497         if (!dev)
498                 return ERR_PTR(-ENOMEM);
499
500         if (unit >= 0) {
501                 sprintf(dev->name, "eth%d", unit);
502                 netdev_boot_setup_check(dev);
503         }
504
505 #ifdef __ISAPNP__
506         if(nopnp == 1)
507                 goto no_pnp;
508         for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
509                 struct pnp_dev *idev = NULL;
510                 int irq;
511                 while((idev = pnp_find_dev(NULL,
512                                            corkscrew_isapnp_adapters[i].vendor,
513                                            corkscrew_isapnp_adapters[i].function,
514                                            idev))) {
515
516                         if (pnp_device_attach(idev) < 0)
517                                 continue;
518                         if (pnp_activate_dev(idev) < 0) {
519                                 printk("pnp activate failed (out of resources?)\n");
520                                 pnp_device_detach(idev);
521                                 continue;
522                         }
523                         if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
524                                 pnp_device_detach(idev);
525                                 continue;
526                         }
527                         ioaddr = pnp_port_start(idev, 0);
528                         irq = pnp_irq(idev, 0);
529                         if (!check_device(ioaddr)) {
530                                 pnp_device_detach(idev);
531                                 continue;
532                         }
533                         if(corkscrew_debug)
534                                 printk ("ISAPNP reports %s at i/o 0x%x, irq %d\n",
535                                         (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
536                         printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
537                                 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
538                         /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
539                         SET_NETDEV_DEV(dev, &idev->dev);
540                         pnp_cards++;
541                         err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
542                         if (!err)
543                                 return dev;
544                         cleanup_card(dev);
545                 }
546         }
547 no_pnp:
548 #endif /* __ISAPNP__ */
549
550         /* Check all locations on the ISA bus -- evil! */
551         for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
552                 if (!check_device(ioaddr))
553                         continue;
554
555                 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
556                      inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
557                 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
558                 if (!err)
559                         return dev;
560                 cleanup_card(dev);
561         }
562         free_netdev(dev);
563         return NULL;
564 }
565
566 static int corkscrew_setup(struct net_device *dev, int ioaddr,
567                             struct pnp_dev *idev, int card_number)
568 {
569         struct corkscrew_private *vp = netdev_priv(dev);
570         unsigned int eeprom[0x40], checksum = 0;        /* EEPROM contents */
571         int i;
572         int irq;
573
574 #ifdef __ISAPNP__
575         if (idev) {
576                 irq = pnp_irq(idev, 0);
577                 vp->dev = &idev->dev;
578         } else {
579                 irq = inw(ioaddr + 0x2002) & 15;
580         }
581 #else
582         irq = inw(ioaddr + 0x2002) & 15;
583 #endif
584
585         dev->base_addr = ioaddr;
586         dev->irq = irq;
587         dev->dma = inw(ioaddr + 0x2000) & 7;
588         vp->product_name = "3c515";
589         vp->options = dev->mem_start;
590         vp->our_dev = dev;
591
592         if (!vp->options) {
593                  if (card_number >= MAX_UNITS)
594                         vp->options = -1;
595                 else
596                         vp->options = options[card_number];
597         }
598
599         if (vp->options >= 0) {
600                 vp->media_override = vp->options & 7;
601                 if (vp->media_override == 2)
602                         vp->media_override = 0;
603                 vp->full_duplex = (vp->options & 8) ? 1 : 0;
604                 vp->bus_master = (vp->options & 16) ? 1 : 0;
605         } else {
606                 vp->media_override = 7;
607                 vp->full_duplex = 0;
608                 vp->bus_master = 0;
609         }
610 #ifdef MODULE
611         list_add(&vp->list, &root_corkscrew_dev);
612 #endif
613
614         printk(KERN_INFO "%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
615
616         spin_lock_init(&vp->lock);
617
618         /* Read the station address from the EEPROM. */
619         EL3WINDOW(0);
620         for (i = 0; i < 0x18; i++) {
621                 __be16 *phys_addr = (__be16 *) dev->dev_addr;
622                 int timer;
623                 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
624                 /* Pause for at least 162 us. for the read to take place. */
625                 for (timer = 4; timer >= 0; timer--) {
626                         udelay(162);
627                         if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
628                                 break;
629                 }
630                 eeprom[i] = inw(ioaddr + Wn0EepromData);
631                 checksum ^= eeprom[i];
632                 if (i < 3)
633                         phys_addr[i] = htons(eeprom[i]);
634         }
635         checksum = (checksum ^ (checksum >> 8)) & 0xff;
636         if (checksum != 0x00)
637                 printk(" ***INVALID CHECKSUM %4.4x*** ", checksum);
638         printk(" %pM", dev->dev_addr);
639         if (eeprom[16] == 0x11c7) {     /* Corkscrew */
640                 if (request_dma(dev->dma, "3c515")) {
641                         printk(", DMA %d allocation failed", dev->dma);
642                         dev->dma = 0;
643                 } else
644                         printk(", DMA %d", dev->dma);
645         }
646         printk(", IRQ %d\n", dev->irq);
647         /* Tell them about an invalid IRQ. */
648         if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
649                 printk(KERN_WARNING " *** Warning: this IRQ is unlikely to work! ***\n");
650
651         {
652                 char *ram_split[] = { "5:3", "3:1", "1:1", "3:5" };
653                 __u32 config;
654                 EL3WINDOW(3);
655                 vp->available_media = inw(ioaddr + Wn3_Options);
656                 config = inl(ioaddr + Wn3_Config);
657                 if (corkscrew_debug > 1)
658                         printk(KERN_INFO "  Internal config register is %4.4x, transceivers %#x.\n",
659                                 config, inw(ioaddr + Wn3_Options));
660                 printk(KERN_INFO "  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
661                         8 << config & Ram_size,
662                         config & Ram_width ? "word" : "byte",
663                         ram_split[(config & Ram_split) >> Ram_split_shift],
664                         config & Autoselect ? "autoselect/" : "",
665                         media_tbl[(config & Xcvr) >> Xcvr_shift].name);
666                 vp->default_media = (config & Xcvr) >> Xcvr_shift;
667                 vp->autoselect = config & Autoselect ? 1 : 0;
668                 dev->if_port = vp->default_media;
669         }
670         if (vp->media_override != 7) {
671                 printk(KERN_INFO "  Media override to transceiver type %d (%s).\n",
672                        vp->media_override,
673                        media_tbl[vp->media_override].name);
674                 dev->if_port = vp->media_override;
675         }
676
677         vp->capabilities = eeprom[16];
678         vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
679         /* Rx is broken at 10mbps, so we always disable it. */
680         /* vp->full_bus_master_rx = 0; */
681         vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
682
683         /* The 3c51x-specific entries in the device structure. */
684         dev->open = &corkscrew_open;
685         dev->hard_start_xmit = &corkscrew_start_xmit;
686         dev->tx_timeout = &corkscrew_timeout;
687         dev->watchdog_timeo = (400 * HZ) / 1000;
688         dev->stop = &corkscrew_close;
689         dev->get_stats = &corkscrew_get_stats;
690         dev->set_multicast_list = &set_rx_mode;
691         dev->ethtool_ops = &netdev_ethtool_ops;
692
693         return register_netdev(dev);
694 }
695
696
697 static int corkscrew_open(struct net_device *dev)
698 {
699         int ioaddr = dev->base_addr;
700         struct corkscrew_private *vp = netdev_priv(dev);
701         __u32 config;
702         int i;
703
704         /* Before initializing select the active media port. */
705         EL3WINDOW(3);
706         if (vp->full_duplex)
707                 outb(0x20, ioaddr + Wn3_MAC_Ctrl);      /* Set the full-duplex bit. */
708         config = inl(ioaddr + Wn3_Config);
709
710         if (vp->media_override != 7) {
711                 if (corkscrew_debug > 1)
712                         printk(KERN_INFO "%s: Media override to transceiver %d (%s).\n",
713                                 dev->name, vp->media_override,
714                                 media_tbl[vp->media_override].name);
715                 dev->if_port = vp->media_override;
716         } else if (vp->autoselect) {
717                 /* Find first available media type, starting with 100baseTx. */
718                 dev->if_port = 4;
719                 while (!(vp->available_media & media_tbl[dev->if_port].mask))
720                         dev->if_port = media_tbl[dev->if_port].next;
721
722                 if (corkscrew_debug > 1)
723                         printk("%s: Initial media type %s.\n",
724                                dev->name, media_tbl[dev->if_port].name);
725
726                 init_timer(&vp->timer);
727                 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
728                 vp->timer.data = (unsigned long) dev;
729                 vp->timer.function = &corkscrew_timer;  /* timer handler */
730                 add_timer(&vp->timer);
731         } else
732                 dev->if_port = vp->default_media;
733
734         config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
735         outl(config, ioaddr + Wn3_Config);
736
737         if (corkscrew_debug > 1) {
738                 printk("%s: corkscrew_open() InternalConfig %8.8x.\n",
739                        dev->name, config);
740         }
741
742         outw(TxReset, ioaddr + EL3_CMD);
743         for (i = 20; i >= 0; i--)
744                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
745                         break;
746
747         outw(RxReset, ioaddr + EL3_CMD);
748         /* Wait a few ticks for the RxReset command to complete. */
749         for (i = 20; i >= 0; i--)
750                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
751                         break;
752
753         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
754
755         /* Use the now-standard shared IRQ implementation. */
756         if (vp->capabilities == 0x11c7) {
757                 /* Corkscrew: Cannot share ISA resources. */
758                 if (dev->irq == 0
759                     || dev->dma == 0
760                     || request_irq(dev->irq, &corkscrew_interrupt, 0,
761                                    vp->product_name, dev)) return -EAGAIN;
762                 enable_dma(dev->dma);
763                 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
764         } else if (request_irq(dev->irq, &corkscrew_interrupt, IRQF_SHARED,
765                                vp->product_name, dev)) {
766                 return -EAGAIN;
767         }
768
769         if (corkscrew_debug > 1) {
770                 EL3WINDOW(4);
771                 printk("%s: corkscrew_open() irq %d media status %4.4x.\n",
772                        dev->name, dev->irq, inw(ioaddr + Wn4_Media));
773         }
774
775         /* Set the station address and mask in window 2 each time opened. */
776         EL3WINDOW(2);
777         for (i = 0; i < 6; i++)
778                 outb(dev->dev_addr[i], ioaddr + i);
779         for (; i < 12; i += 2)
780                 outw(0, ioaddr + i);
781
782         if (dev->if_port == 3)
783                 /* Start the thinnet transceiver. We should really wait 50ms... */
784                 outw(StartCoax, ioaddr + EL3_CMD);
785         EL3WINDOW(4);
786         outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
787              media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
788
789         /* Switch to the stats window, and clear all stats by reading. */
790         outw(StatsDisable, ioaddr + EL3_CMD);
791         EL3WINDOW(6);
792         for (i = 0; i < 10; i++)
793                 inb(ioaddr + i);
794         inw(ioaddr + 10);
795         inw(ioaddr + 12);
796         /* New: On the Vortex we must also clear the BadSSD counter. */
797         EL3WINDOW(4);
798         inb(ioaddr + 12);
799         /* ..and on the Boomerang we enable the extra statistics bits. */
800         outw(0x0040, ioaddr + Wn4_NetDiag);
801
802         /* Switch to register set 7 for normal use. */
803         EL3WINDOW(7);
804
805         if (vp->full_bus_master_rx) {   /* Boomerang bus master. */
806                 vp->cur_rx = vp->dirty_rx = 0;
807                 if (corkscrew_debug > 2)
808                         printk("%s:  Filling in the Rx ring.\n",
809                                dev->name);
810                 for (i = 0; i < RX_RING_SIZE; i++) {
811                         struct sk_buff *skb;
812                         if (i < (RX_RING_SIZE - 1))
813                                 vp->rx_ring[i].next =
814                                     isa_virt_to_bus(&vp->rx_ring[i + 1]);
815                         else
816                                 vp->rx_ring[i].next = 0;
817                         vp->rx_ring[i].status = 0;      /* Clear complete bit. */
818                         vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
819                         skb = dev_alloc_skb(PKT_BUF_SZ);
820                         vp->rx_skbuff[i] = skb;
821                         if (skb == NULL)
822                                 break;  /* Bad news!  */
823                         skb->dev = dev; /* Mark as being used by this device. */
824                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
825                         vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
826                 }
827                 vp->rx_ring[i - 1].next = isa_virt_to_bus(&vp->rx_ring[0]);     /* Wrap the ring. */
828                 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
829         }
830         if (vp->full_bus_master_tx) {   /* Boomerang bus master Tx. */
831                 vp->cur_tx = vp->dirty_tx = 0;
832                 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold);        /* Room for a packet. */
833                 /* Clear the Tx ring. */
834                 for (i = 0; i < TX_RING_SIZE; i++)
835                         vp->tx_skbuff[i] = NULL;
836                 outl(0, ioaddr + DownListPtr);
837         }
838         /* Set receiver mode: presumably accept b-case and phys addr only. */
839         set_rx_mode(dev);
840         outw(StatsEnable, ioaddr + EL3_CMD);    /* Turn on statistics. */
841
842         netif_start_queue(dev);
843
844         outw(RxEnable, ioaddr + EL3_CMD);       /* Enable the receiver. */
845         outw(TxEnable, ioaddr + EL3_CMD);       /* Enable transmitter. */
846         /* Allow status bits to be seen. */
847         outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
848              (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
849              (vp->full_bus_master_rx ? UpComplete : RxComplete) |
850              (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
851         /* Ack all pending events, and set active indicator mask. */
852         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
853              ioaddr + EL3_CMD);
854         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
855              | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
856              ioaddr + EL3_CMD);
857
858         return 0;
859 }
860
861 static void corkscrew_timer(unsigned long data)
862 {
863 #ifdef AUTOMEDIA
864         struct net_device *dev = (struct net_device *) data;
865         struct corkscrew_private *vp = netdev_priv(dev);
866         int ioaddr = dev->base_addr;
867         unsigned long flags;
868         int ok = 0;
869
870         if (corkscrew_debug > 1)
871                 printk("%s: Media selection timer tick happened, %s.\n",
872                        dev->name, media_tbl[dev->if_port].name);
873
874         spin_lock_irqsave(&vp->lock, flags);
875
876         {
877                 int old_window = inw(ioaddr + EL3_CMD) >> 13;
878                 int media_status;
879                 EL3WINDOW(4);
880                 media_status = inw(ioaddr + Wn4_Media);
881                 switch (dev->if_port) {
882                 case 0:
883                 case 4:
884                 case 5: /* 10baseT, 100baseTX, 100baseFX  */
885                         if (media_status & Media_LnkBeat) {
886                                 ok = 1;
887                                 if (corkscrew_debug > 1)
888                                         printk("%s: Media %s has link beat, %x.\n",
889                                                 dev->name,
890                                                 media_tbl[dev->if_port].name,
891                                                 media_status);
892                         } else if (corkscrew_debug > 1)
893                                 printk("%s: Media %s is has no link beat, %x.\n",
894                                         dev->name,
895                                         media_tbl[dev->if_port].name,
896                                         media_status);
897
898                         break;
899                 default:        /* Other media types handled by Tx timeouts. */
900                         if (corkscrew_debug > 1)
901                                 printk("%s: Media %s is has no indication, %x.\n",
902                                         dev->name,
903                                         media_tbl[dev->if_port].name,
904                                         media_status);
905                         ok = 1;
906                 }
907                 if (!ok) {
908                         __u32 config;
909
910                         do {
911                                 dev->if_port =
912                                     media_tbl[dev->if_port].next;
913                         }
914                         while (!(vp->available_media & media_tbl[dev->if_port].mask));
915
916                         if (dev->if_port == 8) {        /* Go back to default. */
917                                 dev->if_port = vp->default_media;
918                                 if (corkscrew_debug > 1)
919                                         printk("%s: Media selection failing, using default %s port.\n",
920                                                 dev->name,
921                                                 media_tbl[dev->if_port].name);
922                         } else {
923                                 if (corkscrew_debug > 1)
924                                         printk("%s: Media selection failed, now trying %s port.\n",
925                                                 dev->name,
926                                                 media_tbl[dev->if_port].name);
927                                 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
928                                 add_timer(&vp->timer);
929                         }
930                         outw((media_status & ~(Media_10TP | Media_SQE)) |
931                              media_tbl[dev->if_port].media_bits,
932                              ioaddr + Wn4_Media);
933
934                         EL3WINDOW(3);
935                         config = inl(ioaddr + Wn3_Config);
936                         config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
937                         outl(config, ioaddr + Wn3_Config);
938
939                         outw(dev->if_port == 3 ? StartCoax : StopCoax,
940                              ioaddr + EL3_CMD);
941                 }
942                 EL3WINDOW(old_window);
943         }
944
945         spin_unlock_irqrestore(&vp->lock, flags);
946         if (corkscrew_debug > 1)
947                 printk("%s: Media selection timer finished, %s.\n",
948                        dev->name, media_tbl[dev->if_port].name);
949
950 #endif                          /* AUTOMEDIA */
951         return;
952 }
953
954 static void corkscrew_timeout(struct net_device *dev)
955 {
956         int i;
957         struct corkscrew_private *vp = netdev_priv(dev);
958         int ioaddr = dev->base_addr;
959
960         printk(KERN_WARNING
961                "%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
962                dev->name, inb(ioaddr + TxStatus),
963                inw(ioaddr + EL3_STATUS));
964         /* Slight code bloat to be user friendly. */
965         if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
966                 printk(KERN_WARNING
967                        "%s: Transmitter encountered 16 collisions -- network"
968                        " network cable problem?\n", dev->name);
969 #ifndef final_version
970         printk("  Flags; bus-master %d, full %d; dirty %d current %d.\n",
971                vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
972                vp->cur_tx);
973         printk("  Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
974                &vp->tx_ring[0]);
975         for (i = 0; i < TX_RING_SIZE; i++) {
976                 printk("  %d: %p  length %8.8x status %8.8x\n", i,
977                        &vp->tx_ring[i],
978                        vp->tx_ring[i].length, vp->tx_ring[i].status);
979         }
980 #endif
981         /* Issue TX_RESET and TX_START commands. */
982         outw(TxReset, ioaddr + EL3_CMD);
983         for (i = 20; i >= 0; i--)
984                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
985                         break;
986         outw(TxEnable, ioaddr + EL3_CMD);
987         dev->trans_start = jiffies;
988         dev->stats.tx_errors++;
989         dev->stats.tx_dropped++;
990         netif_wake_queue(dev);
991 }
992
993 static int corkscrew_start_xmit(struct sk_buff *skb,
994                                 struct net_device *dev)
995 {
996         struct corkscrew_private *vp = netdev_priv(dev);
997         int ioaddr = dev->base_addr;
998
999         /* Block a timer-based transmit from overlapping. */
1000
1001         netif_stop_queue(dev);
1002
1003         if (vp->full_bus_master_tx) {   /* BOOMERANG bus-master */
1004                 /* Calculate the next Tx descriptor entry. */
1005                 int entry = vp->cur_tx % TX_RING_SIZE;
1006                 struct boom_tx_desc *prev_entry;
1007                 unsigned long flags;
1008                 int i;
1009
1010                 if (vp->tx_full)        /* No room to transmit with */
1011                         return 1;
1012                 if (vp->cur_tx != 0)
1013                         prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1014                 else
1015                         prev_entry = NULL;
1016                 if (corkscrew_debug > 3)
1017                         printk("%s: Trying to send a packet, Tx index %d.\n",
1018                                 dev->name, vp->cur_tx);
1019                 /* vp->tx_full = 1; */
1020                 vp->tx_skbuff[entry] = skb;
1021                 vp->tx_ring[entry].next = 0;
1022                 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1023                 vp->tx_ring[entry].length = skb->len | 0x80000000;
1024                 vp->tx_ring[entry].status = skb->len | 0x80000000;
1025
1026                 spin_lock_irqsave(&vp->lock, flags);
1027                 outw(DownStall, ioaddr + EL3_CMD);
1028                 /* Wait for the stall to complete. */
1029                 for (i = 20; i >= 0; i--)
1030                         if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1031                                 break;
1032                 if (prev_entry)
1033                         prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1034                 if (inl(ioaddr + DownListPtr) == 0) {
1035                         outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1036                              ioaddr + DownListPtr);
1037                         queued_packet++;
1038                 }
1039                 outw(DownUnstall, ioaddr + EL3_CMD);
1040                 spin_unlock_irqrestore(&vp->lock, flags);
1041
1042                 vp->cur_tx++;
1043                 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1044                         vp->tx_full = 1;
1045                 else {          /* Clear previous interrupt enable. */
1046                         if (prev_entry)
1047                                 prev_entry->status &= ~0x80000000;
1048                         netif_wake_queue(dev);
1049                 }
1050                 dev->trans_start = jiffies;
1051                 return 0;
1052         }
1053         /* Put out the doubleword header... */
1054         outl(skb->len, ioaddr + TX_FIFO);
1055         dev->stats.tx_bytes += skb->len;
1056 #ifdef VORTEX_BUS_MASTER
1057         if (vp->bus_master) {
1058                 /* Set the bus-master controller to transfer the packet. */
1059                 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1060                 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1061                 vp->tx_skb = skb;
1062                 outw(StartDMADown, ioaddr + EL3_CMD);
1063                 /* queue will be woken at the DMADone interrupt. */
1064         } else {
1065                 /* ... and the packet rounded to a doubleword. */
1066                 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1067                 dev_kfree_skb(skb);
1068                 if (inw(ioaddr + TxFree) > 1536) {
1069                         netif_wake_queue(dev);
1070                 } else
1071                         /* Interrupt us when the FIFO has room for max-sized packet. */
1072                         outw(SetTxThreshold + (1536 >> 2),
1073                              ioaddr + EL3_CMD);
1074         }
1075 #else
1076         /* ... and the packet rounded to a doubleword. */
1077         outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1078         dev_kfree_skb(skb);
1079         if (inw(ioaddr + TxFree) > 1536) {
1080                 netif_wake_queue(dev);
1081         } else
1082                 /* Interrupt us when the FIFO has room for max-sized packet. */
1083                 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1084 #endif                          /* bus master */
1085
1086         dev->trans_start = jiffies;
1087
1088         /* Clear the Tx status stack. */
1089         {
1090                 short tx_status;
1091                 int i = 4;
1092
1093                 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1094                         if (tx_status & 0x3C) { /* A Tx-disabling error occurred.  */
1095                                 if (corkscrew_debug > 2)
1096                                         printk("%s: Tx error, status %2.2x.\n",
1097                                                 dev->name, tx_status);
1098                                 if (tx_status & 0x04)
1099                                         dev->stats.tx_fifo_errors++;
1100                                 if (tx_status & 0x38)
1101                                         dev->stats.tx_aborted_errors++;
1102                                 if (tx_status & 0x30) {
1103                                         int j;
1104                                         outw(TxReset, ioaddr + EL3_CMD);
1105                                         for (j = 20; j >= 0; j--)
1106                                                 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1107                                                         break;
1108                                 }
1109                                 outw(TxEnable, ioaddr + EL3_CMD);
1110                         }
1111                         outb(0x00, ioaddr + TxStatus);  /* Pop the status stack. */
1112                 }
1113         }
1114         return 0;
1115 }
1116
1117 /* The interrupt handler does all of the Rx thread work and cleans up
1118    after the Tx thread. */
1119
1120 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
1121 {
1122         /* Use the now-standard shared IRQ implementation. */
1123         struct net_device *dev = dev_id;
1124         struct corkscrew_private *lp = netdev_priv(dev);
1125         int ioaddr, status;
1126         int latency;
1127         int i = max_interrupt_work;
1128
1129         ioaddr = dev->base_addr;
1130         latency = inb(ioaddr + Timer);
1131
1132         spin_lock(&lp->lock);
1133
1134         status = inw(ioaddr + EL3_STATUS);
1135
1136         if (corkscrew_debug > 4)
1137                 printk("%s: interrupt, status %4.4x, timer %d.\n",
1138                         dev->name, status, latency);
1139         if ((status & 0xE000) != 0xE000) {
1140                 static int donedidthis;
1141                 /* Some interrupt controllers store a bogus interrupt from boot-time.
1142                    Ignore a single early interrupt, but don't hang the machine for
1143                    other interrupt problems. */
1144                 if (donedidthis++ > 100) {
1145                         printk(KERN_ERR "%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1146                                    dev->name, status, netif_running(dev));
1147                         free_irq(dev->irq, dev);
1148                         dev->irq = -1;
1149                 }
1150         }
1151
1152         do {
1153                 if (corkscrew_debug > 5)
1154                         printk("%s: In interrupt loop, status %4.4x.\n",
1155                                dev->name, status);
1156                 if (status & RxComplete)
1157                         corkscrew_rx(dev);
1158
1159                 if (status & TxAvailable) {
1160                         if (corkscrew_debug > 5)
1161                                 printk("        TX room bit was handled.\n");
1162                         /* There's room in the FIFO for a full-sized packet. */
1163                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1164                         netif_wake_queue(dev);
1165                 }
1166                 if (status & DownComplete) {
1167                         unsigned int dirty_tx = lp->dirty_tx;
1168
1169                         while (lp->cur_tx - dirty_tx > 0) {
1170                                 int entry = dirty_tx % TX_RING_SIZE;
1171                                 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1172                                         break;  /* It still hasn't been processed. */
1173                                 if (lp->tx_skbuff[entry]) {
1174                                         dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1175                                         lp->tx_skbuff[entry] = NULL;
1176                                 }
1177                                 dirty_tx++;
1178                         }
1179                         lp->dirty_tx = dirty_tx;
1180                         outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1181                         if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1182                                 lp->tx_full = 0;
1183                                 netif_wake_queue(dev);
1184                         }
1185                 }
1186 #ifdef VORTEX_BUS_MASTER
1187                 if (status & DMADone) {
1188                         outw(0x1000, ioaddr + Wn7_MasterStatus);        /* Ack the event. */
1189                         dev_kfree_skb_irq(lp->tx_skb);  /* Release the transferred buffer */
1190                         netif_wake_queue(dev);
1191                 }
1192 #endif
1193                 if (status & UpComplete) {
1194                         boomerang_rx(dev);
1195                         outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1196                 }
1197                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1198                         /* Handle all uncommon interrupts at once. */
1199                         if (status & RxEarly) { /* Rx early is unused. */
1200                                 corkscrew_rx(dev);
1201                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1202                         }
1203                         if (status & StatsFull) {       /* Empty statistics. */
1204                                 static int DoneDidThat;
1205                                 if (corkscrew_debug > 4)
1206                                         printk("%s: Updating stats.\n", dev->name);
1207                                 update_stats(ioaddr, dev);
1208                                 /* DEBUG HACK: Disable statistics as an interrupt source. */
1209                                 /* This occurs when we have the wrong media type! */
1210                                 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1211                                         int win, reg;
1212                                         printk("%s: Updating stats failed, disabling stats as an"
1213                                              " interrupt source.\n", dev->name);
1214                                         for (win = 0; win < 8; win++) {
1215                                                 EL3WINDOW(win);
1216                                                 printk("\n Vortex window %d:", win);
1217                                                 for (reg = 0; reg < 16; reg++)
1218                                                         printk(" %2.2x", inb(ioaddr + reg));
1219                                         }
1220                                         EL3WINDOW(7);
1221                                         outw(SetIntrEnb | TxAvailable |
1222                                              RxComplete | AdapterFailure |
1223                                              UpComplete | DownComplete |
1224                                              TxComplete, ioaddr + EL3_CMD);
1225                                         DoneDidThat++;
1226                                 }
1227                         }
1228                         if (status & AdapterFailure) {
1229                                 /* Adapter failure requires Rx reset and reinit. */
1230                                 outw(RxReset, ioaddr + EL3_CMD);
1231                                 /* Set the Rx filter to the current state. */
1232                                 set_rx_mode(dev);
1233                                 outw(RxEnable, ioaddr + EL3_CMD);       /* Re-enable the receiver. */
1234                                 outw(AckIntr | AdapterFailure,
1235                                      ioaddr + EL3_CMD);
1236                         }
1237                 }
1238
1239                 if (--i < 0) {
1240                         printk(KERN_ERR "%s: Too much work in interrupt, status %4.4x.  "
1241                              "Disabling functions (%4.4x).\n", dev->name,
1242                              status, SetStatusEnb | ((~status) & 0x7FE));
1243                         /* Disable all pending interrupts. */
1244                         outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1245                         outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1246                         break;
1247                 }
1248                 /* Acknowledge the IRQ. */
1249                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1250
1251         } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1252
1253         spin_unlock(&lp->lock);
1254
1255         if (corkscrew_debug > 4)
1256                 printk("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1257         return IRQ_HANDLED;
1258 }
1259
1260 static int corkscrew_rx(struct net_device *dev)
1261 {
1262         int ioaddr = dev->base_addr;
1263         int i;
1264         short rx_status;
1265
1266         if (corkscrew_debug > 5)
1267                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1268                      inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1269         while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1270                 if (rx_status & 0x4000) {       /* Error, update stats. */
1271                         unsigned char rx_error = inb(ioaddr + RxErrors);
1272                         if (corkscrew_debug > 2)
1273                                 printk(" Rx error: status %2.2x.\n",
1274                                        rx_error);
1275                         dev->stats.rx_errors++;
1276                         if (rx_error & 0x01)
1277                                 dev->stats.rx_over_errors++;
1278                         if (rx_error & 0x02)
1279                                 dev->stats.rx_length_errors++;
1280                         if (rx_error & 0x04)
1281                                 dev->stats.rx_frame_errors++;
1282                         if (rx_error & 0x08)
1283                                 dev->stats.rx_crc_errors++;
1284                         if (rx_error & 0x10)
1285                                 dev->stats.rx_length_errors++;
1286                 } else {
1287                         /* The packet length: up to 4.5K!. */
1288                         short pkt_len = rx_status & 0x1fff;
1289                         struct sk_buff *skb;
1290
1291                         skb = dev_alloc_skb(pkt_len + 5 + 2);
1292                         if (corkscrew_debug > 4)
1293                                 printk("Receiving packet size %d status %4.4x.\n",
1294                                      pkt_len, rx_status);
1295                         if (skb != NULL) {
1296                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1297                                 /* 'skb_put()' points to the start of sk_buff data area. */
1298                                 insl(ioaddr + RX_FIFO,
1299                                      skb_put(skb, pkt_len),
1300                                      (pkt_len + 3) >> 2);
1301                                 outw(RxDiscard, ioaddr + EL3_CMD);      /* Pop top Rx packet. */
1302                                 skb->protocol = eth_type_trans(skb, dev);
1303                                 netif_rx(skb);
1304                                 dev->last_rx = jiffies;
1305                                 dev->stats.rx_packets++;
1306                                 dev->stats.rx_bytes += pkt_len;
1307                                 /* Wait a limited time to go to next packet. */
1308                                 for (i = 200; i >= 0; i--)
1309                                         if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1310                                                 break;
1311                                 continue;
1312                         } else if (corkscrew_debug)
1313                                 printk("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1314                 }
1315                 outw(RxDiscard, ioaddr + EL3_CMD);
1316                 dev->stats.rx_dropped++;
1317                 /* Wait a limited time to skip this packet. */
1318                 for (i = 200; i >= 0; i--)
1319                         if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1320                                 break;
1321         }
1322         return 0;
1323 }
1324
1325 static int boomerang_rx(struct net_device *dev)
1326 {
1327         struct corkscrew_private *vp = netdev_priv(dev);
1328         int entry = vp->cur_rx % RX_RING_SIZE;
1329         int ioaddr = dev->base_addr;
1330         int rx_status;
1331
1332         if (corkscrew_debug > 5)
1333                 printk("   In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1334                         inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1335         while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1336                 if (rx_status & RxDError) {     /* Error, update stats. */
1337                         unsigned char rx_error = rx_status >> 16;
1338                         if (corkscrew_debug > 2)
1339                                 printk(" Rx error: status %2.2x.\n",
1340                                        rx_error);
1341                         dev->stats.rx_errors++;
1342                         if (rx_error & 0x01)
1343                                 dev->stats.rx_over_errors++;
1344                         if (rx_error & 0x02)
1345                                 dev->stats.rx_length_errors++;
1346                         if (rx_error & 0x04)
1347                                 dev->stats.rx_frame_errors++;
1348                         if (rx_error & 0x08)
1349                                 dev->stats.rx_crc_errors++;
1350                         if (rx_error & 0x10)
1351                                 dev->stats.rx_length_errors++;
1352                 } else {
1353                         /* The packet length: up to 4.5K!. */
1354                         short pkt_len = rx_status & 0x1fff;
1355                         struct sk_buff *skb;
1356
1357                         dev->stats.rx_bytes += pkt_len;
1358                         if (corkscrew_debug > 4)
1359                                 printk("Receiving packet size %d status %4.4x.\n",
1360                                      pkt_len, rx_status);
1361
1362                         /* Check if the packet is long enough to just accept without
1363                            copying to a properly sized skbuff. */
1364                         if (pkt_len < rx_copybreak
1365                             && (skb = dev_alloc_skb(pkt_len + 4)) != NULL) {
1366                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1367                                 /* 'skb_put()' points to the start of sk_buff data area. */
1368                                 memcpy(skb_put(skb, pkt_len),
1369                                        isa_bus_to_virt(vp->rx_ring[entry].
1370                                                    addr), pkt_len);
1371                                 rx_copy++;
1372                         } else {
1373                                 void *temp;
1374                                 /* Pass up the skbuff already on the Rx ring. */
1375                                 skb = vp->rx_skbuff[entry];
1376                                 vp->rx_skbuff[entry] = NULL;
1377                                 temp = skb_put(skb, pkt_len);
1378                                 /* Remove this checking code for final release. */
1379                                 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1380                                             printk("%s: Warning -- the skbuff addresses do not match"
1381                                              " in boomerang_rx: %p vs. %p / %p.\n",
1382                                              dev->name,
1383                                              isa_bus_to_virt(vp->
1384                                                          rx_ring[entry].
1385                                                          addr), skb->head,
1386                                              temp);
1387                                 rx_nocopy++;
1388                         }
1389                         skb->protocol = eth_type_trans(skb, dev);
1390                         netif_rx(skb);
1391                         dev->last_rx = jiffies;
1392                         dev->stats.rx_packets++;
1393                 }
1394                 entry = (++vp->cur_rx) % RX_RING_SIZE;
1395         }
1396         /* Refill the Rx ring buffers. */
1397         for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1398                 struct sk_buff *skb;
1399                 entry = vp->dirty_rx % RX_RING_SIZE;
1400                 if (vp->rx_skbuff[entry] == NULL) {
1401                         skb = dev_alloc_skb(PKT_BUF_SZ);
1402                         if (skb == NULL)
1403                                 break;  /* Bad news!  */
1404                         skb->dev = dev; /* Mark as being used by this device. */
1405                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1406                         vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1407                         vp->rx_skbuff[entry] = skb;
1408                 }
1409                 vp->rx_ring[entry].status = 0;  /* Clear complete bit. */
1410         }
1411         return 0;
1412 }
1413
1414 static int corkscrew_close(struct net_device *dev)
1415 {
1416         struct corkscrew_private *vp = netdev_priv(dev);
1417         int ioaddr = dev->base_addr;
1418         int i;
1419
1420         netif_stop_queue(dev);
1421
1422         if (corkscrew_debug > 1) {
1423                 printk("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1424                      dev->name, inw(ioaddr + EL3_STATUS),
1425                      inb(ioaddr + TxStatus));
1426                 printk("%s: corkscrew close stats: rx_nocopy %d rx_copy %d"
1427                        " tx_queued %d.\n", dev->name, rx_nocopy, rx_copy,
1428                        queued_packet);
1429         }
1430
1431         del_timer(&vp->timer);
1432
1433         /* Turn off statistics ASAP.  We update lp->stats below. */
1434         outw(StatsDisable, ioaddr + EL3_CMD);
1435
1436         /* Disable the receiver and transmitter. */
1437         outw(RxDisable, ioaddr + EL3_CMD);
1438         outw(TxDisable, ioaddr + EL3_CMD);
1439
1440         if (dev->if_port == XCVR_10base2)
1441                 /* Turn off thinnet power.  Green! */
1442                 outw(StopCoax, ioaddr + EL3_CMD);
1443
1444         free_irq(dev->irq, dev);
1445
1446         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1447
1448         update_stats(ioaddr, dev);
1449         if (vp->full_bus_master_rx) {   /* Free Boomerang bus master Rx buffers. */
1450                 outl(0, ioaddr + UpListPtr);
1451                 for (i = 0; i < RX_RING_SIZE; i++)
1452                         if (vp->rx_skbuff[i]) {
1453                                 dev_kfree_skb(vp->rx_skbuff[i]);
1454                                 vp->rx_skbuff[i] = NULL;
1455                         }
1456         }
1457         if (vp->full_bus_master_tx) {   /* Free Boomerang bus master Tx buffers. */
1458                 outl(0, ioaddr + DownListPtr);
1459                 for (i = 0; i < TX_RING_SIZE; i++)
1460                         if (vp->tx_skbuff[i]) {
1461                                 dev_kfree_skb(vp->tx_skbuff[i]);
1462                                 vp->tx_skbuff[i] = NULL;
1463                         }
1464         }
1465
1466         return 0;
1467 }
1468
1469 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1470 {
1471         struct corkscrew_private *vp = netdev_priv(dev);
1472         unsigned long flags;
1473
1474         if (netif_running(dev)) {
1475                 spin_lock_irqsave(&vp->lock, flags);
1476                 update_stats(dev->base_addr, dev);
1477                 spin_unlock_irqrestore(&vp->lock, flags);
1478         }
1479         return &dev->stats;
1480 }
1481
1482 /*  Update statistics.
1483         Unlike with the EL3 we need not worry about interrupts changing
1484         the window setting from underneath us, but we must still guard
1485         against a race condition with a StatsUpdate interrupt updating the
1486         table.  This is done by checking that the ASM (!) code generated uses
1487         atomic updates with '+='.
1488         */
1489 static void update_stats(int ioaddr, struct net_device *dev)
1490 {
1491         /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1492         /* Switch to the stats window, and read everything. */
1493         EL3WINDOW(6);
1494         dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1495         dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1496         /* Multiple collisions. */ inb(ioaddr + 2);
1497         dev->stats.collisions += inb(ioaddr + 3);
1498         dev->stats.tx_window_errors += inb(ioaddr + 4);
1499         dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1500         dev->stats.tx_packets += inb(ioaddr + 6);
1501         dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1502                                                 /* Rx packets   */ inb(ioaddr + 7);
1503                                                 /* Must read to clear */
1504         /* Tx deferrals */ inb(ioaddr + 8);
1505         /* Don't bother with register 9, an extension of registers 6&7.
1506            If we do use the 6&7 values the atomic update assumption above
1507            is invalid. */
1508         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1509         inw(ioaddr + 12);
1510         /* New: On the Vortex we must also clear the BadSSD counter. */
1511         EL3WINDOW(4);
1512         inb(ioaddr + 12);
1513
1514         /* We change back to window 7 (not 1) with the Vortex. */
1515         EL3WINDOW(7);
1516         return;
1517 }
1518
1519 /* This new version of set_rx_mode() supports v1.4 kernels.
1520    The Vortex chip has no documented multicast filter, so the only
1521    multicast setting is to receive all multicast frames.  At least
1522    the chip has a very clean way to set the mode, unlike many others. */
1523 static void set_rx_mode(struct net_device *dev)
1524 {
1525         int ioaddr = dev->base_addr;
1526         short new_mode;
1527
1528         if (dev->flags & IFF_PROMISC) {
1529                 if (corkscrew_debug > 3)
1530                         printk("%s: Setting promiscuous mode.\n",
1531                                dev->name);
1532                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1533         } else if ((dev->mc_list) || (dev->flags & IFF_ALLMULTI)) {
1534                 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1535         } else
1536                 new_mode = SetRxFilter | RxStation | RxBroadcast;
1537
1538         outw(new_mode, ioaddr + EL3_CMD);
1539 }
1540
1541 static void netdev_get_drvinfo(struct net_device *dev,
1542                                struct ethtool_drvinfo *info)
1543 {
1544         strcpy(info->driver, DRV_NAME);
1545         strcpy(info->version, DRV_VERSION);
1546         sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1547 }
1548
1549 static u32 netdev_get_msglevel(struct net_device *dev)
1550 {
1551         return corkscrew_debug;
1552 }
1553
1554 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1555 {
1556         corkscrew_debug = level;
1557 }
1558
1559 static const struct ethtool_ops netdev_ethtool_ops = {
1560         .get_drvinfo            = netdev_get_drvinfo,
1561         .get_msglevel           = netdev_get_msglevel,
1562         .set_msglevel           = netdev_set_msglevel,
1563 };
1564
1565
1566 #ifdef MODULE
1567 void cleanup_module(void)
1568 {
1569         while (!list_empty(&root_corkscrew_dev)) {
1570                 struct net_device *dev;
1571                 struct corkscrew_private *vp;
1572
1573                 vp = list_entry(root_corkscrew_dev.next,
1574                                 struct corkscrew_private, list);
1575                 dev = vp->our_dev;
1576                 unregister_netdev(dev);
1577                 cleanup_card(dev);
1578                 free_netdev(dev);
1579         }
1580 }
1581 #endif                          /* MODULE */
1582
1583 /*
1584  * Local variables:
1585  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c 3c515.c"
1586  *  c-indent-level: 4
1587  *  tab-width: 4
1588  * End:
1589  */