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