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 int i;
571 int irq;
572
573 #ifdef __ISAPNP__
574 if (idev) {
575 irq = pnp_irq(idev, 0);
576 vp->dev = &idev->dev;
577 } else {
578 irq = inw(ioaddr + 0x2002) & 15;
579 }
580 #else
581 irq = inw(ioaddr + 0x2002) & 15;
582 #endif
583
584 dev->base_addr = ioaddr;
585 dev->irq = irq;
586 dev->dma = inw(ioaddr + 0x2000) & 7;
587 vp->product_name = "3c515";
588 vp->options = dev->mem_start;
589 vp->our_dev = dev;
590
591 if (!vp->options) {
592 if (card_number >= MAX_UNITS)
593 vp->options = -1;
594 else
595 vp->options = options[card_number];
596 }
597
598 if (vp->options >= 0) {
599 vp->media_override = vp->options & 7;
600 if (vp->media_override == 2)
601 vp->media_override = 0;
602 vp->full_duplex = (vp->options & 8) ? 1 : 0;
603 vp->bus_master = (vp->options & 16) ? 1 : 0;
604 } else {
605 vp->media_override = 7;
606 vp->full_duplex = 0;
607 vp->bus_master = 0;
608 }
609 #ifdef MODULE
610 list_add(&vp->list, &root_corkscrew_dev);
611 #endif
612
613 pr_info("%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
614
615 spin_lock_init(&vp->lock);
616
617 timer_setup(&vp->timer, corkscrew_timer, 0);
618
619 /* Read the station address from the EEPROM. */
620 EL3WINDOW(0);
621 for (i = 0; i < 0x18; i++) {
622 __be16 *phys_addr = (__be16 *) dev->dev_addr;
623 int timer;
624 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
625 /* Pause for at least 162 us. for the read to take place. */
626 for (timer = 4; timer >= 0; timer--) {
627 udelay(162);
628 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
629 break;
630 }
631 eeprom[i] = inw(ioaddr + Wn0EepromData);
632 checksum ^= eeprom[i];
633 if (i < 3)
634 phys_addr[i] = htons(eeprom[i]);
635 }
636 checksum = (checksum ^ (checksum >> 8)) & 0xff;
637 if (checksum != 0x00)
638 pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
639 pr_cont(" %pM", dev->dev_addr);
640 if (eeprom[16] == 0x11c7) { /* Corkscrew */
641 if (request_dma(dev->dma, "3c515")) {
642 pr_cont(", DMA %d allocation failed", dev->dma);
643 dev->dma = 0;
644 } else
645 pr_cont(", DMA %d", dev->dma);
646 }
647 pr_cont(", IRQ %d\n", dev->irq);
648 /* Tell them about an invalid IRQ. */
649 if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
650 pr_warn(" *** Warning: this IRQ is unlikely to work! ***\n");
651
652 {
653 static const char * const ram_split[] = {
654 "5:3", "3:1", "1:1", "3:5"
655 };
656 __u32 config;
657 EL3WINDOW(3);
658 vp->available_media = inw(ioaddr + Wn3_Options);
659 config = inl(ioaddr + Wn3_Config);
660 if (corkscrew_debug > 1)
661 pr_info(" Internal config register is %4.4x, transceivers %#x.\n",
662 config, inw(ioaddr + Wn3_Options));
663 pr_info(" %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
664 8 << config & Ram_size,
665 config & Ram_width ? "word" : "byte",
666 ram_split[(config & Ram_split) >> Ram_split_shift],
667 config & Autoselect ? "autoselect/" : "",
668 media_tbl[(config & Xcvr) >> Xcvr_shift].name);
669 vp->default_media = (config & Xcvr) >> Xcvr_shift;
670 vp->autoselect = config & Autoselect ? 1 : 0;
671 dev->if_port = vp->default_media;
672 }
673 if (vp->media_override != 7) {
674 pr_info(" Media override to transceiver type %d (%s).\n",
675 vp->media_override,
676 media_tbl[vp->media_override].name);
677 dev->if_port = vp->media_override;
678 }
679
680 vp->capabilities = eeprom[16];
681 vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
682 /* Rx is broken at 10mbps, so we always disable it. */
683 /* vp->full_bus_master_rx = 0; */
684 vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
685
686 /* The 3c51x-specific entries in the device structure. */
687 dev->netdev_ops = &netdev_ops;
688 dev->watchdog_timeo = (400 * HZ) / 1000;
689 dev->ethtool_ops = &netdev_ethtool_ops;
690
691 return register_netdev(dev);
692 }
693
694
corkscrew_open(struct net_device * dev)695 static int corkscrew_open(struct net_device *dev)
696 {
697 int ioaddr = dev->base_addr;
698 struct corkscrew_private *vp = netdev_priv(dev);
699 bool armtimer = false;
700 __u32 config;
701 int i;
702
703 /* Before initializing select the active media port. */
704 EL3WINDOW(3);
705 if (vp->full_duplex)
706 outb(0x20, ioaddr + Wn3_MAC_Ctrl); /* Set the full-duplex bit. */
707 config = inl(ioaddr + Wn3_Config);
708
709 if (vp->media_override != 7) {
710 if (corkscrew_debug > 1)
711 pr_info("%s: Media override to transceiver %d (%s).\n",
712 dev->name, vp->media_override,
713 media_tbl[vp->media_override].name);
714 dev->if_port = vp->media_override;
715 } else if (vp->autoselect) {
716 /* Find first available media type, starting with 100baseTx. */
717 dev->if_port = 4;
718 while (!(vp->available_media & media_tbl[dev->if_port].mask))
719 dev->if_port = media_tbl[dev->if_port].next;
720
721 if (corkscrew_debug > 1)
722 pr_debug("%s: Initial media type %s.\n",
723 dev->name, media_tbl[dev->if_port].name);
724 armtimer = true;
725 } else
726 dev->if_port = vp->default_media;
727
728 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
729 outl(config, ioaddr + Wn3_Config);
730
731 if (corkscrew_debug > 1) {
732 pr_debug("%s: corkscrew_open() InternalConfig %8.8x.\n",
733 dev->name, config);
734 }
735
736 outw(TxReset, ioaddr + EL3_CMD);
737 for (i = 20; i >= 0; i--)
738 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
739 break;
740
741 outw(RxReset, ioaddr + EL3_CMD);
742 /* Wait a few ticks for the RxReset command to complete. */
743 for (i = 20; i >= 0; i--)
744 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
745 break;
746
747 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
748
749 /* Use the now-standard shared IRQ implementation. */
750 if (vp->capabilities == 0x11c7) {
751 /* Corkscrew: Cannot share ISA resources. */
752 if (dev->irq == 0 ||
753 dev->dma == 0 ||
754 request_irq(dev->irq, corkscrew_interrupt, 0,
755 vp->product_name, dev))
756 return -EAGAIN;
757 enable_dma(dev->dma);
758 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
759 } else if (request_irq(dev->irq, corkscrew_interrupt, IRQF_SHARED,
760 vp->product_name, dev)) {
761 return -EAGAIN;
762 }
763
764 if (armtimer)
765 mod_timer(&vp->timer, jiffies + media_tbl[dev->if_port].wait);
766
767 if (corkscrew_debug > 1) {
768 EL3WINDOW(4);
769 pr_debug("%s: corkscrew_open() irq %d media status %4.4x.\n",
770 dev->name, dev->irq, inw(ioaddr + Wn4_Media));
771 }
772
773 /* Set the station address and mask in window 2 each time opened. */
774 EL3WINDOW(2);
775 for (i = 0; i < 6; i++)
776 outb(dev->dev_addr[i], ioaddr + i);
777 for (; i < 12; i += 2)
778 outw(0, ioaddr + i);
779
780 if (dev->if_port == 3)
781 /* Start the thinnet transceiver. We should really wait 50ms... */
782 outw(StartCoax, ioaddr + EL3_CMD);
783 EL3WINDOW(4);
784 outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
785 media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
786
787 /* Switch to the stats window, and clear all stats by reading. */
788 outw(StatsDisable, ioaddr + EL3_CMD);
789 EL3WINDOW(6);
790 for (i = 0; i < 10; i++)
791 inb(ioaddr + i);
792 inw(ioaddr + 10);
793 inw(ioaddr + 12);
794 /* New: On the Vortex we must also clear the BadSSD counter. */
795 EL3WINDOW(4);
796 inb(ioaddr + 12);
797 /* ..and on the Boomerang we enable the extra statistics bits. */
798 outw(0x0040, ioaddr + Wn4_NetDiag);
799
800 /* Switch to register set 7 for normal use. */
801 EL3WINDOW(7);
802
803 if (vp->full_bus_master_rx) { /* Boomerang bus master. */
804 vp->cur_rx = vp->dirty_rx = 0;
805 if (corkscrew_debug > 2)
806 pr_debug("%s: Filling in the Rx ring.\n", dev->name);
807 for (i = 0; i < RX_RING_SIZE; i++) {
808 struct sk_buff *skb;
809 if (i < (RX_RING_SIZE - 1))
810 vp->rx_ring[i].next =
811 isa_virt_to_bus(&vp->rx_ring[i + 1]);
812 else
813 vp->rx_ring[i].next = 0;
814 vp->rx_ring[i].status = 0; /* Clear complete bit. */
815 vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
816 skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
817 vp->rx_skbuff[i] = skb;
818 if (skb == NULL)
819 break; /* Bad news! */
820 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
821 vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
822 }
823 if (i != 0)
824 vp->rx_ring[i - 1].next =
825 isa_virt_to_bus(&vp->rx_ring[0]); /* Wrap the ring. */
826 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
827 }
828 if (vp->full_bus_master_tx) { /* Boomerang bus master Tx. */
829 vp->cur_tx = vp->dirty_tx = 0;
830 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold); /* Room for a packet. */
831 /* Clear the Tx ring. */
832 for (i = 0; i < TX_RING_SIZE; i++)
833 vp->tx_skbuff[i] = NULL;
834 outl(0, ioaddr + DownListPtr);
835 }
836 /* Set receiver mode: presumably accept b-case and phys addr only. */
837 set_rx_mode(dev);
838 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
839
840 netif_start_queue(dev);
841
842 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
843 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
844 /* Allow status bits to be seen. */
845 outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
846 (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
847 (vp->full_bus_master_rx ? UpComplete : RxComplete) |
848 (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
849 /* Ack all pending events, and set active indicator mask. */
850 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
851 ioaddr + EL3_CMD);
852 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
853 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
854 ioaddr + EL3_CMD);
855
856 return 0;
857 }
858
corkscrew_timer(struct timer_list * t)859 static void corkscrew_timer(struct timer_list *t)
860 {
861 #ifdef AUTOMEDIA
862 struct corkscrew_private *vp = from_timer(vp, t, timer);
863 struct net_device *dev = vp->our_dev;
864 int ioaddr = dev->base_addr;
865 unsigned long flags;
866 int ok = 0;
867
868 if (corkscrew_debug > 1)
869 pr_debug("%s: Media selection timer tick happened, %s.\n",
870 dev->name, media_tbl[dev->if_port].name);
871
872 spin_lock_irqsave(&vp->lock, flags);
873
874 {
875 int old_window = inw(ioaddr + EL3_CMD) >> 13;
876 int media_status;
877 EL3WINDOW(4);
878 media_status = inw(ioaddr + Wn4_Media);
879 switch (dev->if_port) {
880 case 0:
881 case 4:
882 case 5: /* 10baseT, 100baseTX, 100baseFX */
883 if (media_status & Media_LnkBeat) {
884 ok = 1;
885 if (corkscrew_debug > 1)
886 pr_debug("%s: Media %s has link beat, %x.\n",
887 dev->name,
888 media_tbl[dev->if_port].name,
889 media_status);
890 } else if (corkscrew_debug > 1)
891 pr_debug("%s: Media %s is has no link beat, %x.\n",
892 dev->name,
893 media_tbl[dev->if_port].name,
894 media_status);
895
896 break;
897 default: /* Other media types handled by Tx timeouts. */
898 if (corkscrew_debug > 1)
899 pr_debug("%s: Media %s is has no indication, %x.\n",
900 dev->name,
901 media_tbl[dev->if_port].name,
902 media_status);
903 ok = 1;
904 }
905 if (!ok) {
906 __u32 config;
907
908 do {
909 dev->if_port =
910 media_tbl[dev->if_port].next;
911 }
912 while (!(vp->available_media & media_tbl[dev->if_port].mask));
913
914 if (dev->if_port == 8) { /* Go back to default. */
915 dev->if_port = vp->default_media;
916 if (corkscrew_debug > 1)
917 pr_debug("%s: Media selection failing, using default %s port.\n",
918 dev->name,
919 media_tbl[dev->if_port].name);
920 } else {
921 if (corkscrew_debug > 1)
922 pr_debug("%s: Media selection failed, now trying %s port.\n",
923 dev->name,
924 media_tbl[dev->if_port].name);
925 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
926 add_timer(&vp->timer);
927 }
928 outw((media_status & ~(Media_10TP | Media_SQE)) |
929 media_tbl[dev->if_port].media_bits,
930 ioaddr + Wn4_Media);
931
932 EL3WINDOW(3);
933 config = inl(ioaddr + Wn3_Config);
934 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
935 outl(config, ioaddr + Wn3_Config);
936
937 outw(dev->if_port == 3 ? StartCoax : StopCoax,
938 ioaddr + EL3_CMD);
939 }
940 EL3WINDOW(old_window);
941 }
942
943 spin_unlock_irqrestore(&vp->lock, flags);
944 if (corkscrew_debug > 1)
945 pr_debug("%s: Media selection timer finished, %s.\n",
946 dev->name, media_tbl[dev->if_port].name);
947
948 #endif /* AUTOMEDIA */
949 }
950
corkscrew_timeout(struct net_device * dev,unsigned int txqueue)951 static void corkscrew_timeout(struct net_device *dev, unsigned int txqueue)
952 {
953 int i;
954 struct corkscrew_private *vp = netdev_priv(dev);
955 int ioaddr = dev->base_addr;
956
957 pr_warn("%s: transmit timed out, tx_status %2.2x status %4.4x\n",
958 dev->name, inb(ioaddr + TxStatus),
959 inw(ioaddr + EL3_STATUS));
960 /* Slight code bloat to be user friendly. */
961 if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
962 pr_warn("%s: Transmitter encountered 16 collisions -- network cable problem?\n",
963 dev->name);
964 #ifndef final_version
965 pr_debug(" Flags; bus-master %d, full %d; dirty %d current %d.\n",
966 vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
967 vp->cur_tx);
968 pr_debug(" Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
969 &vp->tx_ring[0]);
970 for (i = 0; i < TX_RING_SIZE; i++) {
971 pr_debug(" %d: %p length %8.8x status %8.8x\n", i,
972 &vp->tx_ring[i],
973 vp->tx_ring[i].length, vp->tx_ring[i].status);
974 }
975 #endif
976 /* Issue TX_RESET and TX_START commands. */
977 outw(TxReset, ioaddr + EL3_CMD);
978 for (i = 20; i >= 0; i--)
979 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
980 break;
981 outw(TxEnable, ioaddr + EL3_CMD);
982 netif_trans_update(dev); /* prevent tx timeout */
983 dev->stats.tx_errors++;
984 dev->stats.tx_dropped++;
985 netif_wake_queue(dev);
986 }
987
corkscrew_start_xmit(struct sk_buff * skb,struct net_device * dev)988 static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
989 struct net_device *dev)
990 {
991 struct corkscrew_private *vp = netdev_priv(dev);
992 int ioaddr = dev->base_addr;
993
994 /* Block a timer-based transmit from overlapping. */
995
996 netif_stop_queue(dev);
997
998 if (vp->full_bus_master_tx) { /* BOOMERANG bus-master */
999 /* Calculate the next Tx descriptor entry. */
1000 int entry = vp->cur_tx % TX_RING_SIZE;
1001 struct boom_tx_desc *prev_entry;
1002 unsigned long flags;
1003 int i;
1004
1005 if (vp->tx_full) /* No room to transmit with */
1006 return NETDEV_TX_BUSY;
1007 if (vp->cur_tx != 0)
1008 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1009 else
1010 prev_entry = NULL;
1011 if (corkscrew_debug > 3)
1012 pr_debug("%s: Trying to send a packet, Tx index %d.\n",
1013 dev->name, vp->cur_tx);
1014 /* vp->tx_full = 1; */
1015 vp->tx_skbuff[entry] = skb;
1016 vp->tx_ring[entry].next = 0;
1017 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1018 vp->tx_ring[entry].length = skb->len | 0x80000000;
1019 vp->tx_ring[entry].status = skb->len | 0x80000000;
1020
1021 spin_lock_irqsave(&vp->lock, flags);
1022 outw(DownStall, ioaddr + EL3_CMD);
1023 /* Wait for the stall to complete. */
1024 for (i = 20; i >= 0; i--)
1025 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1026 break;
1027 if (prev_entry)
1028 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1029 if (inl(ioaddr + DownListPtr) == 0) {
1030 outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1031 ioaddr + DownListPtr);
1032 queued_packet++;
1033 }
1034 outw(DownUnstall, ioaddr + EL3_CMD);
1035 spin_unlock_irqrestore(&vp->lock, flags);
1036
1037 vp->cur_tx++;
1038 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1039 vp->tx_full = 1;
1040 else { /* Clear previous interrupt enable. */
1041 if (prev_entry)
1042 prev_entry->status &= ~0x80000000;
1043 netif_wake_queue(dev);
1044 }
1045 return NETDEV_TX_OK;
1046 }
1047 /* Put out the doubleword header... */
1048 outl(skb->len, ioaddr + TX_FIFO);
1049 dev->stats.tx_bytes += skb->len;
1050 #ifdef VORTEX_BUS_MASTER
1051 if (vp->bus_master) {
1052 /* Set the bus-master controller to transfer the packet. */
1053 outl(isa_virt_to_bus(skb->data), ioaddr + Wn7_MasterAddr);
1054 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1055 vp->tx_skb = skb;
1056 outw(StartDMADown, ioaddr + EL3_CMD);
1057 /* queue will be woken at the DMADone interrupt. */
1058 } else {
1059 /* ... and the packet rounded to a doubleword. */
1060 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1061 dev_kfree_skb(skb);
1062 if (inw(ioaddr + TxFree) > 1536) {
1063 netif_wake_queue(dev);
1064 } else
1065 /* Interrupt us when the FIFO has room for max-sized packet. */
1066 outw(SetTxThreshold + (1536 >> 2),
1067 ioaddr + EL3_CMD);
1068 }
1069 #else
1070 /* ... and the packet rounded to a doubleword. */
1071 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1072 dev_kfree_skb(skb);
1073 if (inw(ioaddr + TxFree) > 1536) {
1074 netif_wake_queue(dev);
1075 } else
1076 /* Interrupt us when the FIFO has room for max-sized packet. */
1077 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1078 #endif /* bus master */
1079
1080
1081 /* Clear the Tx status stack. */
1082 {
1083 short tx_status;
1084 int i = 4;
1085
1086 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1087 if (tx_status & 0x3C) { /* A Tx-disabling error occurred. */
1088 if (corkscrew_debug > 2)
1089 pr_debug("%s: Tx error, status %2.2x.\n",
1090 dev->name, tx_status);
1091 if (tx_status & 0x04)
1092 dev->stats.tx_fifo_errors++;
1093 if (tx_status & 0x38)
1094 dev->stats.tx_aborted_errors++;
1095 if (tx_status & 0x30) {
1096 int j;
1097 outw(TxReset, ioaddr + EL3_CMD);
1098 for (j = 20; j >= 0; j--)
1099 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1100 break;
1101 }
1102 outw(TxEnable, ioaddr + EL3_CMD);
1103 }
1104 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
1105 }
1106 }
1107 return NETDEV_TX_OK;
1108 }
1109
1110 /* The interrupt handler does all of the Rx thread work and cleans up
1111 after the Tx thread. */
1112
corkscrew_interrupt(int irq,void * dev_id)1113 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
1114 {
1115 /* Use the now-standard shared IRQ implementation. */
1116 struct net_device *dev = dev_id;
1117 struct corkscrew_private *lp = netdev_priv(dev);
1118 int ioaddr, status;
1119 int latency;
1120 int i = max_interrupt_work;
1121
1122 ioaddr = dev->base_addr;
1123 latency = inb(ioaddr + Timer);
1124
1125 spin_lock(&lp->lock);
1126
1127 status = inw(ioaddr + EL3_STATUS);
1128
1129 if (corkscrew_debug > 4)
1130 pr_debug("%s: interrupt, status %4.4x, timer %d.\n",
1131 dev->name, status, latency);
1132 if ((status & 0xE000) != 0xE000) {
1133 static int donedidthis;
1134 /* Some interrupt controllers store a bogus interrupt from boot-time.
1135 Ignore a single early interrupt, but don't hang the machine for
1136 other interrupt problems. */
1137 if (donedidthis++ > 100) {
1138 pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1139 dev->name, status, netif_running(dev));
1140 free_irq(dev->irq, dev);
1141 dev->irq = -1;
1142 }
1143 }
1144
1145 do {
1146 if (corkscrew_debug > 5)
1147 pr_debug("%s: In interrupt loop, status %4.4x.\n",
1148 dev->name, status);
1149 if (status & RxComplete)
1150 corkscrew_rx(dev);
1151
1152 if (status & TxAvailable) {
1153 if (corkscrew_debug > 5)
1154 pr_debug(" TX room bit was handled.\n");
1155 /* There's room in the FIFO for a full-sized packet. */
1156 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1157 netif_wake_queue(dev);
1158 }
1159 if (status & DownComplete) {
1160 unsigned int dirty_tx = lp->dirty_tx;
1161
1162 while (lp->cur_tx - dirty_tx > 0) {
1163 int entry = dirty_tx % TX_RING_SIZE;
1164 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1165 break; /* It still hasn't been processed. */
1166 if (lp->tx_skbuff[entry]) {
1167 dev_consume_skb_irq(lp->tx_skbuff[entry]);
1168 lp->tx_skbuff[entry] = NULL;
1169 }
1170 dirty_tx++;
1171 }
1172 lp->dirty_tx = dirty_tx;
1173 outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1174 if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1175 lp->tx_full = 0;
1176 netif_wake_queue(dev);
1177 }
1178 }
1179 #ifdef VORTEX_BUS_MASTER
1180 if (status & DMADone) {
1181 outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
1182 dev_consume_skb_irq(lp->tx_skb); /* Release the transferred buffer */
1183 netif_wake_queue(dev);
1184 }
1185 #endif
1186 if (status & UpComplete) {
1187 boomerang_rx(dev);
1188 outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1189 }
1190 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1191 /* Handle all uncommon interrupts at once. */
1192 if (status & RxEarly) { /* Rx early is unused. */
1193 corkscrew_rx(dev);
1194 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1195 }
1196 if (status & StatsFull) { /* Empty statistics. */
1197 static int DoneDidThat;
1198 if (corkscrew_debug > 4)
1199 pr_debug("%s: Updating stats.\n", dev->name);
1200 update_stats(ioaddr, dev);
1201 /* DEBUG HACK: Disable statistics as an interrupt source. */
1202 /* This occurs when we have the wrong media type! */
1203 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1204 int win, reg;
1205 pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n",
1206 dev->name);
1207 for (win = 0; win < 8; win++) {
1208 EL3WINDOW(win);
1209 pr_notice("Vortex window %d:", win);
1210 for (reg = 0; reg < 16; reg++)
1211 pr_cont(" %2.2x", inb(ioaddr + reg));
1212 pr_cont("\n");
1213 }
1214 EL3WINDOW(7);
1215 outw(SetIntrEnb | TxAvailable |
1216 RxComplete | AdapterFailure |
1217 UpComplete | DownComplete |
1218 TxComplete, ioaddr + EL3_CMD);
1219 DoneDidThat++;
1220 }
1221 }
1222 if (status & AdapterFailure) {
1223 /* Adapter failure requires Rx reset and reinit. */
1224 outw(RxReset, ioaddr + EL3_CMD);
1225 /* Set the Rx filter to the current state. */
1226 set_rx_mode(dev);
1227 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
1228 outw(AckIntr | AdapterFailure,
1229 ioaddr + EL3_CMD);
1230 }
1231 }
1232
1233 if (--i < 0) {
1234 pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n",
1235 dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
1236 /* Disable all pending interrupts. */
1237 outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1238 outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1239 break;
1240 }
1241 /* Acknowledge the IRQ. */
1242 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1243
1244 } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1245
1246 spin_unlock(&lp->lock);
1247
1248 if (corkscrew_debug > 4)
1249 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1250 return IRQ_HANDLED;
1251 }
1252
corkscrew_rx(struct net_device * dev)1253 static int corkscrew_rx(struct net_device *dev)
1254 {
1255 int ioaddr = dev->base_addr;
1256 int i;
1257 short rx_status;
1258
1259 if (corkscrew_debug > 5)
1260 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1261 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1262 while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1263 if (rx_status & 0x4000) { /* Error, update stats. */
1264 unsigned char rx_error = inb(ioaddr + RxErrors);
1265 if (corkscrew_debug > 2)
1266 pr_debug(" Rx error: status %2.2x.\n",
1267 rx_error);
1268 dev->stats.rx_errors++;
1269 if (rx_error & 0x01)
1270 dev->stats.rx_over_errors++;
1271 if (rx_error & 0x02)
1272 dev->stats.rx_length_errors++;
1273 if (rx_error & 0x04)
1274 dev->stats.rx_frame_errors++;
1275 if (rx_error & 0x08)
1276 dev->stats.rx_crc_errors++;
1277 if (rx_error & 0x10)
1278 dev->stats.rx_length_errors++;
1279 } else {
1280 /* The packet length: up to 4.5K!. */
1281 short pkt_len = rx_status & 0x1fff;
1282 struct sk_buff *skb;
1283
1284 skb = netdev_alloc_skb(dev, pkt_len + 5 + 2);
1285 if (corkscrew_debug > 4)
1286 pr_debug("Receiving packet size %d status %4.4x.\n",
1287 pkt_len, rx_status);
1288 if (skb != NULL) {
1289 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1290 /* 'skb_put()' points to the start of sk_buff data area. */
1291 insl(ioaddr + RX_FIFO,
1292 skb_put(skb, pkt_len),
1293 (pkt_len + 3) >> 2);
1294 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1295 skb->protocol = eth_type_trans(skb, dev);
1296 netif_rx(skb);
1297 dev->stats.rx_packets++;
1298 dev->stats.rx_bytes += pkt_len;
1299 /* Wait a limited time to go to next packet. */
1300 for (i = 200; i >= 0; i--)
1301 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1302 break;
1303 continue;
1304 } else if (corkscrew_debug)
1305 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1306 }
1307 outw(RxDiscard, ioaddr + EL3_CMD);
1308 dev->stats.rx_dropped++;
1309 /* Wait a limited time to skip this packet. */
1310 for (i = 200; i >= 0; i--)
1311 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1312 break;
1313 }
1314 return 0;
1315 }
1316
boomerang_rx(struct net_device * dev)1317 static int boomerang_rx(struct net_device *dev)
1318 {
1319 struct corkscrew_private *vp = netdev_priv(dev);
1320 int entry = vp->cur_rx % RX_RING_SIZE;
1321 int ioaddr = dev->base_addr;
1322 int rx_status;
1323
1324 if (corkscrew_debug > 5)
1325 pr_debug(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1326 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1327 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1328 if (rx_status & RxDError) { /* Error, update stats. */
1329 unsigned char rx_error = rx_status >> 16;
1330 if (corkscrew_debug > 2)
1331 pr_debug(" Rx error: status %2.2x.\n",
1332 rx_error);
1333 dev->stats.rx_errors++;
1334 if (rx_error & 0x01)
1335 dev->stats.rx_over_errors++;
1336 if (rx_error & 0x02)
1337 dev->stats.rx_length_errors++;
1338 if (rx_error & 0x04)
1339 dev->stats.rx_frame_errors++;
1340 if (rx_error & 0x08)
1341 dev->stats.rx_crc_errors++;
1342 if (rx_error & 0x10)
1343 dev->stats.rx_length_errors++;
1344 } else {
1345 /* The packet length: up to 4.5K!. */
1346 short pkt_len = rx_status & 0x1fff;
1347 struct sk_buff *skb;
1348
1349 dev->stats.rx_bytes += pkt_len;
1350 if (corkscrew_debug > 4)
1351 pr_debug("Receiving packet size %d status %4.4x.\n",
1352 pkt_len, rx_status);
1353
1354 /* Check if the packet is long enough to just accept without
1355 copying to a properly sized skbuff. */
1356 if (pkt_len < rx_copybreak &&
1357 (skb = netdev_alloc_skb(dev, pkt_len + 4)) != NULL) {
1358 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1359 /* 'skb_put()' points to the start of sk_buff data area. */
1360 skb_put_data(skb,
1361 isa_bus_to_virt(vp->rx_ring[entry].addr),
1362 pkt_len);
1363 rx_copy++;
1364 } else {
1365 void *temp;
1366 /* Pass up the skbuff already on the Rx ring. */
1367 skb = vp->rx_skbuff[entry];
1368 vp->rx_skbuff[entry] = NULL;
1369 temp = skb_put(skb, pkt_len);
1370 /* Remove this checking code for final release. */
1371 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1372 pr_warn("%s: Warning -- the skbuff addresses do not match in boomerang_rx: %p vs. %p / %p\n",
1373 dev->name,
1374 isa_bus_to_virt(vp->rx_ring[entry].addr),
1375 skb->head, temp);
1376 rx_nocopy++;
1377 }
1378 skb->protocol = eth_type_trans(skb, dev);
1379 netif_rx(skb);
1380 dev->stats.rx_packets++;
1381 }
1382 entry = (++vp->cur_rx) % RX_RING_SIZE;
1383 }
1384 /* Refill the Rx ring buffers. */
1385 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1386 struct sk_buff *skb;
1387 entry = vp->dirty_rx % RX_RING_SIZE;
1388 if (vp->rx_skbuff[entry] == NULL) {
1389 skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
1390 if (skb == NULL)
1391 break; /* Bad news! */
1392 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
1393 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1394 vp->rx_skbuff[entry] = skb;
1395 }
1396 vp->rx_ring[entry].status = 0; /* Clear complete bit. */
1397 }
1398 return 0;
1399 }
1400
corkscrew_close(struct net_device * dev)1401 static int corkscrew_close(struct net_device *dev)
1402 {
1403 struct corkscrew_private *vp = netdev_priv(dev);
1404 int ioaddr = dev->base_addr;
1405 int i;
1406
1407 netif_stop_queue(dev);
1408
1409 if (corkscrew_debug > 1) {
1410 pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1411 dev->name, inw(ioaddr + EL3_STATUS),
1412 inb(ioaddr + TxStatus));
1413 pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n",
1414 dev->name, rx_nocopy, rx_copy, queued_packet);
1415 }
1416
1417 del_timer_sync(&vp->timer);
1418
1419 /* Turn off statistics ASAP. We update lp->stats below. */
1420 outw(StatsDisable, ioaddr + EL3_CMD);
1421
1422 /* Disable the receiver and transmitter. */
1423 outw(RxDisable, ioaddr + EL3_CMD);
1424 outw(TxDisable, ioaddr + EL3_CMD);
1425
1426 if (dev->if_port == XCVR_10base2)
1427 /* Turn off thinnet power. Green! */
1428 outw(StopCoax, ioaddr + EL3_CMD);
1429
1430 free_irq(dev->irq, dev);
1431
1432 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1433
1434 update_stats(ioaddr, dev);
1435 if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
1436 outl(0, ioaddr + UpListPtr);
1437 for (i = 0; i < RX_RING_SIZE; i++)
1438 if (vp->rx_skbuff[i]) {
1439 dev_kfree_skb(vp->rx_skbuff[i]);
1440 vp->rx_skbuff[i] = NULL;
1441 }
1442 }
1443 if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
1444 outl(0, ioaddr + DownListPtr);
1445 for (i = 0; i < TX_RING_SIZE; i++)
1446 if (vp->tx_skbuff[i]) {
1447 dev_kfree_skb(vp->tx_skbuff[i]);
1448 vp->tx_skbuff[i] = NULL;
1449 }
1450 }
1451
1452 return 0;
1453 }
1454
corkscrew_get_stats(struct net_device * dev)1455 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1456 {
1457 struct corkscrew_private *vp = netdev_priv(dev);
1458 unsigned long flags;
1459
1460 if (netif_running(dev)) {
1461 spin_lock_irqsave(&vp->lock, flags);
1462 update_stats(dev->base_addr, dev);
1463 spin_unlock_irqrestore(&vp->lock, flags);
1464 }
1465 return &dev->stats;
1466 }
1467
1468 /* Update statistics.
1469 Unlike with the EL3 we need not worry about interrupts changing
1470 the window setting from underneath us, but we must still guard
1471 against a race condition with a StatsUpdate interrupt updating the
1472 table. This is done by checking that the ASM (!) code generated uses
1473 atomic updates with '+='.
1474 */
update_stats(int ioaddr,struct net_device * dev)1475 static void update_stats(int ioaddr, struct net_device *dev)
1476 {
1477 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
1478 /* Switch to the stats window, and read everything. */
1479 EL3WINDOW(6);
1480 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1481 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1482 /* Multiple collisions. */ inb(ioaddr + 2);
1483 dev->stats.collisions += inb(ioaddr + 3);
1484 dev->stats.tx_window_errors += inb(ioaddr + 4);
1485 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1486 dev->stats.tx_packets += inb(ioaddr + 6);
1487 dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1488 /* Rx packets */ inb(ioaddr + 7);
1489 /* Must read to clear */
1490 /* Tx deferrals */ inb(ioaddr + 8);
1491 /* Don't bother with register 9, an extension of registers 6&7.
1492 If we do use the 6&7 values the atomic update assumption above
1493 is invalid. */
1494 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1495 inw(ioaddr + 12);
1496 /* New: On the Vortex we must also clear the BadSSD counter. */
1497 EL3WINDOW(4);
1498 inb(ioaddr + 12);
1499
1500 /* We change back to window 7 (not 1) with the Vortex. */
1501 EL3WINDOW(7);
1502 }
1503
1504 /* This new version of set_rx_mode() supports v1.4 kernels.
1505 The Vortex chip has no documented multicast filter, so the only
1506 multicast setting is to receive all multicast frames. At least
1507 the chip has a very clean way to set the mode, unlike many others. */
set_rx_mode(struct net_device * dev)1508 static void set_rx_mode(struct net_device *dev)
1509 {
1510 int ioaddr = dev->base_addr;
1511 unsigned short new_mode;
1512
1513 if (dev->flags & IFF_PROMISC) {
1514 if (corkscrew_debug > 3)
1515 pr_debug("%s: Setting promiscuous mode.\n",
1516 dev->name);
1517 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1518 } else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) {
1519 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1520 } else
1521 new_mode = SetRxFilter | RxStation | RxBroadcast;
1522
1523 outw(new_mode, ioaddr + EL3_CMD);
1524 }
1525
netdev_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * info)1526 static void netdev_get_drvinfo(struct net_device *dev,
1527 struct ethtool_drvinfo *info)
1528 {
1529 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1530 snprintf(info->bus_info, sizeof(info->bus_info), "ISA 0x%lx",
1531 dev->base_addr);
1532 }
1533
netdev_get_msglevel(struct net_device * dev)1534 static u32 netdev_get_msglevel(struct net_device *dev)
1535 {
1536 return corkscrew_debug;
1537 }
1538
netdev_set_msglevel(struct net_device * dev,u32 level)1539 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1540 {
1541 corkscrew_debug = level;
1542 }
1543
1544 static const struct ethtool_ops netdev_ethtool_ops = {
1545 .get_drvinfo = netdev_get_drvinfo,
1546 .get_msglevel = netdev_get_msglevel,
1547 .set_msglevel = netdev_set_msglevel,
1548 };
1549
1550
1551 #ifdef MODULE
cleanup_module(void)1552 void cleanup_module(void)
1553 {
1554 while (!list_empty(&root_corkscrew_dev)) {
1555 struct net_device *dev;
1556 struct corkscrew_private *vp;
1557
1558 vp = list_entry(root_corkscrew_dev.next,
1559 struct corkscrew_private, list);
1560 dev = vp->our_dev;
1561 unregister_netdev(dev);
1562 cleanup_card(dev);
1563 free_netdev(dev);
1564 }
1565 }
1566 #endif /* MODULE */
1567
