1 /* 3c574.c: A PCMCIA ethernet driver for the 3com 3c574 "RoadRunner".
4 Donald Becker, becker@scyld.com, (driver core) and
5 David Hinds, dahinds@users.sourceforge.net (from his PC card code).
6 Locking fixes (C) Copyright 2003 Red Hat Inc
8 This software may be used and distributed according to the terms of
9 the GNU General Public License, incorporated herein by reference.
11 This driver derives from Donald Becker's 3c509 core, which has the
13 Copyright 1993 United States Government as represented by the
14 Director, National Security Agency.
22 I. Board Compatibility
24 This device driver is designed for the 3Com 3c574 PC card Fast Ethernet
27 II. Board-specific settings
29 None -- PC cards are autoconfigured.
33 The 3c574 uses a Boomerang-style interface, without the bus-master capability.
34 See the Boomerang driver and documentation for most details.
36 IV. Notes and chip documentation.
38 Two added registers are used to enhance PIO performance, RunnerRdCtrl and
39 RunnerWrCtrl. These are 11 bit down-counters that are preloaded with the
40 count of word (16 bits) reads or writes the driver is about to do to the Rx
41 or Tx FIFO. The chip is then able to hide the internal-PCI-bus to PC-card
42 translation latency by buffering the I/O operations with an 8 word FIFO.
43 Note: No other chip accesses are permitted when this buffer is used.
45 A second enhancement is that both attribute and common memory space
46 0x0800-0x0fff can translated to the PIO FIFO. Thus memory operations (faster
47 with *some* PCcard bridges) may be used instead of I/O operations.
48 This is enabled by setting the 0x10 bit in the PCMCIA LAN COR.
50 Some slow PC card bridges work better if they never see a WAIT signal.
51 This is configured by setting the 0x20 bit in the PCMCIA LAN COR.
52 Only do this after testing that it is reliable and improves performance.
54 The upper five bits of RunnerRdCtrl are used to window into PCcard
55 configuration space registers. Window 0 is the regular Boomerang/Odie
56 register set, 1-5 are various PC card control registers, and 16-31 are
57 the (reversed!) CIS table.
59 A final note: writing the InternalConfig register in window 3 with an
60 invalid ramWidth is Very Bad.
64 http://www.scyld.com/expert/NWay.html
65 http://www.national.com/pf/DP/DP83840.html
67 Thanks to Terry Murphy of 3Com for providing development information for
68 earlier 3Com products.
72 #include <linux/module.h>
73 #include <linux/kernel.h>
74 #include <linux/init.h>
75 #include <linux/slab.h>
76 #include <linux/string.h>
77 #include <linux/timer.h>
78 #include <linux/interrupt.h>
80 #include <linux/delay.h>
81 #include <linux/netdevice.h>
82 #include <linux/etherdevice.h>
83 #include <linux/skbuff.h>
84 #include <linux/if_arp.h>
85 #include <linux/ioport.h>
86 #include <linux/ethtool.h>
87 #include <linux/bitops.h>
89 #include <pcmcia/cs_types.h>
90 #include <pcmcia/cs.h>
91 #include <pcmcia/cistpl.h>
92 #include <pcmcia/cisreg.h>
93 #include <pcmcia/ciscode.h>
94 #include <pcmcia/ds.h>
95 #include <pcmcia/mem_op.h>
97 #include <asm/uaccess.h>
99 #include <asm/system.h>
101 /*====================================================================*/
103 /* Module parameters */
105 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
106 MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
107 MODULE_LICENSE("GPL");
109 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
111 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
112 INT_MODULE_PARM(max_interrupt_work, 32);
114 /* Force full duplex modes? */
115 INT_MODULE_PARM(full_duplex, 0);
117 /* Autodetect link polarity reversal? */
118 INT_MODULE_PARM(auto_polarity, 1);
121 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
122 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
123 static char *version =
124 "3c574_cs.c 1.65ac1 2003/04/07 Donald Becker/David Hinds, becker@scyld.com.\n";
126 #define DEBUG(n, args...)
129 /*====================================================================*/
131 /* Time in jiffies before concluding the transmitter is hung. */
132 #define TX_TIMEOUT ((800*HZ)/1000)
134 /* To minimize the size of the driver source and make the driver more
135 readable not all constants are symbolically defined.
136 You'll need the manual if you want to understand driver details anyway. */
137 /* Offsets from base I/O address. */
138 #define EL3_DATA 0x00
140 #define EL3_STATUS 0x0e
142 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
144 /* The top five bits written to EL3_CMD are a command, the lower
145 11 bits are the parameter, if applicable. */
147 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
148 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
149 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
150 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
151 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
152 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
153 StatsDisable = 22<<11, StopCoax = 23<<11,
157 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
158 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
159 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 };
161 /* The SetRxFilter command accepts the following classes: */
163 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
167 Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */
168 IntrStatus=0x0E, /* Valid in all windows. */
170 /* These assumes the larger EEPROM. */
171 enum Win0_EEPROM_cmds {
172 EEPROM_Read = 0x200, EEPROM_WRITE = 0x100, EEPROM_ERASE = 0x300,
173 EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
174 EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
177 /* Register window 1 offsets, the window used in normal operation.
178 On the "Odie" this window is always mapped at offsets 0x10-0x1f.
179 Except for TxFree, which is overlapped by RunnerWrCtrl. */
181 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
182 RxStatus = 0x18, Timer=0x1A, TxStatus = 0x1B,
183 TxFree = 0x0C, /* Remaining free bytes in Tx buffer. */
184 RunnerRdCtrl = 0x16, RunnerWrCtrl = 0x1c,
187 enum Window3 { /* Window 3: MAC/config bits. */
188 Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
192 struct w3_config_fields {
193 unsigned int ram_size:3, ram_width:1, ram_speed:2, rom_size:2;
195 unsigned int ram_split:2, pad18:2, xcvr:3, pad21:1, autoselect:1;
200 enum Window4 { /* Window 4: Xcvr/media bits. */
201 Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
204 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
207 struct pcmcia_device *p_dev;
209 struct net_device_stats stats;
210 u16 advertising, partner; /* NWay media advertisement */
211 unsigned char phys; /* MII device address */
212 unsigned int autoselect:1, default_media:3; /* Read from the EEPROM/Wn3_Config. */
213 /* for transceiver monitoring */
214 struct timer_list media;
215 unsigned short media_status;
216 unsigned short fast_poll;
217 unsigned long last_irq;
218 spinlock_t window_lock; /* Guards the Window selection */
221 /* Set iff a MII transceiver on any interface requires mdio preamble.
222 This only set with the original DP83840 on older 3c905 boards, so the extra
223 code size of a per-interface flag is not worthwhile. */
224 static char mii_preamble_required = 0;
226 /* Index of functions. */
228 static void tc574_config(struct pcmcia_device *link);
229 static void tc574_release(struct pcmcia_device *link);
231 static void mdio_sync(kio_addr_t ioaddr, int bits);
232 static int mdio_read(kio_addr_t ioaddr, int phy_id, int location);
233 static void mdio_write(kio_addr_t ioaddr, int phy_id, int location, int value);
234 static unsigned short read_eeprom(kio_addr_t ioaddr, int index);
235 static void tc574_wait_for_completion(struct net_device *dev, int cmd);
237 static void tc574_reset(struct net_device *dev);
238 static void media_check(unsigned long arg);
239 static int el3_open(struct net_device *dev);
240 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
241 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
242 static void update_stats(struct net_device *dev);
243 static struct net_device_stats *el3_get_stats(struct net_device *dev);
244 static int el3_rx(struct net_device *dev, int worklimit);
245 static int el3_close(struct net_device *dev);
246 static void el3_tx_timeout(struct net_device *dev);
247 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
248 static struct ethtool_ops netdev_ethtool_ops;
249 static void set_rx_mode(struct net_device *dev);
251 static void tc574_detach(struct pcmcia_device *p_dev);
254 tc574_attach() creates an "instance" of the driver, allocating
255 local data structures for one device. The device is registered
259 static int tc574_attach(struct pcmcia_device *link)
261 struct el3_private *lp;
262 struct net_device *dev;
264 DEBUG(0, "3c574_attach()\n");
266 /* Create the PC card device object. */
267 dev = alloc_etherdev(sizeof(struct el3_private));
270 lp = netdev_priv(dev);
274 spin_lock_init(&lp->window_lock);
275 link->io.NumPorts1 = 32;
276 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
277 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
278 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
279 link->irq.Handler = &el3_interrupt;
280 link->irq.Instance = dev;
281 link->conf.Attributes = CONF_ENABLE_IRQ;
282 link->conf.IntType = INT_MEMORY_AND_IO;
283 link->conf.ConfigIndex = 1;
284 link->conf.Present = PRESENT_OPTION;
286 /* The EL3-specific entries in the device structure. */
287 dev->hard_start_xmit = &el3_start_xmit;
288 dev->get_stats = &el3_get_stats;
289 dev->do_ioctl = &el3_ioctl;
290 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
291 dev->set_multicast_list = &set_rx_mode;
292 dev->open = &el3_open;
293 dev->stop = &el3_close;
294 #ifdef HAVE_TX_TIMEOUT
295 dev->tx_timeout = el3_tx_timeout;
296 dev->watchdog_timeo = TX_TIMEOUT;
299 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
307 This deletes a driver "instance". The device is de-registered
308 with Card Services. If it has been released, all local data
309 structures are freed. Otherwise, the structures will be freed
310 when the device is released.
314 static void tc574_detach(struct pcmcia_device *link)
316 struct net_device *dev = link->priv;
318 DEBUG(0, "3c574_detach(0x%p)\n", link);
321 unregister_netdev(dev);
323 if (link->state & DEV_CONFIG)
330 tc574_config() is scheduled to run after a CARD_INSERTION event
331 is received, to configure the PCMCIA socket, and to make the
332 ethernet device available to the system.
335 #define CS_CHECK(fn, ret) \
336 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
338 static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
340 static void tc574_config(struct pcmcia_device *link)
342 struct net_device *dev = link->priv;
343 struct el3_private *lp = netdev_priv(dev);
346 unsigned short buf[32];
347 int last_fn, last_ret, i, j;
351 union wn3_config config;
353 phys_addr = (u16 *)dev->dev_addr;
355 DEBUG(0, "3c574_config(0x%p)\n", link);
357 tuple.Attributes = 0;
358 tuple.DesiredTuple = CISTPL_CONFIG;
359 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
360 tuple.TupleData = (cisdata_t *)buf;
361 tuple.TupleDataMax = 64;
362 tuple.TupleOffset = 0;
363 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
364 CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
365 link->conf.ConfigBase = parse.config.base;
366 link->conf.Present = parse.config.rmask[0];
369 link->state |= DEV_CONFIG;
371 link->io.IOAddrLines = 16;
372 for (i = j = 0; j < 0x400; j += 0x20) {
373 link->io.BasePort1 = j ^ 0x300;
374 i = pcmcia_request_io(link, &link->io);
375 if (i == CS_SUCCESS) break;
377 if (i != CS_SUCCESS) {
378 cs_error(link, RequestIO, i);
381 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
382 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
384 dev->irq = link->irq.AssignedIRQ;
385 dev->base_addr = link->io.BasePort1;
387 ioaddr = dev->base_addr;
389 /* The 3c574 normally uses an EEPROM for configuration info, including
390 the hardware address. The future products may include a modem chip
391 and put the address in the CIS. */
392 tuple.DesiredTuple = 0x88;
393 if (pcmcia_get_first_tuple(link, &tuple) == CS_SUCCESS) {
394 pcmcia_get_tuple_data(link, &tuple);
395 for (i = 0; i < 3; i++)
396 phys_addr[i] = htons(buf[i]);
399 for (i = 0; i < 3; i++)
400 phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
401 if (phys_addr[0] == 0x6060) {
402 printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
403 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
407 tuple.DesiredTuple = CISTPL_VERS_1;
408 if (pcmcia_get_first_tuple(link, &tuple) == CS_SUCCESS &&
409 pcmcia_get_tuple_data(link, &tuple) == CS_SUCCESS &&
410 pcmcia_parse_tuple(link, &tuple, &parse) == CS_SUCCESS) {
411 cardname = parse.version_1.str + parse.version_1.ofs[1];
413 cardname = "3Com 3c574";
417 outw(2<<11, ioaddr + RunnerRdCtrl);
418 mcr = inb(ioaddr + 2);
419 outw(0<<11, ioaddr + RunnerRdCtrl);
420 printk(KERN_INFO " ASIC rev %d,", mcr>>3);
422 config.i = inl(ioaddr + Wn3_Config);
423 lp->default_media = config.u.xcvr;
424 lp->autoselect = config.u.autoselect;
427 init_timer(&lp->media);
432 /* Roadrunner only: Turn on the MII transceiver */
433 outw(0x8040, ioaddr + Wn3_Options);
435 outw(0xc040, ioaddr + Wn3_Options);
436 tc574_wait_for_completion(dev, TxReset);
437 tc574_wait_for_completion(dev, RxReset);
439 outw(0x8040, ioaddr + Wn3_Options);
442 for (phy = 1; phy <= 32; phy++) {
444 mdio_sync(ioaddr, 32);
445 mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
446 if (mii_status != 0xffff) {
447 lp->phys = phy & 0x1f;
448 DEBUG(0, " MII transceiver at index %d, status %x.\n",
450 if ((mii_status & 0x0040) == 0)
451 mii_preamble_required = 1;
456 printk(KERN_NOTICE " No MII transceivers found!\n");
459 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
460 mdio_write(ioaddr, lp->phys, 16, i);
461 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
463 /* Only advertise the FD media types. */
464 lp->advertising &= ~0x02a0;
465 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
469 link->state &= ~DEV_CONFIG_PENDING;
470 link->dev_node = &lp->node;
471 SET_NETDEV_DEV(dev, &handle_to_dev(link));
473 if (register_netdev(dev) != 0) {
474 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
475 link->dev_node = NULL;
479 strcpy(lp->node.dev_name, dev->name);
481 printk(KERN_INFO "%s: %s at io %#3lx, irq %d, hw_addr ",
482 dev->name, cardname, dev->base_addr, dev->irq);
483 for (i = 0; i < 6; i++)
484 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : ".\n"));
485 printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
486 8 << config.u.ram_size, ram_split[config.u.ram_split],
487 config.u.autoselect ? "autoselect " : "");
492 cs_error(link, last_fn, last_ret);
500 After a card is removed, tc574_release() will unregister the net
501 device, and release the PCMCIA configuration. If the device is
502 still open, this will be postponed until it is closed.
505 static void tc574_release(struct pcmcia_device *link)
507 pcmcia_disable_device(link);
510 static int tc574_suspend(struct pcmcia_device *link)
512 struct net_device *dev = link->priv;
514 if ((link->state & DEV_CONFIG) && (link->open))
515 netif_device_detach(dev);
520 static int tc574_resume(struct pcmcia_device *link)
522 struct net_device *dev = link->priv;
524 if ((link->state & DEV_CONFIG) && (link->open)) {
526 netif_device_attach(dev);
532 static void dump_status(struct net_device *dev)
534 kio_addr_t ioaddr = dev->base_addr;
536 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
537 "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
538 inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
541 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
542 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
543 inw(ioaddr+0x08), inw(ioaddr+0x0a));
548 Use this for commands that may take time to finish
550 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
553 outw(cmd, dev->base_addr + EL3_CMD);
555 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
557 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
560 /* Read a word from the EEPROM using the regular EEPROM access register.
561 Assume that we are in register window zero.
563 static unsigned short read_eeprom(kio_addr_t ioaddr, int index)
566 outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
567 /* Pause for at least 162 usec for the read to take place. */
568 for (timer = 1620; timer >= 0; timer--) {
569 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
572 return inw(ioaddr + Wn0EepromData);
575 /* MII transceiver control section.
576 Read and write the MII registers using software-generated serial
577 MDIO protocol. See the MII specifications or DP83840A data sheet
579 The maxium data clock rate is 2.5 Mhz. The timing is easily met by the
580 slow PC card interface. */
582 #define MDIO_SHIFT_CLK 0x01
583 #define MDIO_DIR_WRITE 0x04
584 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
585 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
586 #define MDIO_DATA_READ 0x02
587 #define MDIO_ENB_IN 0x00
589 /* Generate the preamble required for initial synchronization and
590 a few older transceivers. */
591 static void mdio_sync(kio_addr_t ioaddr, int bits)
593 kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
595 /* Establish sync by sending at least 32 logic ones. */
596 while (-- bits >= 0) {
597 outw(MDIO_DATA_WRITE1, mdio_addr);
598 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
602 static int mdio_read(kio_addr_t ioaddr, int phy_id, int location)
605 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
606 unsigned int retval = 0;
607 kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
609 if (mii_preamble_required)
610 mdio_sync(ioaddr, 32);
612 /* Shift the read command bits out. */
613 for (i = 14; i >= 0; i--) {
614 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
615 outw(dataval, mdio_addr);
616 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
618 /* Read the two transition, 16 data, and wire-idle bits. */
619 for (i = 19; i > 0; i--) {
620 outw(MDIO_ENB_IN, mdio_addr);
621 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
622 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
624 return (retval>>1) & 0xffff;
627 static void mdio_write(kio_addr_t ioaddr, int phy_id, int location, int value)
629 int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
630 kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
633 if (mii_preamble_required)
634 mdio_sync(ioaddr, 32);
636 /* Shift the command bits out. */
637 for (i = 31; i >= 0; i--) {
638 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
639 outw(dataval, mdio_addr);
640 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
642 /* Leave the interface idle. */
643 for (i = 1; i >= 0; i--) {
644 outw(MDIO_ENB_IN, mdio_addr);
645 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
651 /* Reset and restore all of the 3c574 registers. */
652 static void tc574_reset(struct net_device *dev)
654 struct el3_private *lp = netdev_priv(dev);
656 kio_addr_t ioaddr = dev->base_addr;
659 tc574_wait_for_completion(dev, TotalReset|0x10);
661 spin_lock_irqsave(&lp->window_lock, flags);
662 /* Clear any transactions in progress. */
663 outw(0, ioaddr + RunnerWrCtrl);
664 outw(0, ioaddr + RunnerRdCtrl);
666 /* Set the station address and mask. */
668 for (i = 0; i < 6; i++)
669 outb(dev->dev_addr[i], ioaddr + i);
673 /* Reset config options */
675 outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
676 outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
677 ioaddr + Wn3_Config);
678 /* Roadrunner only: Turn on the MII transceiver. */
679 outw(0x8040, ioaddr + Wn3_Options);
681 outw(0xc040, ioaddr + Wn3_Options);
683 spin_unlock_irqrestore(&lp->window_lock, flags);
685 tc574_wait_for_completion(dev, TxReset);
686 tc574_wait_for_completion(dev, RxReset);
688 spin_lock_irqsave(&lp->window_lock, flags);
690 outw(0x8040, ioaddr + Wn3_Options);
692 /* Switch to the stats window, and clear all stats by reading. */
693 outw(StatsDisable, ioaddr + EL3_CMD);
695 for (i = 0; i < 10; i++)
703 /* .. enable any extra statistics bits.. */
704 outw(0x0040, ioaddr + Wn4_NetDiag);
707 spin_unlock_irqrestore(&lp->window_lock, flags);
709 /* .. re-sync MII and re-fill what NWay is advertising. */
710 mdio_sync(ioaddr, 32);
711 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
712 if (!auto_polarity) {
713 /* works for TDK 78Q2120 series MII's */
714 int i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
715 mdio_write(ioaddr, lp->phys, 16, i);
718 spin_lock_irqsave(&lp->window_lock, flags);
719 /* Switch to register set 1 for normal use, just for TxFree. */
721 spin_unlock_irqrestore(&lp->window_lock, flags);
722 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
723 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
724 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
725 /* Allow status bits to be seen. */
726 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
727 /* Ack all pending events, and set active indicator mask. */
728 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
730 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
731 | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
734 static int el3_open(struct net_device *dev)
736 struct el3_private *lp = netdev_priv(dev);
737 struct pcmcia_device *link = lp->p_dev;
743 netif_start_queue(dev);
746 lp->media.function = &media_check;
747 lp->media.data = (unsigned long) dev;
748 lp->media.expires = jiffies + HZ;
749 add_timer(&lp->media);
751 DEBUG(2, "%s: opened, status %4.4x.\n",
752 dev->name, inw(dev->base_addr + EL3_STATUS));
757 static void el3_tx_timeout(struct net_device *dev)
759 struct el3_private *lp = netdev_priv(dev);
760 kio_addr_t ioaddr = dev->base_addr;
762 printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
764 lp->stats.tx_errors++;
765 dev->trans_start = jiffies;
766 /* Issue TX_RESET and TX_START commands. */
767 tc574_wait_for_completion(dev, TxReset);
768 outw(TxEnable, ioaddr + EL3_CMD);
769 netif_wake_queue(dev);
772 static void pop_tx_status(struct net_device *dev)
774 struct el3_private *lp = netdev_priv(dev);
775 kio_addr_t ioaddr = dev->base_addr;
778 /* Clear the Tx status stack. */
779 for (i = 32; i > 0; i--) {
780 u_char tx_status = inb(ioaddr + TxStatus);
781 if (!(tx_status & 0x84))
783 /* reset transmitter on jabber error or underrun */
784 if (tx_status & 0x30)
785 tc574_wait_for_completion(dev, TxReset);
786 if (tx_status & 0x38) {
787 DEBUG(1, "%s: transmit error: status 0x%02x\n",
788 dev->name, tx_status);
789 outw(TxEnable, ioaddr + EL3_CMD);
790 lp->stats.tx_aborted_errors++;
792 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
796 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
798 kio_addr_t ioaddr = dev->base_addr;
799 struct el3_private *lp = netdev_priv(dev);
802 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
803 "status %4.4x.\n", dev->name, (long)skb->len,
804 inw(ioaddr + EL3_STATUS));
806 spin_lock_irqsave(&lp->window_lock, flags);
807 outw(skb->len, ioaddr + TX_FIFO);
808 outw(0, ioaddr + TX_FIFO);
809 outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
811 dev->trans_start = jiffies;
813 /* TxFree appears only in Window 1, not offset 0x1c. */
814 if (inw(ioaddr + TxFree) <= 1536) {
815 netif_stop_queue(dev);
816 /* Interrupt us when the FIFO has room for max-sized packet.
817 The threshold is in units of dwords. */
818 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
822 spin_unlock_irqrestore(&lp->window_lock, flags);
827 /* The EL3 interrupt handler. */
828 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
830 struct net_device *dev = (struct net_device *) dev_id;
831 struct el3_private *lp = netdev_priv(dev);
834 int work_budget = max_interrupt_work;
837 if (!netif_device_present(dev))
839 ioaddr = dev->base_addr;
841 DEBUG(3, "%s: interrupt, status %4.4x.\n",
842 dev->name, inw(ioaddr + EL3_STATUS));
844 spin_lock(&lp->window_lock);
846 while ((status = inw(ioaddr + EL3_STATUS)) &
847 (IntLatch | RxComplete | RxEarly | StatsFull)) {
848 if (!netif_device_present(dev) ||
849 ((status & 0xe000) != 0x2000)) {
850 DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
856 if (status & RxComplete)
857 work_budget = el3_rx(dev, work_budget);
859 if (status & TxAvailable) {
860 DEBUG(3, " TX room bit was handled.\n");
861 /* There's room in the FIFO for a full-sized packet. */
862 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
863 netif_wake_queue(dev);
866 if (status & TxComplete)
869 if (status & (AdapterFailure | RxEarly | StatsFull)) {
870 /* Handle all uncommon interrupts. */
871 if (status & StatsFull)
873 if (status & RxEarly) {
874 work_budget = el3_rx(dev, work_budget);
875 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
877 if (status & AdapterFailure) {
880 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
882 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
883 " register %04x.\n", dev->name, fifo_diag);
884 if (fifo_diag & 0x0400) {
886 tc574_wait_for_completion(dev, TxReset);
887 outw(TxEnable, ioaddr + EL3_CMD);
889 if (fifo_diag & 0x2000) {
891 tc574_wait_for_completion(dev, RxReset);
893 outw(RxEnable, ioaddr + EL3_CMD);
895 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
899 if (--work_budget < 0) {
900 DEBUG(0, "%s: Too much work in interrupt, "
901 "status %4.4x.\n", dev->name, status);
902 /* Clear all interrupts */
903 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
906 /* Acknowledge the IRQ. */
907 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
910 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
911 dev->name, inw(ioaddr + EL3_STATUS));
913 spin_unlock(&lp->window_lock);
914 return IRQ_RETVAL(handled);
918 This timer serves two purposes: to check for missed interrupts
919 (and as a last resort, poll the NIC for events), and to monitor
920 the MII, reporting changes in cable status.
922 static void media_check(unsigned long arg)
924 struct net_device *dev = (struct net_device *) arg;
925 struct el3_private *lp = netdev_priv(dev);
926 kio_addr_t ioaddr = dev->base_addr;
928 unsigned short /* cable, */ media, partner;
930 if (!netif_device_present(dev))
933 /* Check for pending interrupt with expired latency timer: with
934 this, we can limp along even if the interrupt is blocked */
935 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
937 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
938 el3_interrupt(dev->irq, lp, NULL);
943 lp->media.expires = jiffies + 2*HZ/100;
944 add_timer(&lp->media);
948 spin_lock_irqsave(&lp->window_lock, flags);
950 media = mdio_read(ioaddr, lp->phys, 1);
951 partner = mdio_read(ioaddr, lp->phys, 5);
954 if (media != lp->media_status) {
955 if ((media ^ lp->media_status) & 0x0004)
956 printk(KERN_INFO "%s: %s link beat\n", dev->name,
957 (lp->media_status & 0x0004) ? "lost" : "found");
958 if ((media ^ lp->media_status) & 0x0020) {
960 if (lp->media_status & 0x0020) {
961 printk(KERN_INFO "%s: autonegotiation restarted\n",
963 } else if (partner) {
964 partner &= lp->advertising;
965 lp->partner = partner;
966 printk(KERN_INFO "%s: autonegotiation complete: "
967 "%sbaseT-%cD selected\n", dev->name,
968 ((partner & 0x0180) ? "100" : "10"),
969 ((partner & 0x0140) ? 'F' : 'H'));
971 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
976 outb((partner & 0x0140 ? 0x20 : 0) |
977 (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
982 printk(KERN_INFO "%s: remote fault detected\n",
985 printk(KERN_INFO "%s: jabber detected\n", dev->name);
986 lp->media_status = media;
988 spin_unlock_irqrestore(&lp->window_lock, flags);
991 lp->media.expires = jiffies + HZ;
992 add_timer(&lp->media);
995 static struct net_device_stats *el3_get_stats(struct net_device *dev)
997 struct el3_private *lp = netdev_priv(dev);
999 if (netif_device_present(dev)) {
1000 unsigned long flags;
1001 spin_lock_irqsave(&lp->window_lock, flags);
1003 spin_unlock_irqrestore(&lp->window_lock, flags);
1008 /* Update statistics.
1009 Suprisingly this need not be run single-threaded, but it effectively is.
1010 The counters clear when read, so the adds must merely be atomic.
1012 static void update_stats(struct net_device *dev)
1014 struct el3_private *lp = netdev_priv(dev);
1015 kio_addr_t ioaddr = dev->base_addr;
1018 DEBUG(2, "%s: updating the statistics.\n", dev->name);
1020 if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1023 /* Unlike the 3c509 we need not turn off stats updates while reading. */
1024 /* Switch to the stats window, and read everything. */
1026 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
1027 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1028 /* Multiple collisions. */ inb(ioaddr + 2);
1029 lp->stats.collisions += inb(ioaddr + 3);
1030 lp->stats.tx_window_errors += inb(ioaddr + 4);
1031 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
1032 lp->stats.tx_packets += inb(ioaddr + 6);
1033 up = inb(ioaddr + 9);
1034 lp->stats.tx_packets += (up&0x30) << 4;
1035 /* Rx packets */ inb(ioaddr + 7);
1036 /* Tx deferrals */ inb(ioaddr + 8);
1037 rx = inw(ioaddr + 10);
1038 tx = inw(ioaddr + 12);
1041 /* BadSSD */ inb(ioaddr + 12);
1042 up = inb(ioaddr + 13);
1044 lp->stats.tx_bytes += tx + ((up & 0xf0) << 12);
1049 static int el3_rx(struct net_device *dev, int worklimit)
1051 struct el3_private *lp = netdev_priv(dev);
1052 kio_addr_t ioaddr = dev->base_addr;
1055 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1056 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1057 while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1058 (--worklimit >= 0)) {
1059 if (rx_status & 0x4000) { /* Error, update stats. */
1060 short error = rx_status & 0x3800;
1061 lp->stats.rx_errors++;
1063 case 0x0000: lp->stats.rx_over_errors++; break;
1064 case 0x0800: lp->stats.rx_length_errors++; break;
1065 case 0x1000: lp->stats.rx_frame_errors++; break;
1066 case 0x1800: lp->stats.rx_length_errors++; break;
1067 case 0x2000: lp->stats.rx_frame_errors++; break;
1068 case 0x2800: lp->stats.rx_crc_errors++; break;
1071 short pkt_len = rx_status & 0x7ff;
1072 struct sk_buff *skb;
1074 skb = dev_alloc_skb(pkt_len+5);
1076 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
1077 pkt_len, rx_status);
1080 skb_reserve(skb, 2);
1081 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1083 skb->protocol = eth_type_trans(skb, dev);
1085 dev->last_rx = jiffies;
1086 lp->stats.rx_packets++;
1087 lp->stats.rx_bytes += pkt_len;
1089 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1090 " size %d.\n", dev->name, pkt_len);
1091 lp->stats.rx_dropped++;
1094 tc574_wait_for_completion(dev, RxDiscard);
1100 static void netdev_get_drvinfo(struct net_device *dev,
1101 struct ethtool_drvinfo *info)
1103 strcpy(info->driver, "3c574_cs");
1106 static struct ethtool_ops netdev_ethtool_ops = {
1107 .get_drvinfo = netdev_get_drvinfo,
1110 /* Provide ioctl() calls to examine the MII xcvr state. */
1111 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1113 struct el3_private *lp = netdev_priv(dev);
1114 kio_addr_t ioaddr = dev->base_addr;
1115 u16 *data = (u16 *)&rq->ifr_ifru;
1116 int phy = lp->phys & 0x1f;
1118 DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1119 dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1120 data[0], data[1], data[2], data[3]);
1123 case SIOCGMIIPHY: /* Get the address of the PHY in use. */
1125 case SIOCGMIIREG: /* Read the specified MII register. */
1128 unsigned long flags;
1130 spin_lock_irqsave(&lp->window_lock, flags);
1131 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1133 data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1134 EL3WINDOW(saved_window);
1135 spin_unlock_irqrestore(&lp->window_lock, flags);
1138 case SIOCSMIIREG: /* Write the specified MII register */
1141 unsigned long flags;
1143 if (!capable(CAP_NET_ADMIN))
1145 spin_lock_irqsave(&lp->window_lock, flags);
1146 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1148 mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1149 EL3WINDOW(saved_window);
1150 spin_unlock_irqrestore(&lp->window_lock, flags);
1158 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1159 documented. Until it is we revert to receiving all multicast frames when
1160 any multicast reception is desired.
1161 Note: My other drivers emit a log message whenever promiscuous mode is
1162 entered to help detect password sniffers. This is less desirable on
1163 typical PC card machines, so we omit the message.
1166 static void set_rx_mode(struct net_device *dev)
1168 kio_addr_t ioaddr = dev->base_addr;
1170 if (dev->flags & IFF_PROMISC)
1171 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1173 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1174 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1176 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1179 static int el3_close(struct net_device *dev)
1181 kio_addr_t ioaddr = dev->base_addr;
1182 struct el3_private *lp = netdev_priv(dev);
1183 struct pcmcia_device *link = lp->p_dev;
1185 DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1188 unsigned long flags;
1190 /* Turn off statistics ASAP. We update lp->stats below. */
1191 outw(StatsDisable, ioaddr + EL3_CMD);
1193 /* Disable the receiver and transmitter. */
1194 outw(RxDisable, ioaddr + EL3_CMD);
1195 outw(TxDisable, ioaddr + EL3_CMD);
1197 /* Note: Switching to window 0 may disable the IRQ. */
1199 spin_lock_irqsave(&lp->window_lock, flags);
1201 spin_unlock_irqrestore(&lp->window_lock, flags);
1203 /* force interrupts off */
1204 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1208 netif_stop_queue(dev);
1209 del_timer_sync(&lp->media);
1214 static struct pcmcia_device_id tc574_ids[] = {
1215 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1216 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "3CCFEM556.cis"),
1219 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1221 static struct pcmcia_driver tc574_driver = {
1222 .owner = THIS_MODULE,
1226 .probe = tc574_attach,
1227 .remove = tc574_detach,
1228 .id_table = tc574_ids,
1229 .suspend = tc574_suspend,
1230 .resume = tc574_resume,
1233 static int __init init_tc574(void)
1235 return pcmcia_register_driver(&tc574_driver);
1238 static void __exit exit_tc574(void)
1240 pcmcia_unregister_driver(&tc574_driver);
1243 module_init(init_tc574);
1244 module_exit(exit_tc574);