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
63
64
65
66
67
68
69
70
71
72#include <linux/module.h>
73#include <linux/kernel.h>
74#include <linux/init.h>
75#include <linux/slab.h>
76#include <linux/string.h>
77#include <linux/timer.h>
78#include <linux/interrupt.h>
79#include <linux/in.h>
80#include <linux/delay.h>
81#include <linux/netdevice.h>
82#include <linux/etherdevice.h>
83#include <linux/skbuff.h>
84#include <linux/if_arp.h>
85#include <linux/ioport.h>
86#include <linux/ethtool.h>
87#include <linux/bitops.h>
88#include <linux/mii.h>
89
90#include <pcmcia/cs_types.h>
91#include <pcmcia/cs.h>
92#include <pcmcia/cistpl.h>
93#include <pcmcia/cisreg.h>
94#include <pcmcia/ciscode.h>
95#include <pcmcia/ds.h>
96#include <pcmcia/mem_op.h>
97
98#include <asm/uaccess.h>
99#include <asm/io.h>
100#include <asm/system.h>
101
102
103
104
105
106MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
107MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
108MODULE_LICENSE("GPL");
109
110#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
111
112
113INT_MODULE_PARM(max_interrupt_work, 32);
114
115
116INT_MODULE_PARM(full_duplex, 0);
117
118
119INT_MODULE_PARM(auto_polarity, 1);
120
121#ifdef PCMCIA_DEBUG
122INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
123#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
124static char *version =
125"3c574_cs.c 1.65ac1 2003/04/07 Donald Becker/David Hinds, becker@scyld.com.\n";
126#else
127#define DEBUG(n, args...)
128#endif
129
130
131
132
133#define TX_TIMEOUT ((800*HZ)/1000)
134
135
136
137
138
139#define EL3_DATA 0x00
140#define EL3_CMD 0x0e
141#define EL3_STATUS 0x0e
142
143#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
144
145
146
147enum el3_cmds {
148 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
149 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
150 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
151 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
152 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
153 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
154 StatsDisable = 22<<11, StopCoax = 23<<11,
155};
156
157enum elxl_status {
158 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
159 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
160 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 };
161
162
163enum RxFilter {
164 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
165};
166
167enum Window0 {
168 Wn0EepromCmd = 10, Wn0EepromData = 12,
169 IntrStatus=0x0E,
170};
171
172enum Win0_EEPROM_cmds {
173 EEPROM_Read = 0x200, EEPROM_WRITE = 0x100, EEPROM_ERASE = 0x300,
174 EEPROM_EWENB = 0x30,
175 EEPROM_EWDIS = 0x00,
176};
177
178
179
180
181enum Window1 {
182 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
183 RxStatus = 0x18, Timer=0x1A, TxStatus = 0x1B,
184 TxFree = 0x0C,
185 RunnerRdCtrl = 0x16, RunnerWrCtrl = 0x1c,
186};
187
188enum Window3 {
189 Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
190};
191enum wn3_config {
192 Ram_size = 7,
193 Ram_width = 8,
194 Ram_speed = 0x30,
195 Rom_size = 0xc0,
196 Ram_split_shift = 16,
197 Ram_split = 3 << Ram_split_shift,
198 Xcvr_shift = 20,
199 Xcvr = 7 << Xcvr_shift,
200 Autoselect = 0x1000000,
201};
202
203enum Window4 {
204 Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
205};
206
207#define MEDIA_TP 0x00C0
208
209struct el3_private {
210 struct pcmcia_device *p_dev;
211 dev_node_t node;
212 u16 advertising, partner;
213 unsigned char phys;
214 unsigned int autoselect:1, default_media:3;
215
216 struct timer_list media;
217 unsigned short media_status;
218 unsigned short fast_poll;
219 unsigned long last_irq;
220 spinlock_t window_lock;
221};
222
223
224
225
226static char mii_preamble_required = 0;
227
228
229
230static int tc574_config(struct pcmcia_device *link);
231static void tc574_release(struct pcmcia_device *link);
232
233static void mdio_sync(unsigned int ioaddr, int bits);
234static int mdio_read(unsigned int ioaddr, int phy_id, int location);
235static void mdio_write(unsigned int ioaddr, int phy_id, int location,
236 int value);
237static unsigned short read_eeprom(unsigned int ioaddr, int index);
238static void tc574_wait_for_completion(struct net_device *dev, int cmd);
239
240static void tc574_reset(struct net_device *dev);
241static void media_check(unsigned long arg);
242static int el3_open(struct net_device *dev);
243static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
244 struct net_device *dev);
245static irqreturn_t el3_interrupt(int irq, void *dev_id);
246static void update_stats(struct net_device *dev);
247static struct net_device_stats *el3_get_stats(struct net_device *dev);
248static int el3_rx(struct net_device *dev, int worklimit);
249static int el3_close(struct net_device *dev);
250static void el3_tx_timeout(struct net_device *dev);
251static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
252static const struct ethtool_ops netdev_ethtool_ops;
253static void set_rx_mode(struct net_device *dev);
254static void set_multicast_list(struct net_device *dev);
255
256static void tc574_detach(struct pcmcia_device *p_dev);
257
258
259
260
261
262
263static const struct net_device_ops el3_netdev_ops = {
264 .ndo_open = el3_open,
265 .ndo_stop = el3_close,
266 .ndo_start_xmit = el3_start_xmit,
267 .ndo_tx_timeout = el3_tx_timeout,
268 .ndo_get_stats = el3_get_stats,
269 .ndo_do_ioctl = el3_ioctl,
270 .ndo_set_multicast_list = set_multicast_list,
271 .ndo_change_mtu = eth_change_mtu,
272 .ndo_set_mac_address = eth_mac_addr,
273 .ndo_validate_addr = eth_validate_addr,
274};
275
276static int tc574_probe(struct pcmcia_device *link)
277{
278 struct el3_private *lp;
279 struct net_device *dev;
280
281 DEBUG(0, "3c574_attach()\n");
282
283
284 dev = alloc_etherdev(sizeof(struct el3_private));
285 if (!dev)
286 return -ENOMEM;
287 lp = netdev_priv(dev);
288 link->priv = dev;
289 lp->p_dev = link;
290
291 spin_lock_init(&lp->window_lock);
292 link->io.NumPorts1 = 32;
293 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
294 link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_HANDLE_PRESENT;
295 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
296 link->irq.Handler = &el3_interrupt;
297 link->irq.Instance = dev;
298 link->conf.Attributes = CONF_ENABLE_IRQ;
299 link->conf.IntType = INT_MEMORY_AND_IO;
300 link->conf.ConfigIndex = 1;
301
302 dev->netdev_ops = &el3_netdev_ops;
303 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
304 dev->watchdog_timeo = TX_TIMEOUT;
305
306 return tc574_config(link);
307}
308
309
310
311
312
313
314
315
316
317
318static void tc574_detach(struct pcmcia_device *link)
319{
320 struct net_device *dev = link->priv;
321
322 DEBUG(0, "3c574_detach(0x%p)\n", link);
323
324 if (link->dev_node)
325 unregister_netdev(dev);
326
327 tc574_release(link);
328
329 free_netdev(dev);
330}
331
332
333
334
335
336
337
338#define CS_CHECK(fn, ret) \
339 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
340
341static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
342
343static int tc574_config(struct pcmcia_device *link)
344{
345 struct net_device *dev = link->priv;
346 struct el3_private *lp = netdev_priv(dev);
347 tuple_t tuple;
348 __le16 buf[32];
349 int last_fn, last_ret, i, j;
350 unsigned int ioaddr;
351 __be16 *phys_addr;
352 char *cardname;
353 __u32 config;
354
355 phys_addr = (__be16 *)dev->dev_addr;
356
357 DEBUG(0, "3c574_config(0x%p)\n", link);
358
359 link->io.IOAddrLines = 16;
360 for (i = j = 0; j < 0x400; j += 0x20) {
361 link->io.BasePort1 = j ^ 0x300;
362 i = pcmcia_request_io(link, &link->io);
363 if (i == 0)
364 break;
365 }
366 if (i != 0) {
367 cs_error(link, RequestIO, i);
368 goto failed;
369 }
370 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
371 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
372
373 dev->irq = link->irq.AssignedIRQ;
374 dev->base_addr = link->io.BasePort1;
375
376 ioaddr = dev->base_addr;
377
378
379
380
381 tuple.Attributes = 0;
382 tuple.TupleData = (cisdata_t *)buf;
383 tuple.TupleDataMax = 64;
384 tuple.TupleOffset = 0;
385 tuple.DesiredTuple = 0x88;
386 if (pcmcia_get_first_tuple(link, &tuple) == 0) {
387 pcmcia_get_tuple_data(link, &tuple);
388 for (i = 0; i < 3; i++)
389 phys_addr[i] = htons(le16_to_cpu(buf[i]));
390 } else {
391 EL3WINDOW(0);
392 for (i = 0; i < 3; i++)
393 phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
394 if (phys_addr[0] == htons(0x6060)) {
395 printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
396 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
397 goto failed;
398 }
399 }
400 if (link->prod_id[1])
401 cardname = link->prod_id[1];
402 else
403 cardname = "3Com 3c574";
404
405 {
406 u_char mcr;
407 outw(2<<11, ioaddr + RunnerRdCtrl);
408 mcr = inb(ioaddr + 2);
409 outw(0<<11, ioaddr + RunnerRdCtrl);
410 printk(KERN_INFO " ASIC rev %d,", mcr>>3);
411 EL3WINDOW(3);
412 config = inl(ioaddr + Wn3_Config);
413 lp->default_media = (config & Xcvr) >> Xcvr_shift;
414 lp->autoselect = config & Autoselect ? 1 : 0;
415 }
416
417 init_timer(&lp->media);
418
419 {
420 int phy;
421
422
423 outw(0x8040, ioaddr + Wn3_Options);
424 mdelay(1);
425 outw(0xc040, ioaddr + Wn3_Options);
426 tc574_wait_for_completion(dev, TxReset);
427 tc574_wait_for_completion(dev, RxReset);
428 mdelay(1);
429 outw(0x8040, ioaddr + Wn3_Options);
430
431 EL3WINDOW(4);
432 for (phy = 1; phy <= 32; phy++) {
433 int mii_status;
434 mdio_sync(ioaddr, 32);
435 mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
436 if (mii_status != 0xffff) {
437 lp->phys = phy & 0x1f;
438 DEBUG(0, " MII transceiver at index %d, status %x.\n",
439 phy, mii_status);
440 if ((mii_status & 0x0040) == 0)
441 mii_preamble_required = 1;
442 break;
443 }
444 }
445 if (phy > 32) {
446 printk(KERN_NOTICE " No MII transceivers found!\n");
447 goto failed;
448 }
449 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
450 mdio_write(ioaddr, lp->phys, 16, i);
451 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
452 if (full_duplex) {
453
454 lp->advertising &= ~0x02a0;
455 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
456 }
457 }
458
459 link->dev_node = &lp->node;
460 SET_NETDEV_DEV(dev, &handle_to_dev(link));
461
462 if (register_netdev(dev) != 0) {
463 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
464 link->dev_node = NULL;
465 goto failed;
466 }
467
468 strcpy(lp->node.dev_name, dev->name);
469
470 printk(KERN_INFO "%s: %s at io %#3lx, irq %d, "
471 "hw_addr %pM.\n",
472 dev->name, cardname, dev->base_addr, dev->irq,
473 dev->dev_addr);
474 printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
475 8 << config & Ram_size,
476 ram_split[(config & Ram_split) >> Ram_split_shift],
477 config & Autoselect ? "autoselect " : "");
478
479 return 0;
480
481cs_failed:
482 cs_error(link, last_fn, last_ret);
483failed:
484 tc574_release(link);
485 return -ENODEV;
486
487}
488
489
490
491
492
493
494
495static void tc574_release(struct pcmcia_device *link)
496{
497 pcmcia_disable_device(link);
498}
499
500static int tc574_suspend(struct pcmcia_device *link)
501{
502 struct net_device *dev = link->priv;
503
504 if (link->open)
505 netif_device_detach(dev);
506
507 return 0;
508}
509
510static int tc574_resume(struct pcmcia_device *link)
511{
512 struct net_device *dev = link->priv;
513
514 if (link->open) {
515 tc574_reset(dev);
516 netif_device_attach(dev);
517 }
518
519 return 0;
520}
521
522static void dump_status(struct net_device *dev)
523{
524 unsigned int ioaddr = dev->base_addr;
525 EL3WINDOW(1);
526 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
527 "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
528 inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
529 inw(ioaddr+TxFree));
530 EL3WINDOW(4);
531 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
532 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
533 inw(ioaddr+0x08), inw(ioaddr+0x0a));
534 EL3WINDOW(1);
535}
536
537
538
539
540static void tc574_wait_for_completion(struct net_device *dev, int cmd)
541{
542 int i = 1500;
543 outw(cmd, dev->base_addr + EL3_CMD);
544 while (--i > 0)
545 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
546 if (i == 0)
547 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
548}
549
550
551
552
553static unsigned short read_eeprom(unsigned int ioaddr, int index)
554{
555 int timer;
556 outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
557
558 for (timer = 1620; timer >= 0; timer--) {
559 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
560 break;
561 }
562 return inw(ioaddr + Wn0EepromData);
563}
564
565
566
567
568
569
570
571
572#define MDIO_SHIFT_CLK 0x01
573#define MDIO_DIR_WRITE 0x04
574#define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
575#define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
576#define MDIO_DATA_READ 0x02
577#define MDIO_ENB_IN 0x00
578
579
580
581static void mdio_sync(unsigned int ioaddr, int bits)
582{
583 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
584
585
586 while (-- bits >= 0) {
587 outw(MDIO_DATA_WRITE1, mdio_addr);
588 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
589 }
590}
591
592static int mdio_read(unsigned int ioaddr, int phy_id, int location)
593{
594 int i;
595 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
596 unsigned int retval = 0;
597 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
598
599 if (mii_preamble_required)
600 mdio_sync(ioaddr, 32);
601
602
603 for (i = 14; i >= 0; i--) {
604 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
605 outw(dataval, mdio_addr);
606 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
607 }
608
609 for (i = 19; i > 0; i--) {
610 outw(MDIO_ENB_IN, mdio_addr);
611 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
612 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
613 }
614 return (retval>>1) & 0xffff;
615}
616
617static void mdio_write(unsigned int ioaddr, int phy_id, int location, int value)
618{
619 int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
620 unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
621 int i;
622
623 if (mii_preamble_required)
624 mdio_sync(ioaddr, 32);
625
626
627 for (i = 31; i >= 0; i--) {
628 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
629 outw(dataval, mdio_addr);
630 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
631 }
632
633 for (i = 1; i >= 0; i--) {
634 outw(MDIO_ENB_IN, mdio_addr);
635 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
636 }
637
638 return;
639}
640
641
642static void tc574_reset(struct net_device *dev)
643{
644 struct el3_private *lp = netdev_priv(dev);
645 int i;
646 unsigned int ioaddr = dev->base_addr;
647 unsigned long flags;
648
649 tc574_wait_for_completion(dev, TotalReset|0x10);
650
651 spin_lock_irqsave(&lp->window_lock, flags);
652
653 outw(0, ioaddr + RunnerWrCtrl);
654 outw(0, ioaddr + RunnerRdCtrl);
655
656
657 EL3WINDOW(2);
658 for (i = 0; i < 6; i++)
659 outb(dev->dev_addr[i], ioaddr + i);
660 for (; i < 12; i+=2)
661 outw(0, ioaddr + i);
662
663
664 EL3WINDOW(3);
665 outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
666 outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
667 ioaddr + Wn3_Config);
668
669 outw(0x8040, ioaddr + Wn3_Options);
670 mdelay(1);
671 outw(0xc040, ioaddr + Wn3_Options);
672 EL3WINDOW(1);
673 spin_unlock_irqrestore(&lp->window_lock, flags);
674
675 tc574_wait_for_completion(dev, TxReset);
676 tc574_wait_for_completion(dev, RxReset);
677 mdelay(1);
678 spin_lock_irqsave(&lp->window_lock, flags);
679 EL3WINDOW(3);
680 outw(0x8040, ioaddr + Wn3_Options);
681
682
683 outw(StatsDisable, ioaddr + EL3_CMD);
684 EL3WINDOW(6);
685 for (i = 0; i < 10; i++)
686 inb(ioaddr + i);
687 inw(ioaddr + 10);
688 inw(ioaddr + 12);
689 EL3WINDOW(4);
690 inb(ioaddr + 12);
691 inb(ioaddr + 13);
692
693
694 outw(0x0040, ioaddr + Wn4_NetDiag);
695
696 EL3WINDOW(1);
697 spin_unlock_irqrestore(&lp->window_lock, flags);
698
699
700 mdio_sync(ioaddr, 32);
701 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
702 if (!auto_polarity) {
703
704 i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
705 mdio_write(ioaddr, lp->phys, 16, i);
706 }
707
708 spin_lock_irqsave(&lp->window_lock, flags);
709
710 set_rx_mode(dev);
711 spin_unlock_irqrestore(&lp->window_lock, flags);
712 outw(StatsEnable, ioaddr + EL3_CMD);
713 outw(RxEnable, ioaddr + EL3_CMD);
714 outw(TxEnable, ioaddr + EL3_CMD);
715
716 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
717
718 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
719 ioaddr + EL3_CMD);
720 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
721 | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
722}
723
724static int el3_open(struct net_device *dev)
725{
726 struct el3_private *lp = netdev_priv(dev);
727 struct pcmcia_device *link = lp->p_dev;
728
729 if (!pcmcia_dev_present(link))
730 return -ENODEV;
731
732 link->open++;
733 netif_start_queue(dev);
734
735 tc574_reset(dev);
736 lp->media.function = &media_check;
737 lp->media.data = (unsigned long) dev;
738 lp->media.expires = jiffies + HZ;
739 add_timer(&lp->media);
740
741 DEBUG(2, "%s: opened, status %4.4x.\n",
742 dev->name, inw(dev->base_addr + EL3_STATUS));
743
744 return 0;
745}
746
747static void el3_tx_timeout(struct net_device *dev)
748{
749 unsigned int ioaddr = dev->base_addr;
750
751 printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
752 dump_status(dev);
753 dev->stats.tx_errors++;
754 dev->trans_start = jiffies;
755
756 tc574_wait_for_completion(dev, TxReset);
757 outw(TxEnable, ioaddr + EL3_CMD);
758 netif_wake_queue(dev);
759}
760
761static void pop_tx_status(struct net_device *dev)
762{
763 unsigned int ioaddr = dev->base_addr;
764 int i;
765
766
767 for (i = 32; i > 0; i--) {
768 u_char tx_status = inb(ioaddr + TxStatus);
769 if (!(tx_status & 0x84))
770 break;
771
772 if (tx_status & 0x30)
773 tc574_wait_for_completion(dev, TxReset);
774 if (tx_status & 0x38) {
775 DEBUG(1, "%s: transmit error: status 0x%02x\n",
776 dev->name, tx_status);
777 outw(TxEnable, ioaddr + EL3_CMD);
778 dev->stats.tx_aborted_errors++;
779 }
780 outb(0x00, ioaddr + TxStatus);
781 }
782}
783
784static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
785 struct net_device *dev)
786{
787 unsigned int ioaddr = dev->base_addr;
788 struct el3_private *lp = netdev_priv(dev);
789 unsigned long flags;
790
791 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
792 "status %4.4x.\n", dev->name, (long)skb->len,
793 inw(ioaddr + EL3_STATUS));
794
795 spin_lock_irqsave(&lp->window_lock, flags);
796 outw(skb->len, ioaddr + TX_FIFO);
797 outw(0, ioaddr + TX_FIFO);
798 outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
799
800 dev->trans_start = jiffies;
801
802
803 if (inw(ioaddr + TxFree) <= 1536) {
804 netif_stop_queue(dev);
805
806
807 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
808 }
809
810 pop_tx_status(dev);
811 spin_unlock_irqrestore(&lp->window_lock, flags);
812 dev_kfree_skb(skb);
813 return NETDEV_TX_OK;
814}
815
816
817static irqreturn_t el3_interrupt(int irq, void *dev_id)
818{
819 struct net_device *dev = (struct net_device *) dev_id;
820 struct el3_private *lp = netdev_priv(dev);
821 unsigned int ioaddr;
822 unsigned status;
823 int work_budget = max_interrupt_work;
824 int handled = 0;
825
826 if (!netif_device_present(dev))
827 return IRQ_NONE;
828 ioaddr = dev->base_addr;
829
830 DEBUG(3, "%s: interrupt, status %4.4x.\n",
831 dev->name, inw(ioaddr + EL3_STATUS));
832
833 spin_lock(&lp->window_lock);
834
835 while ((status = inw(ioaddr + EL3_STATUS)) &
836 (IntLatch | RxComplete | RxEarly | StatsFull)) {
837 if (!netif_device_present(dev) ||
838 ((status & 0xe000) != 0x2000)) {
839 DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
840 break;
841 }
842
843 handled = 1;
844
845 if (status & RxComplete)
846 work_budget = el3_rx(dev, work_budget);
847
848 if (status & TxAvailable) {
849 DEBUG(3, " TX room bit was handled.\n");
850
851 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
852 netif_wake_queue(dev);
853 }
854
855 if (status & TxComplete)
856 pop_tx_status(dev);
857
858 if (status & (AdapterFailure | RxEarly | StatsFull)) {
859
860 if (status & StatsFull)
861 update_stats(dev);
862 if (status & RxEarly) {
863 work_budget = el3_rx(dev, work_budget);
864 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
865 }
866 if (status & AdapterFailure) {
867 u16 fifo_diag;
868 EL3WINDOW(4);
869 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
870 EL3WINDOW(1);
871 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
872 " register %04x.\n", dev->name, fifo_diag);
873 if (fifo_diag & 0x0400) {
874
875 tc574_wait_for_completion(dev, TxReset);
876 outw(TxEnable, ioaddr + EL3_CMD);
877 }
878 if (fifo_diag & 0x2000) {
879
880 tc574_wait_for_completion(dev, RxReset);
881 set_rx_mode(dev);
882 outw(RxEnable, ioaddr + EL3_CMD);
883 }
884 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
885 }
886 }
887
888 if (--work_budget < 0) {
889 DEBUG(0, "%s: Too much work in interrupt, "
890 "status %4.4x.\n", dev->name, status);
891
892 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
893 break;
894 }
895
896 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
897 }
898
899 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
900 dev->name, inw(ioaddr + EL3_STATUS));
901
902 spin_unlock(&lp->window_lock);
903 return IRQ_RETVAL(handled);
904}
905
906
907
908
909
910
911static void media_check(unsigned long arg)
912{
913 struct net_device *dev = (struct net_device *) arg;
914 struct el3_private *lp = netdev_priv(dev);
915 unsigned int ioaddr = dev->base_addr;
916 unsigned long flags;
917 unsigned short media, partner;
918
919 if (!netif_device_present(dev))
920 goto reschedule;
921
922
923
924 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
925 if (!lp->fast_poll)
926 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
927 el3_interrupt(dev->irq, dev);
928 lp->fast_poll = HZ;
929 }
930 if (lp->fast_poll) {
931 lp->fast_poll--;
932 lp->media.expires = jiffies + 2*HZ/100;
933 add_timer(&lp->media);
934 return;
935 }
936
937 spin_lock_irqsave(&lp->window_lock, flags);
938 EL3WINDOW(4);
939 media = mdio_read(ioaddr, lp->phys, 1);
940 partner = mdio_read(ioaddr, lp->phys, 5);
941 EL3WINDOW(1);
942
943 if (media != lp->media_status) {
944 if ((media ^ lp->media_status) & 0x0004)
945 printk(KERN_INFO "%s: %s link beat\n", dev->name,
946 (lp->media_status & 0x0004) ? "lost" : "found");
947 if ((media ^ lp->media_status) & 0x0020) {
948 lp->partner = 0;
949 if (lp->media_status & 0x0020) {
950 printk(KERN_INFO "%s: autonegotiation restarted\n",
951 dev->name);
952 } else if (partner) {
953 partner &= lp->advertising;
954 lp->partner = partner;
955 printk(KERN_INFO "%s: autonegotiation complete: "
956 "%sbaseT-%cD selected\n", dev->name,
957 ((partner & 0x0180) ? "100" : "10"),
958 ((partner & 0x0140) ? 'F' : 'H'));
959 } else {
960 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
961 dev->name);
962 }
963
964 EL3WINDOW(3);
965 outb((partner & 0x0140 ? 0x20 : 0) |
966 (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
967 EL3WINDOW(1);
968
969 }
970 if (media & 0x0010)
971 printk(KERN_INFO "%s: remote fault detected\n",
972 dev->name);
973 if (media & 0x0002)
974 printk(KERN_INFO "%s: jabber detected\n", dev->name);
975 lp->media_status = media;
976 }
977 spin_unlock_irqrestore(&lp->window_lock, flags);
978
979reschedule:
980 lp->media.expires = jiffies + HZ;
981 add_timer(&lp->media);
982}
983
984static struct net_device_stats *el3_get_stats(struct net_device *dev)
985{
986 struct el3_private *lp = netdev_priv(dev);
987
988 if (netif_device_present(dev)) {
989 unsigned long flags;
990 spin_lock_irqsave(&lp->window_lock, flags);
991 update_stats(dev);
992 spin_unlock_irqrestore(&lp->window_lock, flags);
993 }
994 return &dev->stats;
995}
996
997
998
999
1000
1001static void update_stats(struct net_device *dev)
1002{
1003 unsigned int ioaddr = dev->base_addr;
1004 u8 rx, tx, up;
1005
1006 DEBUG(2, "%s: updating the statistics.\n", dev->name);
1007
1008 if (inw(ioaddr+EL3_STATUS) == 0xffff)
1009 return;
1010
1011
1012
1013 EL3WINDOW(6);
1014 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1015 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1016 inb(ioaddr + 2);
1017 dev->stats.collisions += inb(ioaddr + 3);
1018 dev->stats.tx_window_errors += inb(ioaddr + 4);
1019 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1020 dev->stats.tx_packets += inb(ioaddr + 6);
1021 up = inb(ioaddr + 9);
1022 dev->stats.tx_packets += (up&0x30) << 4;
1023 inb(ioaddr + 7);
1024 inb(ioaddr + 8);
1025 rx = inw(ioaddr + 10);
1026 tx = inw(ioaddr + 12);
1027
1028 EL3WINDOW(4);
1029 inb(ioaddr + 12);
1030 up = inb(ioaddr + 13);
1031
1032 dev->stats.tx_bytes += tx + ((up & 0xf0) << 12);
1033
1034 EL3WINDOW(1);
1035}
1036
1037static int el3_rx(struct net_device *dev, int worklimit)
1038{
1039 unsigned int ioaddr = dev->base_addr;
1040 short rx_status;
1041
1042 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1043 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1044 while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1045 worklimit > 0) {
1046 worklimit--;
1047 if (rx_status & 0x4000) {
1048 short error = rx_status & 0x3800;
1049 dev->stats.rx_errors++;
1050 switch (error) {
1051 case 0x0000: dev->stats.rx_over_errors++; break;
1052 case 0x0800: dev->stats.rx_length_errors++; break;
1053 case 0x1000: dev->stats.rx_frame_errors++; break;
1054 case 0x1800: dev->stats.rx_length_errors++; break;
1055 case 0x2000: dev->stats.rx_frame_errors++; break;
1056 case 0x2800: dev->stats.rx_crc_errors++; break;
1057 }
1058 } else {
1059 short pkt_len = rx_status & 0x7ff;
1060 struct sk_buff *skb;
1061
1062 skb = dev_alloc_skb(pkt_len+5);
1063
1064 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
1065 pkt_len, rx_status);
1066 if (skb != NULL) {
1067 skb_reserve(skb, 2);
1068 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1069 ((pkt_len+3)>>2));
1070 skb->protocol = eth_type_trans(skb, dev);
1071 netif_rx(skb);
1072 dev->stats.rx_packets++;
1073 dev->stats.rx_bytes += pkt_len;
1074 } else {
1075 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1076 " size %d.\n", dev->name, pkt_len);
1077 dev->stats.rx_dropped++;
1078 }
1079 }
1080 tc574_wait_for_completion(dev, RxDiscard);
1081 }
1082
1083 return worklimit;
1084}
1085
1086static void netdev_get_drvinfo(struct net_device *dev,
1087 struct ethtool_drvinfo *info)
1088{
1089 strcpy(info->driver, "3c574_cs");
1090}
1091
1092static const struct ethtool_ops netdev_ethtool_ops = {
1093 .get_drvinfo = netdev_get_drvinfo,
1094};
1095
1096
1097static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1098{
1099 struct el3_private *lp = netdev_priv(dev);
1100 unsigned int ioaddr = dev->base_addr;
1101 struct mii_ioctl_data *data = if_mii(rq);
1102 int phy = lp->phys & 0x1f;
1103
1104 DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1105 dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1106 data->phy_id, data->reg_num, data->val_in, data->val_out);
1107
1108 switch(cmd) {
1109 case SIOCGMIIPHY:
1110 data->phy_id = phy;
1111 case SIOCGMIIREG:
1112 {
1113 int saved_window;
1114 unsigned long flags;
1115
1116 spin_lock_irqsave(&lp->window_lock, flags);
1117 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1118 EL3WINDOW(4);
1119 data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f,
1120 data->reg_num & 0x1f);
1121 EL3WINDOW(saved_window);
1122 spin_unlock_irqrestore(&lp->window_lock, flags);
1123 return 0;
1124 }
1125 case SIOCSMIIREG:
1126 {
1127 int saved_window;
1128 unsigned long flags;
1129
1130 spin_lock_irqsave(&lp->window_lock, flags);
1131 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1132 EL3WINDOW(4);
1133 mdio_write(ioaddr, data->phy_id & 0x1f,
1134 data->reg_num & 0x1f, data->val_in);
1135 EL3WINDOW(saved_window);
1136 spin_unlock_irqrestore(&lp->window_lock, flags);
1137 return 0;
1138 }
1139 default:
1140 return -EOPNOTSUPP;
1141 }
1142}
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152static void set_rx_mode(struct net_device *dev)
1153{
1154 unsigned int ioaddr = dev->base_addr;
1155
1156 if (dev->flags & IFF_PROMISC)
1157 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1158 ioaddr + EL3_CMD);
1159 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1160 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1161 else
1162 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1163}
1164
1165static void set_multicast_list(struct net_device *dev)
1166{
1167 struct el3_private *lp = netdev_priv(dev);
1168 unsigned long flags;
1169
1170 spin_lock_irqsave(&lp->window_lock, flags);
1171 set_rx_mode(dev);
1172 spin_unlock_irqrestore(&lp->window_lock, flags);
1173}
1174
1175static int el3_close(struct net_device *dev)
1176{
1177 unsigned int ioaddr = dev->base_addr;
1178 struct el3_private *lp = netdev_priv(dev);
1179 struct pcmcia_device *link = lp->p_dev;
1180
1181 DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1182
1183 if (pcmcia_dev_present(link)) {
1184 unsigned long flags;
1185
1186
1187 outw(StatsDisable, ioaddr + EL3_CMD);
1188
1189
1190 outw(RxDisable, ioaddr + EL3_CMD);
1191 outw(TxDisable, ioaddr + EL3_CMD);
1192
1193
1194 EL3WINDOW(0);
1195 spin_lock_irqsave(&lp->window_lock, flags);
1196 update_stats(dev);
1197 spin_unlock_irqrestore(&lp->window_lock, flags);
1198
1199
1200 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1201 }
1202
1203 link->open--;
1204 netif_stop_queue(dev);
1205 del_timer_sync(&lp->media);
1206
1207 return 0;
1208}
1209
1210static struct pcmcia_device_id tc574_ids[] = {
1211 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1212 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "cis/3CCFEM556.cis"),
1213 PCMCIA_DEVICE_NULL,
1214};
1215MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1216
1217static struct pcmcia_driver tc574_driver = {
1218 .owner = THIS_MODULE,
1219 .drv = {
1220 .name = "3c574_cs",
1221 },
1222 .probe = tc574_probe,
1223 .remove = tc574_detach,
1224 .id_table = tc574_ids,
1225 .suspend = tc574_suspend,
1226 .resume = tc574_resume,
1227};
1228
1229static int __init init_tc574(void)
1230{
1231 return pcmcia_register_driver(&tc574_driver);
1232}
1233
1234static void __exit exit_tc574(void)
1235{
1236 pcmcia_unregister_driver(&tc574_driver);
1237}
1238
1239module_init(init_tc574);
1240module_exit(exit_tc574);
1241