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