blob: 39ac12233aa72778362d0e00eee37830f7d387ce [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040015 2000/2/2- Added support for kernel-level ISAPnP
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 by Stephen Frost <sfrost@snowman.net> and Alessandro Zummo
17 Cleaned up for 2.3.x/softnet by Jeff Garzik and Alan Cox.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040018
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 2001/11/17 - Added ethtool support (jgarzik)
Jeff Garzik6aa20a22006-09-13 13:24:59 -040020
Alan Cox113aa832008-10-13 19:01:08 -070021 2002/10/28 - Locking updates for 2.5 (alan@lxorguk.ukuu.org.uk)
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#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/slab.h>
69#include <linux/skbuff.h>
70#include <linux/etherdevice.h>
71#include <linux/interrupt.h>
72#include <linux/timer.h>
73#include <linux/ethtool.h>
74#include <linux/bitops.h>
75
76#include <asm/uaccess.h>
77#include <asm/io.h>
78#include <asm/dma.h>
79
80#define NEW_MULTICAST
81#include <linux/delay.h>
82
83#define MAX_UNITS 8
84
85MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
86MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
87MODULE_LICENSE("GPL");
88MODULE_VERSION(DRV_VERSION);
89
90/* "Knobs" for adjusting internal parameters. */
91/* Put out somewhat more debugging messages. (0 - no msg, 1 minimal msgs). */
92#define DRIVER_DEBUG 1
93/* Some values here only for performance evaluation and path-coverage
94 debugging. */
95static int rx_nocopy, rx_copy, queued_packet;
96
97/* Number of times to check to see if the Tx FIFO has space, used in some
98 limited cases. */
99#define WAIT_TX_AVAIL 200
100
101/* Operational parameter that usually are not changed. */
102#define TX_TIMEOUT 40 /* Time in jiffies before concluding Tx hung */
103
104/* The size here is somewhat misleading: the Corkscrew also uses the ISA
105 aliased registers at <base>+0x400.
106 */
107#define CORKSCREW_TOTAL_SIZE 0x20
108
109#ifdef DRIVER_DEBUG
110static int corkscrew_debug = DRIVER_DEBUG;
111#else
112static int corkscrew_debug = 1;
113#endif
114
115#define CORKSCREW_ID 10
116
117/*
118 Theory of Operation
119
120I. Board Compatibility
121
122This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL,
1233Com's ISA bus adapter for Fast Ethernet. Due to the unique I/O port layout,
124it's not practical to integrate this driver with the other EtherLink drivers.
125
126II. Board-specific settings
127
128The Corkscrew has an EEPROM for configuration, but no special settings are
129needed for Linux.
130
131III. Driver operation
132
133The 3c515 series use an interface that's very similar to the 3c900 "Boomerang"
134PCI cards, with the bus master interface extensively modified to work with
135the ISA bus.
136
137The card is capable of full-bus-master transfers with separate
138lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
139DEC Tulip and Intel Speedo3.
140
141This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate
142receive buffer. This scheme allocates full-sized skbuffs as receive
143buffers. The value RX_COPYBREAK is used as the copying breakpoint: it is
144chosen to trade-off the memory wasted by passing the full-sized skbuff to
145the queue layer for all frames vs. the copying cost of copying a frame to a
146correctly-sized skbuff.
147
148
149IIIC. Synchronization
150The driver runs as two independent, single-threaded flows of control. One
151is the send-packet routine, which enforces single-threaded use by the netif
152layer. The other thread is the interrupt handler, which is single
153threaded by the hardware and other software.
154
155IV. Notes
156
157Thanks to Terry Murphy of 3Com for providing documentation and a development
158board.
159
160The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com
161project names. I use these names to eliminate confusion -- 3Com product
162numbers and names are very similar and often confused.
163
164The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes!
165This driver only supports ethernet frames because of the recent MTU limit
166of 1.5K, but the changes to support 4.5K are minimal.
167*/
168
169/* Operational definitions.
170 These are not used by other compilation units and thus are not
171 exported in a ".h" file.
172
173 First the windows. There are eight register windows, with the command
174 and status registers available in each.
175 */
176#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
177#define EL3_CMD 0x0e
178#define EL3_STATUS 0x0e
179
180/* The top five bits written to EL3_CMD are a command, the lower
181 11 bits are the parameter, if applicable.
182 Note that 11 parameters bits was fine for ethernet, but the new chips
183 can handle FDDI length frames (~4500 octets) and now parameters count
184 32-bit 'Dwords' rather than octets. */
185
186enum corkscrew_cmd {
187 TotalReset = 0 << 11, SelectWindow = 1 << 11, StartCoax = 2 << 11,
188 RxDisable = 3 << 11, RxEnable = 4 << 11, RxReset = 5 << 11,
189 UpStall = 6 << 11, UpUnstall = (6 << 11) + 1, DownStall = (6 << 11) + 2,
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400190 DownUnstall = (6 << 11) + 3, RxDiscard = 8 << 11, TxEnable = 9 << 11,
191 TxDisable = 10 << 11, TxReset = 11 << 11, FakeIntr = 12 << 11,
192 AckIntr = 13 << 11, SetIntrEnb = 14 << 11, SetStatusEnb = 15 << 11,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 SetRxFilter = 16 << 11, SetRxThreshold = 17 << 11,
194 SetTxThreshold = 18 << 11, SetTxStart = 19 << 11, StartDMAUp = 20 << 11,
195 StartDMADown = (20 << 11) + 1, StatsEnable = 21 << 11,
196 StatsDisable = 22 << 11, StopCoax = 23 << 11,
197};
198
199/* The SetRxFilter command accepts the following classes: */
200enum RxFilter {
201 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
202};
203
204/* Bits in the general status register. */
205enum corkscrew_status {
206 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
207 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
208 IntReq = 0x0040, StatsFull = 0x0080,
209 DMADone = 1 << 8, DownComplete = 1 << 9, UpComplete = 1 << 10,
210 DMAInProgress = 1 << 11, /* DMA controller is still busy. */
211 CmdInProgress = 1 << 12, /* EL3_CMD is still busy. */
212};
213
214/* Register window 1 offsets, the window used in normal operation.
215 On the Corkscrew this window is always mapped at offsets 0x10-0x1f. */
216enum Window1 {
217 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
218 RxStatus = 0x18, Timer = 0x1A, TxStatus = 0x1B,
219 TxFree = 0x1C, /* Remaining free bytes in Tx buffer. */
220};
221enum Window0 {
222 Wn0IRQ = 0x08,
223#if defined(CORKSCREW)
224 Wn0EepromCmd = 0x200A, /* Corkscrew EEPROM command register. */
225 Wn0EepromData = 0x200C, /* Corkscrew EEPROM results register. */
226#else
227 Wn0EepromCmd = 10, /* Window 0: EEPROM command register. */
228 Wn0EepromData = 12, /* Window 0: EEPROM results register. */
229#endif
230};
231enum Win0_EEPROM_bits {
232 EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
233 EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
234 EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
235};
236
237/* EEPROM locations. */
238enum eeprom_offset {
239 PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3,
240 EtherLink3ID = 7,
241};
242
243enum Window3 { /* Window 3: MAC/config bits. */
244 Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8,
245};
Al Virob6659822008-01-13 14:17:35 +0000246enum wn3_config {
247 Ram_size = 7,
248 Ram_width = 8,
249 Ram_speed = 0x30,
250 Rom_size = 0xc0,
251 Ram_split_shift = 16,
252 Ram_split = 3 << Ram_split_shift,
253 Xcvr_shift = 20,
254 Xcvr = 7 << Xcvr_shift,
255 Autoselect = 0x1000000,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256};
257
258enum Window4 {
259 Wn4_NetDiag = 6, Wn4_Media = 10, /* Window 4: Xcvr/media bits. */
260};
261enum Win4_Media_bits {
262 Media_SQE = 0x0008, /* Enable SQE error counting for AUI. */
263 Media_10TP = 0x00C0, /* Enable link beat and jabber for 10baseT. */
264 Media_Lnk = 0x0080, /* Enable just link beat for 100TX/100FX. */
265 Media_LnkBeat = 0x0800,
266};
267enum Window7 { /* Window 7: Bus Master control. */
268 Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
269};
270
271/* Boomerang-style bus master control registers. Note ISA aliases! */
272enum MasterCtrl {
273 PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
274 0x40c,
275 TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
276};
277
278/* The Rx and Tx descriptor lists.
279 Caution Alpha hackers: these types are 32 bits! Note also the 8 byte
280 alignment contraint on tx_ring[] and rx_ring[]. */
281struct boom_rx_desc {
282 u32 next;
283 s32 status;
284 u32 addr;
285 s32 length;
286};
287
288/* Values for the Rx status entry. */
289enum rx_desc_status {
290 RxDComplete = 0x00008000, RxDError = 0x4000,
291 /* See boomerang_rx() for actual error bits */
292};
293
294struct boom_tx_desc {
295 u32 next;
296 s32 status;
297 u32 addr;
298 s32 length;
299};
300
301struct corkscrew_private {
302 const char *product_name;
303 struct list_head list;
304 struct net_device *our_dev;
305 /* The Rx and Tx rings are here to keep them quad-word-aligned. */
306 struct boom_rx_desc rx_ring[RX_RING_SIZE];
307 struct boom_tx_desc tx_ring[TX_RING_SIZE];
308 /* The addresses of transmit- and receive-in-place skbuffs. */
309 struct sk_buff *rx_skbuff[RX_RING_SIZE];
310 struct sk_buff *tx_skbuff[TX_RING_SIZE];
311 unsigned int cur_rx, cur_tx; /* The next free ring entry */
312 unsigned int dirty_rx, dirty_tx;/* The ring entries to be free()ed. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 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. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400342} 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},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 { "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);
b1fc5502005-05-12 20:11:55 -0400368static int corkscrew_setup(struct net_device *dev, int ioaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 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);
David Howells7d12e782006-10-05 14:55:46 +0100377static irqreturn_t corkscrew_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378static int corkscrew_close(struct net_device *dev);
379static void update_stats(int addr, struct net_device *dev);
380static struct net_device_stats *corkscrew_get_stats(struct net_device *dev);
381static void set_rx_mode(struct net_device *dev);
Jeff Garzik7282d492006-09-13 14:30:00 -0400382static const struct ethtool_ops netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400384
385/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 Unfortunately maximizing the shared code between the integrated and
387 module version of the driver results in a complicated set of initialization
388 procedures.
389 init_module() -- modules / tc59x_init() -- built-in
390 The wrappers for corkscrew_scan()
391 corkscrew_scan() The common routine that scans for PCI and EISA cards
392 corkscrew_found_device() Allocate a device structure when we find a card.
393 Different versions exist for modules and built-in.
394 corkscrew_probe1() Fill in the device structure -- this is separated
395 so that the modules code can put it in dev->init.
396*/
397/* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
398/* Note: this is the only limit on the number of cards supported!! */
399static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, };
400
401#ifdef MODULE
402static int debug = -1;
403
404module_param(debug, int, 0);
405module_param_array(options, int, NULL, 0);
406module_param(rx_copybreak, int, 0);
407module_param(max_interrupt_work, int, 0);
408MODULE_PARM_DESC(debug, "3c515 debug level (0-6)");
409MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering");
410MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames");
411MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt");
412
413/* A list of all installed Vortex devices, for removing the driver module. */
414/* we will need locking (and refcounting) if we ever use it for more */
415static LIST_HEAD(root_corkscrew_dev);
416
417int init_module(void)
418{
419 int found = 0;
420 if (debug >= 0)
421 corkscrew_debug = debug;
422 if (corkscrew_debug)
423 printk(version);
424 while (corkscrew_scan(-1))
425 found++;
426 return found ? 0 : -ENODEV;
427}
428
429#else
430struct net_device *tc515_probe(int unit)
431{
432 struct net_device *dev = corkscrew_scan(unit);
433 static int printed;
434
435 if (!dev)
436 return ERR_PTR(-ENODEV);
437
438 if (corkscrew_debug > 0 && !printed) {
439 printed = 1;
440 printk(version);
441 }
442
443 return dev;
444}
445#endif /* not MODULE */
446
447static int check_device(unsigned ioaddr)
448{
449 int timer;
450
451 if (!request_region(ioaddr, CORKSCREW_TOTAL_SIZE, "3c515"))
452 return 0;
453 /* Check the resource configuration for a matching ioaddr. */
454 if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0)) {
455 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
456 return 0;
457 }
458 /* Verify by reading the device ID from the EEPROM. */
459 outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd);
460 /* Pause for at least 162 us. for the read to take place. */
461 for (timer = 4; timer >= 0; timer--) {
462 udelay(162);
463 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
464 break;
465 }
466 if (inw(ioaddr + Wn0EepromData) != 0x6d50) {
467 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
468 return 0;
469 }
470 return 1;
471}
472
473static void cleanup_card(struct net_device *dev)
474{
475 struct corkscrew_private *vp = netdev_priv(dev);
476 list_del_init(&vp->list);
477 if (dev->dma)
478 free_dma(dev->dma);
479 outw(TotalReset, dev->base_addr + EL3_CMD);
480 release_region(dev->base_addr, CORKSCREW_TOTAL_SIZE);
481 if (vp->dev)
482 pnp_device_detach(to_pnp_dev(vp->dev));
483}
484
485static struct net_device *corkscrew_scan(int unit)
486{
487 struct net_device *dev;
488 static int cards_found = 0;
489 static int ioaddr;
490 int err;
491#ifdef __ISAPNP__
492 short i;
493 static int pnp_cards;
494#endif
495
496 dev = alloc_etherdev(sizeof(struct corkscrew_private));
497 if (!dev)
498 return ERR_PTR(-ENOMEM);
499
500 if (unit >= 0) {
501 sprintf(dev->name, "eth%d", unit);
502 netdev_boot_setup_check(dev);
503 }
504
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505#ifdef __ISAPNP__
506 if(nopnp == 1)
507 goto no_pnp;
508 for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
509 struct pnp_dev *idev = NULL;
510 int irq;
511 while((idev = pnp_find_dev(NULL,
512 corkscrew_isapnp_adapters[i].vendor,
513 corkscrew_isapnp_adapters[i].function,
514 idev))) {
515
516 if (pnp_device_attach(idev) < 0)
517 continue;
518 if (pnp_activate_dev(idev) < 0) {
519 printk("pnp activate failed (out of resources?)\n");
520 pnp_device_detach(idev);
521 continue;
522 }
523 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
524 pnp_device_detach(idev);
525 continue;
526 }
527 ioaddr = pnp_port_start(idev, 0);
528 irq = pnp_irq(idev, 0);
529 if (!check_device(ioaddr)) {
530 pnp_device_detach(idev);
531 continue;
532 }
533 if(corkscrew_debug)
534 printk ("ISAPNP reports %s at i/o 0x%x, irq %d\n",
535 (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
536 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
537 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
538 /* irq = inw(ioaddr + 0x2002) & 15; */ /* Use the irq from isapnp */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 SET_NETDEV_DEV(dev, &idev->dev);
540 pnp_cards++;
b1fc5502005-05-12 20:11:55 -0400541 err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 if (!err)
543 return dev;
544 cleanup_card(dev);
545 }
546 }
547no_pnp:
548#endif /* __ISAPNP__ */
549
550 /* Check all locations on the ISA bus -- evil! */
551 for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
552 if (!check_device(ioaddr))
553 continue;
554
555 printk(KERN_INFO "3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
556 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
b1fc5502005-05-12 20:11:55 -0400557 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 if (!err)
559 return dev;
560 cleanup_card(dev);
561 }
562 free_netdev(dev);
563 return NULL;
564}
565
b1fc5502005-05-12 20:11:55 -0400566static int corkscrew_setup(struct net_device *dev, int ioaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 struct pnp_dev *idev, int card_number)
568{
569 struct corkscrew_private *vp = netdev_priv(dev);
570 unsigned int eeprom[0x40], checksum = 0; /* EEPROM contents */
571 int i;
572 int irq;
573
Randy Dunlap92fbc1c2008-05-16 10:35:24 -0700574#ifdef __ISAPNP__
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 if (idev) {
576 irq = pnp_irq(idev, 0);
577 vp->dev = &idev->dev;
578 } else {
579 irq = inw(ioaddr + 0x2002) & 15;
580 }
Randy Dunlap92fbc1c2008-05-16 10:35:24 -0700581#else
582 irq = inw(ioaddr + 0x2002) & 15;
583#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
585 dev->base_addr = ioaddr;
586 dev->irq = irq;
587 dev->dma = inw(ioaddr + 0x2000) & 7;
588 vp->product_name = "3c515";
589 vp->options = dev->mem_start;
590 vp->our_dev = dev;
591
592 if (!vp->options) {
593 if (card_number >= MAX_UNITS)
594 vp->options = -1;
595 else
596 vp->options = options[card_number];
597 }
598
599 if (vp->options >= 0) {
600 vp->media_override = vp->options & 7;
601 if (vp->media_override == 2)
602 vp->media_override = 0;
603 vp->full_duplex = (vp->options & 8) ? 1 : 0;
604 vp->bus_master = (vp->options & 16) ? 1 : 0;
605 } else {
606 vp->media_override = 7;
607 vp->full_duplex = 0;
608 vp->bus_master = 0;
609 }
610#ifdef MODULE
611 list_add(&vp->list, &root_corkscrew_dev);
612#endif
613
614 printk(KERN_INFO "%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
615
616 spin_lock_init(&vp->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 /* Read the station address from the EEPROM. */
619 EL3WINDOW(0);
620 for (i = 0; i < 0x18; i++) {
Al Virob6659822008-01-13 14:17:35 +0000621 __be16 *phys_addr = (__be16 *) dev->dev_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 int timer;
623 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
624 /* Pause for at least 162 us. for the read to take place. */
625 for (timer = 4; timer >= 0; timer--) {
626 udelay(162);
627 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
628 break;
629 }
630 eeprom[i] = inw(ioaddr + Wn0EepromData);
631 checksum ^= eeprom[i];
632 if (i < 3)
633 phys_addr[i] = htons(eeprom[i]);
634 }
635 checksum = (checksum ^ (checksum >> 8)) & 0xff;
636 if (checksum != 0x00)
637 printk(" ***INVALID CHECKSUM %4.4x*** ", checksum);
Johannes Berge1749612008-10-27 15:59:26 -0700638 printk(" %pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 if (eeprom[16] == 0x11c7) { /* Corkscrew */
640 if (request_dma(dev->dma, "3c515")) {
641 printk(", DMA %d allocation failed", dev->dma);
642 dev->dma = 0;
643 } else
644 printk(", DMA %d", dev->dma);
645 }
646 printk(", IRQ %d\n", dev->irq);
647 /* Tell them about an invalid IRQ. */
648 if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
649 printk(KERN_WARNING " *** Warning: this IRQ is unlikely to work! ***\n");
650
651 {
652 char *ram_split[] = { "5:3", "3:1", "1:1", "3:5" };
Al Virob6659822008-01-13 14:17:35 +0000653 __u32 config;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 EL3WINDOW(3);
655 vp->available_media = inw(ioaddr + Wn3_Options);
Al Virob6659822008-01-13 14:17:35 +0000656 config = inl(ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 if (corkscrew_debug > 1)
658 printk(KERN_INFO " Internal config register is %4.4x, transceivers %#x.\n",
Al Virob6659822008-01-13 14:17:35 +0000659 config, inw(ioaddr + Wn3_Options));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 printk(KERN_INFO " %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
Al Virob6659822008-01-13 14:17:35 +0000661 8 << config & Ram_size,
662 config & Ram_width ? "word" : "byte",
663 ram_split[(config & Ram_split) >> Ram_split_shift],
664 config & Autoselect ? "autoselect/" : "",
665 media_tbl[(config & Xcvr) >> Xcvr_shift].name);
666 vp->default_media = (config & Xcvr) >> Xcvr_shift;
667 vp->autoselect = config & Autoselect ? 1 : 0;
668 dev->if_port = vp->default_media;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 }
670 if (vp->media_override != 7) {
671 printk(KERN_INFO " Media override to transceiver type %d (%s).\n",
672 vp->media_override,
673 media_tbl[vp->media_override].name);
674 dev->if_port = vp->media_override;
675 }
676
677 vp->capabilities = eeprom[16];
678 vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
679 /* Rx is broken at 10mbps, so we always disable it. */
680 /* vp->full_bus_master_rx = 0; */
681 vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
682
683 /* The 3c51x-specific entries in the device structure. */
684 dev->open = &corkscrew_open;
685 dev->hard_start_xmit = &corkscrew_start_xmit;
686 dev->tx_timeout = &corkscrew_timeout;
687 dev->watchdog_timeo = (400 * HZ) / 1000;
688 dev->stop = &corkscrew_close;
689 dev->get_stats = &corkscrew_get_stats;
690 dev->set_multicast_list = &set_rx_mode;
691 dev->ethtool_ops = &netdev_ethtool_ops;
b1fc5502005-05-12 20:11:55 -0400692
693 return register_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697static int corkscrew_open(struct net_device *dev)
698{
699 int ioaddr = dev->base_addr;
700 struct corkscrew_private *vp = netdev_priv(dev);
Al Virob6659822008-01-13 14:17:35 +0000701 __u32 config;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 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. */
Al Virob6659822008-01-13 14:17:35 +0000708 config = inl(ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
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;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400719 while (!(vp->available_media & media_tbl[dev->if_port].mask))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 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
Al Virob6659822008-01-13 14:17:35 +0000734 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
735 outl(config, ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
737 if (corkscrew_debug > 1) {
738 printk("%s: corkscrew_open() InternalConfig %8.8x.\n",
Al Virob6659822008-01-13 14:17:35 +0000739 dev->name, config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 }
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);
Thomas Gleixner1fb9df52006-07-01 19:29:39 -0700764 } else if (request_irq(dev->irq, &corkscrew_interrupt, IRQF_SHARED,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 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 */
David S. Miller689be432005-06-28 15:25:31 -0700825 vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 }
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);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400875
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 {
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) {
Al Virob6659822008-01-13 14:17:35 +0000908 __u32 config;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
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));
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400915
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 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);
Al Virob6659822008-01-13 14:17:35 +0000935 config = inl(ioaddr + Wn3_Config);
936 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
937 outl(config, ioaddr + Wn3_Config);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
939 outw(dev->if_port == 3 ? StartCoax : StopCoax,
940 ioaddr + EL3_CMD);
941 }
942 EL3WINDOW(old_window);
943 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400944
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 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;
Paulius Zaleckasdfd44152008-04-29 03:07:31 +0300988 dev->stats.tx_errors++;
989 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 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;
Eric Sesterhenncb958182006-08-19 19:37:57 +02001007 unsigned long flags;
1008 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009
1010 if (vp->tx_full) /* No room to transmit with */
1011 return 1;
1012 if (vp->cur_tx != 0)
1013 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1014 else
1015 prev_entry = NULL;
1016 if (corkscrew_debug > 3)
1017 printk("%s: Trying to send a packet, Tx index %d.\n",
1018 dev->name, vp->cur_tx);
1019 /* vp->tx_full = 1; */
1020 vp->tx_skbuff[entry] = skb;
1021 vp->tx_ring[entry].next = 0;
1022 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1023 vp->tx_ring[entry].length = skb->len | 0x80000000;
1024 vp->tx_ring[entry].status = skb->len | 0x80000000;
1025
1026 spin_lock_irqsave(&vp->lock, flags);
1027 outw(DownStall, ioaddr + EL3_CMD);
1028 /* Wait for the stall to complete. */
1029 for (i = 20; i >= 0; i--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001030 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 break;
1032 if (prev_entry)
1033 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1034 if (inl(ioaddr + DownListPtr) == 0) {
1035 outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1036 ioaddr + DownListPtr);
1037 queued_packet++;
1038 }
1039 outw(DownUnstall, ioaddr + EL3_CMD);
1040 spin_unlock_irqrestore(&vp->lock, flags);
1041
1042 vp->cur_tx++;
1043 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1044 vp->tx_full = 1;
1045 else { /* Clear previous interrupt enable. */
1046 if (prev_entry)
1047 prev_entry->status &= ~0x80000000;
1048 netif_wake_queue(dev);
1049 }
1050 dev->trans_start = jiffies;
1051 return 0;
1052 }
1053 /* Put out the doubleword header... */
1054 outl(skb->len, ioaddr + TX_FIFO);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001055 dev->stats.tx_bytes += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056#ifdef VORTEX_BUS_MASTER
1057 if (vp->bus_master) {
1058 /* Set the bus-master controller to transfer the packet. */
1059 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1060 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1061 vp->tx_skb = skb;
1062 outw(StartDMADown, ioaddr + EL3_CMD);
1063 /* queue will be woken at the DMADone interrupt. */
1064 } else {
1065 /* ... and the packet rounded to a doubleword. */
1066 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1067 dev_kfree_skb(skb);
1068 if (inw(ioaddr + TxFree) > 1536) {
1069 netif_wake_queue(dev);
1070 } else
1071 /* Interrupt us when the FIFO has room for max-sized packet. */
1072 outw(SetTxThreshold + (1536 >> 2),
1073 ioaddr + EL3_CMD);
1074 }
1075#else
1076 /* ... and the packet rounded to a doubleword. */
1077 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1078 dev_kfree_skb(skb);
1079 if (inw(ioaddr + TxFree) > 1536) {
1080 netif_wake_queue(dev);
1081 } else
1082 /* Interrupt us when the FIFO has room for max-sized packet. */
1083 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1084#endif /* bus master */
1085
1086 dev->trans_start = jiffies;
1087
1088 /* Clear the Tx status stack. */
1089 {
1090 short tx_status;
1091 int i = 4;
1092
1093 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1094 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */
1095 if (corkscrew_debug > 2)
1096 printk("%s: Tx error, status %2.2x.\n",
1097 dev->name, tx_status);
1098 if (tx_status & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001099 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 if (tx_status & 0x38)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001101 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 if (tx_status & 0x30) {
1103 int j;
1104 outw(TxReset, ioaddr + EL3_CMD);
1105 for (j = 20; j >= 0; j--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001106 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 break;
1108 }
1109 outw(TxEnable, ioaddr + EL3_CMD);
1110 }
1111 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
1112 }
1113 }
1114 return 0;
1115}
1116
1117/* The interrupt handler does all of the Rx thread work and cleans up
1118 after the Tx thread. */
1119
David Howells7d12e782006-10-05 14:55:46 +01001120static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121{
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);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001133
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 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));
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001252
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 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{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 int ioaddr = dev->base_addr;
1263 int i;
1264 short rx_status;
1265
1266 if (corkscrew_debug > 5)
1267 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1268 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1269 while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1270 if (rx_status & 0x4000) { /* Error, update stats. */
1271 unsigned char rx_error = inb(ioaddr + RxErrors);
1272 if (corkscrew_debug > 2)
1273 printk(" Rx error: status %2.2x.\n",
1274 rx_error);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001275 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 if (rx_error & 0x01)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001277 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278 if (rx_error & 0x02)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001279 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 if (rx_error & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001281 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 if (rx_error & 0x08)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001283 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 if (rx_error & 0x10)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001285 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 } else {
1287 /* The packet length: up to 4.5K!. */
1288 short pkt_len = rx_status & 0x1fff;
1289 struct sk_buff *skb;
1290
1291 skb = dev_alloc_skb(pkt_len + 5 + 2);
1292 if (corkscrew_debug > 4)
1293 printk("Receiving packet size %d status %4.4x.\n",
1294 pkt_len, rx_status);
1295 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1297 /* 'skb_put()' points to the start of sk_buff data area. */
1298 insl(ioaddr + RX_FIFO,
1299 skb_put(skb, pkt_len),
1300 (pkt_len + 3) >> 2);
1301 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1302 skb->protocol = eth_type_trans(skb, dev);
1303 netif_rx(skb);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001304 dev->stats.rx_packets++;
1305 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 /* Wait a limited time to go to next packet. */
1307 for (i = 200; i >= 0; i--)
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001308 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 break;
1310 continue;
1311 } else if (corkscrew_debug)
1312 printk("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1313 }
1314 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001315 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 /* Wait a limited time to skip this packet. */
1317 for (i = 200; i >= 0; i--)
1318 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1319 break;
1320 }
1321 return 0;
1322}
1323
1324static int boomerang_rx(struct net_device *dev)
1325{
1326 struct corkscrew_private *vp = netdev_priv(dev);
1327 int entry = vp->cur_rx % RX_RING_SIZE;
1328 int ioaddr = dev->base_addr;
1329 int rx_status;
1330
1331 if (corkscrew_debug > 5)
1332 printk(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1333 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1334 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1335 if (rx_status & RxDError) { /* Error, update stats. */
1336 unsigned char rx_error = rx_status >> 16;
1337 if (corkscrew_debug > 2)
1338 printk(" Rx error: status %2.2x.\n",
1339 rx_error);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001340 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 if (rx_error & 0x01)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001342 dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 if (rx_error & 0x02)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001344 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 if (rx_error & 0x04)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001346 dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 if (rx_error & 0x08)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001348 dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 if (rx_error & 0x10)
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001350 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 } else {
1352 /* The packet length: up to 4.5K!. */
1353 short pkt_len = rx_status & 0x1fff;
1354 struct sk_buff *skb;
1355
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001356 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 if (corkscrew_debug > 4)
1358 printk("Receiving packet size %d status %4.4x.\n",
1359 pkt_len, rx_status);
1360
1361 /* Check if the packet is long enough to just accept without
1362 copying to a properly sized skbuff. */
1363 if (pkt_len < rx_copybreak
Al Viro79ea13c2008-01-24 02:06:46 -08001364 && (skb = dev_alloc_skb(pkt_len + 4)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1366 /* 'skb_put()' points to the start of sk_buff data area. */
1367 memcpy(skb_put(skb, pkt_len),
1368 isa_bus_to_virt(vp->rx_ring[entry].
1369 addr), pkt_len);
1370 rx_copy++;
1371 } else {
1372 void *temp;
1373 /* Pass up the skbuff already on the Rx ring. */
1374 skb = vp->rx_skbuff[entry];
1375 vp->rx_skbuff[entry] = NULL;
1376 temp = skb_put(skb, pkt_len);
1377 /* Remove this checking code for final release. */
1378 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1379 printk("%s: Warning -- the skbuff addresses do not match"
1380 " in boomerang_rx: %p vs. %p / %p.\n",
1381 dev->name,
1382 isa_bus_to_virt(vp->
1383 rx_ring[entry].
1384 addr), skb->head,
1385 temp);
1386 rx_nocopy++;
1387 }
1388 skb->protocol = eth_type_trans(skb, dev);
1389 netif_rx(skb);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001390 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 }
1392 entry = (++vp->cur_rx) % RX_RING_SIZE;
1393 }
1394 /* Refill the Rx ring buffers. */
1395 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1396 struct sk_buff *skb;
1397 entry = vp->dirty_rx % RX_RING_SIZE;
1398 if (vp->rx_skbuff[entry] == NULL) {
1399 skb = dev_alloc_skb(PKT_BUF_SZ);
1400 if (skb == NULL)
1401 break; /* Bad news! */
1402 skb->dev = dev; /* Mark as being used by this device. */
1403 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
David S. Miller689be432005-06-28 15:25:31 -07001404 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 vp->rx_skbuff[entry] = skb;
1406 }
1407 vp->rx_ring[entry].status = 0; /* Clear complete bit. */
1408 }
1409 return 0;
1410}
1411
1412static int corkscrew_close(struct net_device *dev)
1413{
1414 struct corkscrew_private *vp = netdev_priv(dev);
1415 int ioaddr = dev->base_addr;
1416 int i;
1417
1418 netif_stop_queue(dev);
1419
1420 if (corkscrew_debug > 1) {
1421 printk("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1422 dev->name, inw(ioaddr + EL3_STATUS),
1423 inb(ioaddr + TxStatus));
1424 printk("%s: corkscrew close stats: rx_nocopy %d rx_copy %d"
1425 " tx_queued %d.\n", dev->name, rx_nocopy, rx_copy,
1426 queued_packet);
1427 }
1428
1429 del_timer(&vp->timer);
1430
1431 /* Turn off statistics ASAP. We update lp->stats below. */
1432 outw(StatsDisable, ioaddr + EL3_CMD);
1433
1434 /* Disable the receiver and transmitter. */
1435 outw(RxDisable, ioaddr + EL3_CMD);
1436 outw(TxDisable, ioaddr + EL3_CMD);
1437
1438 if (dev->if_port == XCVR_10base2)
1439 /* Turn off thinnet power. Green! */
1440 outw(StopCoax, ioaddr + EL3_CMD);
1441
1442 free_irq(dev->irq, dev);
1443
1444 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1445
1446 update_stats(ioaddr, dev);
1447 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
1448 outl(0, ioaddr + UpListPtr);
1449 for (i = 0; i < RX_RING_SIZE; i++)
1450 if (vp->rx_skbuff[i]) {
1451 dev_kfree_skb(vp->rx_skbuff[i]);
1452 vp->rx_skbuff[i] = NULL;
1453 }
1454 }
1455 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
1456 outl(0, ioaddr + DownListPtr);
1457 for (i = 0; i < TX_RING_SIZE; i++)
1458 if (vp->tx_skbuff[i]) {
1459 dev_kfree_skb(vp->tx_skbuff[i]);
1460 vp->tx_skbuff[i] = NULL;
1461 }
1462 }
1463
1464 return 0;
1465}
1466
1467static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1468{
1469 struct corkscrew_private *vp = netdev_priv(dev);
1470 unsigned long flags;
1471
1472 if (netif_running(dev)) {
1473 spin_lock_irqsave(&vp->lock, flags);
1474 update_stats(dev->base_addr, dev);
1475 spin_unlock_irqrestore(&vp->lock, flags);
1476 }
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001477 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478}
1479
1480/* Update statistics.
1481 Unlike with the EL3 we need not worry about interrupts changing
1482 the window setting from underneath us, but we must still guard
1483 against a race condition with a StatsUpdate interrupt updating the
1484 table. This is done by checking that the ASM (!) code generated uses
1485 atomic updates with '+='.
1486 */
1487static void update_stats(int ioaddr, struct net_device *dev)
1488{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1490 /* Switch to the stats window, and read everything. */
1491 EL3WINDOW(6);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001492 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1493 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 /* Multiple collisions. */ inb(ioaddr + 2);
Paulius Zaleckasdfd44152008-04-29 03:07:31 +03001495 dev->stats.collisions += inb(ioaddr + 3);
1496 dev->stats.tx_window_errors += inb(ioaddr + 4);
1497 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1498 dev->stats.tx_packets += inb(ioaddr + 6);
1499 dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 /* Rx packets */ inb(ioaddr + 7);
1501 /* Must read to clear */
1502 /* Tx deferrals */ inb(ioaddr + 8);
1503 /* Don't bother with register 9, an extension of registers 6&7.
1504 If we do use the 6&7 values the atomic update assumption above
1505 is invalid. */
1506 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1507 inw(ioaddr + 12);
1508 /* New: On the Vortex we must also clear the BadSSD counter. */
1509 EL3WINDOW(4);
1510 inb(ioaddr + 12);
1511
1512 /* We change back to window 7 (not 1) with the Vortex. */
1513 EL3WINDOW(7);
1514 return;
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 printk("%s: Setting promiscuous mode.\n",
1529 dev->name);
1530 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1531 } else if ((dev->mc_list) || (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 strcpy(info->driver, DRV_NAME);
1543 strcpy(info->version, DRV_VERSION);
1544 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1545}
1546
1547static u32 netdev_get_msglevel(struct net_device *dev)
1548{
1549 return corkscrew_debug;
1550}
1551
1552static void netdev_set_msglevel(struct net_device *dev, u32 level)
1553{
1554 corkscrew_debug = level;
1555}
1556
Jeff Garzik7282d492006-09-13 14:30:00 -04001557static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 .get_drvinfo = netdev_get_drvinfo,
1559 .get_msglevel = netdev_get_msglevel,
1560 .set_msglevel = netdev_set_msglevel,
1561};
1562
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001563
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564#ifdef MODULE
1565void cleanup_module(void)
1566{
1567 while (!list_empty(&root_corkscrew_dev)) {
1568 struct net_device *dev;
1569 struct corkscrew_private *vp;
1570
1571 vp = list_entry(root_corkscrew_dev.next,
1572 struct corkscrew_private, list);
1573 dev = vp->our_dev;
1574 unregister_netdev(dev);
1575 cleanup_card(dev);
1576 free_netdev(dev);
1577 }
1578}
1579#endif /* MODULE */