1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23
24#define DRV_NAME "3c589_cs"
25#define DRV_VERSION "1.162-ac"
26
27#include <linux/module.h>
28#include <linux/kernel.h>
29#include <linux/ptrace.h>
30#include <linux/slab.h>
31#include <linux/string.h>
32#include <linux/timer.h>
33#include <linux/interrupt.h>
34#include <linux/in.h>
35#include <linux/delay.h>
36#include <linux/ethtool.h>
37#include <linux/netdevice.h>
38#include <linux/etherdevice.h>
39#include <linux/skbuff.h>
40#include <linux/if_arp.h>
41#include <linux/ioport.h>
42#include <linux/bitops.h>
43#include <linux/jiffies.h>
44
45#include <pcmcia/cistpl.h>
46#include <pcmcia/cisreg.h>
47#include <pcmcia/ciscode.h>
48#include <pcmcia/ds.h>
49
50#include <asm/uaccess.h>
51#include <asm/io.h>
52
53
54
55
56
57#define EL3_DATA 0x00
58#define EL3_TIMER 0x0a
59#define EL3_CMD 0x0e
60#define EL3_STATUS 0x0e
61
62#define EEPROM_READ 0x0080
63#define EEPROM_BUSY 0x8000
64
65#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
66
67
68
69enum c509cmd {
70 TotalReset = 0<<11,
71 SelectWindow = 1<<11,
72 StartCoax = 2<<11,
73 RxDisable = 3<<11,
74 RxEnable = 4<<11,
75 RxReset = 5<<11,
76 RxDiscard = 8<<11,
77 TxEnable = 9<<11,
78 TxDisable = 10<<11,
79 TxReset = 11<<11,
80 FakeIntr = 12<<11,
81 AckIntr = 13<<11,
82 SetIntrEnb = 14<<11,
83 SetStatusEnb = 15<<11,
84 SetRxFilter = 16<<11,
85 SetRxThreshold = 17<<11,
86 SetTxThreshold = 18<<11,
87 SetTxStart = 19<<11,
88 StatsEnable = 21<<11,
89 StatsDisable = 22<<11,
90 StopCoax = 23<<11
91};
92
93enum c509status {
94 IntLatch = 0x0001,
95 AdapterFailure = 0x0002,
96 TxComplete = 0x0004,
97 TxAvailable = 0x0008,
98 RxComplete = 0x0010,
99 RxEarly = 0x0020,
100 IntReq = 0x0040,
101 StatsFull = 0x0080,
102 CmdBusy = 0x1000
103};
104
105
106enum RxFilter {
107 RxStation = 1,
108 RxMulticast = 2,
109 RxBroadcast = 4,
110 RxProm = 8
111};
112
113
114#define TX_FIFO 0x00
115#define RX_FIFO 0x00
116#define RX_STATUS 0x08
117#define TX_STATUS 0x0B
118#define TX_FREE 0x0C
119
120#define WN0_IRQ 0x08
121#define WN4_MEDIA 0x0A
122#define MEDIA_TP 0x00C0
123#define MEDIA_LED 0x0001
124
125
126#define TX_TIMEOUT ((400*HZ)/1000)
127
128struct el3_private {
129 struct pcmcia_device *p_dev;
130
131 struct timer_list media;
132 u16 media_status;
133 u16 fast_poll;
134 unsigned long last_irq;
135 spinlock_t lock;
136};
137
138static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
139
140
141
142
143
144MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
145MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
146MODULE_LICENSE("GPL");
147
148#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
149
150
151INT_MODULE_PARM(if_port, 0);
152
153
154
155
156static int tc589_config(struct pcmcia_device *link);
157static void tc589_release(struct pcmcia_device *link);
158
159static u16 read_eeprom(unsigned int ioaddr, int index);
160static void tc589_reset(struct net_device *dev);
161static void media_check(unsigned long arg);
162static int el3_config(struct net_device *dev, struct ifmap *map);
163static int el3_open(struct net_device *dev);
164static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
165 struct net_device *dev);
166static irqreturn_t el3_interrupt(int irq, void *dev_id);
167static void update_stats(struct net_device *dev);
168static struct net_device_stats *el3_get_stats(struct net_device *dev);
169static int el3_rx(struct net_device *dev);
170static int el3_close(struct net_device *dev);
171static void el3_tx_timeout(struct net_device *dev);
172static void set_rx_mode(struct net_device *dev);
173static void set_multicast_list(struct net_device *dev);
174static const struct ethtool_ops netdev_ethtool_ops;
175
176static void tc589_detach(struct pcmcia_device *p_dev);
177
178static const struct net_device_ops el3_netdev_ops = {
179 .ndo_open = el3_open,
180 .ndo_stop = el3_close,
181 .ndo_start_xmit = el3_start_xmit,
182 .ndo_tx_timeout = el3_tx_timeout,
183 .ndo_set_config = el3_config,
184 .ndo_get_stats = el3_get_stats,
185 .ndo_set_rx_mode = set_multicast_list,
186 .ndo_change_mtu = eth_change_mtu,
187 .ndo_set_mac_address = eth_mac_addr,
188 .ndo_validate_addr = eth_validate_addr,
189};
190
191static int tc589_probe(struct pcmcia_device *link)
192{
193 struct el3_private *lp;
194 struct net_device *dev;
195
196 dev_dbg(&link->dev, "3c589_attach()\n");
197
198
199 dev = alloc_etherdev(sizeof(struct el3_private));
200 if (!dev)
201 return -ENOMEM;
202 lp = netdev_priv(dev);
203 link->priv = dev;
204 lp->p_dev = link;
205
206 spin_lock_init(&lp->lock);
207 link->resource[0]->end = 16;
208 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
209
210 link->config_flags |= CONF_ENABLE_IRQ;
211 link->config_index = 1;
212
213 dev->netdev_ops = &el3_netdev_ops;
214 dev->watchdog_timeo = TX_TIMEOUT;
215
216 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
217
218 return tc589_config(link);
219}
220
221static void tc589_detach(struct pcmcia_device *link)
222{
223 struct net_device *dev = link->priv;
224
225 dev_dbg(&link->dev, "3c589_detach\n");
226
227 unregister_netdev(dev);
228
229 tc589_release(link);
230
231 free_netdev(dev);
232}
233
234static int tc589_config(struct pcmcia_device *link)
235{
236 struct net_device *dev = link->priv;
237 __be16 *phys_addr;
238 int ret, i, j, multi = 0, fifo;
239 unsigned int ioaddr;
240 static const char * const ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
241 u8 *buf;
242 size_t len;
243
244 dev_dbg(&link->dev, "3c589_config\n");
245
246 phys_addr = (__be16 *)dev->dev_addr;
247
248 if (link->manf_id != MANFID_3COM)
249 dev_info(&link->dev, "hmmm, is this really a 3Com card??\n");
250 multi = (link->card_id == PRODID_3COM_3C562);
251
252 link->io_lines = 16;
253
254
255 for (i = j = 0; j < 0x400; j += 0x10) {
256 if (multi && (j & 0x80)) continue;
257 link->resource[0]->start = j ^ 0x300;
258 i = pcmcia_request_io(link);
259 if (i == 0)
260 break;
261 }
262 if (i != 0)
263 goto failed;
264
265 ret = pcmcia_request_irq(link, el3_interrupt);
266 if (ret)
267 goto failed;
268
269 ret = pcmcia_enable_device(link);
270 if (ret)
271 goto failed;
272
273 dev->irq = link->irq;
274 dev->base_addr = link->resource[0]->start;
275 ioaddr = dev->base_addr;
276 EL3WINDOW(0);
277
278
279
280 len = pcmcia_get_tuple(link, 0x88, &buf);
281 if (buf && len >= 6) {
282 for (i = 0; i < 3; i++)
283 phys_addr[i] = htons(le16_to_cpu(buf[i*2]));
284 kfree(buf);
285 } else {
286 kfree(buf);
287 for (i = 0; i < 3; i++)
288 phys_addr[i] = htons(read_eeprom(ioaddr, i));
289 if (phys_addr[0] == htons(0x6060)) {
290 dev_err(&link->dev, "IO port conflict at 0x%03lx-0x%03lx\n",
291 dev->base_addr, dev->base_addr+15);
292 goto failed;
293 }
294 }
295
296
297
298 outw(0x3f00, ioaddr + 8);
299 fifo = inl(ioaddr);
300
301
302 if ((if_port >= 0) && (if_port <= 3))
303 dev->if_port = if_port;
304 else
305 dev_err(&link->dev, "invalid if_port requested\n");
306
307 SET_NETDEV_DEV(dev, &link->dev);
308
309 if (register_netdev(dev) != 0) {
310 dev_err(&link->dev, "register_netdev() failed\n");
311 goto failed;
312 }
313
314 netdev_info(dev, "3Com 3c%s, io %#3lx, irq %d, hw_addr %pM\n",
315 (multi ? "562" : "589"), dev->base_addr, dev->irq,
316 dev->dev_addr);
317 netdev_info(dev, " %dK FIFO split %s Rx:Tx, %s xcvr\n",
318 (fifo & 7) ? 32 : 8, ram_split[(fifo >> 16) & 3],
319 if_names[dev->if_port]);
320 return 0;
321
322failed:
323 tc589_release(link);
324 return -ENODEV;
325}
326
327static void tc589_release(struct pcmcia_device *link)
328{
329 pcmcia_disable_device(link);
330}
331
332static int tc589_suspend(struct pcmcia_device *link)
333{
334 struct net_device *dev = link->priv;
335
336 if (link->open)
337 netif_device_detach(dev);
338
339 return 0;
340}
341
342static int tc589_resume(struct pcmcia_device *link)
343{
344 struct net_device *dev = link->priv;
345
346 if (link->open) {
347 tc589_reset(dev);
348 netif_device_attach(dev);
349 }
350
351 return 0;
352}
353
354
355
356
357
358
359static void tc589_wait_for_completion(struct net_device *dev, int cmd)
360{
361 int i = 100;
362 outw(cmd, dev->base_addr + EL3_CMD);
363 while (--i > 0)
364 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
365 if (i == 0)
366 netdev_warn(dev, "command 0x%04x did not complete!\n", cmd);
367}
368
369
370
371
372
373static u16 read_eeprom(unsigned int ioaddr, int index)
374{
375 int i;
376 outw(EEPROM_READ + index, ioaddr + 10);
377
378 for (i = 1620; i >= 0; i--)
379 if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0)
380 break;
381 return inw(ioaddr + 12);
382}
383
384
385
386
387
388static void tc589_set_xcvr(struct net_device *dev, int if_port)
389{
390 struct el3_private *lp = netdev_priv(dev);
391 unsigned int ioaddr = dev->base_addr;
392
393 EL3WINDOW(0);
394 switch (if_port) {
395 case 0: case 1: outw(0, ioaddr + 6); break;
396 case 2: outw(3<<14, ioaddr + 6); break;
397 case 3: outw(1<<14, ioaddr + 6); break;
398 }
399
400 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD);
401
402 EL3WINDOW(4);
403 outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA);
404 EL3WINDOW(1);
405 if (if_port == 2)
406 lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000);
407 else
408 lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800);
409}
410
411static void dump_status(struct net_device *dev)
412{
413 unsigned int ioaddr = dev->base_addr;
414 EL3WINDOW(1);
415 netdev_info(dev, " irq status %04x, rx status %04x, tx status %02x tx free %04x\n",
416 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS),
417 inb(ioaddr+TX_STATUS), inw(ioaddr+TX_FREE));
418 EL3WINDOW(4);
419 netdev_info(dev, " diagnostics: fifo %04x net %04x ethernet %04x media %04x\n",
420 inw(ioaddr+0x04), inw(ioaddr+0x06), inw(ioaddr+0x08),
421 inw(ioaddr+0x0a));
422 EL3WINDOW(1);
423}
424
425
426static void tc589_reset(struct net_device *dev)
427{
428 unsigned int ioaddr = dev->base_addr;
429 int i;
430
431 EL3WINDOW(0);
432 outw(0x0001, ioaddr + 4);
433 outw(0x3f00, ioaddr + 8);
434
435
436 EL3WINDOW(2);
437 for (i = 0; i < 6; i++)
438 outb(dev->dev_addr[i], ioaddr + i);
439
440 tc589_set_xcvr(dev, dev->if_port);
441
442
443 outw(StatsDisable, ioaddr + EL3_CMD);
444 EL3WINDOW(6);
445 for (i = 0; i < 9; i++)
446 inb(ioaddr+i);
447 inw(ioaddr + 10);
448 inw(ioaddr + 12);
449
450
451 EL3WINDOW(1);
452
453 set_rx_mode(dev);
454 outw(StatsEnable, ioaddr + EL3_CMD);
455 outw(RxEnable, ioaddr + EL3_CMD);
456 outw(TxEnable, ioaddr + EL3_CMD);
457
458 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
459
460 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
461 ioaddr + EL3_CMD);
462 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
463 | AdapterFailure, ioaddr + EL3_CMD);
464}
465
466static void netdev_get_drvinfo(struct net_device *dev,
467 struct ethtool_drvinfo *info)
468{
469 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
470 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
471 snprintf(info->bus_info, sizeof(info->bus_info),
472 "PCMCIA 0x%lx", dev->base_addr);
473}
474
475static const struct ethtool_ops netdev_ethtool_ops = {
476 .get_drvinfo = netdev_get_drvinfo,
477};
478
479static int el3_config(struct net_device *dev, struct ifmap *map)
480{
481 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
482 if (map->port <= 3) {
483 dev->if_port = map->port;
484 netdev_info(dev, "switched to %s port\n", if_names[dev->if_port]);
485 tc589_set_xcvr(dev, dev->if_port);
486 } else
487 return -EINVAL;
488 }
489 return 0;
490}
491
492static int el3_open(struct net_device *dev)
493{
494 struct el3_private *lp = netdev_priv(dev);
495 struct pcmcia_device *link = lp->p_dev;
496
497 if (!pcmcia_dev_present(link))
498 return -ENODEV;
499
500 link->open++;
501 netif_start_queue(dev);
502
503 tc589_reset(dev);
504 init_timer(&lp->media);
505 lp->media.function = media_check;
506 lp->media.data = (unsigned long) dev;
507 lp->media.expires = jiffies + HZ;
508 add_timer(&lp->media);
509
510 dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
511 dev->name, inw(dev->base_addr + EL3_STATUS));
512
513 return 0;
514}
515
516static void el3_tx_timeout(struct net_device *dev)
517{
518 unsigned int ioaddr = dev->base_addr;
519
520 netdev_warn(dev, "Transmit timed out!\n");
521 dump_status(dev);
522 dev->stats.tx_errors++;
523 dev->trans_start = jiffies;
524
525 tc589_wait_for_completion(dev, TxReset);
526 outw(TxEnable, ioaddr + EL3_CMD);
527 netif_wake_queue(dev);
528}
529
530static void pop_tx_status(struct net_device *dev)
531{
532 unsigned int ioaddr = dev->base_addr;
533 int i;
534
535
536 for (i = 32; i > 0; i--) {
537 u_char tx_status = inb(ioaddr + TX_STATUS);
538 if (!(tx_status & 0x84)) break;
539
540 if (tx_status & 0x30)
541 tc589_wait_for_completion(dev, TxReset);
542 if (tx_status & 0x38) {
543 netdev_dbg(dev, "transmit error: status 0x%02x\n", tx_status);
544 outw(TxEnable, ioaddr + EL3_CMD);
545 dev->stats.tx_aborted_errors++;
546 }
547 outb(0x00, ioaddr + TX_STATUS);
548 }
549}
550
551static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
552 struct net_device *dev)
553{
554 unsigned int ioaddr = dev->base_addr;
555 struct el3_private *priv = netdev_priv(dev);
556 unsigned long flags;
557
558 netdev_dbg(dev, "el3_start_xmit(length = %ld) called, status %4.4x.\n",
559 (long)skb->len, inw(ioaddr + EL3_STATUS));
560
561 spin_lock_irqsave(&priv->lock, flags);
562
563 dev->stats.tx_bytes += skb->len;
564
565
566 outw(skb->len, ioaddr + TX_FIFO);
567 outw(0x00, ioaddr + TX_FIFO);
568
569 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
570
571 if (inw(ioaddr + TX_FREE) <= 1536) {
572 netif_stop_queue(dev);
573
574 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
575 }
576
577 pop_tx_status(dev);
578 spin_unlock_irqrestore(&priv->lock, flags);
579 dev_kfree_skb(skb);
580
581 return NETDEV_TX_OK;
582}
583
584
585static irqreturn_t el3_interrupt(int irq, void *dev_id)
586{
587 struct net_device *dev = (struct net_device *) dev_id;
588 struct el3_private *lp = netdev_priv(dev);
589 unsigned int ioaddr;
590 __u16 status;
591 int i = 0, handled = 1;
592
593 if (!netif_device_present(dev))
594 return IRQ_NONE;
595
596 ioaddr = dev->base_addr;
597
598 netdev_dbg(dev, "interrupt, status %4.4x.\n", inw(ioaddr + EL3_STATUS));
599
600 spin_lock(&lp->lock);
601 while ((status = inw(ioaddr + EL3_STATUS)) &
602 (IntLatch | RxComplete | StatsFull)) {
603 if ((status & 0xe000) != 0x2000) {
604 netdev_dbg(dev, "interrupt from dead card\n");
605 handled = 0;
606 break;
607 }
608 if (status & RxComplete)
609 el3_rx(dev);
610 if (status & TxAvailable) {
611 netdev_dbg(dev, " TX room bit was handled.\n");
612
613 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
614 netif_wake_queue(dev);
615 }
616 if (status & TxComplete)
617 pop_tx_status(dev);
618 if (status & (AdapterFailure | RxEarly | StatsFull)) {
619
620 if (status & StatsFull)
621 update_stats(dev);
622 if (status & RxEarly) {
623 el3_rx(dev);
624 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
625 }
626 if (status & AdapterFailure) {
627 u16 fifo_diag;
628 EL3WINDOW(4);
629 fifo_diag = inw(ioaddr + 4);
630 EL3WINDOW(1);
631 netdev_warn(dev, "adapter failure, FIFO diagnostic register %04x.\n",
632 fifo_diag);
633 if (fifo_diag & 0x0400) {
634
635 tc589_wait_for_completion(dev, TxReset);
636 outw(TxEnable, ioaddr + EL3_CMD);
637 }
638 if (fifo_diag & 0x2000) {
639
640 tc589_wait_for_completion(dev, RxReset);
641 set_rx_mode(dev);
642 outw(RxEnable, ioaddr + EL3_CMD);
643 }
644 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
645 }
646 }
647 if (++i > 10) {
648 netdev_err(dev, "infinite loop in interrupt, status %4.4x.\n",
649 status);
650
651 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
652 break;
653 }
654
655 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
656 }
657 lp->last_irq = jiffies;
658 spin_unlock(&lp->lock);
659 netdev_dbg(dev, "exiting interrupt, status %4.4x.\n",
660 inw(ioaddr + EL3_STATUS));
661 return IRQ_RETVAL(handled);
662}
663
664static void media_check(unsigned long arg)
665{
666 struct net_device *dev = (struct net_device *)(arg);
667 struct el3_private *lp = netdev_priv(dev);
668 unsigned int ioaddr = dev->base_addr;
669 u16 media, errs;
670 unsigned long flags;
671
672 if (!netif_device_present(dev)) goto reschedule;
673
674
675
676 if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
677 (inb(ioaddr + EL3_TIMER) == 0xff)) {
678 if (!lp->fast_poll)
679 netdev_warn(dev, "interrupt(s) dropped!\n");
680
681 local_irq_save(flags);
682 el3_interrupt(dev->irq, dev);
683 local_irq_restore(flags);
684
685 lp->fast_poll = HZ;
686 }
687 if (lp->fast_poll) {
688 lp->fast_poll--;
689 lp->media.expires = jiffies + HZ/100;
690 add_timer(&lp->media);
691 return;
692 }
693
694
695
696 spin_lock_irqsave(&lp->lock, flags);
697 EL3WINDOW(4);
698 media = inw(ioaddr+WN4_MEDIA) & 0xc810;
699
700
701 if (time_before(jiffies, lp->last_irq + HZ)) {
702 media &= ~0x0010;
703 } else {
704
705 EL3WINDOW(6);
706 outw(StatsDisable, ioaddr + EL3_CMD);
707 errs = inb(ioaddr + 0);
708 outw(StatsEnable, ioaddr + EL3_CMD);
709 dev->stats.tx_carrier_errors += errs;
710 if (errs || (lp->media_status & 0x0010)) media |= 0x0010;
711 }
712
713 if (media != lp->media_status) {
714 if ((media & lp->media_status & 0x8000) &&
715 ((lp->media_status ^ media) & 0x0800))
716 netdev_info(dev, "%s link beat\n",
717 (lp->media_status & 0x0800 ? "lost" : "found"));
718 else if ((media & lp->media_status & 0x4000) &&
719 ((lp->media_status ^ media) & 0x0010))
720 netdev_info(dev, "coax cable %s\n",
721 (lp->media_status & 0x0010 ? "ok" : "problem"));
722 if (dev->if_port == 0) {
723 if (media & 0x8000) {
724 if (media & 0x0800)
725 netdev_info(dev, "flipped to 10baseT\n");
726 else
727 tc589_set_xcvr(dev, 2);
728 } else if (media & 0x4000) {
729 if (media & 0x0010)
730 tc589_set_xcvr(dev, 1);
731 else
732 netdev_info(dev, "flipped to 10base2\n");
733 }
734 }
735 lp->media_status = media;
736 }
737
738 EL3WINDOW(1);
739 spin_unlock_irqrestore(&lp->lock, flags);
740
741reschedule:
742 lp->media.expires = jiffies + HZ;
743 add_timer(&lp->media);
744}
745
746static struct net_device_stats *el3_get_stats(struct net_device *dev)
747{
748 struct el3_private *lp = netdev_priv(dev);
749 unsigned long flags;
750 struct pcmcia_device *link = lp->p_dev;
751
752 if (pcmcia_dev_present(link)) {
753 spin_lock_irqsave(&lp->lock, flags);
754 update_stats(dev);
755 spin_unlock_irqrestore(&lp->lock, flags);
756 }
757 return &dev->stats;
758}
759
760
761
762
763
764
765
766
767
768static void update_stats(struct net_device *dev)
769{
770 unsigned int ioaddr = dev->base_addr;
771
772 netdev_dbg(dev, "updating the statistics.\n");
773
774 outw(StatsDisable, ioaddr + EL3_CMD);
775
776 EL3WINDOW(6);
777 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
778 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
779 inb(ioaddr + 2);
780 dev->stats.collisions += inb(ioaddr + 3);
781 dev->stats.tx_window_errors += inb(ioaddr + 4);
782 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
783 dev->stats.tx_packets += inb(ioaddr + 6);
784 inb(ioaddr + 7);
785 inb(ioaddr + 8);
786 inw(ioaddr + 10);
787 inw(ioaddr + 12);
788
789
790 EL3WINDOW(1);
791 outw(StatsEnable, ioaddr + EL3_CMD);
792}
793
794static int el3_rx(struct net_device *dev)
795{
796 unsigned int ioaddr = dev->base_addr;
797 int worklimit = 32;
798 short rx_status;
799
800 netdev_dbg(dev, "in rx_packet(), status %4.4x, rx_status %4.4x.\n",
801 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
802 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) &&
803 worklimit > 0) {
804 worklimit--;
805 if (rx_status & 0x4000) {
806 short error = rx_status & 0x3800;
807 dev->stats.rx_errors++;
808 switch (error) {
809 case 0x0000: dev->stats.rx_over_errors++; break;
810 case 0x0800: dev->stats.rx_length_errors++; break;
811 case 0x1000: dev->stats.rx_frame_errors++; break;
812 case 0x1800: dev->stats.rx_length_errors++; break;
813 case 0x2000: dev->stats.rx_frame_errors++; break;
814 case 0x2800: dev->stats.rx_crc_errors++; break;
815 }
816 } else {
817 short pkt_len = rx_status & 0x7ff;
818 struct sk_buff *skb;
819
820 skb = netdev_alloc_skb(dev, pkt_len + 5);
821
822 netdev_dbg(dev, " Receiving packet size %d status %4.4x.\n",
823 pkt_len, rx_status);
824 if (skb != NULL) {
825 skb_reserve(skb, 2);
826 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
827 (pkt_len+3)>>2);
828 skb->protocol = eth_type_trans(skb, dev);
829 netif_rx(skb);
830 dev->stats.rx_packets++;
831 dev->stats.rx_bytes += pkt_len;
832 } else {
833 netdev_dbg(dev, "couldn't allocate a sk_buff of size %d.\n",
834 pkt_len);
835 dev->stats.rx_dropped++;
836 }
837 }
838
839 tc589_wait_for_completion(dev, RxDiscard);
840 }
841 if (worklimit == 0)
842 netdev_warn(dev, "too much work in el3_rx!\n");
843 return 0;
844}
845
846static void set_rx_mode(struct net_device *dev)
847{
848 unsigned int ioaddr = dev->base_addr;
849 u16 opts = SetRxFilter | RxStation | RxBroadcast;
850
851 if (dev->flags & IFF_PROMISC)
852 opts |= RxMulticast | RxProm;
853 else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI))
854 opts |= RxMulticast;
855 outw(opts, ioaddr + EL3_CMD);
856}
857
858static void set_multicast_list(struct net_device *dev)
859{
860 struct el3_private *priv = netdev_priv(dev);
861 unsigned long flags;
862
863 spin_lock_irqsave(&priv->lock, flags);
864 set_rx_mode(dev);
865 spin_unlock_irqrestore(&priv->lock, flags);
866}
867
868static int el3_close(struct net_device *dev)
869{
870 struct el3_private *lp = netdev_priv(dev);
871 struct pcmcia_device *link = lp->p_dev;
872 unsigned int ioaddr = dev->base_addr;
873
874 dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name);
875
876 if (pcmcia_dev_present(link)) {
877
878 outw(StatsDisable, ioaddr + EL3_CMD);
879
880
881 outw(RxDisable, ioaddr + EL3_CMD);
882 outw(TxDisable, ioaddr + EL3_CMD);
883
884 if (dev->if_port == 2)
885
886 outw(StopCoax, ioaddr + EL3_CMD);
887 else if (dev->if_port == 1) {
888
889 EL3WINDOW(4);
890 outw(0, ioaddr + WN4_MEDIA);
891 }
892
893
894 EL3WINDOW(0);
895
896 outw(0x0f00, ioaddr + WN0_IRQ);
897
898
899 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
900 update_stats(dev);
901 }
902
903 link->open--;
904 netif_stop_queue(dev);
905 del_timer_sync(&lp->media);
906
907 return 0;
908}
909
910static const struct pcmcia_device_id tc589_ids[] = {
911 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562),
912 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77),
913 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589),
914 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202),
915 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "cis/3CXEM556.cis"),
916 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "cis/3CXEM556.cis"),
917 PCMCIA_DEVICE_NULL,
918};
919MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
920
921static struct pcmcia_driver tc589_driver = {
922 .owner = THIS_MODULE,
923 .name = "3c589_cs",
924 .probe = tc589_probe,
925 .remove = tc589_detach,
926 .id_table = tc589_ids,
927 .suspend = tc589_suspend,
928 .resume = tc589_resume,
929};
930module_pcmcia_driver(tc589_driver);
931