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