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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62#define DRV_NAME "3c509"
63#define DRV_VERSION "1.20"
64#define DRV_RELDATE "04Feb2008"
65
66
67
68
69#define TX_TIMEOUT (400*HZ/1000)
70
71#include <linux/module.h>
72#include <linux/isa.h>
73#include <linux/pnp.h>
74#include <linux/string.h>
75#include <linux/interrupt.h>
76#include <linux/errno.h>
77#include <linux/in.h>
78#include <linux/ioport.h>
79#include <linux/init.h>
80#include <linux/netdevice.h>
81#include <linux/etherdevice.h>
82#include <linux/pm.h>
83#include <linux/skbuff.h>
84#include <linux/delay.h>
85#include <linux/spinlock.h>
86#include <linux/ethtool.h>
87#include <linux/device.h>
88#include <linux/eisa.h>
89#include <linux/bitops.h>
90
91#include <asm/uaccess.h>
92#include <asm/io.h>
93#include <asm/irq.h>
94
95static char version[] = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
96
97#ifdef EL3_DEBUG
98static int el3_debug = EL3_DEBUG;
99#else
100static int el3_debug = 2;
101#endif
102
103
104
105
106static int el3_cards = 0;
107#define EL3_MAX_CARDS 8
108
109
110
111
112
113#define EL3_DATA 0x00
114#define EL3_CMD 0x0e
115#define EL3_STATUS 0x0e
116#define EEPROM_READ 0x80
117
118#define EL3_IO_EXTENT 16
119
120#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
121
122
123
124
125enum c509cmd {
126 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
127 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
128 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
129 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
130 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
131 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
132 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
133 PowerDown = 28<<11, PowerAuto = 29<<11};
134
135enum c509status {
136 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
137 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
138 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
139
140
141enum RxFilter {
142 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
143
144
145#define TX_FIFO 0x00
146#define RX_FIFO 0x00
147#define RX_STATUS 0x08
148#define TX_STATUS 0x0B
149#define TX_FREE 0x0C
150
151#define WN0_CONF_CTRL 0x04
152#define WN0_ADDR_CONF 0x06
153#define WN0_IRQ 0x08
154#define WN4_MEDIA 0x0A
155#define MEDIA_TP 0x00C0
156#define WN4_NETDIAG 0x06
157#define FD_ENABLE 0x8000
158
159
160
161
162
163#define SKB_QUEUE_SIZE 64
164
165enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_EISA };
166
167struct el3_private {
168 spinlock_t lock;
169
170 int head, size;
171 struct sk_buff *queue[SKB_QUEUE_SIZE];
172 enum el3_cardtype type;
173};
174static int id_port;
175static int current_tag;
176static struct net_device *el3_devs[EL3_MAX_CARDS];
177
178
179static int debug = -1;
180static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
181
182static int max_interrupt_work = 10;
183#ifdef CONFIG_PNP
184static int nopnp;
185#endif
186
187static int el3_common_init(struct net_device *dev);
188static void el3_common_remove(struct net_device *dev);
189static ushort id_read_eeprom(int index);
190static ushort read_eeprom(int ioaddr, int index);
191static int el3_open(struct net_device *dev);
192static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
193static irqreturn_t el3_interrupt(int irq, void *dev_id);
194static void update_stats(struct net_device *dev);
195static struct net_device_stats *el3_get_stats(struct net_device *dev);
196static int el3_rx(struct net_device *dev);
197static int el3_close(struct net_device *dev);
198static void set_multicast_list(struct net_device *dev);
199static void el3_tx_timeout (struct net_device *dev);
200static void el3_down(struct net_device *dev);
201static void el3_up(struct net_device *dev);
202static const struct ethtool_ops ethtool_ops;
203#ifdef CONFIG_PM
204static int el3_suspend(struct device *, pm_message_t);
205static int el3_resume(struct device *);
206#else
207#define el3_suspend NULL
208#define el3_resume NULL
209#endif
210
211
212
213static int el3_device_remove (struct device *device);
214#ifdef CONFIG_NET_POLL_CONTROLLER
215static void el3_poll_controller(struct net_device *dev);
216#endif
217
218
219static int el3_isa_id_sequence(__be16 *phys_addr)
220{
221 short lrs_state = 0xff;
222 int i;
223
224
225
226
227
228
229 outb(0x00, id_port);
230 outb(0x00, id_port);
231 for (i = 0; i < 255; i++) {
232 outb(lrs_state, id_port);
233 lrs_state <<= 1;
234 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
235 }
236
237 if (current_tag == 0)
238 outb(0xd0, id_port);
239 else
240 outb(0xd8, id_port);
241 if (id_read_eeprom(7) != 0x6d50)
242 return 1;
243
244
245
246 for (i = 0; i < 3; i++)
247 phys_addr[i] = htons(id_read_eeprom(i));
248#ifdef CONFIG_PNP
249 if (!nopnp) {
250
251
252 for (i = 0; i < el3_cards; i++) {
253 struct el3_private *lp = netdev_priv(el3_devs[i]);
254 if (lp->type == EL3_PNP &&
255 !memcmp(phys_addr, el3_devs[i]->dev_addr,
256 ETH_ALEN)) {
257 if (el3_debug > 3)
258 pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
259 phys_addr[0] & 0xff, phys_addr[0] >> 8,
260 phys_addr[1] & 0xff, phys_addr[1] >> 8,
261 phys_addr[2] & 0xff, phys_addr[2] >> 8);
262
263 outb(0xd0 + ++current_tag, id_port);
264 return 2;
265 }
266 }
267 }
268#endif
269 return 0;
270
271}
272
273static void el3_dev_fill(struct net_device *dev, __be16 *phys_addr, int ioaddr,
274 int irq, int if_port, enum el3_cardtype type)
275{
276 struct el3_private *lp = netdev_priv(dev);
277
278 memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
279 dev->base_addr = ioaddr;
280 dev->irq = irq;
281 dev->if_port = if_port;
282 lp->type = type;
283}
284
285static int el3_isa_match(struct device *pdev, unsigned int ndev)
286{
287 struct net_device *dev;
288 int ioaddr, isa_irq, if_port, err;
289 unsigned int iobase;
290 __be16 phys_addr[3];
291
292 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
293 ;
294 if (err == 1)
295 return 0;
296
297 iobase = id_read_eeprom(8);
298 if_port = iobase >> 14;
299 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
300 if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
301 isa_irq = irq[el3_cards];
302 else
303 isa_irq = id_read_eeprom(9) >> 12;
304
305 dev = alloc_etherdev(sizeof(struct el3_private));
306 if (!dev)
307 return -ENOMEM;
308
309 SET_NETDEV_DEV(dev, pdev);
310 netdev_boot_setup_check(dev);
311
312 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
313 free_netdev(dev);
314 return 0;
315 }
316
317
318 outb(0xd0 + ++current_tag, id_port);
319
320
321 outb((ioaddr >> 4) | 0xe0, id_port);
322
323 EL3WINDOW(0);
324 if (inw(ioaddr) != 0x6d50) {
325 free_netdev(dev);
326 return 0;
327 }
328
329
330 outw(0x0f00, ioaddr + WN0_IRQ);
331
332 el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
333 dev_set_drvdata(pdev, dev);
334 if (el3_common_init(dev)) {
335 free_netdev(dev);
336 return 0;
337 }
338
339 el3_devs[el3_cards++] = dev;
340 return 1;
341}
342
343static int el3_isa_remove(struct device *pdev,
344 unsigned int ndev)
345{
346 el3_device_remove(pdev);
347 dev_set_drvdata(pdev, NULL);
348 return 0;
349}
350
351#ifdef CONFIG_PM
352static int el3_isa_suspend(struct device *dev, unsigned int n,
353 pm_message_t state)
354{
355 current_tag = 0;
356 return el3_suspend(dev, state);
357}
358
359static int el3_isa_resume(struct device *dev, unsigned int n)
360{
361 struct net_device *ndev = dev_get_drvdata(dev);
362 int ioaddr = ndev->base_addr, err;
363 __be16 phys_addr[3];
364
365 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
366 ;
367 if (err == 1)
368 return 0;
369
370 outb(0xd0 + ++current_tag, id_port);
371
372 outb((ioaddr >> 4) | 0xe0, id_port);
373 EL3WINDOW(0);
374 if (inw(ioaddr) != 0x6d50)
375 return 1;
376
377 outw(0x0f00, ioaddr + WN0_IRQ);
378 return el3_resume(dev);
379}
380#endif
381
382static struct isa_driver el3_isa_driver = {
383 .match = el3_isa_match,
384 .remove = el3_isa_remove,
385#ifdef CONFIG_PM
386 .suspend = el3_isa_suspend,
387 .resume = el3_isa_resume,
388#endif
389 .driver = {
390 .name = "3c509"
391 },
392};
393static int isa_registered;
394
395#ifdef CONFIG_PNP
396static struct pnp_device_id el3_pnp_ids[] = {
397 { .id = "TCM5090" },
398 { .id = "TCM5091" },
399 { .id = "TCM5094" },
400 { .id = "TCM5095" },
401 { .id = "TCM5098" },
402 { .id = "PNP80f7" },
403 { .id = "PNP80f8" },
404 { .id = "" }
405};
406MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
407
408static int el3_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
409{
410 short i;
411 int ioaddr, irq, if_port;
412 __be16 phys_addr[3];
413 struct net_device *dev = NULL;
414 int err;
415
416 ioaddr = pnp_port_start(pdev, 0);
417 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
418 return -EBUSY;
419 irq = pnp_irq(pdev, 0);
420 EL3WINDOW(0);
421 for (i = 0; i < 3; i++)
422 phys_addr[i] = htons(read_eeprom(ioaddr, i));
423 if_port = read_eeprom(ioaddr, 8) >> 14;
424 dev = alloc_etherdev(sizeof(struct el3_private));
425 if (!dev) {
426 release_region(ioaddr, EL3_IO_EXTENT);
427 return -ENOMEM;
428 }
429 SET_NETDEV_DEV(dev, &pdev->dev);
430 netdev_boot_setup_check(dev);
431
432 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
433 pnp_set_drvdata(pdev, dev);
434 err = el3_common_init(dev);
435
436 if (err) {
437 pnp_set_drvdata(pdev, NULL);
438 free_netdev(dev);
439 return err;
440 }
441
442 el3_devs[el3_cards++] = dev;
443 return 0;
444}
445
446static void el3_pnp_remove(struct pnp_dev *pdev)
447{
448 el3_common_remove(pnp_get_drvdata(pdev));
449 pnp_set_drvdata(pdev, NULL);
450}
451
452#ifdef CONFIG_PM
453static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
454{
455 return el3_suspend(&pdev->dev, state);
456}
457
458static int el3_pnp_resume(struct pnp_dev *pdev)
459{
460 return el3_resume(&pdev->dev);
461}
462#endif
463
464static struct pnp_driver el3_pnp_driver = {
465 .name = "3c509",
466 .id_table = el3_pnp_ids,
467 .probe = el3_pnp_probe,
468 .remove = el3_pnp_remove,
469#ifdef CONFIG_PM
470 .suspend = el3_pnp_suspend,
471 .resume = el3_pnp_resume,
472#endif
473};
474static int pnp_registered;
475#endif
476
477#ifdef CONFIG_EISA
478static struct eisa_device_id el3_eisa_ids[] = {
479 { "TCM5090" },
480 { "TCM5091" },
481 { "TCM5092" },
482 { "TCM5093" },
483 { "TCM5094" },
484 { "TCM5095" },
485 { "TCM5098" },
486 { "" }
487};
488MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
489
490static int el3_eisa_probe (struct device *device);
491
492static struct eisa_driver el3_eisa_driver = {
493 .id_table = el3_eisa_ids,
494 .driver = {
495 .name = "3c579",
496 .probe = el3_eisa_probe,
497 .remove = el3_device_remove,
498 .suspend = el3_suspend,
499 .resume = el3_resume,
500 }
501};
502static int eisa_registered;
503#endif
504
505static const struct net_device_ops netdev_ops = {
506 .ndo_open = el3_open,
507 .ndo_stop = el3_close,
508 .ndo_start_xmit = el3_start_xmit,
509 .ndo_get_stats = el3_get_stats,
510 .ndo_set_rx_mode = set_multicast_list,
511 .ndo_tx_timeout = el3_tx_timeout,
512 .ndo_change_mtu = eth_change_mtu,
513 .ndo_set_mac_address = eth_mac_addr,
514 .ndo_validate_addr = eth_validate_addr,
515#ifdef CONFIG_NET_POLL_CONTROLLER
516 .ndo_poll_controller = el3_poll_controller,
517#endif
518};
519
520static int el3_common_init(struct net_device *dev)
521{
522 struct el3_private *lp = netdev_priv(dev);
523 int err;
524 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
525
526 spin_lock_init(&lp->lock);
527
528 if (dev->mem_start & 0x05) {
529 dev->if_port = (dev->mem_start & 0x0f);
530 } else {
531
532 dev->if_port |= (dev->mem_start & 0x08);
533 }
534
535
536 dev->netdev_ops = &netdev_ops;
537 dev->watchdog_timeo = TX_TIMEOUT;
538 SET_ETHTOOL_OPS(dev, ðtool_ops);
539
540 err = register_netdev(dev);
541 if (err) {
542 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
543 dev->base_addr, dev->irq);
544 release_region(dev->base_addr, EL3_IO_EXTENT);
545 return err;
546 }
547
548 pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
549 dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
550 dev->dev_addr, dev->irq);
551
552 if (el3_debug > 0)
553 pr_info("%s", version);
554 return 0;
555
556}
557
558static void el3_common_remove (struct net_device *dev)
559{
560 unregister_netdev (dev);
561 release_region(dev->base_addr, EL3_IO_EXTENT);
562 free_netdev (dev);
563}
564
565#ifdef CONFIG_EISA
566static int __init el3_eisa_probe (struct device *device)
567{
568 short i;
569 int ioaddr, irq, if_port;
570 __be16 phys_addr[3];
571 struct net_device *dev = NULL;
572 struct eisa_device *edev;
573 int err;
574
575
576 edev = to_eisa_device (device);
577 ioaddr = edev->base_addr;
578
579 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
580 return -EBUSY;
581
582
583 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
584
585 irq = inw(ioaddr + WN0_IRQ) >> 12;
586 if_port = inw(ioaddr + 6)>>14;
587 for (i = 0; i < 3; i++)
588 phys_addr[i] = htons(read_eeprom(ioaddr, i));
589
590
591 read_eeprom(ioaddr, 3);
592
593 dev = alloc_etherdev(sizeof (struct el3_private));
594 if (dev == NULL) {
595 release_region(ioaddr, EL3_IO_EXTENT);
596 return -ENOMEM;
597 }
598
599 SET_NETDEV_DEV(dev, device);
600 netdev_boot_setup_check(dev);
601
602 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
603 eisa_set_drvdata (edev, dev);
604 err = el3_common_init(dev);
605
606 if (err) {
607 eisa_set_drvdata (edev, NULL);
608 free_netdev(dev);
609 return err;
610 }
611
612 el3_devs[el3_cards++] = dev;
613 return 0;
614}
615#endif
616
617
618
619
620static int el3_device_remove(struct device *device)
621{
622 struct net_device *dev;
623
624 dev = dev_get_drvdata(device);
625
626 el3_common_remove (dev);
627 return 0;
628}
629
630
631
632
633static ushort read_eeprom(int ioaddr, int index)
634{
635 outw(EEPROM_READ + index, ioaddr + 10);
636
637
638 mdelay(2);
639 return inw(ioaddr + 12);
640}
641
642
643static ushort id_read_eeprom(int index)
644{
645 int bit, word = 0;
646
647
648
649 outb(EEPROM_READ + index, id_port);
650
651
652
653 mdelay(4);
654
655 for (bit = 15; bit >= 0; bit--)
656 word = (word << 1) + (inb(id_port) & 0x01);
657
658 if (el3_debug > 3)
659 pr_debug(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
660
661 return word;
662}
663
664
665static int
666el3_open(struct net_device *dev)
667{
668 int ioaddr = dev->base_addr;
669 int i;
670
671 outw(TxReset, ioaddr + EL3_CMD);
672 outw(RxReset, ioaddr + EL3_CMD);
673 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
674
675 i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
676 if (i)
677 return i;
678
679 EL3WINDOW(0);
680 if (el3_debug > 3)
681 pr_debug("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
682 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
683
684 el3_up(dev);
685
686 if (el3_debug > 3)
687 pr_debug("%s: Opened 3c509 IRQ %d status %4.4x.\n",
688 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
689
690 return 0;
691}
692
693static void
694el3_tx_timeout (struct net_device *dev)
695{
696 int ioaddr = dev->base_addr;
697
698
699 pr_warning("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d.\n",
700 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
701 inw(ioaddr + TX_FREE));
702 dev->stats.tx_errors++;
703 dev->trans_start = jiffies;
704
705 outw(TxReset, ioaddr + EL3_CMD);
706 outw(TxEnable, ioaddr + EL3_CMD);
707 netif_wake_queue(dev);
708}
709
710
711static netdev_tx_t
712el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
713{
714 struct el3_private *lp = netdev_priv(dev);
715 int ioaddr = dev->base_addr;
716 unsigned long flags;
717
718 netif_stop_queue (dev);
719
720 dev->stats.tx_bytes += skb->len;
721
722 if (el3_debug > 4) {
723 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
724 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
725 }
726#if 0
727#ifndef final_version
728 {
729 ushort status = inw(ioaddr + EL3_STATUS);
730 if (status & 0x0001 &&
731 inw(ioaddr + EL3_STATUS) & 1) {
732 pr_debug("%s: Missed interrupt, status then %04x now %04x"
733 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
734 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
735 inw(ioaddr + RX_STATUS));
736
737 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
738 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
739 ioaddr + EL3_CMD);
740 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
741 }
742 }
743#endif
744#endif
745
746
747
748
749
750
751
752
753
754
755
756 spin_lock_irqsave(&lp->lock, flags);
757
758
759 outw(skb->len, ioaddr + TX_FIFO);
760 outw(0x00, ioaddr + TX_FIFO);
761
762 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
763
764 if (inw(ioaddr + TX_FREE) > 1536)
765 netif_start_queue(dev);
766 else
767
768 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
769
770 spin_unlock_irqrestore(&lp->lock, flags);
771
772 dev_kfree_skb (skb);
773
774
775 {
776 short tx_status;
777 int i = 4;
778
779 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
780 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
781 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
782 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
783 outb(0x00, ioaddr + TX_STATUS);
784 }
785 }
786 return NETDEV_TX_OK;
787}
788
789
790static irqreturn_t
791el3_interrupt(int irq, void *dev_id)
792{
793 struct net_device *dev = dev_id;
794 struct el3_private *lp;
795 int ioaddr, status;
796 int i = max_interrupt_work;
797
798 lp = netdev_priv(dev);
799 spin_lock(&lp->lock);
800
801 ioaddr = dev->base_addr;
802
803 if (el3_debug > 4) {
804 status = inw(ioaddr + EL3_STATUS);
805 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
806 }
807
808 while ((status = inw(ioaddr + EL3_STATUS)) &
809 (IntLatch | RxComplete | StatsFull)) {
810
811 if (status & RxComplete)
812 el3_rx(dev);
813
814 if (status & TxAvailable) {
815 if (el3_debug > 5)
816 pr_debug(" TX room bit was handled.\n");
817
818 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
819 netif_wake_queue (dev);
820 }
821 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
822
823 if (status & StatsFull)
824 update_stats(dev);
825 if (status & RxEarly) {
826 el3_rx(dev);
827 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
828 }
829 if (status & TxComplete) {
830 short tx_status;
831 int i = 4;
832
833 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
834 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
835 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
836 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
837 outb(0x00, ioaddr + TX_STATUS);
838 }
839 }
840 if (status & AdapterFailure) {
841
842 outw(RxReset, ioaddr + EL3_CMD);
843
844 outw(SetRxFilter | RxStation | RxBroadcast
845 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
846 | (dev->flags & IFF_PROMISC ? RxProm : 0),
847 ioaddr + EL3_CMD);
848 outw(RxEnable, ioaddr + EL3_CMD);
849 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
850 }
851 }
852
853 if (--i < 0) {
854 pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
855 dev->name, status);
856
857 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
858 break;
859 }
860
861 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
862 }
863
864 if (el3_debug > 4) {
865 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
866 inw(ioaddr + EL3_STATUS));
867 }
868 spin_unlock(&lp->lock);
869 return IRQ_HANDLED;
870}
871
872
873#ifdef CONFIG_NET_POLL_CONTROLLER
874
875
876
877
878static void el3_poll_controller(struct net_device *dev)
879{
880 disable_irq(dev->irq);
881 el3_interrupt(dev->irq, dev);
882 enable_irq(dev->irq);
883}
884#endif
885
886static struct net_device_stats *
887el3_get_stats(struct net_device *dev)
888{
889 struct el3_private *lp = netdev_priv(dev);
890 unsigned long flags;
891
892
893
894
895
896
897 spin_lock_irqsave(&lp->lock, flags);
898 update_stats(dev);
899 spin_unlock_irqrestore(&lp->lock, flags);
900 return &dev->stats;
901}
902
903
904
905
906
907
908static void update_stats(struct net_device *dev)
909{
910 int ioaddr = dev->base_addr;
911
912 if (el3_debug > 5)
913 pr_debug(" Updating the statistics.\n");
914
915 outw(StatsDisable, ioaddr + EL3_CMD);
916
917 EL3WINDOW(6);
918 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
919 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
920 inb(ioaddr + 2);
921 dev->stats.collisions += inb(ioaddr + 3);
922 dev->stats.tx_window_errors += inb(ioaddr + 4);
923 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
924 dev->stats.tx_packets += inb(ioaddr + 6);
925 inb(ioaddr + 7);
926 inb(ioaddr + 8);
927 inw(ioaddr + 10);
928 inw(ioaddr + 12);
929
930
931 EL3WINDOW(1);
932 outw(StatsEnable, ioaddr + EL3_CMD);
933}
934
935static int
936el3_rx(struct net_device *dev)
937{
938 int ioaddr = dev->base_addr;
939 short rx_status;
940
941 if (el3_debug > 5)
942 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
943 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
944 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
945 if (rx_status & 0x4000) {
946 short error = rx_status & 0x3800;
947
948 outw(RxDiscard, ioaddr + EL3_CMD);
949 dev->stats.rx_errors++;
950 switch (error) {
951 case 0x0000: dev->stats.rx_over_errors++; break;
952 case 0x0800: dev->stats.rx_length_errors++; break;
953 case 0x1000: dev->stats.rx_frame_errors++; break;
954 case 0x1800: dev->stats.rx_length_errors++; break;
955 case 0x2000: dev->stats.rx_frame_errors++; break;
956 case 0x2800: dev->stats.rx_crc_errors++; break;
957 }
958 } else {
959 short pkt_len = rx_status & 0x7ff;
960 struct sk_buff *skb;
961
962 skb = netdev_alloc_skb(dev, pkt_len + 5);
963 if (el3_debug > 4)
964 pr_debug("Receiving packet size %d status %4.4x.\n",
965 pkt_len, rx_status);
966 if (skb != NULL) {
967 skb_reserve(skb, 2);
968
969
970 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
971 (pkt_len + 3) >> 2);
972
973 outw(RxDiscard, ioaddr + EL3_CMD);
974 skb->protocol = eth_type_trans(skb,dev);
975 netif_rx(skb);
976 dev->stats.rx_bytes += pkt_len;
977 dev->stats.rx_packets++;
978 continue;
979 }
980 outw(RxDiscard, ioaddr + EL3_CMD);
981 dev->stats.rx_dropped++;
982 if (el3_debug)
983 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
984 dev->name, pkt_len);
985 }
986 inw(ioaddr + EL3_STATUS);
987 while (inw(ioaddr + EL3_STATUS) & 0x1000)
988 pr_debug(" Waiting for 3c509 to discard packet, status %x.\n",
989 inw(ioaddr + EL3_STATUS) );
990 }
991
992 return 0;
993}
994
995
996
997
998static void
999set_multicast_list(struct net_device *dev)
1000{
1001 unsigned long flags;
1002 struct el3_private *lp = netdev_priv(dev);
1003 int ioaddr = dev->base_addr;
1004 int mc_count = netdev_mc_count(dev);
1005
1006 if (el3_debug > 1) {
1007 static int old;
1008 if (old != mc_count) {
1009 old = mc_count;
1010 pr_debug("%s: Setting Rx mode to %d addresses.\n",
1011 dev->name, mc_count);
1012 }
1013 }
1014 spin_lock_irqsave(&lp->lock, flags);
1015 if (dev->flags&IFF_PROMISC) {
1016 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1017 ioaddr + EL3_CMD);
1018 }
1019 else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
1020 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1021 }
1022 else
1023 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1024 spin_unlock_irqrestore(&lp->lock, flags);
1025}
1026
1027static int
1028el3_close(struct net_device *dev)
1029{
1030 int ioaddr = dev->base_addr;
1031 struct el3_private *lp = netdev_priv(dev);
1032
1033 if (el3_debug > 2)
1034 pr_debug("%s: Shutting down ethercard.\n", dev->name);
1035
1036 el3_down(dev);
1037
1038 free_irq(dev->irq, dev);
1039
1040 EL3WINDOW(0);
1041 if (lp->type != EL3_EISA) {
1042
1043
1044
1045 outw(0x0f00, ioaddr + WN0_IRQ);
1046 }
1047
1048 return 0;
1049}
1050
1051static int
1052el3_link_ok(struct net_device *dev)
1053{
1054 int ioaddr = dev->base_addr;
1055 u16 tmp;
1056
1057 EL3WINDOW(4);
1058 tmp = inw(ioaddr + WN4_MEDIA);
1059 EL3WINDOW(1);
1060 return tmp & (1<<11);
1061}
1062
1063static int
1064el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1065{
1066 u16 tmp;
1067 int ioaddr = dev->base_addr;
1068
1069 EL3WINDOW(0);
1070
1071 tmp = inw(ioaddr + WN0_ADDR_CONF);
1072 ecmd->transceiver = XCVR_INTERNAL;
1073 switch (tmp >> 14) {
1074 case 0:
1075 ecmd->port = PORT_TP;
1076 break;
1077 case 1:
1078 ecmd->port = PORT_AUI;
1079 ecmd->transceiver = XCVR_EXTERNAL;
1080 break;
1081 case 3:
1082 ecmd->port = PORT_BNC;
1083 default:
1084 break;
1085 }
1086
1087 ecmd->duplex = DUPLEX_HALF;
1088 ecmd->supported = 0;
1089 tmp = inw(ioaddr + WN0_CONF_CTRL);
1090 if (tmp & (1<<13))
1091 ecmd->supported |= SUPPORTED_AUI;
1092 if (tmp & (1<<12))
1093 ecmd->supported |= SUPPORTED_BNC;
1094 if (tmp & (1<<9)) {
1095 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1096 SUPPORTED_10baseT_Full;
1097 EL3WINDOW(4);
1098 tmp = inw(ioaddr + WN4_NETDIAG);
1099 if (tmp & FD_ENABLE)
1100 ecmd->duplex = DUPLEX_FULL;
1101 }
1102
1103 ethtool_cmd_speed_set(ecmd, SPEED_10);
1104 EL3WINDOW(1);
1105 return 0;
1106}
1107
1108static int
1109el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1110{
1111 u16 tmp;
1112 int ioaddr = dev->base_addr;
1113
1114 if (ecmd->speed != SPEED_10)
1115 return -EINVAL;
1116 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1117 return -EINVAL;
1118 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1119 return -EINVAL;
1120
1121
1122 EL3WINDOW(0);
1123 tmp = inw(ioaddr + WN0_ADDR_CONF);
1124 switch (ecmd->port) {
1125 case PORT_TP:
1126 tmp &= ~(3<<14);
1127 dev->if_port = 0;
1128 break;
1129 case PORT_AUI:
1130 tmp |= (1<<14);
1131 dev->if_port = 1;
1132 break;
1133 case PORT_BNC:
1134 tmp |= (3<<14);
1135 dev->if_port = 3;
1136 break;
1137 default:
1138 return -EINVAL;
1139 }
1140
1141 outw(tmp, ioaddr + WN0_ADDR_CONF);
1142 if (dev->if_port == 3) {
1143
1144 tmp = inw(ioaddr + WN0_ADDR_CONF);
1145 if (tmp & (3 << 14)) {
1146 outw(StartCoax, ioaddr + EL3_CMD);
1147 udelay(800);
1148 } else
1149 return -EIO;
1150 }
1151
1152 EL3WINDOW(4);
1153 tmp = inw(ioaddr + WN4_NETDIAG);
1154 if (ecmd->duplex == DUPLEX_FULL)
1155 tmp |= FD_ENABLE;
1156 else
1157 tmp &= ~FD_ENABLE;
1158 outw(tmp, ioaddr + WN4_NETDIAG);
1159 EL3WINDOW(1);
1160
1161 return 0;
1162}
1163
1164static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1165{
1166 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1167 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1168}
1169
1170static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1171{
1172 struct el3_private *lp = netdev_priv(dev);
1173 int ret;
1174
1175 spin_lock_irq(&lp->lock);
1176 ret = el3_netdev_get_ecmd(dev, ecmd);
1177 spin_unlock_irq(&lp->lock);
1178 return ret;
1179}
1180
1181static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1182{
1183 struct el3_private *lp = netdev_priv(dev);
1184 int ret;
1185
1186 spin_lock_irq(&lp->lock);
1187 ret = el3_netdev_set_ecmd(dev, ecmd);
1188 spin_unlock_irq(&lp->lock);
1189 return ret;
1190}
1191
1192static u32 el3_get_link(struct net_device *dev)
1193{
1194 struct el3_private *lp = netdev_priv(dev);
1195 u32 ret;
1196
1197 spin_lock_irq(&lp->lock);
1198 ret = el3_link_ok(dev);
1199 spin_unlock_irq(&lp->lock);
1200 return ret;
1201}
1202
1203static u32 el3_get_msglevel(struct net_device *dev)
1204{
1205 return el3_debug;
1206}
1207
1208static void el3_set_msglevel(struct net_device *dev, u32 v)
1209{
1210 el3_debug = v;
1211}
1212
1213static const struct ethtool_ops ethtool_ops = {
1214 .get_drvinfo = el3_get_drvinfo,
1215 .get_settings = el3_get_settings,
1216 .set_settings = el3_set_settings,
1217 .get_link = el3_get_link,
1218 .get_msglevel = el3_get_msglevel,
1219 .set_msglevel = el3_set_msglevel,
1220};
1221
1222static void
1223el3_down(struct net_device *dev)
1224{
1225 int ioaddr = dev->base_addr;
1226
1227 netif_stop_queue(dev);
1228
1229
1230 outw(StatsDisable, ioaddr + EL3_CMD);
1231
1232
1233 outw(RxDisable, ioaddr + EL3_CMD);
1234 outw(TxDisable, ioaddr + EL3_CMD);
1235
1236 if (dev->if_port == 3)
1237
1238 outw(StopCoax, ioaddr + EL3_CMD);
1239 else if (dev->if_port == 0) {
1240
1241 EL3WINDOW(4);
1242 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1243 }
1244
1245 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1246
1247 update_stats(dev);
1248}
1249
1250static void
1251el3_up(struct net_device *dev)
1252{
1253 int i, sw_info, net_diag;
1254 int ioaddr = dev->base_addr;
1255
1256
1257 outw(0x0001, ioaddr + 4);
1258
1259
1260 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1261
1262
1263 EL3WINDOW(2);
1264
1265 for (i = 0; i < 6; i++)
1266 outb(dev->dev_addr[i], ioaddr + i);
1267
1268 if ((dev->if_port & 0x03) == 3)
1269
1270 outw(StartCoax, ioaddr + EL3_CMD);
1271 else if ((dev->if_port & 0x03) == 0) {
1272
1273
1274 EL3WINDOW(0);
1275 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1276 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1277
1278 EL3WINDOW(4);
1279 net_diag = inw(ioaddr + WN4_NETDIAG);
1280 net_diag = (net_diag | FD_ENABLE);
1281 pr_info("%s: ", dev->name);
1282 switch (dev->if_port & 0x0c) {
1283 case 12:
1284
1285 if (sw_info & 0x000f) {
1286 pr_cont("Forcing 3c5x9b full-duplex mode");
1287 break;
1288 }
1289 case 8:
1290
1291 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1292 pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1293 break;
1294 }
1295 default:
1296
1297 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1298 net_diag = (net_diag & ~FD_ENABLE);
1299 }
1300
1301 outw(net_diag, ioaddr + WN4_NETDIAG);
1302 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1303 if (el3_debug > 3)
1304 pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1305
1306 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1307 }
1308
1309
1310 outw(StatsDisable, ioaddr + EL3_CMD);
1311 EL3WINDOW(6);
1312 for (i = 0; i < 9; i++)
1313 inb(ioaddr + i);
1314 inw(ioaddr + 10);
1315 inw(ioaddr + 12);
1316
1317
1318 EL3WINDOW(1);
1319
1320
1321 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1322 outw(StatsEnable, ioaddr + EL3_CMD);
1323
1324 outw(RxEnable, ioaddr + EL3_CMD);
1325 outw(TxEnable, ioaddr + EL3_CMD);
1326
1327 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1328
1329 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1330 ioaddr + EL3_CMD);
1331 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1332 ioaddr + EL3_CMD);
1333
1334 netif_start_queue(dev);
1335}
1336
1337
1338#ifdef CONFIG_PM
1339
1340static int
1341el3_suspend(struct device *pdev, pm_message_t state)
1342{
1343 unsigned long flags;
1344 struct net_device *dev;
1345 struct el3_private *lp;
1346 int ioaddr;
1347
1348 dev = dev_get_drvdata(pdev);
1349 lp = netdev_priv(dev);
1350 ioaddr = dev->base_addr;
1351
1352 spin_lock_irqsave(&lp->lock, flags);
1353
1354 if (netif_running(dev))
1355 netif_device_detach(dev);
1356
1357 el3_down(dev);
1358 outw(PowerDown, ioaddr + EL3_CMD);
1359
1360 spin_unlock_irqrestore(&lp->lock, flags);
1361 return 0;
1362}
1363
1364static int
1365el3_resume(struct device *pdev)
1366{
1367 unsigned long flags;
1368 struct net_device *dev;
1369 struct el3_private *lp;
1370 int ioaddr;
1371
1372 dev = dev_get_drvdata(pdev);
1373 lp = netdev_priv(dev);
1374 ioaddr = dev->base_addr;
1375
1376 spin_lock_irqsave(&lp->lock, flags);
1377
1378 outw(PowerUp, ioaddr + EL3_CMD);
1379 EL3WINDOW(0);
1380 el3_up(dev);
1381
1382 if (netif_running(dev))
1383 netif_device_attach(dev);
1384
1385 spin_unlock_irqrestore(&lp->lock, flags);
1386 return 0;
1387}
1388
1389#endif
1390
1391module_param(debug,int, 0);
1392module_param_array(irq, int, NULL, 0);
1393module_param(max_interrupt_work, int, 0);
1394MODULE_PARM_DESC(debug, "debug level (0-6)");
1395MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1396MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1397#ifdef CONFIG_PNP
1398module_param(nopnp, int, 0);
1399MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1400#endif
1401MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1402MODULE_LICENSE("GPL");
1403
1404static int __init el3_init_module(void)
1405{
1406 int ret = 0;
1407
1408 if (debug >= 0)
1409 el3_debug = debug;
1410
1411#ifdef CONFIG_PNP
1412 if (!nopnp) {
1413 ret = pnp_register_driver(&el3_pnp_driver);
1414 if (!ret)
1415 pnp_registered = 1;
1416 }
1417#endif
1418
1419
1420 for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1421 if (!request_region(id_port, 1, "3c509-control"))
1422 continue;
1423 outb(0x00, id_port);
1424 outb(0xff, id_port);
1425 if (inb(id_port) & 0x01)
1426 break;
1427 else
1428 release_region(id_port, 1);
1429 }
1430 if (id_port >= 0x200) {
1431 id_port = 0;
1432 pr_err("No I/O port available for 3c509 activation.\n");
1433 } else {
1434 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1435 if (!ret)
1436 isa_registered = 1;
1437 }
1438#ifdef CONFIG_EISA
1439 ret = eisa_driver_register(&el3_eisa_driver);
1440 if (!ret)
1441 eisa_registered = 1;
1442#endif
1443
1444#ifdef CONFIG_PNP
1445 if (pnp_registered)
1446 ret = 0;
1447#endif
1448 if (isa_registered)
1449 ret = 0;
1450#ifdef CONFIG_EISA
1451 if (eisa_registered)
1452 ret = 0;
1453#endif
1454 return ret;
1455}
1456
1457static void __exit el3_cleanup_module(void)
1458{
1459#ifdef CONFIG_PNP
1460 if (pnp_registered)
1461 pnp_unregister_driver(&el3_pnp_driver);
1462#endif
1463 if (isa_registered)
1464 isa_unregister_driver(&el3_isa_driver);
1465 if (id_port)
1466 release_region(id_port, 1);
1467#ifdef CONFIG_EISA
1468 if (eisa_registered)
1469 eisa_driver_unregister(&el3_eisa_driver);
1470#endif
1471}
1472
1473module_init (el3_init_module);
1474module_exit (el3_cleanup_module);
1475