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