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>
42 #include <linux/jiffies.h>
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>
51 #include <asm/uaccess.h>
53 #include <asm/system.h>
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. */
60 #define EL3_TIMER 0x0a
62 #define EL3_STATUS 0x0e
64 #define EEPROM_READ 0x0080
65 #define EEPROM_BUSY 0x8000
67 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
69 /* The top five bits written to EL3_CMD are a command, the lower
70 11 bits are the parameter, if applicable. */
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,
82 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
83 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
84 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000
87 /* The SetRxFilter command accepts the following classes: */
89 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
92 /* Register window 1 offsets, the window used in normal operation. */
95 #define RX_STATUS 0x08
96 #define TX_STATUS 0x0B
97 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
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. */
104 /* Time in jiffies before concluding Tx hung */
105 #define TX_TIMEOUT ((400*HZ)/1000)
110 struct net_device_stats stats;
111 /* For transceiver monitoring */
112 struct timer_list media;
115 unsigned long last_irq;
119 static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" };
121 /*====================================================================*/
123 /* Module parameters */
125 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
126 MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver");
127 MODULE_LICENSE("GPL");
129 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
131 /* Special hook for setting if_port when module is loaded */
132 INT_MODULE_PARM(if_port, 0);
135 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
136 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
137 static char *version =
138 DRV_NAME ".c " DRV_VERSION " 2001/10/13 00:08:50 (David Hinds)";
140 #define DEBUG(n, args...)
143 /*====================================================================*/
145 static void tc589_config(dev_link_t *link);
146 static void tc589_release(dev_link_t *link);
148 static u16 read_eeprom(kio_addr_t ioaddr, int index);
149 static void tc589_reset(struct net_device *dev);
150 static void media_check(unsigned long arg);
151 static int el3_config(struct net_device *dev, struct ifmap *map);
152 static int el3_open(struct net_device *dev);
153 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
154 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
155 static void update_stats(struct net_device *dev);
156 static struct net_device_stats *el3_get_stats(struct net_device *dev);
157 static int el3_rx(struct net_device *dev);
158 static int el3_close(struct net_device *dev);
159 static void el3_tx_timeout(struct net_device *dev);
160 static void set_multicast_list(struct net_device *dev);
161 static struct ethtool_ops netdev_ethtool_ops;
163 static void tc589_detach(struct pcmcia_device *p_dev);
165 /*======================================================================
167 tc589_attach() creates an "instance" of the driver, allocating
168 local data structures for one device. The device is registered
171 ======================================================================*/
173 static int tc589_attach(struct pcmcia_device *p_dev)
175 struct el3_private *lp;
177 struct net_device *dev;
179 DEBUG(0, "3c589_attach()\n");
181 /* Create new ethernet device */
182 dev = alloc_etherdev(sizeof(struct el3_private));
185 lp = netdev_priv(dev);
189 spin_lock_init(&lp->lock);
190 link->io.NumPorts1 = 16;
191 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
192 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
193 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
194 link->irq.Handler = &el3_interrupt;
195 link->irq.Instance = dev;
196 link->conf.Attributes = CONF_ENABLE_IRQ;
198 link->conf.IntType = INT_MEMORY_AND_IO;
199 link->conf.ConfigIndex = 1;
200 link->conf.Present = PRESENT_OPTION;
202 /* The EL3-specific entries in the device structure. */
203 SET_MODULE_OWNER(dev);
204 dev->hard_start_xmit = &el3_start_xmit;
205 dev->set_config = &el3_config;
206 dev->get_stats = &el3_get_stats;
207 dev->set_multicast_list = &set_multicast_list;
208 dev->open = &el3_open;
209 dev->stop = &el3_close;
210 #ifdef HAVE_TX_TIMEOUT
211 dev->tx_timeout = el3_tx_timeout;
212 dev->watchdog_timeo = TX_TIMEOUT;
214 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
216 link->handle = p_dev;
217 p_dev->instance = link;
219 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
225 /*======================================================================
227 This deletes a driver "instance". The device is de-registered
228 with Card Services. If it has been released, all local data
229 structures are freed. Otherwise, the structures will be freed
230 when the device is released.
232 ======================================================================*/
234 static void tc589_detach(struct pcmcia_device *p_dev)
236 dev_link_t *link = dev_to_instance(p_dev);
237 struct net_device *dev = link->priv;
239 DEBUG(0, "3c589_detach(0x%p)\n", link);
242 unregister_netdev(dev);
244 if (link->state & DEV_CONFIG)
250 /*======================================================================
252 tc589_config() is scheduled to run after a CARD_INSERTION event
253 is received, to configure the PCMCIA socket, and to make the
254 ethernet device available to the system.
256 ======================================================================*/
258 #define CS_CHECK(fn, ret) \
259 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
261 static void tc589_config(dev_link_t *link)
263 client_handle_t handle = link->handle;
264 struct net_device *dev = link->priv;
265 struct el3_private *lp = netdev_priv(dev);
268 u16 buf[32], *phys_addr;
269 int last_fn, last_ret, i, j, multi = 0, fifo;
271 char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
273 DEBUG(0, "3c589_config(0x%p)\n", link);
275 phys_addr = (u16 *)dev->dev_addr;
276 tuple.Attributes = 0;
277 tuple.DesiredTuple = CISTPL_CONFIG;
278 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
279 tuple.TupleData = (cisdata_t *)buf;
280 tuple.TupleDataMax = sizeof(buf);
281 tuple.TupleOffset = 0;
282 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
283 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
284 link->conf.ConfigBase = parse.config.base;
285 link->conf.Present = parse.config.rmask[0];
287 /* Is this a 3c562? */
288 tuple.DesiredTuple = CISTPL_MANFID;
289 tuple.Attributes = TUPLE_RETURN_COMMON;
290 if ((pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) &&
291 (pcmcia_get_tuple_data(handle, &tuple) == CS_SUCCESS)) {
292 if (le16_to_cpu(buf[0]) != MANFID_3COM)
293 printk(KERN_INFO "3c589_cs: hmmm, is this really a "
295 multi = (le16_to_cpu(buf[1]) == PRODID_3COM_3C562);
299 link->state |= DEV_CONFIG;
301 /* For the 3c562, the base address must be xx00-xx7f */
302 link->io.IOAddrLines = 16;
303 for (i = j = 0; j < 0x400; j += 0x10) {
304 if (multi && (j & 0x80)) continue;
305 link->io.BasePort1 = j ^ 0x300;
306 i = pcmcia_request_io(link->handle, &link->io);
307 if (i == CS_SUCCESS) break;
309 if (i != CS_SUCCESS) {
310 cs_error(link->handle, RequestIO, i);
313 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
314 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
316 dev->irq = link->irq.AssignedIRQ;
317 dev->base_addr = link->io.BasePort1;
318 ioaddr = dev->base_addr;
321 /* The 3c589 has an extra EEPROM for configuration info, including
322 the hardware address. The 3c562 puts the address in the CIS. */
323 tuple.DesiredTuple = 0x88;
324 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) {
325 pcmcia_get_tuple_data(handle, &tuple);
326 for (i = 0; i < 3; i++)
327 phys_addr[i] = htons(buf[i]);
329 for (i = 0; i < 3; i++)
330 phys_addr[i] = htons(read_eeprom(ioaddr, i));
331 if (phys_addr[0] == 0x6060) {
332 printk(KERN_ERR "3c589_cs: IO port conflict at 0x%03lx"
333 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
338 /* The address and resource configuration register aren't loaded from
339 the EEPROM and *must* be set to 0 and IRQ3 for the PCMCIA version. */
340 outw(0x3f00, ioaddr + 8);
343 /* The if_port symbol can be set when the module is loaded */
344 if ((if_port >= 0) && (if_port <= 3))
345 dev->if_port = if_port;
347 printk(KERN_ERR "3c589_cs: invalid if_port requested\n");
349 link->dev = &lp->node;
350 link->state &= ~DEV_CONFIG_PENDING;
351 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
353 if (register_netdev(dev) != 0) {
354 printk(KERN_ERR "3c589_cs: register_netdev() failed\n");
359 strcpy(lp->node.dev_name, dev->name);
361 printk(KERN_INFO "%s: 3Com 3c%s, io %#3lx, irq %d, hw_addr ",
362 dev->name, (multi ? "562" : "589"), dev->base_addr,
364 for (i = 0; i < 6; i++)
365 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
366 printk(KERN_INFO " %dK FIFO split %s Rx:Tx, %s xcvr\n",
367 (fifo & 7) ? 32 : 8, ram_split[(fifo >> 16) & 3],
368 if_names[dev->if_port]);
372 cs_error(link->handle, last_fn, last_ret);
379 /*======================================================================
381 After a card is removed, tc589_release() will unregister the net
382 device, and release the PCMCIA configuration. If the device is
383 still open, this will be postponed until it is closed.
385 ======================================================================*/
387 static void tc589_release(dev_link_t *link)
389 pcmcia_disable_device(link->handle);
392 static int tc589_suspend(struct pcmcia_device *p_dev)
394 dev_link_t *link = dev_to_instance(p_dev);
395 struct net_device *dev = link->priv;
397 if ((link->state & DEV_CONFIG) && (link->open))
398 netif_device_detach(dev);
403 static int tc589_resume(struct pcmcia_device *p_dev)
405 dev_link_t *link = dev_to_instance(p_dev);
406 struct net_device *dev = link->priv;
408 if ((link->state & DEV_CONFIG) && (link->open)) {
410 netif_device_attach(dev);
416 /*====================================================================*/
419 Use this for commands that may take time to finish
421 static void tc589_wait_for_completion(struct net_device *dev, int cmd)
424 outw(cmd, dev->base_addr + EL3_CMD);
426 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
428 printk(KERN_WARNING "%s: command 0x%04x did not complete!\n",
433 Read a word from the EEPROM using the regular EEPROM access register.
434 Assume that we are in register window zero.
436 static u16 read_eeprom(kio_addr_t ioaddr, int index)
439 outw(EEPROM_READ + index, ioaddr + 10);
440 /* Reading the eeprom takes 162 us */
441 for (i = 1620; i >= 0; i--)
442 if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0)
444 return inw(ioaddr + 12);
448 Set transceiver type, perhaps to something other than what the user
449 specified in dev->if_port.
451 static void tc589_set_xcvr(struct net_device *dev, int if_port)
453 struct el3_private *lp = netdev_priv(dev);
454 kio_addr_t ioaddr = dev->base_addr;
458 case 0: case 1: outw(0, ioaddr + 6); break;
459 case 2: outw(3<<14, ioaddr + 6); break;
460 case 3: outw(1<<14, ioaddr + 6); break;
462 /* On PCMCIA, this just turns on the LED */
463 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD);
464 /* 10baseT interface, enable link beat and jabber check. */
466 outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA);
469 lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000);
471 lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800);
474 static void dump_status(struct net_device *dev)
476 kio_addr_t ioaddr = dev->base_addr;
478 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
479 "%02x tx free %04x\n", inw(ioaddr+EL3_STATUS),
480 inw(ioaddr+RX_STATUS), inb(ioaddr+TX_STATUS),
481 inw(ioaddr+TX_FREE));
483 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
484 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
485 inw(ioaddr+0x08), inw(ioaddr+0x0a));
489 /* Reset and restore all of the 3c589 registers. */
490 static void tc589_reset(struct net_device *dev)
492 kio_addr_t ioaddr = dev->base_addr;
496 outw(0x0001, ioaddr + 4); /* Activate board. */
497 outw(0x3f00, ioaddr + 8); /* Set the IRQ line. */
499 /* Set the station address in window 2. */
501 for (i = 0; i < 6; i++)
502 outb(dev->dev_addr[i], ioaddr + i);
504 tc589_set_xcvr(dev, dev->if_port);
506 /* Switch to the stats window, and clear all stats by reading. */
507 outw(StatsDisable, ioaddr + EL3_CMD);
509 for (i = 0; i < 9; i++)
514 /* Switch to register set 1 for normal use. */
517 /* Accept b-cast and phys addr only. */
518 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
519 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
520 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
521 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
522 /* Allow status bits to be seen. */
523 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
524 /* Ack all pending events, and set active indicator mask. */
525 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
527 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
528 | AdapterFailure, ioaddr + EL3_CMD);
531 static void netdev_get_drvinfo(struct net_device *dev,
532 struct ethtool_drvinfo *info)
534 strcpy(info->driver, DRV_NAME);
535 strcpy(info->version, DRV_VERSION);
536 sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
540 static u32 netdev_get_msglevel(struct net_device *dev)
545 static void netdev_set_msglevel(struct net_device *dev, u32 level)
549 #endif /* PCMCIA_DEBUG */
551 static struct ethtool_ops netdev_ethtool_ops = {
552 .get_drvinfo = netdev_get_drvinfo,
554 .get_msglevel = netdev_get_msglevel,
555 .set_msglevel = netdev_set_msglevel,
556 #endif /* PCMCIA_DEBUG */
559 static int el3_config(struct net_device *dev, struct ifmap *map)
561 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
562 if (map->port <= 3) {
563 dev->if_port = map->port;
564 printk(KERN_INFO "%s: switched to %s port\n",
565 dev->name, if_names[dev->if_port]);
566 tc589_set_xcvr(dev, dev->if_port);
573 static int el3_open(struct net_device *dev)
575 struct el3_private *lp = netdev_priv(dev);
576 dev_link_t *link = &lp->link;
582 netif_start_queue(dev);
585 init_timer(&lp->media);
586 lp->media.function = &media_check;
587 lp->media.data = (unsigned long) dev;
588 lp->media.expires = jiffies + HZ;
589 add_timer(&lp->media);
591 DEBUG(1, "%s: opened, status %4.4x.\n",
592 dev->name, inw(dev->base_addr + EL3_STATUS));
597 static void el3_tx_timeout(struct net_device *dev)
599 struct el3_private *lp = netdev_priv(dev);
600 kio_addr_t ioaddr = dev->base_addr;
602 printk(KERN_WARNING "%s: Transmit timed out!\n", dev->name);
604 lp->stats.tx_errors++;
605 dev->trans_start = jiffies;
606 /* Issue TX_RESET and TX_START commands. */
607 tc589_wait_for_completion(dev, TxReset);
608 outw(TxEnable, ioaddr + EL3_CMD);
609 netif_wake_queue(dev);
612 static void pop_tx_status(struct net_device *dev)
614 struct el3_private *lp = netdev_priv(dev);
615 kio_addr_t ioaddr = dev->base_addr;
618 /* Clear the Tx status stack. */
619 for (i = 32; i > 0; i--) {
620 u_char tx_status = inb(ioaddr + TX_STATUS);
621 if (!(tx_status & 0x84)) break;
622 /* reset transmitter on jabber error or underrun */
623 if (tx_status & 0x30)
624 tc589_wait_for_completion(dev, TxReset);
625 if (tx_status & 0x38) {
626 DEBUG(1, "%s: transmit error: status 0x%02x\n",
627 dev->name, tx_status);
628 outw(TxEnable, ioaddr + EL3_CMD);
629 lp->stats.tx_aborted_errors++;
631 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
635 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
637 kio_addr_t ioaddr = dev->base_addr;
638 struct el3_private *priv = netdev_priv(dev);
640 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
641 "status %4.4x.\n", dev->name, (long)skb->len,
642 inw(ioaddr + EL3_STATUS));
644 priv->stats.tx_bytes += skb->len;
646 /* Put out the doubleword header... */
647 outw(skb->len, ioaddr + TX_FIFO);
648 outw(0x00, ioaddr + TX_FIFO);
649 /* ... and the packet rounded to a doubleword. */
650 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
652 dev->trans_start = jiffies;
653 if (inw(ioaddr + TX_FREE) <= 1536) {
654 netif_stop_queue(dev);
655 /* Interrupt us when the FIFO has room for max-sized packet. */
656 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
665 /* The EL3 interrupt handler. */
666 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
668 struct net_device *dev = (struct net_device *) dev_id;
669 struct el3_private *lp = netdev_priv(dev);
672 int i = 0, handled = 1;
674 if (!netif_device_present(dev))
677 ioaddr = dev->base_addr;
679 DEBUG(3, "%s: interrupt, status %4.4x.\n",
680 dev->name, inw(ioaddr + EL3_STATUS));
682 spin_lock(&lp->lock);
683 while ((status = inw(ioaddr + EL3_STATUS)) &
684 (IntLatch | RxComplete | StatsFull)) {
685 if ((status & 0xe000) != 0x2000) {
686 DEBUG(1, "%s: interrupt from dead card\n", dev->name);
691 if (status & RxComplete)
694 if (status & TxAvailable) {
695 DEBUG(3, " TX room bit was handled.\n");
696 /* There's room in the FIFO for a full-sized packet. */
697 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
698 netif_wake_queue(dev);
701 if (status & TxComplete)
704 if (status & (AdapterFailure | RxEarly | StatsFull)) {
705 /* Handle all uncommon interrupts. */
706 if (status & StatsFull) /* Empty statistics. */
708 if (status & RxEarly) { /* Rx early is unused. */
710 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
712 if (status & AdapterFailure) {
715 fifo_diag = inw(ioaddr + 4);
717 printk(KERN_WARNING "%s: adapter failure, FIFO diagnostic"
718 " register %04x.\n", dev->name, fifo_diag);
719 if (fifo_diag & 0x0400) {
721 tc589_wait_for_completion(dev, TxReset);
722 outw(TxEnable, ioaddr + EL3_CMD);
724 if (fifo_diag & 0x2000) {
726 tc589_wait_for_completion(dev, RxReset);
727 set_multicast_list(dev);
728 outw(RxEnable, ioaddr + EL3_CMD);
730 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
735 printk(KERN_ERR "%s: infinite loop in interrupt, "
736 "status %4.4x.\n", dev->name, status);
737 /* Clear all interrupts */
738 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
741 /* Acknowledge the IRQ. */
742 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
745 lp->last_irq = jiffies;
746 spin_unlock(&lp->lock);
747 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
748 dev->name, inw(ioaddr + EL3_STATUS));
749 return IRQ_RETVAL(handled);
752 static void media_check(unsigned long arg)
754 struct net_device *dev = (struct net_device *)(arg);
755 struct el3_private *lp = netdev_priv(dev);
756 kio_addr_t ioaddr = dev->base_addr;
760 if (!netif_device_present(dev)) goto reschedule;
763 /* Check for pending interrupt with expired latency timer: with
764 this, we can limp along even if the interrupt is blocked */
765 if ((inw(ioaddr + EL3_STATUS) & IntLatch) &&
766 (inb(ioaddr + EL3_TIMER) == 0xff)) {
768 printk(KERN_WARNING "%s: interrupt(s) dropped!\n", dev->name);
769 el3_interrupt(dev->irq, lp, NULL);
774 lp->media.expires = jiffies + HZ/100;
775 add_timer(&lp->media);
779 /* lp->lock guards the EL3 window. Window should always be 1 except
780 when the lock is held */
781 spin_lock_irqsave(&lp->lock, flags);
783 media = inw(ioaddr+WN4_MEDIA) & 0xc810;
785 /* Ignore collisions unless we've had no irq's recently */
786 if (time_before(jiffies, lp->last_irq + HZ)) {
789 /* Try harder to detect carrier errors */
791 outw(StatsDisable, ioaddr + EL3_CMD);
792 errs = inb(ioaddr + 0);
793 outw(StatsEnable, ioaddr + EL3_CMD);
794 lp->stats.tx_carrier_errors += errs;
795 if (errs || (lp->media_status & 0x0010)) media |= 0x0010;
798 if (media != lp->media_status) {
799 if ((media & lp->media_status & 0x8000) &&
800 ((lp->media_status ^ media) & 0x0800))
801 printk(KERN_INFO "%s: %s link beat\n", dev->name,
802 (lp->media_status & 0x0800 ? "lost" : "found"));
803 else if ((media & lp->media_status & 0x4000) &&
804 ((lp->media_status ^ media) & 0x0010))
805 printk(KERN_INFO "%s: coax cable %s\n", dev->name,
806 (lp->media_status & 0x0010 ? "ok" : "problem"));
807 if (dev->if_port == 0) {
808 if (media & 0x8000) {
810 printk(KERN_INFO "%s: flipped to 10baseT\n",
813 tc589_set_xcvr(dev, 2);
814 } else if (media & 0x4000) {
816 tc589_set_xcvr(dev, 1);
818 printk(KERN_INFO "%s: flipped to 10base2\n",
822 lp->media_status = media;
826 spin_unlock_irqrestore(&lp->lock, flags);
829 lp->media.expires = jiffies + HZ;
830 add_timer(&lp->media);
833 static struct net_device_stats *el3_get_stats(struct net_device *dev)
835 struct el3_private *lp = netdev_priv(dev);
837 dev_link_t *link = &lp->link;
840 spin_lock_irqsave(&lp->lock, flags);
842 spin_unlock_irqrestore(&lp->lock, flags);
848 Update statistics. We change to register window 6, so this should be run
849 single-threaded if the device is active. This is expected to be a rare
850 operation, and it's simpler for the rest of the driver to assume that
851 window 1 is always valid rather than use a special window-state variable.
853 Caller must hold the lock for this
855 static void update_stats(struct net_device *dev)
857 struct el3_private *lp = netdev_priv(dev);
858 kio_addr_t ioaddr = dev->base_addr;
860 DEBUG(2, "%s: updating the statistics.\n", dev->name);
861 /* Turn off statistics updates while reading. */
862 outw(StatsDisable, ioaddr + EL3_CMD);
863 /* Switch to the stats window, and read everything. */
865 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
866 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
867 /* Multiple collisions. */ inb(ioaddr + 2);
868 lp->stats.collisions += inb(ioaddr + 3);
869 lp->stats.tx_window_errors += inb(ioaddr + 4);
870 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
871 lp->stats.tx_packets += inb(ioaddr + 6);
872 /* Rx packets */ inb(ioaddr + 7);
873 /* Tx deferrals */ inb(ioaddr + 8);
874 /* Rx octets */ inw(ioaddr + 10);
875 /* Tx octets */ inw(ioaddr + 12);
877 /* Back to window 1, and turn statistics back on. */
879 outw(StatsEnable, ioaddr + EL3_CMD);
882 static int el3_rx(struct net_device *dev)
884 struct el3_private *lp = netdev_priv(dev);
885 kio_addr_t ioaddr = dev->base_addr;
889 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
890 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
891 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) &&
892 (--worklimit >= 0)) {
893 if (rx_status & 0x4000) { /* Error, update stats. */
894 short error = rx_status & 0x3800;
895 lp->stats.rx_errors++;
897 case 0x0000: lp->stats.rx_over_errors++; break;
898 case 0x0800: lp->stats.rx_length_errors++; break;
899 case 0x1000: lp->stats.rx_frame_errors++; break;
900 case 0x1800: lp->stats.rx_length_errors++; break;
901 case 0x2000: lp->stats.rx_frame_errors++; break;
902 case 0x2800: lp->stats.rx_crc_errors++; break;
905 short pkt_len = rx_status & 0x7ff;
908 skb = dev_alloc_skb(pkt_len+5);
910 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
915 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
917 skb->protocol = eth_type_trans(skb, dev);
919 dev->last_rx = jiffies;
920 lp->stats.rx_packets++;
921 lp->stats.rx_bytes += pkt_len;
923 DEBUG(1, "%s: couldn't allocate a sk_buff of"
924 " size %d.\n", dev->name, pkt_len);
925 lp->stats.rx_dropped++;
928 /* Pop the top of the Rx FIFO */
929 tc589_wait_for_completion(dev, RxDiscard);
932 printk(KERN_WARNING "%s: too much work in el3_rx!\n", dev->name);
936 static void set_multicast_list(struct net_device *dev)
938 struct el3_private *lp = netdev_priv(dev);
939 dev_link_t *link = &lp->link;
940 kio_addr_t ioaddr = dev->base_addr;
941 u16 opts = SetRxFilter | RxStation | RxBroadcast;
943 if (!(DEV_OK(link))) return;
944 if (dev->flags & IFF_PROMISC)
945 opts |= RxMulticast | RxProm;
946 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
948 outw(opts, ioaddr + EL3_CMD);
951 static int el3_close(struct net_device *dev)
953 struct el3_private *lp = netdev_priv(dev);
954 dev_link_t *link = &lp->link;
955 kio_addr_t ioaddr = dev->base_addr;
957 DEBUG(1, "%s: shutting down ethercard.\n", dev->name);
960 /* Turn off statistics ASAP. We update lp->stats below. */
961 outw(StatsDisable, ioaddr + EL3_CMD);
963 /* Disable the receiver and transmitter. */
964 outw(RxDisable, ioaddr + EL3_CMD);
965 outw(TxDisable, ioaddr + EL3_CMD);
967 if (dev->if_port == 2)
968 /* Turn off thinnet power. Green! */
969 outw(StopCoax, ioaddr + EL3_CMD);
970 else if (dev->if_port == 1) {
971 /* Disable link beat and jabber */
973 outw(0, ioaddr + WN4_MEDIA);
976 /* Switching back to window 0 disables the IRQ. */
978 /* But we explicitly zero the IRQ line select anyway. */
979 outw(0x0f00, ioaddr + WN0_IRQ);
981 /* Check if the card still exists */
982 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000)
987 netif_stop_queue(dev);
988 del_timer_sync(&lp->media);
993 static struct pcmcia_device_id tc589_ids[] = {
994 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562),
995 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77),
996 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589),
997 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202),
998 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "3CXEM556.cis"),
999 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "3CXEM556.cis"),
1002 MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
1004 static struct pcmcia_driver tc589_driver = {
1005 .owner = THIS_MODULE,
1009 .probe = tc589_attach,
1010 .remove = tc589_detach,
1011 .id_table = tc589_ids,
1012 .suspend = tc589_suspend,
1013 .resume = tc589_resume,
1016 static int __init init_tc589(void)
1018 return pcmcia_register_driver(&tc589_driver);
1021 static void __exit exit_tc589(void)
1023 pcmcia_unregister_driver(&tc589_driver);
1026 module_init(init_tc589);
1027 module_exit(exit_tc589);