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