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
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
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(error: -ENODEV);
430
431	return dev;
432	}
433	#endif /* not MODULE */
434
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(port: 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(value: EEPROM_Read + 7, port: 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(port: ioaddr + Wn0EepromCmd) & 0x0200) == 0)
452	break;
453	}
454	if (inw(port: ioaddr + Wn0EepromData) != 0x6d50) {
455	release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
456	return 0;
457	}
458	return 1;
459	}
460
461	static void cleanup_card(struct net_device *dev)
462	{
463	struct corkscrew_private *vp = netdev_priv(dev);
464	list_del_init(entry: &vp->list);
465	if (dev->dma)
466	free_dma(dmanr: dev->dma);
467	outw(value: TotalReset, port: 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
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(error: -ENOMEM);
487
488	if (unit >= 0) {
489	sprintf(buf: dev->name, fmt: "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	vendor: corkscrew_isapnp_adapters[i].vendor,
501	function: corkscrew_isapnp_adapters[i].function,
502	from: idev))) {
503
504	if (pnp_device_attach(pnp_dev: idev) < 0)
505	continue;
506	if (pnp_activate_dev(dev: idev) < 0) {
507	pr_warn("pnp activate failed (out of resources?)\n");
508	pnp_device_detach(pnp_dev: idev);
509	continue;
510	}
511	if (!pnp_port_valid(dev: idev, bar: 0) || !pnp_irq_valid(dev: idev, bar: 0)) {
512	pnp_device_detach(pnp_dev: idev);
513	continue;
514	}
515	ioaddr = pnp_port_start(dev: idev, bar: 0);
516	irq = pnp_irq(dev: idev, bar: 0);
517	if (!check_device(ioaddr)) {
518	pnp_device_detach(pnp_dev: 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, card_number: 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, card_number: 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
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(dev: idev, bar: 0);
579	vp->dev = &idev->dev;
580	} else {
581	irq = inw(port: 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(port: 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(value: EEPROM_Read + i, port: 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(port: ioaddr + Wn0EepromCmd) & 0x0200) == 0)
631	break;
632	}
633	eeprom[i] = inw(port: ioaddr + Wn0EepromData);
634	checksum ^= eeprom[i];
635	if (i < 3)
636	addr[i] = htons(eeprom[i]);
637	}
638	eth_hw_addr_set(dev, addr: (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(dmanr: dev->dma, device_id: "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(port: ioaddr + Wn3_Options);
662	config = inl(port: 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
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(value: 0x20, port: ioaddr + Wn3_MAC_Ctrl); /* Set the full-duplex bit. */
710	config = inl(port: 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(value: config, port: 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(value: TxReset, port: ioaddr + EL3_CMD);
740	for (i = 20; i >= 0; i--)
741	if (!(inw(port: ioaddr + EL3_STATUS) & CmdInProgress))
742	break;
743
744	outw(value: RxReset, port: ioaddr + EL3_CMD);
745	/* Wait a few ticks for the RxReset command to complete. */
746	for (i = 20; i >= 0; i--)
747	if (!(inw(port: ioaddr + EL3_STATUS) & CmdInProgress))
748	break;
749
750	outw(value: SetStatusEnb | 0x00, port: 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(irq: dev->irq, handler: corkscrew_interrupt, flags: 0,
758	name: vp->product_name, dev))
759	return -EAGAIN;
760	enable_dma(dmanr: dev->dma);
761	set_dma_mode(dmanr: dev->dma, DMA_MODE_CASCADE);
762	} else if (request_irq(irq: dev->irq, handler: corkscrew_interrupt, IRQF_SHARED,
763	name: vp->product_name, dev)) {
764	return -EAGAIN;
765	}
766
767	if (armtimer)
768	mod_timer(timer: &vp->timer, expires: 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(value: dev->dev_addr[i], port: ioaddr + i);
780	for (; i < 12; i += 2)
781	outw(value: 0, port: ioaddr + i);
782
783	if (dev->if_port == 3)
784	/* Start the thinnet transceiver. We should really wait 50ms... */
785	outw(value: StartCoax, port: ioaddr + EL3_CMD);
786	EL3WINDOW(4);
787	outw(value: (inw(port: ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
788	media_tbl[dev->if_port].media_bits, port: ioaddr + Wn4_Media);
789
790	/* Switch to the stats window, and clear all stats by reading. */
791	outw(value: StatsDisable, port: ioaddr + EL3_CMD);
792	EL3WINDOW(6);
793	for (i = 0; i < 10; i++)
794	inb(port: ioaddr + i);
795	inw(port: ioaddr + 10);
796	inw(port: ioaddr + 12);
797	/* New: On the Vortex we must also clear the BadSSD counter. */
798	EL3WINDOW(4);
799	inb(port: ioaddr + 12);
800	/* ..and on the Boomerang we enable the extra statistics bits. */
801	outw(value: 0x0040, port: 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(address: &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, len: 2); /* Align IP on 16 byte boundaries */
824	vp->rx_ring[i].addr = isa_virt_to_bus(address: skb->data);
825	}
826	if (i != 0)
827	vp->rx_ring[i - 1].next =
828	isa_virt_to_bus(address: &vp->rx_ring[0]); /* Wrap the ring. */
829	outl(value: isa_virt_to_bus(address: &vp->rx_ring[0]), port: 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, port: 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(value: 0, port: ioaddr + DownListPtr);
838	}
839	/* Set receiver mode: presumably accept b-case and phys addr only. */
840	set_rx_mode(dev);
841	outw(value: StatsEnable, port: ioaddr + EL3_CMD); /* Turn on statistics. */
842
843	netif_start_queue(dev);
844
845	outw(value: RxEnable, port: ioaddr + EL3_CMD); /* Enable the receiver. */
846	outw(value: TxEnable, port: ioaddr + EL3_CMD); /* Enable transmitter. */
847	/* Allow status bits to be seen. */
848	outw(value: 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), port: ioaddr + EL3_CMD);
852	/* Ack all pending events, and set active indicator mask. */
853	outw(value: AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
854	port: ioaddr + EL3_CMD);
855	outw(value: SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
856	| (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
857	port: ioaddr + EL3_CMD);
858
859	return 0;
860	}
861
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(port: ioaddr + EL3_CMD) >> 13;
879	int media_status;
880	EL3WINDOW(4);
881	media_status = inw(port: 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(timer: &vp->timer);
930	}
931	outw(value: (media_status & ~(Media_10TP | Media_SQE)) |
932	media_tbl[dev->if_port].media_bits,
933	port: ioaddr + Wn4_Media);
934
935	EL3WINDOW(3);
936	config = inl(port: ioaddr + Wn3_Config);
937	config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
938	outl(value: config, port: ioaddr + Wn3_Config);
939
940	outw(value: dev->if_port == 3 ? StartCoax : StopCoax,
941	port: ioaddr + EL3_CMD);
942	}
943	EL3WINDOW(old_window);
944	}
945
946	spin_unlock_irqrestore(lock: &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
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(port: 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(value: TxReset, port: ioaddr + EL3_CMD);
981	for (i = 20; i >= 0; i--)
982	if (!(inw(port: ioaddr + EL3_STATUS) & CmdInProgress))
983	break;
984	outw(value: TxEnable, port: 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
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(address: 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(value: DownStall, port: ioaddr + EL3_CMD);
1026	/* Wait for the stall to complete. */
1027	for (i = 20; i >= 0; i--)
1028	if ((inw(port: ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1029	break;
1030	if (prev_entry)
1031	prev_entry->next = isa_virt_to_bus(address: &vp->tx_ring[entry]);
1032	if (inl(port: ioaddr + DownListPtr) == 0) {
1033	outl(value: isa_virt_to_bus(address: &vp->tx_ring[entry]),
1034	port: ioaddr + DownListPtr);
1035	queued_packet++;
1036	}
1037	outw(value: DownUnstall, port: ioaddr + EL3_CMD);
1038	spin_unlock_irqrestore(lock: &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(value: skb->len, port: 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(value: isa_virt_to_bus(address: skb->data), port: ioaddr + Wn7_MasterAddr);
1057	outw(value: (skb->len + 3) & ~3, port: ioaddr + Wn7_MasterLen);
1058	vp->tx_skb = skb;
1059	outw(value: StartDMADown, port: ioaddr + EL3_CMD);
1060	/* queue will be woken at the DMADone interrupt. */
1061	} else {
1062	/* ... and the packet rounded to a doubleword. */
1063	outsl(port: ioaddr + TX_FIFO, addr: skb->data, count: (skb->len + 3) >> 2);
1064	dev_kfree_skb(skb);
1065	if (inw(port: ioaddr + TxFree) > 1536) {
1066	netif_wake_queue(dev);
1067	} else
1068	/* Interrupt us when the FIFO has room for max-sized packet. */
1069	outw(value: SetTxThreshold + (1536 >> 2),
1070	port: 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(port: 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(value: TxReset, port: ioaddr + EL3_CMD);
1101	for (j = 20; j >= 0; j--)
1102	if (!(inw(port: ioaddr + EL3_STATUS) & CmdInProgress))
1103	break;
1104	}
1105	outw(value: TxEnable, port: ioaddr + EL3_CMD);
1106	}
1107	outb(value: 0x00, port: 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
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(port: ioaddr + Timer);
1127
1128	spin_lock(lock: &lp->lock);
1129
1130	status = inw(port: 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(value: AckIntr | TxAvailable, port: 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(port: ioaddr + DownListPtr) == isa_virt_to_bus(address: &lp->tx_ring[entry]))
1168	break; /* It still hasn't been processed. */
1169	if (lp->tx_skbuff[entry]) {
1170	dev_consume_skb_irq(skb: lp->tx_skbuff[entry]);
1171	lp->tx_skbuff[entry] = NULL;
1172	}
1173	dirty_tx++;
1174	}
1175	lp->dirty_tx = dirty_tx;
1176	outw(value: AckIntr | DownComplete, port: 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(value: 0x1000, port: ioaddr + Wn7_MasterStatus); /* Ack the event. */
1185	dev_consume_skb_irq(skb: 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(value: AckIntr | UpComplete, port: 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(value: AckIntr | RxEarly, port: 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(addr: 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(port: 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(value: SetIntrEnb | TxAvailable |
1219	RxComplete | AdapterFailure |
1220	UpComplete | DownComplete |
1221	TxComplete, port: ioaddr + EL3_CMD);
1222	DoneDidThat++;
1223	}
1224	}
1225	if (status & AdapterFailure) {
1226	/* Adapter failure requires Rx reset and reinit. */
1227	outw(value: RxReset, port: ioaddr + EL3_CMD);
1228	/* Set the Rx filter to the current state. */
1229	set_rx_mode(dev);
1230	outw(value: RxEnable, port: ioaddr + EL3_CMD); /* Re-enable the receiver. */
1231	outw(value: AckIntr | AdapterFailure,
1232	port: 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(value: SetStatusEnb | ((~status) & 0x7FE), port: ioaddr + EL3_CMD);
1241	outw(value: AckIntr | 0x7FF, port: ioaddr + EL3_CMD);
1242	break;
1243	}
1244	/* Acknowledge the IRQ. */
1245	outw(value: AckIntr | IntReq | IntLatch, port: ioaddr + EL3_CMD);
1246
1247	} while ((status = inw(port: ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1248
1249	spin_unlock(lock: &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
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(port: ioaddr + RxStatus)) > 0) {
1266	if (rx_status & 0x4000) { /* Error, update stats. */
1267	unsigned char rx_error = inb(port: 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, length: 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, len: 2); /* Align IP on 16 byte boundaries */
1293	/* 'skb_put()' points to the start of sk_buff data area. */
1294	insl(port: ioaddr + RX_FIFO,
1295	addr: skb_put(skb, len: pkt_len),
1296	count: (pkt_len + 3) >> 2);
1297	outw(value: RxDiscard, port: 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(port: 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(value: RxDiscard, port: 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(port: ioaddr + EL3_STATUS) & CmdInProgress))
1315	break;
1316	}
1317	return 0;
1318	}
1319
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, length: pkt_len + 4)) != NULL) {
1361	skb_reserve(skb, len: 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(address: vp->rx_ring[entry].addr),
1365	len: 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, len: pkt_len);
1373	/* Remove this checking code for final release. */
1374	if (isa_bus_to_virt(address: 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, len: 2); /* Align IP on 16 byte boundaries */
1396	vp->rx_ring[entry].addr = isa_virt_to_bus(address: 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
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(timer: &vp->timer);
1421
1422	/* Turn off statistics ASAP. We update lp->stats below. */
1423	outw(value: StatsDisable, port: ioaddr + EL3_CMD);
1424
1425	/* Disable the receiver and transmitter. */
1426	outw(value: RxDisable, port: ioaddr + EL3_CMD);
1427	outw(value: TxDisable, port: ioaddr + EL3_CMD);
1428
1429	if (dev->if_port == XCVR_10base2)
1430	/* Turn off thinnet power. Green! */
1431	outw(value: StopCoax, port: ioaddr + EL3_CMD);
1432
1433	free_irq(dev->irq, dev);
1434
1435	outw(value: SetIntrEnb | 0x0000, port: ioaddr + EL3_CMD);
1436
1437	update_stats(addr: ioaddr, dev);
1438	if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
1439	outl(value: 0, port: 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(value: 0, port: 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
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(addr: dev->base_addr, dev);
1466	spin_unlock_irqrestore(lock: &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	*/
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(port: ioaddr + 0);
1484	dev->stats.tx_heartbeat_errors += inb(port: ioaddr + 1);
1485	/* Multiple collisions. */ inb(port: ioaddr + 2);
1486	dev->stats.collisions += inb(port: ioaddr + 3);
1487	dev->stats.tx_window_errors += inb(port: ioaddr + 4);
1488	dev->stats.rx_fifo_errors += inb(port: ioaddr + 5);
1489	dev->stats.tx_packets += inb(port: ioaddr + 6);
1490	dev->stats.tx_packets += (inb(port: ioaddr + 9) & 0x30) << 4;
1491	/* Rx packets */ inb(port: ioaddr + 7);
1492	/* Must read to clear */
1493	/* Tx deferrals */ inb(port: 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(port: ioaddr + 10); /* Total Rx and Tx octets. */
1498	inw(port: ioaddr + 12);
1499	/* New: On the Vortex we must also clear the BadSSD counter. */
1500	EL3WINDOW(4);
1501	inb(port: 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. */
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(value: new_mode, port: ioaddr + EL3_CMD);
1527	}
1528
1529	static void netdev_get_drvinfo(struct net_device *dev,
1530	struct ethtool_drvinfo *info)
1531	{
1532	strscpy(p: info->driver, DRV_NAME, size: sizeof(info->driver));
1533	snprintf(buf: info->bus_info, size: sizeof(info->bus_info), fmt: "ISA 0x%lx",
1534	dev->base_addr);
1535	}
1536
1537	static u32 netdev_get_msglevel(struct net_device *dev)
1538	{
1539	return corkscrew_debug;
1540	}
1541
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
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