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. */
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(dev_link_t *link);
229 static void tc574_release(dev_link_t *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 *p_dev)
261 struct el3_private *lp;
263 struct net_device *dev;
265 DEBUG(0, "3c574_attach()\n");
267 /* Create the PC card device object. */
268 dev = alloc_etherdev(sizeof(struct el3_private));
271 lp = netdev_priv(dev);
275 spin_lock_init(&lp->window_lock);
276 link->io.NumPorts1 = 32;
277 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
278 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
279 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
280 link->irq.Handler = &el3_interrupt;
281 link->irq.Instance = dev;
282 link->conf.Attributes = CONF_ENABLE_IRQ;
284 link->conf.IntType = INT_MEMORY_AND_IO;
285 link->conf.ConfigIndex = 1;
286 link->conf.Present = PRESENT_OPTION;
288 /* The EL3-specific entries in the device structure. */
289 dev->hard_start_xmit = &el3_start_xmit;
290 dev->get_stats = &el3_get_stats;
291 dev->do_ioctl = &el3_ioctl;
292 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
293 dev->set_multicast_list = &set_rx_mode;
294 dev->open = &el3_open;
295 dev->stop = &el3_close;
296 #ifdef HAVE_TX_TIMEOUT
297 dev->tx_timeout = el3_tx_timeout;
298 dev->watchdog_timeo = TX_TIMEOUT;
301 link->handle = p_dev;
302 p_dev->instance = link;
304 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
312 This deletes a driver "instance". The device is de-registered
313 with Card Services. If it has been released, all local data
314 structures are freed. Otherwise, the structures will be freed
315 when the device is released.
319 static void tc574_detach(struct pcmcia_device *p_dev)
321 dev_link_t *link = dev_to_instance(p_dev);
322 struct net_device *dev = link->priv;
324 DEBUG(0, "3c574_detach(0x%p)\n", link);
327 unregister_netdev(dev);
329 if (link->state & DEV_CONFIG)
336 tc574_config() is scheduled to run after a CARD_INSERTION event
337 is received, to configure the PCMCIA socket, and to make the
338 ethernet device available to the system.
341 #define CS_CHECK(fn, ret) \
342 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
344 static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
346 static void tc574_config(dev_link_t *link)
348 client_handle_t handle = link->handle;
349 struct net_device *dev = link->priv;
350 struct el3_private *lp = netdev_priv(dev);
353 unsigned short buf[32];
354 int last_fn, last_ret, i, j;
358 union wn3_config config;
360 phys_addr = (u16 *)dev->dev_addr;
362 DEBUG(0, "3c574_config(0x%p)\n", link);
364 tuple.Attributes = 0;
365 tuple.DesiredTuple = CISTPL_CONFIG;
366 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
367 tuple.TupleData = (cisdata_t *)buf;
368 tuple.TupleDataMax = 64;
369 tuple.TupleOffset = 0;
370 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
371 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
372 link->conf.ConfigBase = parse.config.base;
373 link->conf.Present = parse.config.rmask[0];
376 link->state |= DEV_CONFIG;
378 link->io.IOAddrLines = 16;
379 for (i = j = 0; j < 0x400; j += 0x20) {
380 link->io.BasePort1 = j ^ 0x300;
381 i = pcmcia_request_io(link->handle, &link->io);
382 if (i == CS_SUCCESS) break;
384 if (i != CS_SUCCESS) {
385 cs_error(link->handle, RequestIO, i);
388 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
389 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
391 dev->irq = link->irq.AssignedIRQ;
392 dev->base_addr = link->io.BasePort1;
394 ioaddr = dev->base_addr;
396 /* The 3c574 normally uses an EEPROM for configuration info, including
397 the hardware address. The future products may include a modem chip
398 and put the address in the CIS. */
399 tuple.DesiredTuple = 0x88;
400 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) {
401 pcmcia_get_tuple_data(handle, &tuple);
402 for (i = 0; i < 3; i++)
403 phys_addr[i] = htons(buf[i]);
406 for (i = 0; i < 3; i++)
407 phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
408 if (phys_addr[0] == 0x6060) {
409 printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
410 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
414 tuple.DesiredTuple = CISTPL_VERS_1;
415 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS &&
416 pcmcia_get_tuple_data(handle, &tuple) == CS_SUCCESS &&
417 pcmcia_parse_tuple(handle, &tuple, &parse) == CS_SUCCESS) {
418 cardname = parse.version_1.str + parse.version_1.ofs[1];
420 cardname = "3Com 3c574";
424 outw(2<<11, ioaddr + RunnerRdCtrl);
425 mcr = inb(ioaddr + 2);
426 outw(0<<11, ioaddr + RunnerRdCtrl);
427 printk(KERN_INFO " ASIC rev %d,", mcr>>3);
429 config.i = inl(ioaddr + Wn3_Config);
430 lp->default_media = config.u.xcvr;
431 lp->autoselect = config.u.autoselect;
434 init_timer(&lp->media);
439 /* Roadrunner only: Turn on the MII transceiver */
440 outw(0x8040, ioaddr + Wn3_Options);
442 outw(0xc040, ioaddr + Wn3_Options);
443 tc574_wait_for_completion(dev, TxReset);
444 tc574_wait_for_completion(dev, RxReset);
446 outw(0x8040, ioaddr + Wn3_Options);
449 for (phy = 1; phy <= 32; phy++) {
451 mdio_sync(ioaddr, 32);
452 mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
453 if (mii_status != 0xffff) {
454 lp->phys = phy & 0x1f;
455 DEBUG(0, " MII transceiver at index %d, status %x.\n",
457 if ((mii_status & 0x0040) == 0)
458 mii_preamble_required = 1;
463 printk(KERN_NOTICE " No MII transceivers found!\n");
466 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
467 mdio_write(ioaddr, lp->phys, 16, i);
468 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
470 /* Only advertise the FD media types. */
471 lp->advertising &= ~0x02a0;
472 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
476 link->state &= ~DEV_CONFIG_PENDING;
477 link->dev = &lp->node;
478 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
480 if (register_netdev(dev) != 0) {
481 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
486 strcpy(lp->node.dev_name, dev->name);
488 printk(KERN_INFO "%s: %s at io %#3lx, irq %d, hw_addr ",
489 dev->name, cardname, dev->base_addr, dev->irq);
490 for (i = 0; i < 6; i++)
491 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : ".\n"));
492 printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
493 8 << config.u.ram_size, ram_split[config.u.ram_split],
494 config.u.autoselect ? "autoselect " : "");
499 cs_error(link->handle, last_fn, last_ret);
507 After a card is removed, tc574_release() will unregister the net
508 device, and release the PCMCIA configuration. If the device is
509 still open, this will be postponed until it is closed.
512 static void tc574_release(dev_link_t *link)
514 pcmcia_disable_device(link->handle);
517 static int tc574_suspend(struct pcmcia_device *p_dev)
519 dev_link_t *link = dev_to_instance(p_dev);
520 struct net_device *dev = link->priv;
522 if ((link->state & DEV_CONFIG) && (link->open))
523 netif_device_detach(dev);
528 static int tc574_resume(struct pcmcia_device *p_dev)
530 dev_link_t *link = dev_to_instance(p_dev);
531 struct net_device *dev = link->priv;
533 if ((link->state & DEV_CONFIG) && (link->open)) {
535 netif_device_attach(dev);
541 static void dump_status(struct net_device *dev)
543 kio_addr_t ioaddr = dev->base_addr;
545 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
546 "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
547 inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
550 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
551 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
552 inw(ioaddr+0x08), inw(ioaddr+0x0a));
557 Use this for commands that may take time to finish
559 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
562 outw(cmd, dev->base_addr + EL3_CMD);
564 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
566 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
569 /* Read a word from the EEPROM using the regular EEPROM access register.
570 Assume that we are in register window zero.
572 static unsigned short read_eeprom(kio_addr_t ioaddr, int index)
575 outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
576 /* Pause for at least 162 usec for the read to take place. */
577 for (timer = 1620; timer >= 0; timer--) {
578 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
581 return inw(ioaddr + Wn0EepromData);
584 /* MII transceiver control section.
585 Read and write the MII registers using software-generated serial
586 MDIO protocol. See the MII specifications or DP83840A data sheet
588 The maxium data clock rate is 2.5 Mhz. The timing is easily met by the
589 slow PC card interface. */
591 #define MDIO_SHIFT_CLK 0x01
592 #define MDIO_DIR_WRITE 0x04
593 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
594 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
595 #define MDIO_DATA_READ 0x02
596 #define MDIO_ENB_IN 0x00
598 /* Generate the preamble required for initial synchronization and
599 a few older transceivers. */
600 static void mdio_sync(kio_addr_t ioaddr, int bits)
602 kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
604 /* Establish sync by sending at least 32 logic ones. */
605 while (-- bits >= 0) {
606 outw(MDIO_DATA_WRITE1, mdio_addr);
607 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
611 static int mdio_read(kio_addr_t ioaddr, int phy_id, int location)
614 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
615 unsigned int retval = 0;
616 kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
618 if (mii_preamble_required)
619 mdio_sync(ioaddr, 32);
621 /* Shift the read command bits out. */
622 for (i = 14; i >= 0; i--) {
623 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
624 outw(dataval, mdio_addr);
625 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
627 /* Read the two transition, 16 data, and wire-idle bits. */
628 for (i = 19; i > 0; i--) {
629 outw(MDIO_ENB_IN, mdio_addr);
630 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
631 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
633 return (retval>>1) & 0xffff;
636 static void mdio_write(kio_addr_t ioaddr, int phy_id, int location, int value)
638 int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
639 kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
642 if (mii_preamble_required)
643 mdio_sync(ioaddr, 32);
645 /* Shift the command bits out. */
646 for (i = 31; i >= 0; i--) {
647 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
648 outw(dataval, mdio_addr);
649 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
651 /* Leave the interface idle. */
652 for (i = 1; i >= 0; i--) {
653 outw(MDIO_ENB_IN, mdio_addr);
654 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
660 /* Reset and restore all of the 3c574 registers. */
661 static void tc574_reset(struct net_device *dev)
663 struct el3_private *lp = netdev_priv(dev);
665 kio_addr_t ioaddr = dev->base_addr;
668 tc574_wait_for_completion(dev, TotalReset|0x10);
670 spin_lock_irqsave(&lp->window_lock, flags);
671 /* Clear any transactions in progress. */
672 outw(0, ioaddr + RunnerWrCtrl);
673 outw(0, ioaddr + RunnerRdCtrl);
675 /* Set the station address and mask. */
677 for (i = 0; i < 6; i++)
678 outb(dev->dev_addr[i], ioaddr + i);
682 /* Reset config options */
684 outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
685 outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
686 ioaddr + Wn3_Config);
687 /* Roadrunner only: Turn on the MII transceiver. */
688 outw(0x8040, ioaddr + Wn3_Options);
690 outw(0xc040, ioaddr + Wn3_Options);
692 spin_unlock_irqrestore(&lp->window_lock, flags);
694 tc574_wait_for_completion(dev, TxReset);
695 tc574_wait_for_completion(dev, RxReset);
697 spin_lock_irqsave(&lp->window_lock, flags);
699 outw(0x8040, ioaddr + Wn3_Options);
701 /* Switch to the stats window, and clear all stats by reading. */
702 outw(StatsDisable, ioaddr + EL3_CMD);
704 for (i = 0; i < 10; i++)
712 /* .. enable any extra statistics bits.. */
713 outw(0x0040, ioaddr + Wn4_NetDiag);
716 spin_unlock_irqrestore(&lp->window_lock, flags);
718 /* .. re-sync MII and re-fill what NWay is advertising. */
719 mdio_sync(ioaddr, 32);
720 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
721 if (!auto_polarity) {
722 /* works for TDK 78Q2120 series MII's */
723 int i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
724 mdio_write(ioaddr, lp->phys, 16, i);
727 spin_lock_irqsave(&lp->window_lock, flags);
728 /* Switch to register set 1 for normal use, just for TxFree. */
730 spin_unlock_irqrestore(&lp->window_lock, flags);
731 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
732 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
733 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
734 /* Allow status bits to be seen. */
735 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
736 /* Ack all pending events, and set active indicator mask. */
737 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
739 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
740 | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
743 static int el3_open(struct net_device *dev)
745 struct el3_private *lp = netdev_priv(dev);
746 dev_link_t *link = &lp->link;
752 netif_start_queue(dev);
755 lp->media.function = &media_check;
756 lp->media.data = (unsigned long) dev;
757 lp->media.expires = jiffies + HZ;
758 add_timer(&lp->media);
760 DEBUG(2, "%s: opened, status %4.4x.\n",
761 dev->name, inw(dev->base_addr + EL3_STATUS));
766 static void el3_tx_timeout(struct net_device *dev)
768 struct el3_private *lp = netdev_priv(dev);
769 kio_addr_t ioaddr = dev->base_addr;
771 printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
773 lp->stats.tx_errors++;
774 dev->trans_start = jiffies;
775 /* Issue TX_RESET and TX_START commands. */
776 tc574_wait_for_completion(dev, TxReset);
777 outw(TxEnable, ioaddr + EL3_CMD);
778 netif_wake_queue(dev);
781 static void pop_tx_status(struct net_device *dev)
783 struct el3_private *lp = netdev_priv(dev);
784 kio_addr_t ioaddr = dev->base_addr;
787 /* Clear the Tx status stack. */
788 for (i = 32; i > 0; i--) {
789 u_char tx_status = inb(ioaddr + TxStatus);
790 if (!(tx_status & 0x84))
792 /* reset transmitter on jabber error or underrun */
793 if (tx_status & 0x30)
794 tc574_wait_for_completion(dev, TxReset);
795 if (tx_status & 0x38) {
796 DEBUG(1, "%s: transmit error: status 0x%02x\n",
797 dev->name, tx_status);
798 outw(TxEnable, ioaddr + EL3_CMD);
799 lp->stats.tx_aborted_errors++;
801 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
805 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
807 kio_addr_t ioaddr = dev->base_addr;
808 struct el3_private *lp = netdev_priv(dev);
811 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
812 "status %4.4x.\n", dev->name, (long)skb->len,
813 inw(ioaddr + EL3_STATUS));
815 spin_lock_irqsave(&lp->window_lock, flags);
816 outw(skb->len, ioaddr + TX_FIFO);
817 outw(0, ioaddr + TX_FIFO);
818 outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
820 dev->trans_start = jiffies;
822 /* TxFree appears only in Window 1, not offset 0x1c. */
823 if (inw(ioaddr + TxFree) <= 1536) {
824 netif_stop_queue(dev);
825 /* Interrupt us when the FIFO has room for max-sized packet.
826 The threshold is in units of dwords. */
827 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
831 spin_unlock_irqrestore(&lp->window_lock, flags);
836 /* The EL3 interrupt handler. */
837 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
839 struct net_device *dev = (struct net_device *) dev_id;
840 struct el3_private *lp = netdev_priv(dev);
843 int work_budget = max_interrupt_work;
846 if (!netif_device_present(dev))
848 ioaddr = dev->base_addr;
850 DEBUG(3, "%s: interrupt, status %4.4x.\n",
851 dev->name, inw(ioaddr + EL3_STATUS));
853 spin_lock(&lp->window_lock);
855 while ((status = inw(ioaddr + EL3_STATUS)) &
856 (IntLatch | RxComplete | RxEarly | StatsFull)) {
857 if (!netif_device_present(dev) ||
858 ((status & 0xe000) != 0x2000)) {
859 DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
865 if (status & RxComplete)
866 work_budget = el3_rx(dev, work_budget);
868 if (status & TxAvailable) {
869 DEBUG(3, " TX room bit was handled.\n");
870 /* There's room in the FIFO for a full-sized packet. */
871 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
872 netif_wake_queue(dev);
875 if (status & TxComplete)
878 if (status & (AdapterFailure | RxEarly | StatsFull)) {
879 /* Handle all uncommon interrupts. */
880 if (status & StatsFull)
882 if (status & RxEarly) {
883 work_budget = el3_rx(dev, work_budget);
884 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
886 if (status & AdapterFailure) {
889 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
891 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
892 " register %04x.\n", dev->name, fifo_diag);
893 if (fifo_diag & 0x0400) {
895 tc574_wait_for_completion(dev, TxReset);
896 outw(TxEnable, ioaddr + EL3_CMD);
898 if (fifo_diag & 0x2000) {
900 tc574_wait_for_completion(dev, RxReset);
902 outw(RxEnable, ioaddr + EL3_CMD);
904 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
908 if (--work_budget < 0) {
909 DEBUG(0, "%s: Too much work in interrupt, "
910 "status %4.4x.\n", dev->name, status);
911 /* Clear all interrupts */
912 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
915 /* Acknowledge the IRQ. */
916 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
919 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
920 dev->name, inw(ioaddr + EL3_STATUS));
922 spin_unlock(&lp->window_lock);
923 return IRQ_RETVAL(handled);
927 This timer serves two purposes: to check for missed interrupts
928 (and as a last resort, poll the NIC for events), and to monitor
929 the MII, reporting changes in cable status.
931 static void media_check(unsigned long arg)
933 struct net_device *dev = (struct net_device *) arg;
934 struct el3_private *lp = netdev_priv(dev);
935 kio_addr_t ioaddr = dev->base_addr;
937 unsigned short /* cable, */ media, partner;
939 if (!netif_device_present(dev))
942 /* Check for pending interrupt with expired latency timer: with
943 this, we can limp along even if the interrupt is blocked */
944 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
946 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
947 el3_interrupt(dev->irq, lp, NULL);
952 lp->media.expires = jiffies + 2*HZ/100;
953 add_timer(&lp->media);
957 spin_lock_irqsave(&lp->window_lock, flags);
959 media = mdio_read(ioaddr, lp->phys, 1);
960 partner = mdio_read(ioaddr, lp->phys, 5);
963 if (media != lp->media_status) {
964 if ((media ^ lp->media_status) & 0x0004)
965 printk(KERN_INFO "%s: %s link beat\n", dev->name,
966 (lp->media_status & 0x0004) ? "lost" : "found");
967 if ((media ^ lp->media_status) & 0x0020) {
969 if (lp->media_status & 0x0020) {
970 printk(KERN_INFO "%s: autonegotiation restarted\n",
972 } else if (partner) {
973 partner &= lp->advertising;
974 lp->partner = partner;
975 printk(KERN_INFO "%s: autonegotiation complete: "
976 "%sbaseT-%cD selected\n", dev->name,
977 ((partner & 0x0180) ? "100" : "10"),
978 ((partner & 0x0140) ? 'F' : 'H'));
980 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
985 outb((partner & 0x0140 ? 0x20 : 0) |
986 (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
991 printk(KERN_INFO "%s: remote fault detected\n",
994 printk(KERN_INFO "%s: jabber detected\n", dev->name);
995 lp->media_status = media;
997 spin_unlock_irqrestore(&lp->window_lock, flags);
1000 lp->media.expires = jiffies + HZ;
1001 add_timer(&lp->media);
1004 static struct net_device_stats *el3_get_stats(struct net_device *dev)
1006 struct el3_private *lp = netdev_priv(dev);
1008 if (netif_device_present(dev)) {
1009 unsigned long flags;
1010 spin_lock_irqsave(&lp->window_lock, flags);
1012 spin_unlock_irqrestore(&lp->window_lock, flags);
1017 /* Update statistics.
1018 Suprisingly this need not be run single-threaded, but it effectively is.
1019 The counters clear when read, so the adds must merely be atomic.
1021 static void update_stats(struct net_device *dev)
1023 struct el3_private *lp = netdev_priv(dev);
1024 kio_addr_t ioaddr = dev->base_addr;
1027 DEBUG(2, "%s: updating the statistics.\n", dev->name);
1029 if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1032 /* Unlike the 3c509 we need not turn off stats updates while reading. */
1033 /* Switch to the stats window, and read everything. */
1035 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
1036 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1037 /* Multiple collisions. */ inb(ioaddr + 2);
1038 lp->stats.collisions += inb(ioaddr + 3);
1039 lp->stats.tx_window_errors += inb(ioaddr + 4);
1040 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
1041 lp->stats.tx_packets += inb(ioaddr + 6);
1042 up = inb(ioaddr + 9);
1043 lp->stats.tx_packets += (up&0x30) << 4;
1044 /* Rx packets */ inb(ioaddr + 7);
1045 /* Tx deferrals */ inb(ioaddr + 8);
1046 rx = inw(ioaddr + 10);
1047 tx = inw(ioaddr + 12);
1050 /* BadSSD */ inb(ioaddr + 12);
1051 up = inb(ioaddr + 13);
1053 lp->stats.tx_bytes += tx + ((up & 0xf0) << 12);
1058 static int el3_rx(struct net_device *dev, int worklimit)
1060 struct el3_private *lp = netdev_priv(dev);
1061 kio_addr_t ioaddr = dev->base_addr;
1064 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1065 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1066 while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1067 (--worklimit >= 0)) {
1068 if (rx_status & 0x4000) { /* Error, update stats. */
1069 short error = rx_status & 0x3800;
1070 lp->stats.rx_errors++;
1072 case 0x0000: lp->stats.rx_over_errors++; break;
1073 case 0x0800: lp->stats.rx_length_errors++; break;
1074 case 0x1000: lp->stats.rx_frame_errors++; break;
1075 case 0x1800: lp->stats.rx_length_errors++; break;
1076 case 0x2000: lp->stats.rx_frame_errors++; break;
1077 case 0x2800: lp->stats.rx_crc_errors++; break;
1080 short pkt_len = rx_status & 0x7ff;
1081 struct sk_buff *skb;
1083 skb = dev_alloc_skb(pkt_len+5);
1085 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
1086 pkt_len, rx_status);
1089 skb_reserve(skb, 2);
1090 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1092 skb->protocol = eth_type_trans(skb, dev);
1094 dev->last_rx = jiffies;
1095 lp->stats.rx_packets++;
1096 lp->stats.rx_bytes += pkt_len;
1098 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1099 " size %d.\n", dev->name, pkt_len);
1100 lp->stats.rx_dropped++;
1103 tc574_wait_for_completion(dev, RxDiscard);
1109 static void netdev_get_drvinfo(struct net_device *dev,
1110 struct ethtool_drvinfo *info)
1112 strcpy(info->driver, "3c574_cs");
1115 static struct ethtool_ops netdev_ethtool_ops = {
1116 .get_drvinfo = netdev_get_drvinfo,
1119 /* Provide ioctl() calls to examine the MII xcvr state. */
1120 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1122 struct el3_private *lp = netdev_priv(dev);
1123 kio_addr_t ioaddr = dev->base_addr;
1124 u16 *data = (u16 *)&rq->ifr_ifru;
1125 int phy = lp->phys & 0x1f;
1127 DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1128 dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1129 data[0], data[1], data[2], data[3]);
1132 case SIOCGMIIPHY: /* Get the address of the PHY in use. */
1134 case SIOCGMIIREG: /* Read the specified MII register. */
1137 unsigned long flags;
1139 spin_lock_irqsave(&lp->window_lock, flags);
1140 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1142 data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1143 EL3WINDOW(saved_window);
1144 spin_unlock_irqrestore(&lp->window_lock, flags);
1147 case SIOCSMIIREG: /* Write the specified MII register */
1150 unsigned long flags;
1152 if (!capable(CAP_NET_ADMIN))
1154 spin_lock_irqsave(&lp->window_lock, flags);
1155 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1157 mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1158 EL3WINDOW(saved_window);
1159 spin_unlock_irqrestore(&lp->window_lock, flags);
1167 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1168 documented. Until it is we revert to receiving all multicast frames when
1169 any multicast reception is desired.
1170 Note: My other drivers emit a log message whenever promiscuous mode is
1171 entered to help detect password sniffers. This is less desirable on
1172 typical PC card machines, so we omit the message.
1175 static void set_rx_mode(struct net_device *dev)
1177 kio_addr_t ioaddr = dev->base_addr;
1179 if (dev->flags & IFF_PROMISC)
1180 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1182 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1183 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1185 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1188 static int el3_close(struct net_device *dev)
1190 kio_addr_t ioaddr = dev->base_addr;
1191 struct el3_private *lp = netdev_priv(dev);
1192 dev_link_t *link = &lp->link;
1194 DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1197 unsigned long flags;
1199 /* Turn off statistics ASAP. We update lp->stats below. */
1200 outw(StatsDisable, ioaddr + EL3_CMD);
1202 /* Disable the receiver and transmitter. */
1203 outw(RxDisable, ioaddr + EL3_CMD);
1204 outw(TxDisable, ioaddr + EL3_CMD);
1206 /* Note: Switching to window 0 may disable the IRQ. */
1208 spin_lock_irqsave(&lp->window_lock, flags);
1210 spin_unlock_irqrestore(&lp->window_lock, flags);
1212 /* force interrupts off */
1213 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1217 netif_stop_queue(dev);
1218 del_timer_sync(&lp->media);
1223 static struct pcmcia_device_id tc574_ids[] = {
1224 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1225 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "3CCFEM556.cis"),
1228 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1230 static struct pcmcia_driver tc574_driver = {
1231 .owner = THIS_MODULE,
1235 .probe = tc574_attach,
1236 .remove = tc574_detach,
1237 .id_table = tc574_ids,
1238 .suspend = tc574_suspend,
1239 .resume = tc574_resume,
1242 static int __init init_tc574(void)
1244 return pcmcia_register_driver(&tc574_driver);
1247 static void __exit exit_tc574(void)
1249 pcmcia_unregister_driver(&tc574_driver);
1252 module_init(init_tc574);
1253 module_exit(exit_tc574);