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