?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PM / sleep: Asynchronous threads for suspend_noirq
[linux/fpc-iii.git] / drivers / net / ethernet / 3com / 3c589_cs.c
blob5992860a39c97747e64befccd939f2e1f99e78f4
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/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 /* To minimize the size of the driver source I only define operating
54 constants if they are used several times. You'll need the manual
55 if you want to understand driver details. */
56 /* Offsets from base I/O address. */
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 /* The top five bits written to EL3_CMD are a command, the lower
68 11 bits are the parameter, if applicable. */
69 enum 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
93 enum 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 /* The SetRxFilter command accepts the following classes: */
106 enum RxFilter {
107 RxStation = 1,
108 RxMulticast = 2,
109 RxBroadcast = 4,
110 RxProm = 8
111 };
112
113 /* Register window 1 offsets, the window used in normal operation. */
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 /* Remaining free bytes in Tx buffer. */
119
120 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
121 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
122 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
123 #define MEDIA_LED 0x0001 /* Enable link light on 3C589E cards. */
124
125 /* Time in jiffies before concluding Tx hung */
126 #define TX_TIMEOUT ((400*HZ)/1000)
127
128 struct el3_private {
129 struct pcmcia_device *p_dev;
130 /* For transceiver monitoring */
131 struct timer_list media;
132 u16 media_status;
133 u16 fast_poll;
134 unsigned long last_irq;
135 spinlock_t lock;
136 };
137
138 static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
139
140 /*====================================================================*/
141
142 /* Module parameters */
143
144 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
145 MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
146 MODULE_LICENSE("GPL");
147
148 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
149
150 /* Special hook for setting if_port when module is loaded */
151 INT_MODULE_PARM(if_port, 0);
152
153
154 /*====================================================================*/
155
156 static int tc589_config(struct pcmcia_device *link);
157 static void tc589_release(struct pcmcia_device *link);
158
159 static u16 read_eeprom(unsigned int ioaddr, int index);
160 static void tc589_reset(struct net_device *dev);
161 static void media_check(unsigned long arg);
162 static int el3_config(struct net_device *dev, struct ifmap *map);
163 static int el3_open(struct net_device *dev);
164 static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
165 struct net_device *dev);
166 static irqreturn_t el3_interrupt(int irq, void *dev_id);
167 static void update_stats(struct net_device *dev);
168 static struct net_device_stats *el3_get_stats(struct net_device *dev);
169 static int el3_rx(struct net_device *dev);
170 static int el3_close(struct net_device *dev);
171 static void el3_tx_timeout(struct net_device *dev);
172 static void set_rx_mode(struct net_device *dev);
173 static void set_multicast_list(struct net_device *dev);
174 static const struct ethtool_ops netdev_ethtool_ops;
175
176 static void tc589_detach(struct pcmcia_device *p_dev);
177
178 static 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
191 static 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 /* Create new ethernet device */
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
221 static 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 } /* tc589_detach */
233
234 static 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 /* Is this a 3c562? */
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 /* For the 3c562, the base address must be xx00-xx7f */
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 /* The 3c589 has an extra EEPROM for configuration info, including
279 the hardware address. The 3c562 puts the address in the CIS. */
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); /* 0 < len < 6 */
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 /* The address and resource configuration register aren't loaded from
297 the EEPROM and *must* be set to 0 and IRQ3 for the PCMCIA version. */
298 outw(0x3f00, ioaddr + 8);
299 fifo = inl(ioaddr);
300
301 /* The if_port symbol can be set when the module is loaded */
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
322 failed:
323 tc589_release(link);
324 return -ENODEV;
325 } /* tc589_config */
326
327 static void tc589_release(struct pcmcia_device *link)
328 {
329 pcmcia_disable_device(link);
330 }
331
332 static 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
342 static 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 Use this for commands that may take time to finish
358 */
359 static 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 Read a word from the EEPROM using the regular EEPROM access register.
371 Assume that we are in register window zero.
372 */
373 static u16 read_eeprom(unsigned int ioaddr, int index)
374 {
375 int i;
376 outw(EEPROM_READ + index, ioaddr + 10);
377 /* Reading the eeprom takes 162 us */
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 Set transceiver type, perhaps to something other than what the user
386 specified in dev->if_port.
387 */
388 static 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 /* On PCMCIA, this just turns on the LED */
400 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD);
401 /* 10baseT interface, enable link beat and jabber check. */
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
411 static 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 /* Reset and restore all of the 3c589 registers. */
426 static 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); /* Activate board. */
433 outw(0x3f00, ioaddr + 8); /* Set the IRQ line. */
434
435 /* Set the station address in window 2. */
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 /* Switch to the stats window, and clear all stats by reading. */
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 /* Switch to register set 1 for normal use. */
451 EL3WINDOW(1);
452
453 set_rx_mode(dev);
454 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
455 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
456 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
457 /* Allow status bits to be seen. */
458 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
459 /* Ack all pending events, and set active indicator mask. */
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
466 static 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
475 static const struct ethtool_ops netdev_ethtool_ops = {
476 .get_drvinfo = netdev_get_drvinfo,
477 };
478
479 static 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
492 static 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
516 static 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; /* prevent tx timeout */
524 /* Issue TX_RESET and TX_START commands. */
525 tc589_wait_for_completion(dev, TxReset);
526 outw(TxEnable, ioaddr + EL3_CMD);
527 netif_wake_queue(dev);
528 }
529
530 static void pop_tx_status(struct net_device *dev)
531 {
532 unsigned int ioaddr = dev->base_addr;
533 int i;
534
535 /* Clear the Tx status stack. */
536 for (i = 32; i > 0; i--) {
537 u_char tx_status = inb(ioaddr + TX_STATUS);
538 if (!(tx_status & 0x84)) break;
539 /* reset transmitter on jabber error or underrun */
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); /* Pop the status stack. */
548 }
549 }
550
551 static 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 /* Put out the doubleword header... */
566 outw(skb->len, ioaddr + TX_FIFO);
567 outw(0x00, ioaddr + TX_FIFO);
568 /* ... and the packet rounded to a doubleword. */
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 /* Interrupt us when the FIFO has room for max-sized packet. */
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 /* The EL3 interrupt handler. */
585 static 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 /* There's room in the FIFO for a full-sized packet. */
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 /* Handle all uncommon interrupts. */
620 if (status & StatsFull) /* Empty statistics. */
621 update_stats(dev);
622 if (status & RxEarly) { /* Rx early is unused. */
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 /* Tx overrun */
635 tc589_wait_for_completion(dev, TxReset);
636 outw(TxEnable, ioaddr + EL3_CMD);
637 }
638 if (fifo_diag & 0x2000) {
639 /* Rx underrun */
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 /* Clear all interrupts */
651 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
652 break;
653 }
654 /* Acknowledge the IRQ. */
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
664 static 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 /* Check for pending interrupt with expired latency timer: with
675 this, we can limp along even if the interrupt is blocked */
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 /* lp->lock guards the EL3 window. Window should always be 1 except
695 when the lock is held */
696 spin_lock_irqsave(&lp->lock, flags);
697 EL3WINDOW(4);
698 media = inw(ioaddr+WN4_MEDIA) & 0xc810;
699
700 /* Ignore collisions unless we've had no irq's recently */
701 if (time_before(jiffies, lp->last_irq + HZ)) {
702 media &= ~0x0010;
703 } else {
704 /* Try harder to detect carrier errors */
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
741 reschedule:
742 lp->media.expires = jiffies + HZ;
743 add_timer(&lp->media);
744 }
745
746 static 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 Update statistics. We change to register window 6, so this should be run
762 single-threaded if the device is active. This is expected to be a rare
763 operation, and it's simpler for the rest of the driver to assume that
764 window 1 is always valid rather than use a special window-state variable.
765
766 Caller must hold the lock for this
767 */
768 static 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 /* Turn off statistics updates while reading. */
774 outw(StatsDisable, ioaddr + EL3_CMD);
775 /* Switch to the stats window, and read everything. */
776 EL3WINDOW(6);
777 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
778 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
779 /* Multiple collisions. */ 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 /* Rx packets */ inb(ioaddr + 7);
785 /* Tx deferrals */ inb(ioaddr + 8);
786 /* Rx octets */ inw(ioaddr + 10);
787 /* Tx octets */ inw(ioaddr + 12);
788
789 /* Back to window 1, and turn statistics back on. */
790 EL3WINDOW(1);
791 outw(StatsEnable, ioaddr + EL3_CMD);
792 }
793
794 static 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) { /* Error, update stats. */
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 /* Pop the top of the Rx FIFO */
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
846 static 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
858 static 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
868 static 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 /* Turn off statistics ASAP. We update dev->stats below. */
878 outw(StatsDisable, ioaddr + EL3_CMD);
879
880 /* Disable the receiver and transmitter. */
881 outw(RxDisable, ioaddr + EL3_CMD);
882 outw(TxDisable, ioaddr + EL3_CMD);
883
884 if (dev->if_port == 2)
885 /* Turn off thinnet power. Green! */
886 outw(StopCoax, ioaddr + EL3_CMD);
887 else if (dev->if_port == 1) {
888 /* Disable link beat and jabber */
889 EL3WINDOW(4);
890 outw(0, ioaddr + WN4_MEDIA);
891 }
892
893 /* Switching back to window 0 disables the IRQ. */
894 EL3WINDOW(0);
895 /* But we explicitly zero the IRQ line select anyway. */
896 outw(0x0f00, ioaddr + WN0_IRQ);
897
898 /* Check if the card still exists */
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
910 static 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 };
919 MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
920
921 static 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 };
930 module_pcmcia_driver(tc589_driver);
Linux with added FPC-III support