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