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