This source file includes following definitions.
- init_module
- tc515_probe
- check_device
- cleanup_card
- corkscrew_scan
- corkscrew_setup
- corkscrew_open
- corkscrew_timer
- corkscrew_timeout
- corkscrew_start_xmit
- corkscrew_interrupt
- corkscrew_rx
- boomerang_rx
- corkscrew_close
- corkscrew_get_stats
- update_stats
- set_rx_mode
- netdev_get_drvinfo
- netdev_get_msglevel
- netdev_set_msglevel
- cleanup_module
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
35
36
37 static int rx_copybreak = 200;
38
39
40 static const int mtu = 1500;
41
42
43 static int max_interrupt_work = 20;
44
45
46 #define AUTOMEDIA 1
47
48
49
50
51
52 #define VORTEX_BUS_MASTER
53
54
55
56 #define TX_RING_SIZE 16
57 #define RX_RING_SIZE 16
58 #define PKT_BUF_SZ 1536
59
60 #include <linux/module.h>
61 #include <linux/isapnp.h>
62 #include <linux/kernel.h>
63 #include <linux/netdevice.h>
64 #include <linux/string.h>
65 #include <linux/errno.h>
66 #include <linux/in.h>
67 #include <linux/ioport.h>
68 #include <linux/skbuff.h>
69 #include <linux/etherdevice.h>
70 #include <linux/interrupt.h>
71 #include <linux/timer.h>
72 #include <linux/ethtool.h>
73 #include <linux/bitops.h>
74
75 #include <linux/uaccess.h>
76 #include <asm/io.h>
77 #include <asm/dma.h>
78
79 #define NEW_MULTICAST
80 #include <linux/delay.h>
81
82 #define MAX_UNITS 8
83
84 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
85 MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
86 MODULE_LICENSE("GPL");
87 MODULE_VERSION(DRV_VERSION);
88
89
90
91 #define DRIVER_DEBUG 1
92
93
94 static int rx_nocopy, rx_copy, queued_packet;
95
96
97
98 #define WAIT_TX_AVAIL 200
99
100
101 #define TX_TIMEOUT ((4*HZ)/10)
102
103
104
105
106 #define CORKSCREW_TOTAL_SIZE 0x20
107
108 #ifdef DRIVER_DEBUG
109 static int corkscrew_debug = DRIVER_DEBUG;
110 #else
111 static int corkscrew_debug = 1;
112 #endif
113
114 #define CORKSCREW_ID 10
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
176 #define EL3_CMD 0x0e
177 #define EL3_STATUS 0x0e
178
179
180
181
182
183
184
185 enum corkscrew_cmd {
186 TotalReset = 0 << 11, SelectWindow = 1 << 11, StartCoax = 2 << 11,
187 RxDisable = 3 << 11, RxEnable = 4 << 11, RxReset = 5 << 11,
188 UpStall = 6 << 11, UpUnstall = (6 << 11) + 1, DownStall = (6 << 11) + 2,
189 DownUnstall = (6 << 11) + 3, RxDiscard = 8 << 11, TxEnable = 9 << 11,
190 TxDisable = 10 << 11, TxReset = 11 << 11, FakeIntr = 12 << 11,
191 AckIntr = 13 << 11, SetIntrEnb = 14 << 11, SetStatusEnb = 15 << 11,
192 SetRxFilter = 16 << 11, SetRxThreshold = 17 << 11,
193 SetTxThreshold = 18 << 11, SetTxStart = 19 << 11, StartDMAUp = 20 << 11,
194 StartDMADown = (20 << 11) + 1, StatsEnable = 21 << 11,
195 StatsDisable = 22 << 11, StopCoax = 23 << 11,
196 };
197
198
199 enum RxFilter {
200 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
201 };
202
203
204 enum corkscrew_status {
205 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
206 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
207 IntReq = 0x0040, StatsFull = 0x0080,
208 DMADone = 1 << 8, DownComplete = 1 << 9, UpComplete = 1 << 10,
209 DMAInProgress = 1 << 11,
210 CmdInProgress = 1 << 12,
211 };
212
213
214
215 enum Window1 {
216 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
217 RxStatus = 0x18, Timer = 0x1A, TxStatus = 0x1B,
218 TxFree = 0x1C,
219 };
220 enum Window0 {
221 Wn0IRQ = 0x08,
222 #if defined(CORKSCREW)
223 Wn0EepromCmd = 0x200A,
224 Wn0EepromData = 0x200C,
225 #else
226 Wn0EepromCmd = 10,
227 Wn0EepromData = 12,
228 #endif
229 };
230 enum Win0_EEPROM_bits {
231 EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
232 EEPROM_EWENB = 0x30,
233 EEPROM_EWDIS = 0x00,
234 };
235
236
237 enum eeprom_offset {
238 PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3,
239 EtherLink3ID = 7,
240 };
241
242 enum Window3 {
243 Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8,
244 };
245 enum wn3_config {
246 Ram_size = 7,
247 Ram_width = 8,
248 Ram_speed = 0x30,
249 Rom_size = 0xc0,
250 Ram_split_shift = 16,
251 Ram_split = 3 << Ram_split_shift,
252 Xcvr_shift = 20,
253 Xcvr = 7 << Xcvr_shift,
254 Autoselect = 0x1000000,
255 };
256
257 enum Window4 {
258 Wn4_NetDiag = 6, Wn4_Media = 10,
259 };
260 enum Win4_Media_bits {
261 Media_SQE = 0x0008,
262 Media_10TP = 0x00C0,
263 Media_Lnk = 0x0080,
264 Media_LnkBeat = 0x0800,
265 };
266 enum Window7 {
267 Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
268 };
269
270
271 enum MasterCtrl {
272 PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
273 0x40c,
274 TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
275 };
276
277
278
279
280 struct boom_rx_desc {
281 u32 next;
282 s32 status;
283 u32 addr;
284 s32 length;
285 };
286
287
288 enum rx_desc_status {
289 RxDComplete = 0x00008000, RxDError = 0x4000,
290
291 };
292
293 struct boom_tx_desc {
294 u32 next;
295 s32 status;
296 u32 addr;
297 s32 length;
298 };
299
300 struct corkscrew_private {
301 const char *product_name;
302 struct list_head list;
303 struct net_device *our_dev;
304
305 struct boom_rx_desc rx_ring[RX_RING_SIZE];
306 struct boom_tx_desc tx_ring[TX_RING_SIZE];
307
308 struct sk_buff *rx_skbuff[RX_RING_SIZE];
309 struct sk_buff *tx_skbuff[TX_RING_SIZE];
310 unsigned int cur_rx, cur_tx;
311 unsigned int dirty_rx, dirty_tx;
312 struct sk_buff *tx_skb;
313 struct timer_list timer;
314 int capabilities ;
315 int options;
316 int last_rx_packets;
317 unsigned int available_media:8,
318 media_override:3,
319 default_media:3,
320 full_duplex:1, autoselect:1, bus_master:1,
321 full_bus_master_tx:1, full_bus_master_rx:1,
322 tx_full:1;
323 spinlock_t lock;
324 struct device *dev;
325 };
326
327
328
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,
338 mask:8,
339 next:8;
340 short wait;
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 { }
359 };
360
361 MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
362
363 static int nopnp;
364 #endif
365
366 static struct net_device *corkscrew_scan(int unit);
367 static int 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(struct timer_list *t);
371 static netdev_tx_t 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 static int corkscrew_close(struct net_device *dev);
378 static void update_stats(int addr, struct net_device *dev);
379 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev);
380 static void set_rx_mode(struct net_device *dev);
381 static const struct ethtool_ops netdev_ethtool_ops;
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398 static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, };
399
400 #ifdef MODULE
401 static int debug = -1;
402
403 module_param(debug, int, 0);
404 module_param_array(options, int, NULL, 0);
405 module_param(rx_copybreak, int, 0);
406 module_param(max_interrupt_work, int, 0);
407 MODULE_PARM_DESC(debug, "3c515 debug level (0-6)");
408 MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering");
409 MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames");
410 MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt");
411
412
413
414 static LIST_HEAD(root_corkscrew_dev);
415
416 int init_module(void)
417 {
418 int found = 0;
419 if (debug >= 0)
420 corkscrew_debug = debug;
421 if (corkscrew_debug)
422 pr_debug("%s", version);
423 while (corkscrew_scan(-1))
424 found++;
425 return found ? 0 : -ENODEV;
426 }
427
428 #else
429 struct net_device *tc515_probe(int unit)
430 {
431 struct net_device *dev = corkscrew_scan(unit);
432 static int printed;
433
434 if (!dev)
435 return ERR_PTR(-ENODEV);
436
437 if (corkscrew_debug > 0 && !printed) {
438 printed = 1;
439 pr_debug("%s", version);
440 }
441
442 return dev;
443 }
444 #endif
445
446 static int check_device(unsigned ioaddr)
447 {
448 int timer;
449
450 if (!request_region(ioaddr, CORKSCREW_TOTAL_SIZE, "3c515"))
451 return 0;
452
453 if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0)) {
454 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
455 return 0;
456 }
457
458 outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd);
459
460 for (timer = 4; timer >= 0; timer--) {
461 udelay(162);
462 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
463 break;
464 }
465 if (inw(ioaddr + Wn0EepromData) != 0x6d50) {
466 release_region(ioaddr, CORKSCREW_TOTAL_SIZE);
467 return 0;
468 }
469 return 1;
470 }
471
472 static void cleanup_card(struct net_device *dev)
473 {
474 struct corkscrew_private *vp = netdev_priv(dev);
475 list_del_init(&vp->list);
476 if (dev->dma)
477 free_dma(dev->dma);
478 outw(TotalReset, dev->base_addr + EL3_CMD);
479 release_region(dev->base_addr, CORKSCREW_TOTAL_SIZE);
480 if (vp->dev)
481 pnp_device_detach(to_pnp_dev(vp->dev));
482 }
483
484 static struct net_device *corkscrew_scan(int unit)
485 {
486 struct net_device *dev;
487 static int cards_found = 0;
488 static int ioaddr;
489 int err;
490 #ifdef __ISAPNP__
491 short i;
492 static int pnp_cards;
493 #endif
494
495 dev = alloc_etherdev(sizeof(struct corkscrew_private));
496 if (!dev)
497 return ERR_PTR(-ENOMEM);
498
499 if (unit >= 0) {
500 sprintf(dev->name, "eth%d", unit);
501 netdev_boot_setup_check(dev);
502 }
503
504 #ifdef __ISAPNP__
505 if(nopnp == 1)
506 goto no_pnp;
507 for(i=0; corkscrew_isapnp_adapters[i].vendor != 0; i++) {
508 struct pnp_dev *idev = NULL;
509 int irq;
510 while((idev = pnp_find_dev(NULL,
511 corkscrew_isapnp_adapters[i].vendor,
512 corkscrew_isapnp_adapters[i].function,
513 idev))) {
514
515 if (pnp_device_attach(idev) < 0)
516 continue;
517 if (pnp_activate_dev(idev) < 0) {
518 pr_warn("pnp activate failed (out of resources?)\n");
519 pnp_device_detach(idev);
520 continue;
521 }
522 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
523 pnp_device_detach(idev);
524 continue;
525 }
526 ioaddr = pnp_port_start(idev, 0);
527 irq = pnp_irq(idev, 0);
528 if (!check_device(ioaddr)) {
529 pnp_device_detach(idev);
530 continue;
531 }
532 if(corkscrew_debug)
533 pr_debug("ISAPNP reports %s at i/o 0x%x, irq %d\n",
534 (char*) corkscrew_isapnp_adapters[i].driver_data, ioaddr, irq);
535 pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
536 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
537
538 SET_NETDEV_DEV(dev, &idev->dev);
539 pnp_cards++;
540 err = corkscrew_setup(dev, ioaddr, idev, cards_found++);
541 if (!err)
542 return dev;
543 cleanup_card(dev);
544 }
545 }
546 no_pnp:
547 #endif
548
549
550 for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x20) {
551 if (!check_device(ioaddr))
552 continue;
553
554 pr_info("3c515 Resource configuration register %#4.4x, DCR %4.4x.\n",
555 inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
556 err = corkscrew_setup(dev, ioaddr, NULL, cards_found++);
557 if (!err)
558 return dev;
559 cleanup_card(dev);
560 }
561 free_netdev(dev);
562 return NULL;
563 }
564
565
566 static const struct net_device_ops netdev_ops = {
567 .ndo_open = corkscrew_open,
568 .ndo_stop = corkscrew_close,
569 .ndo_start_xmit = corkscrew_start_xmit,
570 .ndo_tx_timeout = corkscrew_timeout,
571 .ndo_get_stats = corkscrew_get_stats,
572 .ndo_set_rx_mode = set_rx_mode,
573 .ndo_set_mac_address = eth_mac_addr,
574 .ndo_validate_addr = eth_validate_addr,
575 };
576
577
578 static int corkscrew_setup(struct net_device *dev, int ioaddr,
579 struct pnp_dev *idev, int card_number)
580 {
581 struct corkscrew_private *vp = netdev_priv(dev);
582 unsigned int eeprom[0x40], checksum = 0;
583 int i;
584 int irq;
585
586 #ifdef __ISAPNP__
587 if (idev) {
588 irq = pnp_irq(idev, 0);
589 vp->dev = &idev->dev;
590 } else {
591 irq = inw(ioaddr + 0x2002) & 15;
592 }
593 #else
594 irq = inw(ioaddr + 0x2002) & 15;
595 #endif
596
597 dev->base_addr = ioaddr;
598 dev->irq = irq;
599 dev->dma = inw(ioaddr + 0x2000) & 7;
600 vp->product_name = "3c515";
601 vp->options = dev->mem_start;
602 vp->our_dev = dev;
603
604 if (!vp->options) {
605 if (card_number >= MAX_UNITS)
606 vp->options = -1;
607 else
608 vp->options = options[card_number];
609 }
610
611 if (vp->options >= 0) {
612 vp->media_override = vp->options & 7;
613 if (vp->media_override == 2)
614 vp->media_override = 0;
615 vp->full_duplex = (vp->options & 8) ? 1 : 0;
616 vp->bus_master = (vp->options & 16) ? 1 : 0;
617 } else {
618 vp->media_override = 7;
619 vp->full_duplex = 0;
620 vp->bus_master = 0;
621 }
622 #ifdef MODULE
623 list_add(&vp->list, &root_corkscrew_dev);
624 #endif
625
626 pr_info("%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
627
628 spin_lock_init(&vp->lock);
629
630 timer_setup(&vp->timer, corkscrew_timer, 0);
631
632
633 EL3WINDOW(0);
634 for (i = 0; i < 0x18; i++) {
635 __be16 *phys_addr = (__be16 *) dev->dev_addr;
636 int timer;
637 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
638
639 for (timer = 4; timer >= 0; timer--) {
640 udelay(162);
641 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
642 break;
643 }
644 eeprom[i] = inw(ioaddr + Wn0EepromData);
645 checksum ^= eeprom[i];
646 if (i < 3)
647 phys_addr[i] = htons(eeprom[i]);
648 }
649 checksum = (checksum ^ (checksum >> 8)) & 0xff;
650 if (checksum != 0x00)
651 pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
652 pr_cont(" %pM", dev->dev_addr);
653 if (eeprom[16] == 0x11c7) {
654 if (request_dma(dev->dma, "3c515")) {
655 pr_cont(", DMA %d allocation failed", dev->dma);
656 dev->dma = 0;
657 } else
658 pr_cont(", DMA %d", dev->dma);
659 }
660 pr_cont(", IRQ %d\n", dev->irq);
661
662 if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
663 pr_warn(" *** Warning: this IRQ is unlikely to work! ***\n");
664
665 {
666 static const char * const ram_split[] = {
667 "5:3", "3:1", "1:1", "3:5"
668 };
669 __u32 config;
670 EL3WINDOW(3);
671 vp->available_media = inw(ioaddr + Wn3_Options);
672 config = inl(ioaddr + Wn3_Config);
673 if (corkscrew_debug > 1)
674 pr_info(" Internal config register is %4.4x, transceivers %#x.\n",
675 config, inw(ioaddr + Wn3_Options));
676 pr_info(" %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
677 8 << config & Ram_size,
678 config & Ram_width ? "word" : "byte",
679 ram_split[(config & Ram_split) >> Ram_split_shift],
680 config & Autoselect ? "autoselect/" : "",
681 media_tbl[(config & Xcvr) >> Xcvr_shift].name);
682 vp->default_media = (config & Xcvr) >> Xcvr_shift;
683 vp->autoselect = config & Autoselect ? 1 : 0;
684 dev->if_port = vp->default_media;
685 }
686 if (vp->media_override != 7) {
687 pr_info(" Media override to transceiver type %d (%s).\n",
688 vp->media_override,
689 media_tbl[vp->media_override].name);
690 dev->if_port = vp->media_override;
691 }
692
693 vp->capabilities = eeprom[16];
694 vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
695
696
697 vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
698
699
700 dev->netdev_ops = &netdev_ops;
701 dev->watchdog_timeo = (400 * HZ) / 1000;
702 dev->ethtool_ops = &netdev_ethtool_ops;
703
704 return register_netdev(dev);
705 }
706
707
708 static int corkscrew_open(struct net_device *dev)
709 {
710 int ioaddr = dev->base_addr;
711 struct corkscrew_private *vp = netdev_priv(dev);
712 bool armtimer = false;
713 __u32 config;
714 int i;
715
716
717 EL3WINDOW(3);
718 if (vp->full_duplex)
719 outb(0x20, ioaddr + Wn3_MAC_Ctrl);
720 config = inl(ioaddr + Wn3_Config);
721
722 if (vp->media_override != 7) {
723 if (corkscrew_debug > 1)
724 pr_info("%s: Media override to transceiver %d (%s).\n",
725 dev->name, vp->media_override,
726 media_tbl[vp->media_override].name);
727 dev->if_port = vp->media_override;
728 } else if (vp->autoselect) {
729
730 dev->if_port = 4;
731 while (!(vp->available_media & media_tbl[dev->if_port].mask))
732 dev->if_port = media_tbl[dev->if_port].next;
733
734 if (corkscrew_debug > 1)
735 pr_debug("%s: Initial media type %s.\n",
736 dev->name, media_tbl[dev->if_port].name);
737 armtimer = true;
738 } else
739 dev->if_port = vp->default_media;
740
741 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
742 outl(config, ioaddr + Wn3_Config);
743
744 if (corkscrew_debug > 1) {
745 pr_debug("%s: corkscrew_open() InternalConfig %8.8x.\n",
746 dev->name, config);
747 }
748
749 outw(TxReset, ioaddr + EL3_CMD);
750 for (i = 20; i >= 0; i--)
751 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
752 break;
753
754 outw(RxReset, ioaddr + EL3_CMD);
755
756 for (i = 20; i >= 0; i--)
757 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
758 break;
759
760 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
761
762
763 if (vp->capabilities == 0x11c7) {
764
765 if (dev->irq == 0 ||
766 dev->dma == 0 ||
767 request_irq(dev->irq, corkscrew_interrupt, 0,
768 vp->product_name, dev))
769 return -EAGAIN;
770 enable_dma(dev->dma);
771 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
772 } else if (request_irq(dev->irq, corkscrew_interrupt, IRQF_SHARED,
773 vp->product_name, dev)) {
774 return -EAGAIN;
775 }
776
777 if (armtimer)
778 mod_timer(&vp->timer, jiffies + media_tbl[dev->if_port].wait);
779
780 if (corkscrew_debug > 1) {
781 EL3WINDOW(4);
782 pr_debug("%s: corkscrew_open() irq %d media status %4.4x.\n",
783 dev->name, dev->irq, inw(ioaddr + Wn4_Media));
784 }
785
786
787 EL3WINDOW(2);
788 for (i = 0; i < 6; i++)
789 outb(dev->dev_addr[i], ioaddr + i);
790 for (; i < 12; i += 2)
791 outw(0, ioaddr + i);
792
793 if (dev->if_port == 3)
794
795 outw(StartCoax, ioaddr + EL3_CMD);
796 EL3WINDOW(4);
797 outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP | Media_SQE)) |
798 media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
799
800
801 outw(StatsDisable, ioaddr + EL3_CMD);
802 EL3WINDOW(6);
803 for (i = 0; i < 10; i++)
804 inb(ioaddr + i);
805 inw(ioaddr + 10);
806 inw(ioaddr + 12);
807
808 EL3WINDOW(4);
809 inb(ioaddr + 12);
810
811 outw(0x0040, ioaddr + Wn4_NetDiag);
812
813
814 EL3WINDOW(7);
815
816 if (vp->full_bus_master_rx) {
817 vp->cur_rx = vp->dirty_rx = 0;
818 if (corkscrew_debug > 2)
819 pr_debug("%s: Filling in the Rx ring.\n", dev->name);
820 for (i = 0; i < RX_RING_SIZE; i++) {
821 struct sk_buff *skb;
822 if (i < (RX_RING_SIZE - 1))
823 vp->rx_ring[i].next =
824 isa_virt_to_bus(&vp->rx_ring[i + 1]);
825 else
826 vp->rx_ring[i].next = 0;
827 vp->rx_ring[i].status = 0;
828 vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
829 skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
830 vp->rx_skbuff[i] = skb;
831 if (skb == NULL)
832 break;
833 skb_reserve(skb, 2);
834 vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
835 }
836 if (i != 0)
837 vp->rx_ring[i - 1].next =
838 isa_virt_to_bus(&vp->rx_ring[0]);
839 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
840 }
841 if (vp->full_bus_master_tx) {
842 vp->cur_tx = vp->dirty_tx = 0;
843 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold);
844
845 for (i = 0; i < TX_RING_SIZE; i++)
846 vp->tx_skbuff[i] = NULL;
847 outl(0, ioaddr + DownListPtr);
848 }
849
850 set_rx_mode(dev);
851 outw(StatsEnable, ioaddr + EL3_CMD);
852
853 netif_start_queue(dev);
854
855 outw(RxEnable, ioaddr + EL3_CMD);
856 outw(TxEnable, ioaddr + EL3_CMD);
857
858 outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
859 (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
860 (vp->full_bus_master_rx ? UpComplete : RxComplete) |
861 (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
862
863 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
864 ioaddr + EL3_CMD);
865 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
866 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
867 ioaddr + EL3_CMD);
868
869 return 0;
870 }
871
872 static void corkscrew_timer(struct timer_list *t)
873 {
874 #ifdef AUTOMEDIA
875 struct corkscrew_private *vp = from_timer(vp, t, timer);
876 struct net_device *dev = vp->our_dev;
877 int ioaddr = dev->base_addr;
878 unsigned long flags;
879 int ok = 0;
880
881 if (corkscrew_debug > 1)
882 pr_debug("%s: Media selection timer tick happened, %s.\n",
883 dev->name, media_tbl[dev->if_port].name);
884
885 spin_lock_irqsave(&vp->lock, flags);
886
887 {
888 int old_window = inw(ioaddr + EL3_CMD) >> 13;
889 int media_status;
890 EL3WINDOW(4);
891 media_status = inw(ioaddr + Wn4_Media);
892 switch (dev->if_port) {
893 case 0:
894 case 4:
895 case 5:
896 if (media_status & Media_LnkBeat) {
897 ok = 1;
898 if (corkscrew_debug > 1)
899 pr_debug("%s: Media %s has link beat, %x.\n",
900 dev->name,
901 media_tbl[dev->if_port].name,
902 media_status);
903 } else if (corkscrew_debug > 1)
904 pr_debug("%s: Media %s is has no link beat, %x.\n",
905 dev->name,
906 media_tbl[dev->if_port].name,
907 media_status);
908
909 break;
910 default:
911 if (corkscrew_debug > 1)
912 pr_debug("%s: Media %s is has no indication, %x.\n",
913 dev->name,
914 media_tbl[dev->if_port].name,
915 media_status);
916 ok = 1;
917 }
918 if (!ok) {
919 __u32 config;
920
921 do {
922 dev->if_port =
923 media_tbl[dev->if_port].next;
924 }
925 while (!(vp->available_media & media_tbl[dev->if_port].mask));
926
927 if (dev->if_port == 8) {
928 dev->if_port = vp->default_media;
929 if (corkscrew_debug > 1)
930 pr_debug("%s: Media selection failing, using default %s port.\n",
931 dev->name,
932 media_tbl[dev->if_port].name);
933 } else {
934 if (corkscrew_debug > 1)
935 pr_debug("%s: Media selection failed, now trying %s port.\n",
936 dev->name,
937 media_tbl[dev->if_port].name);
938 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
939 add_timer(&vp->timer);
940 }
941 outw((media_status & ~(Media_10TP | Media_SQE)) |
942 media_tbl[dev->if_port].media_bits,
943 ioaddr + Wn4_Media);
944
945 EL3WINDOW(3);
946 config = inl(ioaddr + Wn3_Config);
947 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
948 outl(config, ioaddr + Wn3_Config);
949
950 outw(dev->if_port == 3 ? StartCoax : StopCoax,
951 ioaddr + EL3_CMD);
952 }
953 EL3WINDOW(old_window);
954 }
955
956 spin_unlock_irqrestore(&vp->lock, flags);
957 if (corkscrew_debug > 1)
958 pr_debug("%s: Media selection timer finished, %s.\n",
959 dev->name, media_tbl[dev->if_port].name);
960
961 #endif
962 }
963
964 static void corkscrew_timeout(struct net_device *dev)
965 {
966 int i;
967 struct corkscrew_private *vp = netdev_priv(dev);
968 int ioaddr = dev->base_addr;
969
970 pr_warn("%s: transmit timed out, tx_status %2.2x status %4.4x\n",
971 dev->name, inb(ioaddr + TxStatus),
972 inw(ioaddr + EL3_STATUS));
973
974 if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
975 pr_warn("%s: Transmitter encountered 16 collisions -- network cable problem?\n",
976 dev->name);
977 #ifndef final_version
978 pr_debug(" Flags; bus-master %d, full %d; dirty %d current %d.\n",
979 vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
980 vp->cur_tx);
981 pr_debug(" Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
982 &vp->tx_ring[0]);
983 for (i = 0; i < TX_RING_SIZE; i++) {
984 pr_debug(" %d: %p length %8.8x status %8.8x\n", i,
985 &vp->tx_ring[i],
986 vp->tx_ring[i].length, vp->tx_ring[i].status);
987 }
988 #endif
989
990 outw(TxReset, ioaddr + EL3_CMD);
991 for (i = 20; i >= 0; i--)
992 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
993 break;
994 outw(TxEnable, ioaddr + EL3_CMD);
995 netif_trans_update(dev);
996 dev->stats.tx_errors++;
997 dev->stats.tx_dropped++;
998 netif_wake_queue(dev);
999 }
1000
1001 static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
1002 struct net_device *dev)
1003 {
1004 struct corkscrew_private *vp = netdev_priv(dev);
1005 int ioaddr = dev->base_addr;
1006
1007
1008
1009 netif_stop_queue(dev);
1010
1011 if (vp->full_bus_master_tx) {
1012
1013 int entry = vp->cur_tx % TX_RING_SIZE;
1014 struct boom_tx_desc *prev_entry;
1015 unsigned long flags;
1016 int i;
1017
1018 if (vp->tx_full)
1019 return NETDEV_TX_BUSY;
1020 if (vp->cur_tx != 0)
1021 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1022 else
1023 prev_entry = NULL;
1024 if (corkscrew_debug > 3)
1025 pr_debug("%s: Trying to send a packet, Tx index %d.\n",
1026 dev->name, vp->cur_tx);
1027
1028 vp->tx_skbuff[entry] = skb;
1029 vp->tx_ring[entry].next = 0;
1030 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1031 vp->tx_ring[entry].length = skb->len | 0x80000000;
1032 vp->tx_ring[entry].status = skb->len | 0x80000000;
1033
1034 spin_lock_irqsave(&vp->lock, flags);
1035 outw(DownStall, ioaddr + EL3_CMD);
1036
1037 for (i = 20; i >= 0; i--)
1038 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1039 break;
1040 if (prev_entry)
1041 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1042 if (inl(ioaddr + DownListPtr) == 0) {
1043 outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1044 ioaddr + DownListPtr);
1045 queued_packet++;
1046 }
1047 outw(DownUnstall, ioaddr + EL3_CMD);
1048 spin_unlock_irqrestore(&vp->lock, flags);
1049
1050 vp->cur_tx++;
1051 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1052 vp->tx_full = 1;
1053 else {
1054 if (prev_entry)
1055 prev_entry->status &= ~0x80000000;
1056 netif_wake_queue(dev);
1057 }
1058 return NETDEV_TX_OK;
1059 }
1060
1061 outl(skb->len, ioaddr + TX_FIFO);
1062 dev->stats.tx_bytes += skb->len;
1063 #ifdef VORTEX_BUS_MASTER
1064 if (vp->bus_master) {
1065
1066 outl((int) (skb->data), ioaddr + Wn7_MasterAddr);
1067 outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
1068 vp->tx_skb = skb;
1069 outw(StartDMADown, ioaddr + EL3_CMD);
1070
1071 } else {
1072
1073 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1074 dev_kfree_skb(skb);
1075 if (inw(ioaddr + TxFree) > 1536) {
1076 netif_wake_queue(dev);
1077 } else
1078
1079 outw(SetTxThreshold + (1536 >> 2),
1080 ioaddr + EL3_CMD);
1081 }
1082 #else
1083
1084 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1085 dev_kfree_skb(skb);
1086 if (inw(ioaddr + TxFree) > 1536) {
1087 netif_wake_queue(dev);
1088 } else
1089
1090 outw(SetTxThreshold + (1536 >> 2), ioaddr + EL3_CMD);
1091 #endif
1092
1093
1094
1095 {
1096 short tx_status;
1097 int i = 4;
1098
1099 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1100 if (tx_status & 0x3C) {
1101 if (corkscrew_debug > 2)
1102 pr_debug("%s: Tx error, status %2.2x.\n",
1103 dev->name, tx_status);
1104 if (tx_status & 0x04)
1105 dev->stats.tx_fifo_errors++;
1106 if (tx_status & 0x38)
1107 dev->stats.tx_aborted_errors++;
1108 if (tx_status & 0x30) {
1109 int j;
1110 outw(TxReset, ioaddr + EL3_CMD);
1111 for (j = 20; j >= 0; j--)
1112 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1113 break;
1114 }
1115 outw(TxEnable, ioaddr + EL3_CMD);
1116 }
1117 outb(0x00, ioaddr + TxStatus);
1118 }
1119 }
1120 return NETDEV_TX_OK;
1121 }
1122
1123
1124
1125
1126 static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
1127 {
1128
1129 struct net_device *dev = dev_id;
1130 struct corkscrew_private *lp = netdev_priv(dev);
1131 int ioaddr, status;
1132 int latency;
1133 int i = max_interrupt_work;
1134
1135 ioaddr = dev->base_addr;
1136 latency = inb(ioaddr + Timer);
1137
1138 spin_lock(&lp->lock);
1139
1140 status = inw(ioaddr + EL3_STATUS);
1141
1142 if (corkscrew_debug > 4)
1143 pr_debug("%s: interrupt, status %4.4x, timer %d.\n",
1144 dev->name, status, latency);
1145 if ((status & 0xE000) != 0xE000) {
1146 static int donedidthis;
1147
1148
1149
1150 if (donedidthis++ > 100) {
1151 pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1152 dev->name, status, netif_running(dev));
1153 free_irq(dev->irq, dev);
1154 dev->irq = -1;
1155 }
1156 }
1157
1158 do {
1159 if (corkscrew_debug > 5)
1160 pr_debug("%s: In interrupt loop, status %4.4x.\n",
1161 dev->name, status);
1162 if (status & RxComplete)
1163 corkscrew_rx(dev);
1164
1165 if (status & TxAvailable) {
1166 if (corkscrew_debug > 5)
1167 pr_debug(" TX room bit was handled.\n");
1168
1169 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1170 netif_wake_queue(dev);
1171 }
1172 if (status & DownComplete) {
1173 unsigned int dirty_tx = lp->dirty_tx;
1174
1175 while (lp->cur_tx - dirty_tx > 0) {
1176 int entry = dirty_tx % TX_RING_SIZE;
1177 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1178 break;
1179 if (lp->tx_skbuff[entry]) {
1180 dev_consume_skb_irq(lp->tx_skbuff[entry]);
1181 lp->tx_skbuff[entry] = NULL;
1182 }
1183 dirty_tx++;
1184 }
1185 lp->dirty_tx = dirty_tx;
1186 outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1187 if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1188 lp->tx_full = 0;
1189 netif_wake_queue(dev);
1190 }
1191 }
1192 #ifdef VORTEX_BUS_MASTER
1193 if (status & DMADone) {
1194 outw(0x1000, ioaddr + Wn7_MasterStatus);
1195 dev_consume_skb_irq(lp->tx_skb);
1196 netif_wake_queue(dev);
1197 }
1198 #endif
1199 if (status & UpComplete) {
1200 boomerang_rx(dev);
1201 outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1202 }
1203 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1204
1205 if (status & RxEarly) {
1206 corkscrew_rx(dev);
1207 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1208 }
1209 if (status & StatsFull) {
1210 static int DoneDidThat;
1211 if (corkscrew_debug > 4)
1212 pr_debug("%s: Updating stats.\n", dev->name);
1213 update_stats(ioaddr, dev);
1214
1215
1216 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1217 int win, reg;
1218 pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n",
1219 dev->name);
1220 for (win = 0; win < 8; win++) {
1221 EL3WINDOW(win);
1222 pr_notice("Vortex window %d:", win);
1223 for (reg = 0; reg < 16; reg++)
1224 pr_cont(" %2.2x", inb(ioaddr + reg));
1225 pr_cont("\n");
1226 }
1227 EL3WINDOW(7);
1228 outw(SetIntrEnb | TxAvailable |
1229 RxComplete | AdapterFailure |
1230 UpComplete | DownComplete |
1231 TxComplete, ioaddr + EL3_CMD);
1232 DoneDidThat++;
1233 }
1234 }
1235 if (status & AdapterFailure) {
1236
1237 outw(RxReset, ioaddr + EL3_CMD);
1238
1239 set_rx_mode(dev);
1240 outw(RxEnable, ioaddr + EL3_CMD);
1241 outw(AckIntr | AdapterFailure,
1242 ioaddr + EL3_CMD);
1243 }
1244 }
1245
1246 if (--i < 0) {
1247 pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n",
1248 dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
1249
1250 outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1251 outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1252 break;
1253 }
1254
1255 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1256
1257 } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1258
1259 spin_unlock(&lp->lock);
1260
1261 if (corkscrew_debug > 4)
1262 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1263 return IRQ_HANDLED;
1264 }
1265
1266 static int corkscrew_rx(struct net_device *dev)
1267 {
1268 int ioaddr = dev->base_addr;
1269 int i;
1270 short rx_status;
1271
1272 if (corkscrew_debug > 5)
1273 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1274 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1275 while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1276 if (rx_status & 0x4000) {
1277 unsigned char rx_error = inb(ioaddr + RxErrors);
1278 if (corkscrew_debug > 2)
1279 pr_debug(" Rx error: status %2.2x.\n",
1280 rx_error);
1281 dev->stats.rx_errors++;
1282 if (rx_error & 0x01)
1283 dev->stats.rx_over_errors++;
1284 if (rx_error & 0x02)
1285 dev->stats.rx_length_errors++;
1286 if (rx_error & 0x04)
1287 dev->stats.rx_frame_errors++;
1288 if (rx_error & 0x08)
1289 dev->stats.rx_crc_errors++;
1290 if (rx_error & 0x10)
1291 dev->stats.rx_length_errors++;
1292 } else {
1293
1294 short pkt_len = rx_status & 0x1fff;
1295 struct sk_buff *skb;
1296
1297 skb = netdev_alloc_skb(dev, pkt_len + 5 + 2);
1298 if (corkscrew_debug > 4)
1299 pr_debug("Receiving packet size %d status %4.4x.\n",
1300 pkt_len, rx_status);
1301 if (skb != NULL) {
1302 skb_reserve(skb, 2);
1303
1304 insl(ioaddr + RX_FIFO,
1305 skb_put(skb, pkt_len),
1306 (pkt_len + 3) >> 2);
1307 outw(RxDiscard, ioaddr + EL3_CMD);
1308 skb->protocol = eth_type_trans(skb, dev);
1309 netif_rx(skb);
1310 dev->stats.rx_packets++;
1311 dev->stats.rx_bytes += pkt_len;
1312
1313 for (i = 200; i >= 0; i--)
1314 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1315 break;
1316 continue;
1317 } else if (corkscrew_debug)
1318 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1319 }
1320 outw(RxDiscard, ioaddr + EL3_CMD);
1321 dev->stats.rx_dropped++;
1322
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 = netdev_priv(dev);
1333 int entry = vp->cur_rx % RX_RING_SIZE;
1334 int ioaddr = dev->base_addr;
1335 int rx_status;
1336
1337 if (corkscrew_debug > 5)
1338 pr_debug(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1339 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1340 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1341 if (rx_status & RxDError) {
1342 unsigned char rx_error = rx_status >> 16;
1343 if (corkscrew_debug > 2)
1344 pr_debug(" Rx error: status %2.2x.\n",
1345 rx_error);
1346 dev->stats.rx_errors++;
1347 if (rx_error & 0x01)
1348 dev->stats.rx_over_errors++;
1349 if (rx_error & 0x02)
1350 dev->stats.rx_length_errors++;
1351 if (rx_error & 0x04)
1352 dev->stats.rx_frame_errors++;
1353 if (rx_error & 0x08)
1354 dev->stats.rx_crc_errors++;
1355 if (rx_error & 0x10)
1356 dev->stats.rx_length_errors++;
1357 } else {
1358
1359 short pkt_len = rx_status & 0x1fff;
1360 struct sk_buff *skb;
1361
1362 dev->stats.rx_bytes += pkt_len;
1363 if (corkscrew_debug > 4)
1364 pr_debug("Receiving packet size %d status %4.4x.\n",
1365 pkt_len, rx_status);
1366
1367
1368
1369 if (pkt_len < rx_copybreak &&
1370 (skb = netdev_alloc_skb(dev, pkt_len + 4)) != NULL) {
1371 skb_reserve(skb, 2);
1372
1373 skb_put_data(skb,
1374 isa_bus_to_virt(vp->rx_ring[entry].addr),
1375 pkt_len);
1376 rx_copy++;
1377 } else {
1378 void *temp;
1379
1380 skb = vp->rx_skbuff[entry];
1381 vp->rx_skbuff[entry] = NULL;
1382 temp = skb_put(skb, pkt_len);
1383
1384 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1385 pr_warn("%s: Warning -- the skbuff addresses do not match in boomerang_rx: %p vs. %p / %p\n",
1386 dev->name,
1387 isa_bus_to_virt(vp->rx_ring[entry].addr),
1388 skb->head, temp);
1389 rx_nocopy++;
1390 }
1391 skb->protocol = eth_type_trans(skb, dev);
1392 netif_rx(skb);
1393 dev->stats.rx_packets++;
1394 }
1395 entry = (++vp->cur_rx) % RX_RING_SIZE;
1396 }
1397
1398 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1399 struct sk_buff *skb;
1400 entry = vp->dirty_rx % RX_RING_SIZE;
1401 if (vp->rx_skbuff[entry] == NULL) {
1402 skb = netdev_alloc_skb(dev, PKT_BUF_SZ);
1403 if (skb == NULL)
1404 break;
1405 skb_reserve(skb, 2);
1406 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1407 vp->rx_skbuff[entry] = skb;
1408 }
1409 vp->rx_ring[entry].status = 0;
1410 }
1411 return 0;
1412 }
1413
1414 static int corkscrew_close(struct net_device *dev)
1415 {
1416 struct corkscrew_private *vp = netdev_priv(dev);
1417 int ioaddr = dev->base_addr;
1418 int i;
1419
1420 netif_stop_queue(dev);
1421
1422 if (corkscrew_debug > 1) {
1423 pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1424 dev->name, inw(ioaddr + EL3_STATUS),
1425 inb(ioaddr + TxStatus));
1426 pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n",
1427 dev->name, rx_nocopy, rx_copy, queued_packet);
1428 }
1429
1430 del_timer_sync(&vp->timer);
1431
1432
1433 outw(StatsDisable, ioaddr + EL3_CMD);
1434
1435
1436 outw(RxDisable, ioaddr + EL3_CMD);
1437 outw(TxDisable, ioaddr + EL3_CMD);
1438
1439 if (dev->if_port == XCVR_10base2)
1440
1441 outw(StopCoax, ioaddr + EL3_CMD);
1442
1443 free_irq(dev->irq, dev);
1444
1445 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1446
1447 update_stats(ioaddr, dev);
1448 if (vp->full_bus_master_rx) {
1449 outl(0, ioaddr + UpListPtr);
1450 for (i = 0; i < RX_RING_SIZE; i++)
1451 if (vp->rx_skbuff[i]) {
1452 dev_kfree_skb(vp->rx_skbuff[i]);
1453 vp->rx_skbuff[i] = NULL;
1454 }
1455 }
1456 if (vp->full_bus_master_tx) {
1457 outl(0, ioaddr + DownListPtr);
1458 for (i = 0; i < TX_RING_SIZE; i++)
1459 if (vp->tx_skbuff[i]) {
1460 dev_kfree_skb(vp->tx_skbuff[i]);
1461 vp->tx_skbuff[i] = NULL;
1462 }
1463 }
1464
1465 return 0;
1466 }
1467
1468 static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1469 {
1470 struct corkscrew_private *vp = netdev_priv(dev);
1471 unsigned long flags;
1472
1473 if (netif_running(dev)) {
1474 spin_lock_irqsave(&vp->lock, flags);
1475 update_stats(dev->base_addr, dev);
1476 spin_unlock_irqrestore(&vp->lock, flags);
1477 }
1478 return &dev->stats;
1479 }
1480
1481
1482
1483
1484
1485
1486
1487
1488 static void update_stats(int ioaddr, struct net_device *dev)
1489 {
1490
1491
1492 EL3WINDOW(6);
1493 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1494 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1495 inb(ioaddr + 2);
1496 dev->stats.collisions += inb(ioaddr + 3);
1497 dev->stats.tx_window_errors += inb(ioaddr + 4);
1498 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1499 dev->stats.tx_packets += inb(ioaddr + 6);
1500 dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1501 inb(ioaddr + 7);
1502
1503 inb(ioaddr + 8);
1504
1505
1506
1507 inw(ioaddr + 10);
1508 inw(ioaddr + 12);
1509
1510 EL3WINDOW(4);
1511 inb(ioaddr + 12);
1512
1513
1514 EL3WINDOW(7);
1515 }
1516
1517
1518
1519
1520
1521 static void set_rx_mode(struct net_device *dev)
1522 {
1523 int ioaddr = dev->base_addr;
1524 unsigned short new_mode;
1525
1526 if (dev->flags & IFF_PROMISC) {
1527 if (corkscrew_debug > 3)
1528 pr_debug("%s: Setting promiscuous mode.\n",
1529 dev->name);
1530 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1531 } else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) {
1532 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1533 } else
1534 new_mode = SetRxFilter | RxStation | RxBroadcast;
1535
1536 outw(new_mode, ioaddr + EL3_CMD);
1537 }
1538
1539 static void netdev_get_drvinfo(struct net_device *dev,
1540 struct ethtool_drvinfo *info)
1541 {
1542 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1543 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1544 snprintf(info->bus_info, sizeof(info->bus_info), "ISA 0x%lx",
1545 dev->base_addr);
1546 }
1547
1548 static u32 netdev_get_msglevel(struct net_device *dev)
1549 {
1550 return corkscrew_debug;
1551 }
1552
1553 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1554 {
1555 corkscrew_debug = level;
1556 }
1557
1558 static const struct ethtool_ops netdev_ethtool_ops = {
1559 .get_drvinfo = netdev_get_drvinfo,
1560 .get_msglevel = netdev_get_msglevel,
1561 .set_msglevel = netdev_set_msglevel,
1562 };
1563
1564
1565 #ifdef MODULE
1566 void cleanup_module(void)
1567 {
1568 while (!list_empty(&root_corkscrew_dev)) {
1569 struct net_device *dev;
1570 struct corkscrew_private *vp;
1571
1572 vp = list_entry(root_corkscrew_dev.next,
1573 struct corkscrew_private, list);
1574 dev = vp->our_dev;
1575 unregister_netdev(dev);
1576 cleanup_card(dev);
1577 free_netdev(dev);
1578 }
1579 }
1580 #endif