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