1 /*======================================================================
3 A PCMCIA ethernet driver for the 3com 3c589 card.
5 Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
7 3c589_cs.c 1.162 2001/10/13 00:08:50
9 The network driver code is based on Donald Becker's 3c589 code:
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
18 Updated for 2.5.x by Alan Cox <alan@redhat.com>
20 ======================================================================*/
22 #define DRV_NAME "3c589_cs"
23 #define DRV_VERSION "1.162-ac"
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>
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>
43 #include <pcmcia/cs_types.h>
44 #include <pcmcia/cs.h>
45 #include <pcmcia/cistpl.h>
46 #include <pcmcia/cisreg.h>
47 #include <pcmcia/ciscode.h>
48 #include <pcmcia/ds.h>
50 #include <asm/uaccess.h>
52 #include <asm/system.h>
54 /* To minimize the size of the driver source I only define operating
55 constants if they are used several times. You'll need the manual
56 if you want to understand driver details. */
57 /* Offsets from base I/O address. */
59 #define EL3_TIMER 0x0a
61 #define EL3_STATUS 0x0e
63 #define EEPROM_READ 0x0080
64 #define EEPROM_BUSY 0x8000
66 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
68 /* The top five bits written to EL3_CMD are a command, the lower
69 11 bits are the parameter, if applicable. */
71 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
72 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
73 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
74 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
75 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
76 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
77 StatsDisable = 22<<11, StopCoax = 23<<11,
81 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
82 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
83 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000
86 /* The SetRxFilter command accepts the following classes: */
88 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
91 /* Register window 1 offsets, the window used in normal operation. */
94 #define RX_STATUS 0x08
95 #define TX_STATUS 0x0B
96 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
98 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
99 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
100 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
101 #define MEDIA_LED 0x0001 /* Enable link light on 3C589E cards. */
103 /* Time in jiffies before concluding Tx hung */
104 #define TX_TIMEOUT ((400*HZ)/1000)
109 struct net_device_stats stats;
110 /* For transceiver monitoring */
111 struct timer_list media;
114 unsigned long last_irq;
118 static char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
120 /*====================================================================*/
122 /* Module parameters */
124 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
125 MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
126 MODULE_LICENSE("GPL");
128 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
130 /* Special hook for setting if_port when module is loaded */
131 INT_MODULE_PARM(if_port, 0);
134 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
135 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
136 static char *version =
137 DRV_NAME ".c " DRV_VERSION " 2001/10/13 00:08:50 (David Hinds)";
139 #define DEBUG(n, args...)
142 /*====================================================================*/
144 static void tc589_config(dev_link_t *link);
145 static void tc589_release(dev_link_t *link);
146 static int tc589_event(event_t event, int priority,
147 event_callback_args_t *args);
149 static u16 read_eeprom(kio_addr_t ioaddr, int index);
150 static void tc589_reset(struct net_device *dev);
151 static void media_check(unsigned long arg);
152 static int el3_config(struct net_device *dev, struct ifmap *map);
153 static int el3_open(struct net_device *dev);
154 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
155 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
156 static void update_stats(struct net_device *dev);
157 static struct net_device_stats *el3_get_stats(struct net_device *dev);
158 static int el3_rx(struct net_device *dev);
159 static int el3_close(struct net_device *dev);
160 static void el3_tx_timeout(struct net_device *dev);
161 static void set_multicast_list(struct net_device *dev);
162 static struct ethtool_ops netdev_ethtool_ops;
164 static dev_info_t dev_info = "3c589_cs";
166 static dev_link_t *tc589_attach(void);
167 static void tc589_detach(struct pcmcia_device *p_dev);
169 /*======================================================================
171 tc589_attach() creates an "instance" of the driver, allocating
172 local data structures for one device. The device is registered
175 ======================================================================*/
177 static dev_link_t *tc589_attach(void)
179 struct el3_private *lp;
180 client_reg_t client_reg;
182 struct net_device *dev;
185 DEBUG(0, "3c589_attach()\n");
187 /* Create new ethernet device */
188 dev = alloc_etherdev(sizeof(struct el3_private));
191 lp = netdev_priv(dev);
195 spin_lock_init(&lp->lock);
196 link->io.NumPorts1 = 16;
197 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
198 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
199 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
200 link->irq.Handler = &el3_interrupt;
201 link->irq.Instance = dev;
202 link->conf.Attributes = CONF_ENABLE_IRQ;
204 link->conf.IntType = INT_MEMORY_AND_IO;
205 link->conf.ConfigIndex = 1;
206 link->conf.Present = PRESENT_OPTION;
208 /* The EL3-specific entries in the device structure. */
209 SET_MODULE_OWNER(dev);
210 dev->hard_start_xmit = &el3_start_xmit;
211 dev->set_config = &el3_config;
212 dev->get_stats = &el3_get_stats;
213 dev->set_multicast_list = &set_multicast_list;
214 dev->open = &el3_open;
215 dev->stop = &el3_close;
216 #ifdef HAVE_TX_TIMEOUT
217 dev->tx_timeout = el3_tx_timeout;
218 dev->watchdog_timeo = TX_TIMEOUT;
220 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
222 /* Register with Card Services */
224 client_reg.dev_info = &dev_info;
225 client_reg.Version = 0x0210;
226 client_reg.event_callback_args.client_data = link;
227 ret = pcmcia_register_client(&link->handle, &client_reg);
229 cs_error(link->handle, RegisterClient, ret);
230 tc589_detach(link->handle);
237 /*======================================================================
239 This deletes a driver "instance". The device is de-registered
240 with Card Services. If it has been released, all local data
241 structures are freed. Otherwise, the structures will be freed
242 when the device is released.
244 ======================================================================*/
246 static void tc589_detach(struct pcmcia_device *p_dev)
248 dev_link_t *link = dev_to_instance(p_dev);
249 struct net_device *dev = link->priv;
251 DEBUG(0, "3c589_detach(0x%p)\n", link);
254 unregister_netdev(dev);
256 if (link->state & DEV_CONFIG)
262 /*======================================================================
264 tc589_config() is scheduled to run after a CARD_INSERTION event
265 is received, to configure the PCMCIA socket, and to make the
266 ethernet device available to the system.
268 ======================================================================*/
270 #define CS_CHECK(fn, ret) \
271 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
273 static void tc589_config(dev_link_t *link)
275 client_handle_t handle = link->handle;
276 struct net_device *dev = link->priv;
277 struct el3_private *lp = netdev_priv(dev);
280 u16 buf[32], *phys_addr;
281 int last_fn, last_ret, i, j, multi = 0, fifo;
283 char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
285 DEBUG(0, "3c589_config(0x%p)\n", link);
287 phys_addr = (u16 *)dev->dev_addr;
288 tuple.Attributes = 0;
289 tuple.DesiredTuple = CISTPL_CONFIG;
290 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
291 tuple.TupleData = (cisdata_t *)buf;
292 tuple.TupleDataMax = sizeof(buf);
293 tuple.TupleOffset = 0;
294 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
295 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
296 link->conf.ConfigBase = parse.config.base;
297 link->conf.Present = parse.config.rmask[0];
299 /* Is this a 3c562? */
300 tuple.DesiredTuple = CISTPL_MANFID;
301 tuple.Attributes = TUPLE_RETURN_COMMON;
302 if ((pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) &&
303 (pcmcia_get_tuple_data(handle, &tuple) == CS_SUCCESS)) {
304 if (le16_to_cpu(buf[0]) != MANFID_3COM)
305 printk(KERN_INFO "3c589_cs: hmmm, is this really a "
307 multi = (le16_to_cpu(buf[1]) == PRODID_3COM_3C562);
311 link->state |= DEV_CONFIG;
313 /* For the 3c562, the base address must be xx00-xx7f */
314 link->io.IOAddrLines = 16;
315 for (i = j = 0; j < 0x400; j += 0x10) {
316 if (multi && (j & 0x80)) continue;
317 link->io.BasePort1 = j ^ 0x300;
318 i = pcmcia_request_io(link->handle, &link->io);
319 if (i == CS_SUCCESS) break;
321 if (i != CS_SUCCESS) {
322 cs_error(link->handle, RequestIO, i);
325 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
326 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
328 dev->irq = link->irq.AssignedIRQ;
329 dev->base_addr = link->io.BasePort1;
330 ioaddr = dev->base_addr;
333 /* The 3c589 has an extra EEPROM for configuration info, including
334 the hardware address. The 3c562 puts the address in the CIS. */
335 tuple.DesiredTuple = 0x88;
336 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) {
337 pcmcia_get_tuple_data(handle, &tuple);
338 for (i = 0; i < 3; i++)
339 phys_addr[i] = htons(buf[i]);
341 for (i = 0; i < 3; i++)
342 phys_addr[i] = htons(read_eeprom(ioaddr, i));
343 if (phys_addr[0] == 0x6060) {
344 printk(KERN_ERR "3c589_cs: IO port conflict at 0x%03lx"
345 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
350 /* The address and resource configuration register aren't loaded from
351 the EEPROM and *must* be set to 0 and IRQ3 for the PCMCIA version. */
352 outw(0x3f00, ioaddr + 8);
355 /* The if_port symbol can be set when the module is loaded */
356 if ((if_port >= 0) && (if_port <= 3))
357 dev->if_port = if_port;
359 printk(KERN_ERR "3c589_cs: invalid if_port requested\n");
361 link->dev = &lp->node;
362 link->state &= ~DEV_CONFIG_PENDING;
363 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
365 if (register_netdev(dev) != 0) {
366 printk(KERN_ERR "3c589_cs: register_netdev() failed\n");
371 strcpy(lp->node.dev_name, dev->name);
373 printk(KERN_INFO "%s: 3Com 3c%s, io %#3lx, irq %d, hw_addr ",
374 dev->name, (multi ? "562" : "589"), dev->base_addr,
376 for (i = 0; i < 6; i++)
377 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
378 printk(KERN_INFO " %dK FIFO split %s Rx:Tx, %s xcvr\n",
379 (fifo & 7) ? 32 : 8, ram_split[(fifo >> 16) & 3],
380 if_names[dev->if_port]);
384 cs_error(link->handle, last_fn, last_ret);
391 /*======================================================================
393 After a card is removed, tc589_release() will unregister the net
394 device, and release the PCMCIA configuration. If the device is
395 still open, this will be postponed until it is closed.
397 ======================================================================*/
399 static void tc589_release(dev_link_t *link)
401 DEBUG(0, "3c589_release(0x%p)\n", link);
403 pcmcia_release_configuration(link->handle);
404 pcmcia_release_io(link->handle, &link->io);
405 pcmcia_release_irq(link->handle, &link->irq);
407 link->state &= ~DEV_CONFIG;
410 static int tc589_suspend(struct pcmcia_device *p_dev)
412 dev_link_t *link = dev_to_instance(p_dev);
413 struct net_device *dev = link->priv;
415 link->state |= DEV_SUSPEND;
416 if (link->state & DEV_CONFIG) {
418 netif_device_detach(dev);
419 pcmcia_release_configuration(link->handle);
425 static int tc589_resume(struct pcmcia_device *p_dev)
427 dev_link_t *link = dev_to_instance(p_dev);
428 struct net_device *dev = link->priv;
430 link->state &= ~DEV_SUSPEND;
431 if (link->state & DEV_CONFIG) {
432 pcmcia_request_configuration(link->handle, &link->conf);
435 netif_device_attach(dev);
442 /*======================================================================
444 The card status event handler. Mostly, this schedules other
445 stuff to run after an event is received. A CARD_REMOVAL event
446 also sets some flags to discourage the net drivers from trying
447 to talk to the card any more.
449 ======================================================================*/
451 static int tc589_event(event_t event, int priority,
452 event_callback_args_t *args)
454 dev_link_t *link = args->client_data;
456 DEBUG(1, "3c589_event(0x%06x)\n", event);
459 case CS_EVENT_CARD_INSERTION:
460 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
467 /*====================================================================*/
470 Use this for commands that may take time to finish
472 static void tc589_wait_for_completion(struct net_device *dev, int cmd)
475 outw(cmd, dev->base_addr + EL3_CMD);
477 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
479 printk(KERN_WARNING "%s: command 0x%04x did not complete!\n",
484 Read a word from the EEPROM using the regular EEPROM access register.
485 Assume that we are in register window zero.
487 static u16 read_eeprom(kio_addr_t ioaddr, int index)
490 outw(EEPROM_READ + index, ioaddr + 10);
491 /* Reading the eeprom takes 162 us */
492 for (i = 1620; i >= 0; i--)
493 if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0)
495 return inw(ioaddr + 12);
499 Set transceiver type, perhaps to something other than what the user
500 specified in dev->if_port.
502 static void tc589_set_xcvr(struct net_device *dev, int if_port)
504 struct el3_private *lp = netdev_priv(dev);
505 kio_addr_t ioaddr = dev->base_addr;
509 case 0: case 1: outw(0, ioaddr + 6); break;
510 case 2: outw(3<<14, ioaddr + 6); break;
511 case 3: outw(1<<14, ioaddr + 6); break;
513 /* On PCMCIA, this just turns on the LED */
514 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD);
515 /* 10baseT interface, enable link beat and jabber check. */
517 outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA);
520 lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000);
522 lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800);
525 static void dump_status(struct net_device *dev)
527 kio_addr_t ioaddr = dev->base_addr;
529 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
530 "%02x tx free %04x\n", inw(ioaddr+EL3_STATUS),
531 inw(ioaddr+RX_STATUS), inb(ioaddr+TX_STATUS),
532 inw(ioaddr+TX_FREE));
534 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
535 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
536 inw(ioaddr+0x08), inw(ioaddr+0x0a));
540 /* Reset and restore all of the 3c589 registers. */
541 static void tc589_reset(struct net_device *dev)
543 kio_addr_t ioaddr = dev->base_addr;
547 outw(0x0001, ioaddr + 4); /* Activate board. */
548 outw(0x3f00, ioaddr + 8); /* Set the IRQ line. */
550 /* Set the station address in window 2. */
552 for (i = 0; i < 6; i++)
553 outb(dev->dev_addr[i], ioaddr + i);
555 tc589_set_xcvr(dev, dev->if_port);
557 /* Switch to the stats window, and clear all stats by reading. */
558 outw(StatsDisable, ioaddr + EL3_CMD);
560 for (i = 0; i < 9; i++)
565 /* Switch to register set 1 for normal use. */
568 /* Accept b-cast and phys addr only. */
569 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
570 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
571 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
572 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
573 /* Allow status bits to be seen. */
574 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
575 /* Ack all pending events, and set active indicator mask. */
576 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
578 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
579 | AdapterFailure, ioaddr + EL3_CMD);
582 static void netdev_get_drvinfo(struct net_device *dev,
583 struct ethtool_drvinfo *info)
585 strcpy(info->driver, DRV_NAME);
586 strcpy(info->version, DRV_VERSION);
587 sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
591 static u32 netdev_get_msglevel(struct net_device *dev)
596 static void netdev_set_msglevel(struct net_device *dev, u32 level)
600 #endif /* PCMCIA_DEBUG */
602 static struct ethtool_ops netdev_ethtool_ops = {
603 .get_drvinfo = netdev_get_drvinfo,
605 .get_msglevel = netdev_get_msglevel,
606 .set_msglevel = netdev_set_msglevel,
607 #endif /* PCMCIA_DEBUG */
610 static int el3_config(struct net_device *dev, struct ifmap *map)
612 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
613 if (map->port <= 3) {
614 dev->if_port = map->port;
615 printk(KERN_INFO "%s: switched to %s port\n",
616 dev->name, if_names[dev->if_port]);
617 tc589_set_xcvr(dev, dev->if_port);
624 static int el3_open(struct net_device *dev)
626 struct el3_private *lp = netdev_priv(dev);
627 dev_link_t *link = &lp->link;
633 netif_start_queue(dev);
636 init_timer(&lp->media);
637 lp->media.function = &media_check;
638 lp->media.data = (unsigned long) dev;
639 lp->media.expires = jiffies + HZ;
640 add_timer(&lp->media);
642 DEBUG(1, "%s: opened, status %4.4x.\n",
643 dev->name, inw(dev->base_addr + EL3_STATUS));
648 static void el3_tx_timeout(struct net_device *dev)
650 struct el3_private *lp = netdev_priv(dev);
651 kio_addr_t ioaddr = dev->base_addr;
653 printk(KERN_WARNING "%s: Transmit timed out!\n", dev->name);
655 lp->stats.tx_errors++;
656 dev->trans_start = jiffies;
657 /* Issue TX_RESET and TX_START commands. */
658 tc589_wait_for_completion(dev, TxReset);
659 outw(TxEnable, ioaddr + EL3_CMD);
660 netif_wake_queue(dev);
663 static void pop_tx_status(struct net_device *dev)
665 struct el3_private *lp = netdev_priv(dev);
666 kio_addr_t ioaddr = dev->base_addr;
669 /* Clear the Tx status stack. */
670 for (i = 32; i > 0; i--) {
671 u_char tx_status = inb(ioaddr + TX_STATUS);
672 if (!(tx_status & 0x84)) break;
673 /* reset transmitter on jabber error or underrun */
674 if (tx_status & 0x30)
675 tc589_wait_for_completion(dev, TxReset);
676 if (tx_status & 0x38) {
677 DEBUG(1, "%s: transmit error: status 0x%02x\n",
678 dev->name, tx_status);
679 outw(TxEnable, ioaddr + EL3_CMD);
680 lp->stats.tx_aborted_errors++;
682 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
686 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
688 kio_addr_t ioaddr = dev->base_addr;
689 struct el3_private *priv = netdev_priv(dev);
691 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
692 "status %4.4x.\n", dev->name, (long)skb->len,
693 inw(ioaddr + EL3_STATUS));
695 priv->stats.tx_bytes += skb->len;
697 /* Put out the doubleword header... */
698 outw(skb->len, ioaddr + TX_FIFO);
699 outw(0x00, ioaddr + TX_FIFO);
700 /* ... and the packet rounded to a doubleword. */
701 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
703 dev->trans_start = jiffies;
704 if (inw(ioaddr + TX_FREE) <= 1536) {
705 netif_stop_queue(dev);
706 /* Interrupt us when the FIFO has room for max-sized packet. */
707 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
716 /* The EL3 interrupt handler. */
717 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
719 struct net_device *dev = (struct net_device *) dev_id;
720 struct el3_private *lp = netdev_priv(dev);
723 int i = 0, handled = 1;
725 if (!netif_device_present(dev))
728 ioaddr = dev->base_addr;
730 DEBUG(3, "%s: interrupt, status %4.4x.\n",
731 dev->name, inw(ioaddr + EL3_STATUS));
733 spin_lock(&lp->lock);
734 while ((status = inw(ioaddr + EL3_STATUS)) &
735 (IntLatch | RxComplete | StatsFull)) {
736 if ((status & 0xe000) != 0x2000) {
737 DEBUG(1, "%s: interrupt from dead card\n", dev->name);
742 if (status & RxComplete)
745 if (status & TxAvailable) {
746 DEBUG(3, " TX room bit was handled.\n");
747 /* There's room in the FIFO for a full-sized packet. */
748 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
749 netif_wake_queue(dev);
752 if (status & TxComplete)
755 if (status & (AdapterFailure | RxEarly | StatsFull)) {
756 /* Handle all uncommon interrupts. */
757 if (status & StatsFull) /* Empty statistics. */
759 if (status & RxEarly) { /* Rx early is unused. */
761 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
763 if (status & AdapterFailure) {
766 fifo_diag = inw(ioaddr + 4);
768 printk(KERN_WARNING "%s: adapter failure, FIFO diagnostic"
769 " register %04x.\n", dev->name, fifo_diag);
770 if (fifo_diag & 0x0400) {
772 tc589_wait_for_completion(dev, TxReset);
773 outw(TxEnable, ioaddr + EL3_CMD);
775 if (fifo_diag & 0x2000) {
777 tc589_wait_for_completion(dev, RxReset);
778 set_multicast_list(dev);
779 outw(RxEnable, ioaddr + EL3_CMD);
781 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
786 printk(KERN_ERR "%s: infinite loop in interrupt, "
787 "status %4.4x.\n", dev->name, status);
788 /* Clear all interrupts */
789 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
792 /* Acknowledge the IRQ. */
793 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
796 lp->last_irq = jiffies;
797 spin_unlock(&lp->lock);
798 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
799 dev->name, inw(ioaddr + EL3_STATUS));
800 return IRQ_RETVAL(handled);
803 static void media_check(unsigned long arg)
805 struct net_device *dev = (struct net_device *)(arg);
806 struct el3_private *lp = netdev_priv(dev);
807 kio_addr_t ioaddr = dev->base_addr;
811 if (!netif_device_present(dev)) goto reschedule;
814 /* Check for pending interrupt with expired latency timer: with
815 this, we can limp along even if the interrupt is blocked */
816 if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
817 (inb(ioaddr + EL3_TIMER) == 0xff)) {
819 printk(KERN_WARNING "%s: interrupt(s) dropped!\n", dev->name);
820 el3_interrupt(dev->irq, lp, NULL);
825 lp->media.expires = jiffies + HZ/100;
826 add_timer(&lp->media);
830 /* lp->lock guards the EL3 window. Window should always be 1 except
831 when the lock is held */
832 spin_lock_irqsave(&lp->lock, flags);
834 media = inw(ioaddr+WN4_MEDIA) & 0xc810;
836 /* Ignore collisions unless we've had no irq's recently */
837 if (jiffies - lp->last_irq < HZ) {
840 /* Try harder to detect carrier errors */
842 outw(StatsDisable, ioaddr + EL3_CMD);
843 errs = inb(ioaddr + 0);
844 outw(StatsEnable, ioaddr + EL3_CMD);
845 lp->stats.tx_carrier_errors += errs;
846 if (errs || (lp->media_status & 0x0010)) media |= 0x0010;
849 if (media != lp->media_status) {
850 if ((media & lp->media_status & 0x8000) &&
851 ((lp->media_status ^ media) & 0x0800))
852 printk(KERN_INFO "%s: %s link beat\n", dev->name,
853 (lp->media_status & 0x0800 ? "lost" : "found"));
854 else if ((media & lp->media_status & 0x4000) &&
855 ((lp->media_status ^ media) & 0x0010))
856 printk(KERN_INFO "%s: coax cable %s\n", dev->name,
857 (lp->media_status & 0x0010 ? "ok" : "problem"));
858 if (dev->if_port == 0) {
859 if (media & 0x8000) {
861 printk(KERN_INFO "%s: flipped to 10baseT\n",
864 tc589_set_xcvr(dev, 2);
865 } else if (media & 0x4000) {
867 tc589_set_xcvr(dev, 1);
869 printk(KERN_INFO "%s: flipped to 10base2\n",
873 lp->media_status = media;
877 spin_unlock_irqrestore(&lp->lock, flags);
880 lp->media.expires = jiffies + HZ;
881 add_timer(&lp->media);
884 static struct net_device_stats *el3_get_stats(struct net_device *dev)
886 struct el3_private *lp = netdev_priv(dev);
888 dev_link_t *link = &lp->link;
891 spin_lock_irqsave(&lp->lock, flags);
893 spin_unlock_irqrestore(&lp->lock, flags);
899 Update statistics. We change to register window 6, so this should be run
900 single-threaded if the device is active. This is expected to be a rare
901 operation, and it's simpler for the rest of the driver to assume that
902 window 1 is always valid rather than use a special window-state variable.
904 Caller must hold the lock for this
906 static void update_stats(struct net_device *dev)
908 struct el3_private *lp = netdev_priv(dev);
909 kio_addr_t ioaddr = dev->base_addr;
911 DEBUG(2, "%s: updating the statistics.\n", dev->name);
912 /* Turn off statistics updates while reading. */
913 outw(StatsDisable, ioaddr + EL3_CMD);
914 /* Switch to the stats window, and read everything. */
916 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
917 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
918 /* Multiple collisions. */ inb(ioaddr + 2);
919 lp->stats.collisions += inb(ioaddr + 3);
920 lp->stats.tx_window_errors += inb(ioaddr + 4);
921 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
922 lp->stats.tx_packets += inb(ioaddr + 6);
923 /* Rx packets */ inb(ioaddr + 7);
924 /* Tx deferrals */ inb(ioaddr + 8);
925 /* Rx octets */ inw(ioaddr + 10);
926 /* Tx octets */ inw(ioaddr + 12);
928 /* Back to window 1, and turn statistics back on. */
930 outw(StatsEnable, ioaddr + EL3_CMD);
933 static int el3_rx(struct net_device *dev)
935 struct el3_private *lp = netdev_priv(dev);
936 kio_addr_t ioaddr = dev->base_addr;
940 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
941 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
942 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) &&
943 (--worklimit >= 0)) {
944 if (rx_status & 0x4000) { /* Error, update stats. */
945 short error = rx_status & 0x3800;
946 lp->stats.rx_errors++;
948 case 0x0000: lp->stats.rx_over_errors++; break;
949 case 0x0800: lp->stats.rx_length_errors++; break;
950 case 0x1000: lp->stats.rx_frame_errors++; break;
951 case 0x1800: lp->stats.rx_length_errors++; break;
952 case 0x2000: lp->stats.rx_frame_errors++; break;
953 case 0x2800: lp->stats.rx_crc_errors++; break;
956 short pkt_len = rx_status & 0x7ff;
959 skb = dev_alloc_skb(pkt_len+5);
961 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
966 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
968 skb->protocol = eth_type_trans(skb, dev);
970 dev->last_rx = jiffies;
971 lp->stats.rx_packets++;
972 lp->stats.rx_bytes += pkt_len;
974 DEBUG(1, "%s: couldn't allocate a sk_buff of"
975 " size %d.\n", dev->name, pkt_len);
976 lp->stats.rx_dropped++;
979 /* Pop the top of the Rx FIFO */
980 tc589_wait_for_completion(dev, RxDiscard);
983 printk(KERN_WARNING "%s: too much work in el3_rx!\n", dev->name);
987 static void set_multicast_list(struct net_device *dev)
989 struct el3_private *lp = netdev_priv(dev);
990 dev_link_t *link = &lp->link;
991 kio_addr_t ioaddr = dev->base_addr;
992 u16 opts = SetRxFilter | RxStation | RxBroadcast;
994 if (!(DEV_OK(link))) return;
995 if (dev->flags & IFF_PROMISC)
996 opts |= RxMulticast | RxProm;
997 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
999 outw(opts, ioaddr + EL3_CMD);
1002 static int el3_close(struct net_device *dev)
1004 struct el3_private *lp = netdev_priv(dev);
1005 dev_link_t *link = &lp->link;
1006 kio_addr_t ioaddr = dev->base_addr;
1008 DEBUG(1, "%s: shutting down ethercard.\n", dev->name);
1011 /* Turn off statistics ASAP. We update lp->stats below. */
1012 outw(StatsDisable, ioaddr + EL3_CMD);
1014 /* Disable the receiver and transmitter. */
1015 outw(RxDisable, ioaddr + EL3_CMD);
1016 outw(TxDisable, ioaddr + EL3_CMD);
1018 if (dev->if_port == 2)
1019 /* Turn off thinnet power. Green! */
1020 outw(StopCoax, ioaddr + EL3_CMD);
1021 else if (dev->if_port == 1) {
1022 /* Disable link beat and jabber */
1024 outw(0, ioaddr + WN4_MEDIA);
1027 /* Switching back to window 0 disables the IRQ. */
1029 /* But we explicitly zero the IRQ line select anyway. */
1030 outw(0x0f00, ioaddr + WN0_IRQ);
1032 /* Check if the card still exists */
1033 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
1038 netif_stop_queue(dev);
1039 del_timer_sync(&lp->media);
1044 static struct pcmcia_device_id tc589_ids[] = {
1045 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562),
1046 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77),
1047 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589),
1048 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202),
1049 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "3CXEM556.cis"),
1050 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "3CXEM556.cis"),
1053 MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
1055 static struct pcmcia_driver tc589_driver = {
1056 .owner = THIS_MODULE,
1060 .attach = tc589_attach,
1061 .event = tc589_event,
1062 .remove = tc589_detach,
1063 .id_table = tc589_ids,
1064 .suspend = tc589_suspend,
1065 .resume = tc589_resume,
1068 static int __init init_tc589(void)
1070 return pcmcia_register_driver(&tc589_driver);
1073 static void __exit exit_tc589(void)
1075 pcmcia_unregister_driver(&tc589_driver);
1078 module_init(init_tc589);
1079 module_exit(exit_tc589);