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/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 <asm/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
84MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
85MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
86MODULE_LICENSE("GPL");
87MODULE_VERSION(DRV_VERSION);
88
89
90
91#define DRIVER_DEBUG 1
92
93
94static 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
109static int corkscrew_debug = DRIVER_DEBUG;
110#else
111static 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
185enum 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
199enum RxFilter {
200 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
201};
202
203
204enum 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
215enum Window1 {
216 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
217 RxStatus = 0x18, Timer = 0x1A, TxStatus = 0x1B,
218 TxFree = 0x1C,
219};
220enum 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};
230enum Win0_EEPROM_bits {
231 EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
232 EEPROM_EWENB = 0x30,
233 EEPROM_EWDIS = 0x00,
234};
235
236
237enum eeprom_offset {
238 PhysAddr01 = 0, PhysAddr23 = 1, PhysAddr45 = 2, ModelID = 3,
239 EtherLink3ID = 7,
240};
241
242enum Window3 {
243 Wn3_Config = 0, Wn3_MAC_Ctrl = 6, Wn3_Options = 8,
244};
245enum 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
257enum Window4 {
258 Wn4_NetDiag = 6, Wn4_Media = 10,
259};
260enum Win4_Media_bits {
261 Media_SQE = 0x0008,
262 Media_10TP = 0x00C0,
263 Media_Lnk = 0x0080,
264 Media_LnkBeat = 0x0800,
265};
266enum Window7 {
267 Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
268};
269
270
271enum MasterCtrl {
272 PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen =
273 0x40c,
274 TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
275};
276
277
278
279
280struct boom_rx_desc {
281 u32 next;
282 s32 status;
283 u32 addr;
284 s32 length;
285};
286
287
288enum rx_desc_status {
289 RxDComplete = 0x00008000, RxDError = 0x4000,
290
291};
292
293struct boom_tx_desc {
294 u32 next;
295 s32 status;
296 u32 addr;
297 s32 length;
298};
299
300struct 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
330enum 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
335static 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__
354static 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
361MODULE_DEVICE_TABLE(isapnp, corkscrew_isapnp_adapters);
362
363static int nopnp;
364#endif
365
366static struct net_device *corkscrew_scan(int unit);
367static int corkscrew_setup(struct net_device *dev, int ioaddr,
368 struct pnp_dev *idev, int card_number);
369static int corkscrew_open(struct net_device *dev);
370static void corkscrew_timer(unsigned long arg);
371static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
372 struct net_device *dev);
373static int corkscrew_rx(struct net_device *dev);
374static void corkscrew_timeout(struct net_device *dev);
375static int boomerang_rx(struct net_device *dev);
376static irqreturn_t corkscrew_interrupt(int irq, void *dev_id);
377static int corkscrew_close(struct net_device *dev);
378static void update_stats(int addr, struct net_device *dev);
379static struct net_device_stats *corkscrew_get_stats(struct net_device *dev);
380static void set_rx_mode(struct net_device *dev);
381static const struct ethtool_ops netdev_ethtool_ops;
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1, };
399
400#ifdef MODULE
401static int debug = -1;
402
403module_param(debug, int, 0);
404module_param_array(options, int, NULL, 0);
405module_param(rx_copybreak, int, 0);
406module_param(max_interrupt_work, int, 0);
407MODULE_PARM_DESC(debug, "3c515 debug level (0-6)");
408MODULE_PARM_DESC(options, "3c515: Bits 0-2: media type, bit 3: full duplex, bit 4: bus mastering");
409MODULE_PARM_DESC(rx_copybreak, "3c515 copy breakpoint for copy-only-tiny-frames");
410MODULE_PARM_DESC(max_interrupt_work, "3c515 maximum events handled per interrupt");
411
412
413
414static LIST_HEAD(root_corkscrew_dev);
415
416int 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
429struct 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
446static 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
472static 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
484static 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_warning("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 }
546no_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
566static 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_multicast_list = set_rx_mode,
573 .ndo_change_mtu = eth_change_mtu,
574 .ndo_set_mac_address = eth_mac_addr,
575 .ndo_validate_addr = eth_validate_addr,
576};
577
578
579static int corkscrew_setup(struct net_device *dev, int ioaddr,
580 struct pnp_dev *idev, int card_number)
581{
582 struct corkscrew_private *vp = netdev_priv(dev);
583 unsigned int eeprom[0x40], checksum = 0;
584 int i;
585 int irq;
586
587#ifdef __ISAPNP__
588 if (idev) {
589 irq = pnp_irq(idev, 0);
590 vp->dev = &idev->dev;
591 } else {
592 irq = inw(ioaddr + 0x2002) & 15;
593 }
594#else
595 irq = inw(ioaddr + 0x2002) & 15;
596#endif
597
598 dev->base_addr = ioaddr;
599 dev->irq = irq;
600 dev->dma = inw(ioaddr + 0x2000) & 7;
601 vp->product_name = "3c515";
602 vp->options = dev->mem_start;
603 vp->our_dev = dev;
604
605 if (!vp->options) {
606 if (card_number >= MAX_UNITS)
607 vp->options = -1;
608 else
609 vp->options = options[card_number];
610 }
611
612 if (vp->options >= 0) {
613 vp->media_override = vp->options & 7;
614 if (vp->media_override == 2)
615 vp->media_override = 0;
616 vp->full_duplex = (vp->options & 8) ? 1 : 0;
617 vp->bus_master = (vp->options & 16) ? 1 : 0;
618 } else {
619 vp->media_override = 7;
620 vp->full_duplex = 0;
621 vp->bus_master = 0;
622 }
623#ifdef MODULE
624 list_add(&vp->list, &root_corkscrew_dev);
625#endif
626
627 pr_info("%s: 3Com %s at %#3x,", dev->name, vp->product_name, ioaddr);
628
629 spin_lock_init(&vp->lock);
630
631
632 EL3WINDOW(0);
633 for (i = 0; i < 0x18; i++) {
634 __be16 *phys_addr = (__be16 *) dev->dev_addr;
635 int timer;
636 outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
637
638 for (timer = 4; timer >= 0; timer--) {
639 udelay(162);
640 if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
641 break;
642 }
643 eeprom[i] = inw(ioaddr + Wn0EepromData);
644 checksum ^= eeprom[i];
645 if (i < 3)
646 phys_addr[i] = htons(eeprom[i]);
647 }
648 checksum = (checksum ^ (checksum >> 8)) & 0xff;
649 if (checksum != 0x00)
650 pr_cont(" ***INVALID CHECKSUM %4.4x*** ", checksum);
651 pr_cont(" %pM", dev->dev_addr);
652 if (eeprom[16] == 0x11c7) {
653 if (request_dma(dev->dma, "3c515")) {
654 pr_cont(", DMA %d allocation failed", dev->dma);
655 dev->dma = 0;
656 } else
657 pr_cont(", DMA %d", dev->dma);
658 }
659 pr_cont(", IRQ %d\n", dev->irq);
660
661 if (corkscrew_debug && (dev->irq <= 0 || dev->irq > 15))
662 pr_warning(" *** Warning: this IRQ is unlikely to work! ***\n");
663
664 {
665 static const char * const ram_split[] = {
666 "5:3", "3:1", "1:1", "3:5"
667 };
668 __u32 config;
669 EL3WINDOW(3);
670 vp->available_media = inw(ioaddr + Wn3_Options);
671 config = inl(ioaddr + Wn3_Config);
672 if (corkscrew_debug > 1)
673 pr_info(" Internal config register is %4.4x, transceivers %#x.\n",
674 config, inw(ioaddr + Wn3_Options));
675 pr_info(" %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
676 8 << config & Ram_size,
677 config & Ram_width ? "word" : "byte",
678 ram_split[(config & Ram_split) >> Ram_split_shift],
679 config & Autoselect ? "autoselect/" : "",
680 media_tbl[(config & Xcvr) >> Xcvr_shift].name);
681 vp->default_media = (config & Xcvr) >> Xcvr_shift;
682 vp->autoselect = config & Autoselect ? 1 : 0;
683 dev->if_port = vp->default_media;
684 }
685 if (vp->media_override != 7) {
686 pr_info(" Media override to transceiver type %d (%s).\n",
687 vp->media_override,
688 media_tbl[vp->media_override].name);
689 dev->if_port = vp->media_override;
690 }
691
692 vp->capabilities = eeprom[16];
693 vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
694
695
696 vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
697
698
699 dev->netdev_ops = &netdev_ops;
700 dev->watchdog_timeo = (400 * HZ) / 1000;
701 dev->ethtool_ops = &netdev_ethtool_ops;
702
703 return register_netdev(dev);
704}
705
706
707static int corkscrew_open(struct net_device *dev)
708{
709 int ioaddr = dev->base_addr;
710 struct corkscrew_private *vp = netdev_priv(dev);
711 __u32 config;
712 int i;
713
714
715 EL3WINDOW(3);
716 if (vp->full_duplex)
717 outb(0x20, ioaddr + Wn3_MAC_Ctrl);
718 config = inl(ioaddr + Wn3_Config);
719
720 if (vp->media_override != 7) {
721 if (corkscrew_debug > 1)
722 pr_info("%s: Media override to transceiver %d (%s).\n",
723 dev->name, vp->media_override,
724 media_tbl[vp->media_override].name);
725 dev->if_port = vp->media_override;
726 } else if (vp->autoselect) {
727
728 dev->if_port = 4;
729 while (!(vp->available_media & media_tbl[dev->if_port].mask))
730 dev->if_port = media_tbl[dev->if_port].next;
731
732 if (corkscrew_debug > 1)
733 pr_debug("%s: Initial media type %s.\n",
734 dev->name, media_tbl[dev->if_port].name);
735
736 init_timer(&vp->timer);
737 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
738 vp->timer.data = (unsigned long) dev;
739 vp->timer.function = corkscrew_timer;
740 add_timer(&vp->timer);
741 } else
742 dev->if_port = vp->default_media;
743
744 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
745 outl(config, ioaddr + Wn3_Config);
746
747 if (corkscrew_debug > 1) {
748 pr_debug("%s: corkscrew_open() InternalConfig %8.8x.\n",
749 dev->name, config);
750 }
751
752 outw(TxReset, ioaddr + EL3_CMD);
753 for (i = 20; i >= 0; i--)
754 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
755 break;
756
757 outw(RxReset, ioaddr + EL3_CMD);
758
759 for (i = 20; i >= 0; i--)
760 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
761 break;
762
763 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
764
765
766 if (vp->capabilities == 0x11c7) {
767
768 if (dev->irq == 0 ||
769 dev->dma == 0 ||
770 request_irq(dev->irq, corkscrew_interrupt, 0,
771 vp->product_name, dev))
772 return -EAGAIN;
773 enable_dma(dev->dma);
774 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
775 } else if (request_irq(dev->irq, corkscrew_interrupt, IRQF_SHARED,
776 vp->product_name, dev)) {
777 return -EAGAIN;
778 }
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 = dev_alloc_skb(PKT_BUF_SZ);
830 vp->rx_skbuff[i] = skb;
831 if (skb == NULL)
832 break;
833 skb->dev = dev;
834 skb_reserve(skb, 2);
835 vp->rx_ring[i].addr = isa_virt_to_bus(skb->data);
836 }
837 if (i != 0)
838 vp->rx_ring[i - 1].next =
839 isa_virt_to_bus(&vp->rx_ring[0]);
840 outl(isa_virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
841 }
842 if (vp->full_bus_master_tx) {
843 vp->cur_tx = vp->dirty_tx = 0;
844 outb(PKT_BUF_SZ >> 8, ioaddr + TxFreeThreshold);
845
846 for (i = 0; i < TX_RING_SIZE; i++)
847 vp->tx_skbuff[i] = NULL;
848 outl(0, ioaddr + DownListPtr);
849 }
850
851 set_rx_mode(dev);
852 outw(StatsEnable, ioaddr + EL3_CMD);
853
854 netif_start_queue(dev);
855
856 outw(RxEnable, ioaddr + EL3_CMD);
857 outw(TxEnable, ioaddr + EL3_CMD);
858
859 outw(SetStatusEnb | AdapterFailure | IntReq | StatsFull |
860 (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
861 (vp->full_bus_master_rx ? UpComplete : RxComplete) |
862 (vp->bus_master ? DMADone : 0), ioaddr + EL3_CMD);
863
864 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
865 ioaddr + EL3_CMD);
866 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
867 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
868 ioaddr + EL3_CMD);
869
870 return 0;
871}
872
873static void corkscrew_timer(unsigned long data)
874{
875#ifdef AUTOMEDIA
876 struct net_device *dev = (struct net_device *) data;
877 struct corkscrew_private *vp = netdev_priv(dev);
878 int ioaddr = dev->base_addr;
879 unsigned long flags;
880 int ok = 0;
881
882 if (corkscrew_debug > 1)
883 pr_debug("%s: Media selection timer tick happened, %s.\n",
884 dev->name, media_tbl[dev->if_port].name);
885
886 spin_lock_irqsave(&vp->lock, flags);
887
888 {
889 int old_window = inw(ioaddr + EL3_CMD) >> 13;
890 int media_status;
891 EL3WINDOW(4);
892 media_status = inw(ioaddr + Wn4_Media);
893 switch (dev->if_port) {
894 case 0:
895 case 4:
896 case 5:
897 if (media_status & Media_LnkBeat) {
898 ok = 1;
899 if (corkscrew_debug > 1)
900 pr_debug("%s: Media %s has link beat, %x.\n",
901 dev->name,
902 media_tbl[dev->if_port].name,
903 media_status);
904 } else if (corkscrew_debug > 1)
905 pr_debug("%s: Media %s is has no link beat, %x.\n",
906 dev->name,
907 media_tbl[dev->if_port].name,
908 media_status);
909
910 break;
911 default:
912 if (corkscrew_debug > 1)
913 pr_debug("%s: Media %s is has no indication, %x.\n",
914 dev->name,
915 media_tbl[dev->if_port].name,
916 media_status);
917 ok = 1;
918 }
919 if (!ok) {
920 __u32 config;
921
922 do {
923 dev->if_port =
924 media_tbl[dev->if_port].next;
925 }
926 while (!(vp->available_media & media_tbl[dev->if_port].mask));
927
928 if (dev->if_port == 8) {
929 dev->if_port = vp->default_media;
930 if (corkscrew_debug > 1)
931 pr_debug("%s: Media selection failing, using default %s port.\n",
932 dev->name,
933 media_tbl[dev->if_port].name);
934 } else {
935 if (corkscrew_debug > 1)
936 pr_debug("%s: Media selection failed, now trying %s port.\n",
937 dev->name,
938 media_tbl[dev->if_port].name);
939 vp->timer.expires = jiffies + media_tbl[dev->if_port].wait;
940 add_timer(&vp->timer);
941 }
942 outw((media_status & ~(Media_10TP | Media_SQE)) |
943 media_tbl[dev->if_port].media_bits,
944 ioaddr + Wn4_Media);
945
946 EL3WINDOW(3);
947 config = inl(ioaddr + Wn3_Config);
948 config = (config & ~Xcvr) | (dev->if_port << Xcvr_shift);
949 outl(config, ioaddr + Wn3_Config);
950
951 outw(dev->if_port == 3 ? StartCoax : StopCoax,
952 ioaddr + EL3_CMD);
953 }
954 EL3WINDOW(old_window);
955 }
956
957 spin_unlock_irqrestore(&vp->lock, flags);
958 if (corkscrew_debug > 1)
959 pr_debug("%s: Media selection timer finished, %s.\n",
960 dev->name, media_tbl[dev->if_port].name);
961
962#endif
963}
964
965static void corkscrew_timeout(struct net_device *dev)
966{
967 int i;
968 struct corkscrew_private *vp = netdev_priv(dev);
969 int ioaddr = dev->base_addr;
970
971 pr_warning("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
972 dev->name, inb(ioaddr + TxStatus),
973 inw(ioaddr + EL3_STATUS));
974
975 if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
976 pr_warning("%s: Transmitter encountered 16 collisions --"
977 " network cable problem?\n", dev->name);
978#ifndef final_version
979 pr_debug(" Flags; bus-master %d, full %d; dirty %d current %d.\n",
980 vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx,
981 vp->cur_tx);
982 pr_debug(" Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
983 &vp->tx_ring[0]);
984 for (i = 0; i < TX_RING_SIZE; i++) {
985 pr_debug(" %d: %p length %8.8x status %8.8x\n", i,
986 &vp->tx_ring[i],
987 vp->tx_ring[i].length, vp->tx_ring[i].status);
988 }
989#endif
990
991 outw(TxReset, ioaddr + EL3_CMD);
992 for (i = 20; i >= 0; i--)
993 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
994 break;
995 outw(TxEnable, ioaddr + EL3_CMD);
996 dev->trans_start = jiffies;
997 dev->stats.tx_errors++;
998 dev->stats.tx_dropped++;
999 netif_wake_queue(dev);
1000}
1001
1002static netdev_tx_t corkscrew_start_xmit(struct sk_buff *skb,
1003 struct net_device *dev)
1004{
1005 struct corkscrew_private *vp = netdev_priv(dev);
1006 int ioaddr = dev->base_addr;
1007
1008
1009
1010 netif_stop_queue(dev);
1011
1012 if (vp->full_bus_master_tx) {
1013
1014 int entry = vp->cur_tx % TX_RING_SIZE;
1015 struct boom_tx_desc *prev_entry;
1016 unsigned long flags;
1017 int i;
1018
1019 if (vp->tx_full)
1020 return NETDEV_TX_BUSY;
1021 if (vp->cur_tx != 0)
1022 prev_entry = &vp->tx_ring[(vp->cur_tx - 1) % TX_RING_SIZE];
1023 else
1024 prev_entry = NULL;
1025 if (corkscrew_debug > 3)
1026 pr_debug("%s: Trying to send a packet, Tx index %d.\n",
1027 dev->name, vp->cur_tx);
1028
1029 vp->tx_skbuff[entry] = skb;
1030 vp->tx_ring[entry].next = 0;
1031 vp->tx_ring[entry].addr = isa_virt_to_bus(skb->data);
1032 vp->tx_ring[entry].length = skb->len | 0x80000000;
1033 vp->tx_ring[entry].status = skb->len | 0x80000000;
1034
1035 spin_lock_irqsave(&vp->lock, flags);
1036 outw(DownStall, ioaddr + EL3_CMD);
1037
1038 for (i = 20; i >= 0; i--)
1039 if ((inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
1040 break;
1041 if (prev_entry)
1042 prev_entry->next = isa_virt_to_bus(&vp->tx_ring[entry]);
1043 if (inl(ioaddr + DownListPtr) == 0) {
1044 outl(isa_virt_to_bus(&vp->tx_ring[entry]),
1045 ioaddr + DownListPtr);
1046 queued_packet++;
1047 }
1048 outw(DownUnstall, ioaddr + EL3_CMD);
1049 spin_unlock_irqrestore(&vp->lock, flags);
1050
1051 vp->cur_tx++;
1052 if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
1053 vp->tx_full = 1;
1054 else {
1055 if (prev_entry)
1056 prev_entry->status &= ~0x80000000;
1057 netif_wake_queue(dev);
1058 }
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
1095
1096 {
1097 short tx_status;
1098 int i = 4;
1099
1100 while (--i > 0 && (tx_status = inb(ioaddr + TxStatus)) > 0) {
1101 if (tx_status & 0x3C) {
1102 if (corkscrew_debug > 2)
1103 pr_debug("%s: Tx error, status %2.2x.\n",
1104 dev->name, tx_status);
1105 if (tx_status & 0x04)
1106 dev->stats.tx_fifo_errors++;
1107 if (tx_status & 0x38)
1108 dev->stats.tx_aborted_errors++;
1109 if (tx_status & 0x30) {
1110 int j;
1111 outw(TxReset, ioaddr + EL3_CMD);
1112 for (j = 20; j >= 0; j--)
1113 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1114 break;
1115 }
1116 outw(TxEnable, ioaddr + EL3_CMD);
1117 }
1118 outb(0x00, ioaddr + TxStatus);
1119 }
1120 }
1121 return NETDEV_TX_OK;
1122}
1123
1124
1125
1126
1127static irqreturn_t corkscrew_interrupt(int irq, void *dev_id)
1128{
1129
1130 struct net_device *dev = dev_id;
1131 struct corkscrew_private *lp = netdev_priv(dev);
1132 int ioaddr, status;
1133 int latency;
1134 int i = max_interrupt_work;
1135
1136 ioaddr = dev->base_addr;
1137 latency = inb(ioaddr + Timer);
1138
1139 spin_lock(&lp->lock);
1140
1141 status = inw(ioaddr + EL3_STATUS);
1142
1143 if (corkscrew_debug > 4)
1144 pr_debug("%s: interrupt, status %4.4x, timer %d.\n",
1145 dev->name, status, latency);
1146 if ((status & 0xE000) != 0xE000) {
1147 static int donedidthis;
1148
1149
1150
1151 if (donedidthis++ > 100) {
1152 pr_err("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
1153 dev->name, status, netif_running(dev));
1154 free_irq(dev->irq, dev);
1155 dev->irq = -1;
1156 }
1157 }
1158
1159 do {
1160 if (corkscrew_debug > 5)
1161 pr_debug("%s: In interrupt loop, status %4.4x.\n",
1162 dev->name, status);
1163 if (status & RxComplete)
1164 corkscrew_rx(dev);
1165
1166 if (status & TxAvailable) {
1167 if (corkscrew_debug > 5)
1168 pr_debug(" TX room bit was handled.\n");
1169
1170 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
1171 netif_wake_queue(dev);
1172 }
1173 if (status & DownComplete) {
1174 unsigned int dirty_tx = lp->dirty_tx;
1175
1176 while (lp->cur_tx - dirty_tx > 0) {
1177 int entry = dirty_tx % TX_RING_SIZE;
1178 if (inl(ioaddr + DownListPtr) == isa_virt_to_bus(&lp->tx_ring[entry]))
1179 break;
1180 if (lp->tx_skbuff[entry]) {
1181 dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1182 lp->tx_skbuff[entry] = NULL;
1183 }
1184 dirty_tx++;
1185 }
1186 lp->dirty_tx = dirty_tx;
1187 outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
1188 if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
1189 lp->tx_full = 0;
1190 netif_wake_queue(dev);
1191 }
1192 }
1193#ifdef VORTEX_BUS_MASTER
1194 if (status & DMADone) {
1195 outw(0x1000, ioaddr + Wn7_MasterStatus);
1196 dev_kfree_skb_irq(lp->tx_skb);
1197 netif_wake_queue(dev);
1198 }
1199#endif
1200 if (status & UpComplete) {
1201 boomerang_rx(dev);
1202 outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
1203 }
1204 if (status & (AdapterFailure | RxEarly | StatsFull)) {
1205
1206 if (status & RxEarly) {
1207 corkscrew_rx(dev);
1208 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
1209 }
1210 if (status & StatsFull) {
1211 static int DoneDidThat;
1212 if (corkscrew_debug > 4)
1213 pr_debug("%s: Updating stats.\n", dev->name);
1214 update_stats(ioaddr, dev);
1215
1216
1217 if (DoneDidThat == 0 && inw(ioaddr + EL3_STATUS) & StatsFull) {
1218 int win, reg;
1219 pr_notice("%s: Updating stats failed, disabling stats as an interrupt source.\n",
1220 dev->name);
1221 for (win = 0; win < 8; win++) {
1222 EL3WINDOW(win);
1223 pr_notice("Vortex window %d:", win);
1224 for (reg = 0; reg < 16; reg++)
1225 pr_cont(" %2.2x", inb(ioaddr + reg));
1226 pr_cont("\n");
1227 }
1228 EL3WINDOW(7);
1229 outw(SetIntrEnb | TxAvailable |
1230 RxComplete | AdapterFailure |
1231 UpComplete | DownComplete |
1232 TxComplete, ioaddr + EL3_CMD);
1233 DoneDidThat++;
1234 }
1235 }
1236 if (status & AdapterFailure) {
1237
1238 outw(RxReset, ioaddr + EL3_CMD);
1239
1240 set_rx_mode(dev);
1241 outw(RxEnable, ioaddr + EL3_CMD);
1242 outw(AckIntr | AdapterFailure,
1243 ioaddr + EL3_CMD);
1244 }
1245 }
1246
1247 if (--i < 0) {
1248 pr_err("%s: Too much work in interrupt, status %4.4x. Disabling functions (%4.4x).\n",
1249 dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
1250
1251 outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
1252 outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
1253 break;
1254 }
1255
1256 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
1257
1258 } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
1259
1260 spin_unlock(&lp->lock);
1261
1262 if (corkscrew_debug > 4)
1263 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
1264 return IRQ_HANDLED;
1265}
1266
1267static int corkscrew_rx(struct net_device *dev)
1268{
1269 int ioaddr = dev->base_addr;
1270 int i;
1271 short rx_status;
1272
1273 if (corkscrew_debug > 5)
1274 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1275 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1276 while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
1277 if (rx_status & 0x4000) {
1278 unsigned char rx_error = inb(ioaddr + RxErrors);
1279 if (corkscrew_debug > 2)
1280 pr_debug(" Rx error: status %2.2x.\n",
1281 rx_error);
1282 dev->stats.rx_errors++;
1283 if (rx_error & 0x01)
1284 dev->stats.rx_over_errors++;
1285 if (rx_error & 0x02)
1286 dev->stats.rx_length_errors++;
1287 if (rx_error & 0x04)
1288 dev->stats.rx_frame_errors++;
1289 if (rx_error & 0x08)
1290 dev->stats.rx_crc_errors++;
1291 if (rx_error & 0x10)
1292 dev->stats.rx_length_errors++;
1293 } else {
1294
1295 short pkt_len = rx_status & 0x1fff;
1296 struct sk_buff *skb;
1297
1298 skb = dev_alloc_skb(pkt_len + 5 + 2);
1299 if (corkscrew_debug > 4)
1300 pr_debug("Receiving packet size %d status %4.4x.\n",
1301 pkt_len, rx_status);
1302 if (skb != NULL) {
1303 skb_reserve(skb, 2);
1304
1305 insl(ioaddr + RX_FIFO,
1306 skb_put(skb, pkt_len),
1307 (pkt_len + 3) >> 2);
1308 outw(RxDiscard, ioaddr + EL3_CMD);
1309 skb->protocol = eth_type_trans(skb, dev);
1310 netif_rx(skb);
1311 dev->stats.rx_packets++;
1312 dev->stats.rx_bytes += pkt_len;
1313
1314 for (i = 200; i >= 0; i--)
1315 if (! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
1316 break;
1317 continue;
1318 } else if (corkscrew_debug)
1319 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, pkt_len);
1320 }
1321 outw(RxDiscard, ioaddr + EL3_CMD);
1322 dev->stats.rx_dropped++;
1323
1324 for (i = 200; i >= 0; i--)
1325 if (!(inw(ioaddr + EL3_STATUS) & CmdInProgress))
1326 break;
1327 }
1328 return 0;
1329}
1330
1331static int boomerang_rx(struct net_device *dev)
1332{
1333 struct corkscrew_private *vp = netdev_priv(dev);
1334 int entry = vp->cur_rx % RX_RING_SIZE;
1335 int ioaddr = dev->base_addr;
1336 int rx_status;
1337
1338 if (corkscrew_debug > 5)
1339 pr_debug(" In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
1340 inw(ioaddr + EL3_STATUS), inw(ioaddr + RxStatus));
1341 while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
1342 if (rx_status & RxDError) {
1343 unsigned char rx_error = rx_status >> 16;
1344 if (corkscrew_debug > 2)
1345 pr_debug(" Rx error: status %2.2x.\n",
1346 rx_error);
1347 dev->stats.rx_errors++;
1348 if (rx_error & 0x01)
1349 dev->stats.rx_over_errors++;
1350 if (rx_error & 0x02)
1351 dev->stats.rx_length_errors++;
1352 if (rx_error & 0x04)
1353 dev->stats.rx_frame_errors++;
1354 if (rx_error & 0x08)
1355 dev->stats.rx_crc_errors++;
1356 if (rx_error & 0x10)
1357 dev->stats.rx_length_errors++;
1358 } else {
1359
1360 short pkt_len = rx_status & 0x1fff;
1361 struct sk_buff *skb;
1362
1363 dev->stats.rx_bytes += pkt_len;
1364 if (corkscrew_debug > 4)
1365 pr_debug("Receiving packet size %d status %4.4x.\n",
1366 pkt_len, rx_status);
1367
1368
1369
1370 if (pkt_len < rx_copybreak &&
1371 (skb = dev_alloc_skb(pkt_len + 4)) != NULL) {
1372 skb_reserve(skb, 2);
1373
1374 memcpy(skb_put(skb, pkt_len),
1375 isa_bus_to_virt(vp->rx_ring[entry].
1376 addr), pkt_len);
1377 rx_copy++;
1378 } else {
1379 void *temp;
1380
1381 skb = vp->rx_skbuff[entry];
1382 vp->rx_skbuff[entry] = NULL;
1383 temp = skb_put(skb, pkt_len);
1384
1385 if (isa_bus_to_virt(vp->rx_ring[entry].addr) != temp)
1386 pr_warning("%s: Warning -- the skbuff addresses do not match"
1387 " in boomerang_rx: %p vs. %p / %p.\n",
1388 dev->name,
1389 isa_bus_to_virt(vp->
1390 rx_ring[entry].
1391 addr), skb->head,
1392 temp);
1393 rx_nocopy++;
1394 }
1395 skb->protocol = eth_type_trans(skb, dev);
1396 netif_rx(skb);
1397 dev->stats.rx_packets++;
1398 }
1399 entry = (++vp->cur_rx) % RX_RING_SIZE;
1400 }
1401
1402 for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
1403 struct sk_buff *skb;
1404 entry = vp->dirty_rx % RX_RING_SIZE;
1405 if (vp->rx_skbuff[entry] == NULL) {
1406 skb = dev_alloc_skb(PKT_BUF_SZ);
1407 if (skb == NULL)
1408 break;
1409 skb->dev = dev;
1410 skb_reserve(skb, 2);
1411 vp->rx_ring[entry].addr = isa_virt_to_bus(skb->data);
1412 vp->rx_skbuff[entry] = skb;
1413 }
1414 vp->rx_ring[entry].status = 0;
1415 }
1416 return 0;
1417}
1418
1419static int corkscrew_close(struct net_device *dev)
1420{
1421 struct corkscrew_private *vp = netdev_priv(dev);
1422 int ioaddr = dev->base_addr;
1423 int i;
1424
1425 netif_stop_queue(dev);
1426
1427 if (corkscrew_debug > 1) {
1428 pr_debug("%s: corkscrew_close() status %4.4x, Tx status %2.2x.\n",
1429 dev->name, inw(ioaddr + EL3_STATUS),
1430 inb(ioaddr + TxStatus));
1431 pr_debug("%s: corkscrew close stats: rx_nocopy %d rx_copy %d tx_queued %d.\n",
1432 dev->name, rx_nocopy, rx_copy, queued_packet);
1433 }
1434
1435 del_timer(&vp->timer);
1436
1437
1438 outw(StatsDisable, ioaddr + EL3_CMD);
1439
1440
1441 outw(RxDisable, ioaddr + EL3_CMD);
1442 outw(TxDisable, ioaddr + EL3_CMD);
1443
1444 if (dev->if_port == XCVR_10base2)
1445
1446 outw(StopCoax, ioaddr + EL3_CMD);
1447
1448 free_irq(dev->irq, dev);
1449
1450 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1451
1452 update_stats(ioaddr, dev);
1453 if (vp->full_bus_master_rx) {
1454 outl(0, ioaddr + UpListPtr);
1455 for (i = 0; i < RX_RING_SIZE; i++)
1456 if (vp->rx_skbuff[i]) {
1457 dev_kfree_skb(vp->rx_skbuff[i]);
1458 vp->rx_skbuff[i] = NULL;
1459 }
1460 }
1461 if (vp->full_bus_master_tx) {
1462 outl(0, ioaddr + DownListPtr);
1463 for (i = 0; i < TX_RING_SIZE; i++)
1464 if (vp->tx_skbuff[i]) {
1465 dev_kfree_skb(vp->tx_skbuff[i]);
1466 vp->tx_skbuff[i] = NULL;
1467 }
1468 }
1469
1470 return 0;
1471}
1472
1473static struct net_device_stats *corkscrew_get_stats(struct net_device *dev)
1474{
1475 struct corkscrew_private *vp = netdev_priv(dev);
1476 unsigned long flags;
1477
1478 if (netif_running(dev)) {
1479 spin_lock_irqsave(&vp->lock, flags);
1480 update_stats(dev->base_addr, dev);
1481 spin_unlock_irqrestore(&vp->lock, flags);
1482 }
1483 return &dev->stats;
1484}
1485
1486
1487
1488
1489
1490
1491
1492
1493static void update_stats(int ioaddr, struct net_device *dev)
1494{
1495
1496
1497 EL3WINDOW(6);
1498 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1499 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1500 inb(ioaddr + 2);
1501 dev->stats.collisions += inb(ioaddr + 3);
1502 dev->stats.tx_window_errors += inb(ioaddr + 4);
1503 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1504 dev->stats.tx_packets += inb(ioaddr + 6);
1505 dev->stats.tx_packets += (inb(ioaddr + 9) & 0x30) << 4;
1506 inb(ioaddr + 7);
1507
1508 inb(ioaddr + 8);
1509
1510
1511
1512 inw(ioaddr + 10);
1513 inw(ioaddr + 12);
1514
1515 EL3WINDOW(4);
1516 inb(ioaddr + 12);
1517
1518
1519 EL3WINDOW(7);
1520}
1521
1522
1523
1524
1525
1526static void set_rx_mode(struct net_device *dev)
1527{
1528 int ioaddr = dev->base_addr;
1529 short new_mode;
1530
1531 if (dev->flags & IFF_PROMISC) {
1532 if (corkscrew_debug > 3)
1533 pr_debug("%s: Setting promiscuous mode.\n",
1534 dev->name);
1535 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm;
1536 } else if (!netdev_mc_empty(dev) || dev->flags & IFF_ALLMULTI) {
1537 new_mode = SetRxFilter | RxStation | RxMulticast | RxBroadcast;
1538 } else
1539 new_mode = SetRxFilter | RxStation | RxBroadcast;
1540
1541 outw(new_mode, ioaddr + EL3_CMD);
1542}
1543
1544static void netdev_get_drvinfo(struct net_device *dev,
1545 struct ethtool_drvinfo *info)
1546{
1547 strcpy(info->driver, DRV_NAME);
1548 strcpy(info->version, DRV_VERSION);
1549 sprintf(info->bus_info, "ISA 0x%lx", dev->base_addr);
1550}
1551
1552static u32 netdev_get_msglevel(struct net_device *dev)
1553{
1554 return corkscrew_debug;
1555}
1556
1557static void netdev_set_msglevel(struct net_device *dev, u32 level)
1558{
1559 corkscrew_debug = level;
1560}
1561
1562static const struct ethtool_ops netdev_ethtool_ops = {
1563 .get_drvinfo = netdev_get_drvinfo,
1564 .get_msglevel = netdev_get_msglevel,
1565 .set_msglevel = netdev_set_msglevel,
1566};
1567
1568
1569#ifdef MODULE
1570void cleanup_module(void)
1571{
1572 while (!list_empty(&root_corkscrew_dev)) {
1573 struct net_device *dev;
1574 struct corkscrew_private *vp;
1575
1576 vp = list_entry(root_corkscrew_dev.next,
1577 struct corkscrew_private, list);
1578 dev = vp->our_dev;
1579 unregister_netdev(dev);
1580 cleanup_card(dev);
1581 free_netdev(dev);
1582 }
1583}
1584#endif
1585