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