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