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