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