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