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>
88 #include <pcmcia/version.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>
100 #include <asm/bitops.h>
102 /*====================================================================*/
104 /* Module parameters */
106 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
107 MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
108 MODULE_LICENSE("GPL");
110 #define INT_MODULE_PARM(n, v) static int n = v; MODULE_PARM(n, "i")
112 /* Now-standard PC card module parameters. */
113 INT_MODULE_PARM(irq_mask, 0xdeb8);
114 static int irq_list[4] = { -1 };
115 MODULE_PARM(irq_list, "1-4i");
117 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
118 INT_MODULE_PARM(max_interrupt_work, 32);
120 /* Force full duplex modes? */
121 INT_MODULE_PARM(full_duplex, 0);
123 /* Autodetect link polarity reversal? */
124 INT_MODULE_PARM(auto_polarity, 1);
127 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
128 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
129 static char *version =
130 "3c574_cs.c 1.65ac1 2003/04/07 Donald Becker/David Hinds, becker@scyld.com.\n";
132 #define DEBUG(n, args...)
135 /*====================================================================*/
137 /* Time in jiffies before concluding the transmitter is hung. */
138 #define TX_TIMEOUT ((800*HZ)/1000)
140 /* To minimize the size of the driver source and make the driver more
141 readable not all constants are symbolically defined.
142 You'll need the manual if you want to understand driver details anyway. */
143 /* Offsets from base I/O address. */
144 #define EL3_DATA 0x00
146 #define EL3_STATUS 0x0e
148 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
150 /* The top five bits written to EL3_CMD are a command, the lower
151 11 bits are the parameter, if applicable. */
153 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
154 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
155 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
156 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
157 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
158 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
159 StatsDisable = 22<<11, StopCoax = 23<<11,
163 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
164 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
165 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 };
167 /* The SetRxFilter command accepts the following classes: */
169 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
173 Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */
174 IntrStatus=0x0E, /* Valid in all windows. */
176 /* These assumes the larger EEPROM. */
177 enum Win0_EEPROM_cmds {
178 EEPROM_Read = 0x200, EEPROM_WRITE = 0x100, EEPROM_ERASE = 0x300,
179 EEPROM_EWENB = 0x30, /* Enable erasing/writing for 10 msec. */
180 EEPROM_EWDIS = 0x00, /* Disable EWENB before 10 msec timeout. */
183 /* Register window 1 offsets, the window used in normal operation.
184 On the "Odie" this window is always mapped at offsets 0x10-0x1f.
185 Except for TxFree, which is overlapped by RunnerWrCtrl. */
187 TX_FIFO = 0x10, RX_FIFO = 0x10, RxErrors = 0x14,
188 RxStatus = 0x18, Timer=0x1A, TxStatus = 0x1B,
189 TxFree = 0x0C, /* Remaining free bytes in Tx buffer. */
190 RunnerRdCtrl = 0x16, RunnerWrCtrl = 0x1c,
193 enum Window3 { /* Window 3: MAC/config bits. */
194 Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
198 struct w3_config_fields {
199 unsigned int ram_size:3, ram_width:1, ram_speed:2, rom_size:2;
201 unsigned int ram_split:2, pad18:2, xcvr:3, pad21:1, autoselect:1;
206 enum Window4 { /* Window 4: Xcvr/media bits. */
207 Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
210 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
215 struct net_device_stats stats;
216 u16 advertising, partner; /* NWay media advertisement */
217 unsigned char phys; /* MII device address */
218 unsigned int autoselect:1, default_media:3; /* Read from the EEPROM/Wn3_Config. */
219 /* for transceiver monitoring */
220 struct timer_list media;
221 unsigned short media_status;
222 unsigned short fast_poll;
223 unsigned long last_irq;
224 spinlock_t window_lock; /* Guards the Window selection */
227 /* Set iff a MII transceiver on any interface requires mdio preamble.
228 This only set with the original DP83840 on older 3c905 boards, so the extra
229 code size of a per-interface flag is not worthwhile. */
230 static char mii_preamble_required = 0;
232 /* Index of functions. */
234 static void tc574_config(dev_link_t *link);
235 static void tc574_release(dev_link_t *link);
236 static int tc574_event(event_t event, int priority,
237 event_callback_args_t *args);
239 static void mdio_sync(ioaddr_t ioaddr, int bits);
240 static int mdio_read(ioaddr_t ioaddr, int phy_id, int location);
241 static void mdio_write(ioaddr_t ioaddr, int phy_id, int location, int value);
242 static unsigned short read_eeprom(ioaddr_t ioaddr, int index);
243 static void tc574_wait_for_completion(struct net_device *dev, int cmd);
245 static void tc574_reset(struct net_device *dev);
246 static void media_check(unsigned long arg);
247 static int el3_open(struct net_device *dev);
248 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
249 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
250 static void update_stats(struct net_device *dev);
251 static struct net_device_stats *el3_get_stats(struct net_device *dev);
252 static int el3_rx(struct net_device *dev, int worklimit);
253 static int el3_close(struct net_device *dev);
254 static void el3_tx_timeout(struct net_device *dev);
255 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
256 static struct ethtool_ops netdev_ethtool_ops;
257 static void set_rx_mode(struct net_device *dev);
259 static dev_info_t dev_info = "3c574_cs";
261 static dev_link_t *tc574_attach(void);
262 static void tc574_detach(dev_link_t *);
264 static dev_link_t *dev_list;
267 tc574_attach() creates an "instance" of the driver, allocating
268 local data structures for one device. The device is registered
272 static dev_link_t *tc574_attach(void)
274 struct el3_private *lp;
275 client_reg_t client_reg;
277 struct net_device *dev;
280 DEBUG(0, "3c574_attach()\n");
282 /* Create the PC card device object. */
283 dev = alloc_etherdev(sizeof(struct el3_private));
286 lp = netdev_priv(dev);
290 spin_lock_init(&lp->window_lock);
291 link->io.NumPorts1 = 32;
292 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
293 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
294 link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
295 if (irq_list[0] == -1)
296 link->irq.IRQInfo2 = irq_mask;
298 for (i = 0; i < 4; i++)
299 link->irq.IRQInfo2 |= 1 << irq_list[i];
300 link->irq.Handler = &el3_interrupt;
301 link->irq.Instance = dev;
302 link->conf.Attributes = CONF_ENABLE_IRQ;
304 link->conf.IntType = INT_MEMORY_AND_IO;
305 link->conf.ConfigIndex = 1;
306 link->conf.Present = PRESENT_OPTION;
308 /* The EL3-specific entries in the device structure. */
309 dev->hard_start_xmit = &el3_start_xmit;
310 dev->get_stats = &el3_get_stats;
311 dev->do_ioctl = &el3_ioctl;
312 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
313 dev->set_multicast_list = &set_rx_mode;
314 dev->open = &el3_open;
315 dev->stop = &el3_close;
316 #ifdef HAVE_TX_TIMEOUT
317 dev->tx_timeout = el3_tx_timeout;
318 dev->watchdog_timeo = TX_TIMEOUT;
321 /* Register with Card Services */
322 link->next = dev_list;
324 client_reg.dev_info = &dev_info;
325 client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
326 client_reg.EventMask =
327 CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
328 CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
329 CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
330 client_reg.event_handler = &tc574_event;
331 client_reg.Version = 0x0210;
332 client_reg.event_callback_args.client_data = link;
333 ret = pcmcia_register_client(&link->handle, &client_reg);
335 cs_error(link->handle, RegisterClient, ret);
345 This deletes a driver "instance". The device is de-registered
346 with Card Services. If it has been released, all local data
347 structures are freed. Otherwise, the structures will be freed
348 when the device is released.
352 static void tc574_detach(dev_link_t *link)
354 struct net_device *dev = link->priv;
357 DEBUG(0, "3c574_detach(0x%p)\n", link);
359 /* Locate device structure */
360 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
361 if (*linkp == link) break;
365 if (link->state & DEV_CONFIG)
369 pcmcia_deregister_client(link->handle);
371 /* Unlink device structure, free bits */
374 unregister_netdev(dev);
379 tc574_config() is scheduled to run after a CARD_INSERTION event
380 is received, to configure the PCMCIA socket, and to make the
381 ethernet device available to the system.
384 #define CS_CHECK(fn, ret) \
385 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
387 static char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
389 static void tc574_config(dev_link_t *link)
391 client_handle_t handle = link->handle;
392 struct net_device *dev = link->priv;
393 struct el3_private *lp = netdev_priv(dev);
396 unsigned short buf[32];
397 int last_fn, last_ret, i, j;
401 union wn3_config config;
403 phys_addr = (u16 *)dev->dev_addr;
405 DEBUG(0, "3c574_config(0x%p)\n", link);
407 tuple.Attributes = 0;
408 tuple.DesiredTuple = CISTPL_CONFIG;
409 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
410 tuple.TupleData = (cisdata_t *)buf;
411 tuple.TupleDataMax = 64;
412 tuple.TupleOffset = 0;
413 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
414 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
415 link->conf.ConfigBase = parse.config.base;
416 link->conf.Present = parse.config.rmask[0];
419 link->state |= DEV_CONFIG;
421 link->io.IOAddrLines = 16;
422 for (i = j = 0; j < 0x400; j += 0x20) {
423 link->io.BasePort1 = j ^ 0x300;
424 i = pcmcia_request_io(link->handle, &link->io);
425 if (i == CS_SUCCESS) break;
427 if (i != CS_SUCCESS) {
428 cs_error(link->handle, RequestIO, i);
431 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
432 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
434 dev->irq = link->irq.AssignedIRQ;
435 dev->base_addr = link->io.BasePort1;
437 ioaddr = dev->base_addr;
439 /* The 3c574 normally uses an EEPROM for configuration info, including
440 the hardware address. The future products may include a modem chip
441 and put the address in the CIS. */
442 tuple.DesiredTuple = 0x88;
443 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) {
444 pcmcia_get_tuple_data(handle, &tuple);
445 for (i = 0; i < 3; i++)
446 phys_addr[i] = htons(buf[i]);
449 for (i = 0; i < 3; i++)
450 phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
451 if (phys_addr[0] == 0x6060) {
452 printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
453 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
457 tuple.DesiredTuple = CISTPL_VERS_1;
458 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS &&
459 pcmcia_get_tuple_data(handle, &tuple) == CS_SUCCESS &&
460 pcmcia_parse_tuple(handle, &tuple, &parse) == CS_SUCCESS) {
461 cardname = parse.version_1.str + parse.version_1.ofs[1];
463 cardname = "3Com 3c574";
467 outw(2<<11, ioaddr + RunnerRdCtrl);
468 mcr = inb(ioaddr + 2);
469 outw(0<<11, ioaddr + RunnerRdCtrl);
470 printk(KERN_INFO " ASIC rev %d,", mcr>>3);
472 config.i = inl(ioaddr + Wn3_Config);
473 lp->default_media = config.u.xcvr;
474 lp->autoselect = config.u.autoselect;
477 init_timer(&lp->media);
482 /* Roadrunner only: Turn on the MII transceiver */
483 outw(0x8040, ioaddr + Wn3_Options);
485 outw(0xc040, ioaddr + Wn3_Options);
486 tc574_wait_for_completion(dev, TxReset);
487 tc574_wait_for_completion(dev, RxReset);
489 outw(0x8040, ioaddr + Wn3_Options);
492 for (phy = 1; phy <= 32; phy++) {
494 mdio_sync(ioaddr, 32);
495 mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
496 if (mii_status != 0xffff) {
497 lp->phys = phy & 0x1f;
498 DEBUG(0, " MII transceiver at index %d, status %x.\n",
500 if ((mii_status & 0x0040) == 0)
501 mii_preamble_required = 1;
506 printk(KERN_NOTICE " No MII transceivers found!\n");
509 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
510 mdio_write(ioaddr, lp->phys, 16, i);
511 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
513 /* Only advertise the FD media types. */
514 lp->advertising &= ~0x02a0;
515 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
519 link->state &= ~DEV_CONFIG_PENDING;
520 link->dev = &lp->node;
522 if (register_netdev(dev) != 0) {
523 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
528 strcpy(lp->node.dev_name, dev->name);
530 printk(KERN_INFO "%s: %s at io %#3lx, irq %d, hw_addr ",
531 dev->name, cardname, dev->base_addr, dev->irq);
532 for (i = 0; i < 6; i++)
533 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : ".\n"));
534 printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
535 8 << config.u.ram_size, ram_split[config.u.ram_split],
536 config.u.autoselect ? "autoselect " : "");
541 cs_error(link->handle, last_fn, last_ret);
549 After a card is removed, tc574_release() will unregister the net
550 device, and release the PCMCIA configuration. If the device is
551 still open, this will be postponed until it is closed.
554 static void tc574_release(dev_link_t *link)
556 DEBUG(0, "3c574_release(0x%p)\n", link);
558 pcmcia_release_configuration(link->handle);
559 pcmcia_release_io(link->handle, &link->io);
560 pcmcia_release_irq(link->handle, &link->irq);
562 link->state &= ~DEV_CONFIG;
566 The card status event handler. Mostly, this schedules other
567 stuff to run after an event is received. A CARD_REMOVAL event
568 also sets some flags to discourage the net drivers from trying
569 to talk to the card any more.
572 static int tc574_event(event_t event, int priority,
573 event_callback_args_t *args)
575 dev_link_t *link = args->client_data;
576 struct net_device *dev = link->priv;
578 DEBUG(1, "3c574_event(0x%06x)\n", event);
581 case CS_EVENT_CARD_REMOVAL:
582 link->state &= ~DEV_PRESENT;
583 if (link->state & DEV_CONFIG) {
584 netif_device_detach(dev);
588 case CS_EVENT_CARD_INSERTION:
589 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
592 case CS_EVENT_PM_SUSPEND:
593 link->state |= DEV_SUSPEND;
594 /* Fall through... */
595 case CS_EVENT_RESET_PHYSICAL:
596 if (link->state & DEV_CONFIG) {
598 netif_device_detach(dev);
599 pcmcia_release_configuration(link->handle);
602 case CS_EVENT_PM_RESUME:
603 link->state &= ~DEV_SUSPEND;
604 /* Fall through... */
605 case CS_EVENT_CARD_RESET:
606 if (link->state & DEV_CONFIG) {
607 pcmcia_request_configuration(link->handle, &link->conf);
610 netif_device_attach(dev);
618 static void dump_status(struct net_device *dev)
620 ioaddr_t ioaddr = dev->base_addr;
622 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
623 "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
624 inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
627 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
628 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
629 inw(ioaddr+0x08), inw(ioaddr+0x0a));
634 Use this for commands that may take time to finish
636 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
639 outw(cmd, dev->base_addr + EL3_CMD);
641 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
643 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
646 /* Read a word from the EEPROM using the regular EEPROM access register.
647 Assume that we are in register window zero.
649 static unsigned short read_eeprom(ioaddr_t ioaddr, int index)
652 outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
653 /* Pause for at least 162 usec for the read to take place. */
654 for (timer = 1620; timer >= 0; timer--) {
655 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
658 return inw(ioaddr + Wn0EepromData);
661 /* MII transceiver control section.
662 Read and write the MII registers using software-generated serial
663 MDIO protocol. See the MII specifications or DP83840A data sheet
665 The maxium data clock rate is 2.5 Mhz. The timing is easily met by the
666 slow PC card interface. */
668 #define MDIO_SHIFT_CLK 0x01
669 #define MDIO_DIR_WRITE 0x04
670 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
671 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
672 #define MDIO_DATA_READ 0x02
673 #define MDIO_ENB_IN 0x00
675 /* Generate the preamble required for initial synchronization and
676 a few older transceivers. */
677 static void mdio_sync(ioaddr_t ioaddr, int bits)
679 int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
681 /* Establish sync by sending at least 32 logic ones. */
682 while (-- bits >= 0) {
683 outw(MDIO_DATA_WRITE1, mdio_addr);
684 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
688 static int mdio_read(ioaddr_t ioaddr, int phy_id, int location)
691 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
692 unsigned int retval = 0;
693 int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
695 if (mii_preamble_required)
696 mdio_sync(ioaddr, 32);
698 /* Shift the read command bits out. */
699 for (i = 14; i >= 0; i--) {
700 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
701 outw(dataval, mdio_addr);
702 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
704 /* Read the two transition, 16 data, and wire-idle bits. */
705 for (i = 19; i > 0; i--) {
706 outw(MDIO_ENB_IN, mdio_addr);
707 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
708 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
710 return (retval>>1) & 0xffff;
713 static void mdio_write(ioaddr_t ioaddr, int phy_id, int location, int value)
715 int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
716 int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
719 if (mii_preamble_required)
720 mdio_sync(ioaddr, 32);
722 /* Shift the command bits out. */
723 for (i = 31; i >= 0; i--) {
724 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
725 outw(dataval, mdio_addr);
726 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
728 /* Leave the interface idle. */
729 for (i = 1; i >= 0; i--) {
730 outw(MDIO_ENB_IN, mdio_addr);
731 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
737 /* Reset and restore all of the 3c574 registers. */
738 static void tc574_reset(struct net_device *dev)
740 struct el3_private *lp = netdev_priv(dev);
741 int i, ioaddr = dev->base_addr;
744 tc574_wait_for_completion(dev, TotalReset|0x10);
746 spin_lock_irqsave(&lp->window_lock, flags);
747 /* Clear any transactions in progress. */
748 outw(0, ioaddr + RunnerWrCtrl);
749 outw(0, ioaddr + RunnerRdCtrl);
751 /* Set the station address and mask. */
753 for (i = 0; i < 6; i++)
754 outb(dev->dev_addr[i], ioaddr + i);
758 /* Reset config options */
760 outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
761 outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
762 ioaddr + Wn3_Config);
763 /* Roadrunner only: Turn on the MII transceiver. */
764 outw(0x8040, ioaddr + Wn3_Options);
766 outw(0xc040, ioaddr + Wn3_Options);
768 spin_unlock_irqrestore(&lp->window_lock, flags);
770 tc574_wait_for_completion(dev, TxReset);
771 tc574_wait_for_completion(dev, RxReset);
773 spin_lock_irqsave(&lp->window_lock, flags);
775 outw(0x8040, ioaddr + Wn3_Options);
777 /* Switch to the stats window, and clear all stats by reading. */
778 outw(StatsDisable, ioaddr + EL3_CMD);
780 for (i = 0; i < 10; i++)
788 /* .. enable any extra statistics bits.. */
789 outw(0x0040, ioaddr + Wn4_NetDiag);
792 spin_unlock_irqrestore(&lp->window_lock, flags);
794 /* .. re-sync MII and re-fill what NWay is advertising. */
795 mdio_sync(ioaddr, 32);
796 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
797 if (!auto_polarity) {
798 /* works for TDK 78Q2120 series MII's */
799 int i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
800 mdio_write(ioaddr, lp->phys, 16, i);
803 spin_lock_irqsave(&lp->window_lock, flags);
804 /* Switch to register set 1 for normal use, just for TxFree. */
806 spin_unlock_irqrestore(&lp->window_lock, flags);
807 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
808 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
809 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
810 /* Allow status bits to be seen. */
811 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
812 /* Ack all pending events, and set active indicator mask. */
813 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
815 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
816 | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
819 static int el3_open(struct net_device *dev)
821 struct el3_private *lp = netdev_priv(dev);
822 dev_link_t *link = &lp->link;
828 netif_start_queue(dev);
831 lp->media.function = &media_check;
832 lp->media.data = (unsigned long) dev;
833 lp->media.expires = jiffies + HZ;
834 add_timer(&lp->media);
836 DEBUG(2, "%s: opened, status %4.4x.\n",
837 dev->name, inw(dev->base_addr + EL3_STATUS));
842 static void el3_tx_timeout(struct net_device *dev)
844 struct el3_private *lp = netdev_priv(dev);
845 ioaddr_t ioaddr = dev->base_addr;
847 printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
849 lp->stats.tx_errors++;
850 dev->trans_start = jiffies;
851 /* Issue TX_RESET and TX_START commands. */
852 tc574_wait_for_completion(dev, TxReset);
853 outw(TxEnable, ioaddr + EL3_CMD);
854 netif_wake_queue(dev);
857 static void pop_tx_status(struct net_device *dev)
859 struct el3_private *lp = netdev_priv(dev);
860 ioaddr_t ioaddr = dev->base_addr;
863 /* Clear the Tx status stack. */
864 for (i = 32; i > 0; i--) {
865 u_char tx_status = inb(ioaddr + TxStatus);
866 if (!(tx_status & 0x84))
868 /* reset transmitter on jabber error or underrun */
869 if (tx_status & 0x30)
870 tc574_wait_for_completion(dev, TxReset);
871 if (tx_status & 0x38) {
872 DEBUG(1, "%s: transmit error: status 0x%02x\n",
873 dev->name, tx_status);
874 outw(TxEnable, ioaddr + EL3_CMD);
875 lp->stats.tx_aborted_errors++;
877 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
881 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
883 ioaddr_t ioaddr = dev->base_addr;
884 struct el3_private *lp = netdev_priv(dev);
887 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
888 "status %4.4x.\n", dev->name, (long)skb->len,
889 inw(ioaddr + EL3_STATUS));
891 spin_lock_irqsave(&lp->window_lock, flags);
892 outw(skb->len, ioaddr + TX_FIFO);
893 outw(0, ioaddr + TX_FIFO);
894 outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
896 dev->trans_start = jiffies;
898 /* TxFree appears only in Window 1, not offset 0x1c. */
899 if (inw(ioaddr + TxFree) <= 1536) {
900 netif_stop_queue(dev);
901 /* Interrupt us when the FIFO has room for max-sized packet.
902 The threshold is in units of dwords. */
903 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
907 spin_unlock_irqrestore(&lp->window_lock, flags);
912 /* The EL3 interrupt handler. */
913 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
915 struct net_device *dev = (struct net_device *) dev_id;
916 struct el3_private *lp = netdev_priv(dev);
917 ioaddr_t ioaddr, status;
918 int work_budget = max_interrupt_work;
921 if (!netif_device_present(dev))
923 ioaddr = dev->base_addr;
925 DEBUG(3, "%s: interrupt, status %4.4x.\n",
926 dev->name, inw(ioaddr + EL3_STATUS));
928 spin_lock(&lp->window_lock);
930 while ((status = inw(ioaddr + EL3_STATUS)) &
931 (IntLatch | RxComplete | RxEarly | StatsFull)) {
932 if (!netif_device_present(dev) ||
933 ((status & 0xe000) != 0x2000)) {
934 DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
940 if (status & RxComplete)
941 work_budget = el3_rx(dev, work_budget);
943 if (status & TxAvailable) {
944 DEBUG(3, " TX room bit was handled.\n");
945 /* There's room in the FIFO for a full-sized packet. */
946 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
947 netif_wake_queue(dev);
950 if (status & TxComplete)
953 if (status & (AdapterFailure | RxEarly | StatsFull)) {
954 /* Handle all uncommon interrupts. */
955 if (status & StatsFull)
957 if (status & RxEarly) {
958 work_budget = el3_rx(dev, work_budget);
959 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
961 if (status & AdapterFailure) {
964 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
966 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
967 " register %04x.\n", dev->name, fifo_diag);
968 if (fifo_diag & 0x0400) {
970 tc574_wait_for_completion(dev, TxReset);
971 outw(TxEnable, ioaddr + EL3_CMD);
973 if (fifo_diag & 0x2000) {
975 tc574_wait_for_completion(dev, RxReset);
977 outw(RxEnable, ioaddr + EL3_CMD);
979 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
983 if (--work_budget < 0) {
984 DEBUG(0, "%s: Too much work in interrupt, "
985 "status %4.4x.\n", dev->name, status);
986 /* Clear all interrupts */
987 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
990 /* Acknowledge the IRQ. */
991 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
994 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
995 dev->name, inw(ioaddr + EL3_STATUS));
997 spin_unlock(&lp->window_lock);
998 return IRQ_RETVAL(handled);
1002 This timer serves two purposes: to check for missed interrupts
1003 (and as a last resort, poll the NIC for events), and to monitor
1004 the MII, reporting changes in cable status.
1006 static void media_check(unsigned long arg)
1008 struct net_device *dev = (struct net_device *) arg;
1009 struct el3_private *lp = netdev_priv(dev);
1010 ioaddr_t ioaddr = dev->base_addr;
1011 unsigned long flags;
1012 unsigned short /* cable, */ media, partner;
1014 if (!netif_device_present(dev))
1017 /* Check for pending interrupt with expired latency timer: with
1018 this, we can limp along even if the interrupt is blocked */
1019 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
1021 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
1022 el3_interrupt(dev->irq, lp, NULL);
1025 if (lp->fast_poll) {
1027 lp->media.expires = jiffies + 2*HZ/100;
1028 add_timer(&lp->media);
1032 spin_lock_irqsave(&lp->window_lock, flags);
1034 media = mdio_read(ioaddr, lp->phys, 1);
1035 partner = mdio_read(ioaddr, lp->phys, 5);
1038 if (media != lp->media_status) {
1039 if ((media ^ lp->media_status) & 0x0004)
1040 printk(KERN_INFO "%s: %s link beat\n", dev->name,
1041 (lp->media_status & 0x0004) ? "lost" : "found");
1042 if ((media ^ lp->media_status) & 0x0020) {
1044 if (lp->media_status & 0x0020) {
1045 printk(KERN_INFO "%s: autonegotiation restarted\n",
1047 } else if (partner) {
1048 partner &= lp->advertising;
1049 lp->partner = partner;
1050 printk(KERN_INFO "%s: autonegotiation complete: "
1051 "%sbaseT-%cD selected\n", dev->name,
1052 ((partner & 0x0180) ? "100" : "10"),
1053 ((partner & 0x0140) ? 'F' : 'H'));
1055 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
1060 outb((partner & 0x0140 ? 0x20 : 0) |
1061 (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
1066 printk(KERN_INFO "%s: remote fault detected\n",
1069 printk(KERN_INFO "%s: jabber detected\n", dev->name);
1070 lp->media_status = media;
1072 spin_unlock_irqrestore(&lp->window_lock, flags);
1075 lp->media.expires = jiffies + HZ;
1076 add_timer(&lp->media);
1079 static struct net_device_stats *el3_get_stats(struct net_device *dev)
1081 struct el3_private *lp = netdev_priv(dev);
1083 if (netif_device_present(dev)) {
1084 unsigned long flags;
1085 spin_lock_irqsave(&lp->window_lock, flags);
1087 spin_unlock_irqrestore(&lp->window_lock, flags);
1092 /* Update statistics.
1093 Suprisingly this need not be run single-threaded, but it effectively is.
1094 The counters clear when read, so the adds must merely be atomic.
1096 static void update_stats(struct net_device *dev)
1098 struct el3_private *lp = netdev_priv(dev);
1099 ioaddr_t ioaddr = dev->base_addr;
1102 DEBUG(2, "%s: updating the statistics.\n", dev->name);
1104 if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1107 /* Unlike the 3c509 we need not turn off stats updates while reading. */
1108 /* Switch to the stats window, and read everything. */
1110 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
1111 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1112 /* Multiple collisions. */ inb(ioaddr + 2);
1113 lp->stats.collisions += inb(ioaddr + 3);
1114 lp->stats.tx_window_errors += inb(ioaddr + 4);
1115 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
1116 lp->stats.tx_packets += inb(ioaddr + 6);
1117 up = inb(ioaddr + 9);
1118 lp->stats.tx_packets += (up&0x30) << 4;
1119 /* Rx packets */ inb(ioaddr + 7);
1120 /* Tx deferrals */ inb(ioaddr + 8);
1121 rx = inw(ioaddr + 10);
1122 tx = inw(ioaddr + 12);
1125 /* BadSSD */ inb(ioaddr + 12);
1126 up = inb(ioaddr + 13);
1128 lp->stats.tx_bytes += tx + ((up & 0xf0) << 12);
1133 static int el3_rx(struct net_device *dev, int worklimit)
1135 struct el3_private *lp = netdev_priv(dev);
1136 ioaddr_t ioaddr = dev->base_addr;
1139 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1140 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1141 while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1142 (--worklimit >= 0)) {
1143 if (rx_status & 0x4000) { /* Error, update stats. */
1144 short error = rx_status & 0x3800;
1145 lp->stats.rx_errors++;
1147 case 0x0000: lp->stats.rx_over_errors++; break;
1148 case 0x0800: lp->stats.rx_length_errors++; break;
1149 case 0x1000: lp->stats.rx_frame_errors++; break;
1150 case 0x1800: lp->stats.rx_length_errors++; break;
1151 case 0x2000: lp->stats.rx_frame_errors++; break;
1152 case 0x2800: lp->stats.rx_crc_errors++; break;
1155 short pkt_len = rx_status & 0x7ff;
1156 struct sk_buff *skb;
1158 skb = dev_alloc_skb(pkt_len+5);
1160 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
1161 pkt_len, rx_status);
1164 skb_reserve(skb, 2);
1165 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1167 skb->protocol = eth_type_trans(skb, dev);
1169 dev->last_rx = jiffies;
1170 lp->stats.rx_packets++;
1171 lp->stats.rx_bytes += pkt_len;
1173 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1174 " size %d.\n", dev->name, pkt_len);
1175 lp->stats.rx_dropped++;
1178 tc574_wait_for_completion(dev, RxDiscard);
1184 static void netdev_get_drvinfo(struct net_device *dev,
1185 struct ethtool_drvinfo *info)
1187 strcpy(info->driver, "3c574_cs");
1190 static struct ethtool_ops netdev_ethtool_ops = {
1191 .get_drvinfo = netdev_get_drvinfo,
1194 /* Provide ioctl() calls to examine the MII xcvr state. */
1195 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1197 struct el3_private *lp = netdev_priv(dev);
1198 ioaddr_t ioaddr = dev->base_addr;
1199 u16 *data = (u16 *)&rq->ifr_data;
1200 int phy = lp->phys & 0x1f;
1202 DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1203 dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1204 data[0], data[1], data[2], data[3]);
1207 case SIOCGMIIPHY: /* Get the address of the PHY in use. */
1209 case SIOCGMIIREG: /* Read the specified MII register. */
1212 unsigned long flags;
1214 spin_lock_irqsave(&lp->window_lock, flags);
1215 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1217 data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1218 EL3WINDOW(saved_window);
1219 spin_unlock_irqrestore(&lp->window_lock, flags);
1222 case SIOCSMIIREG: /* Write the specified MII register */
1225 unsigned long flags;
1227 if (!capable(CAP_NET_ADMIN))
1229 spin_lock_irqsave(&lp->window_lock, flags);
1230 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1232 mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1233 EL3WINDOW(saved_window);
1234 spin_unlock_irqrestore(&lp->window_lock, flags);
1242 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1243 documented. Until it is we revert to receiving all multicast frames when
1244 any multicast reception is desired.
1245 Note: My other drivers emit a log message whenever promiscuous mode is
1246 entered to help detect password sniffers. This is less desirable on
1247 typical PC card machines, so we omit the message.
1250 static void set_rx_mode(struct net_device *dev)
1252 ioaddr_t ioaddr = dev->base_addr;
1254 if (dev->flags & IFF_PROMISC)
1255 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1257 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1258 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1260 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1263 static int el3_close(struct net_device *dev)
1265 ioaddr_t ioaddr = dev->base_addr;
1266 struct el3_private *lp = netdev_priv(dev);
1267 dev_link_t *link = &lp->link;
1269 DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1272 unsigned long flags;
1274 /* Turn off statistics ASAP. We update lp->stats below. */
1275 outw(StatsDisable, ioaddr + EL3_CMD);
1277 /* Disable the receiver and transmitter. */
1278 outw(RxDisable, ioaddr + EL3_CMD);
1279 outw(TxDisable, ioaddr + EL3_CMD);
1281 /* Note: Switching to window 0 may disable the IRQ. */
1283 spin_lock_irqsave(&lp->window_lock, flags);
1285 spin_unlock_irqrestore(&lp->window_lock, flags);
1289 netif_stop_queue(dev);
1290 del_timer_sync(&lp->media);
1295 static struct pcmcia_driver tc574_driver = {
1296 .owner = THIS_MODULE,
1300 .attach = tc574_attach,
1301 .detach = tc574_detach,
1304 static int __init init_tc574(void)
1306 return pcmcia_register_driver(&tc574_driver);
1309 static void __exit exit_tc574(void)
1311 pcmcia_unregister_driver(&tc574_driver);
1312 while (dev_list != NULL)
1313 tc574_detach(dev_list);
1316 module_init(init_tc574);
1317 module_exit(exit_tc574);