3c574_cs: use netstats in net_device structure
[linux-2.6.git] / drivers / net / pcmcia / 3c574_cs.c
1 /* 3c574.c: A PCMCIA ethernet driver for the 3com 3c574 "RoadRunner".
2
3         Written 1993-1998 by
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
7
8         This software may be used and distributed according to the terms of
9         the GNU General Public License, incorporated herein by reference.
10
11         This driver derives from Donald Becker's 3c509 core, which has the
12         following copyright:
13         Copyright 1993 United States Government as represented by the
14         Director, National Security Agency.
15         
16
17 */
18
19 /*
20                                 Theory of Operation
21
22 I. Board Compatibility
23
24 This device driver is designed for the 3Com 3c574 PC card Fast Ethernet
25 Adapter.
26
27 II. Board-specific settings
28
29 None -- PC cards are autoconfigured.
30
31 III. Driver operation
32
33 The 3c574 uses a Boomerang-style interface, without the bus-master capability.
34 See the Boomerang driver and documentation for most details.
35
36 IV. Notes and chip documentation.
37
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.
44
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.
49
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.
53
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.
58
59 A final note: writing the InternalConfig register in window 3 with an
60 invalid ramWidth is Very Bad.
61
62 V. References
63
64 http://www.scyld.com/expert/NWay.html
65 http://www.national.com/pf/DP/DP83840.html
66
67 Thanks to Terry Murphy of 3Com for providing development information for
68 earlier 3Com products.
69
70 */
71
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>
79 #include <linux/in.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>
88
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>
96
97 #include <asm/uaccess.h>
98 #include <asm/io.h>
99 #include <asm/system.h>
100
101 /*====================================================================*/
102
103 /* Module parameters */
104
105 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
106 MODULE_DESCRIPTION("3Com 3c574 series PCMCIA ethernet driver");
107 MODULE_LICENSE("GPL");
108
109 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
110
111 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
112 INT_MODULE_PARM(max_interrupt_work, 32);
113
114 /* Force full duplex modes? */
115 INT_MODULE_PARM(full_duplex, 0);
116
117 /* Autodetect link polarity reversal? */
118 INT_MODULE_PARM(auto_polarity, 1);
119
120 #ifdef PCMCIA_DEBUG
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";
125 #else
126 #define DEBUG(n, args...)
127 #endif
128
129 /*====================================================================*/
130
131 /* Time in jiffies before concluding the transmitter is hung. */
132 #define TX_TIMEOUT  ((800*HZ)/1000)
133
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
139 #define EL3_CMD         0x0e
140 #define EL3_STATUS      0x0e
141
142 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
143
144 /* The top five bits written to EL3_CMD are a command, the lower
145    11 bits are the parameter, if applicable. */
146 enum el3_cmds {
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,
154 };
155
156 enum elxl_status {
157         IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
158         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
159         IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000 };
160
161 /* The SetRxFilter command accepts the following classes: */
162 enum RxFilter {
163         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8
164 };
165
166 enum Window0 {
167         Wn0EepromCmd = 10, Wn0EepromData = 12, /* EEPROM command/address, data. */
168         IntrStatus=0x0E,                /* Valid in all windows. */
169 };
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. */
175 };
176
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. */
180 enum Window1 {
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,
185 };
186
187 enum Window3 {                  /* Window 3: MAC/config bits. */
188         Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
189 };
190 enum wn3_config {
191         Ram_size = 7,
192         Ram_width = 8,
193         Ram_speed = 0x30,
194         Rom_size = 0xc0,
195         Ram_split_shift = 16,
196         Ram_split = 3 << Ram_split_shift,
197         Xcvr_shift = 20,
198         Xcvr = 7 << Xcvr_shift,
199         Autoselect = 0x1000000,
200 };
201
202 enum Window4 {          /* Window 4: Xcvr/media bits. */
203         Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
204 };
205
206 #define MEDIA_TP        0x00C0  /* Enable link beat and jabber for 10baseT. */
207
208 struct el3_private {
209         struct pcmcia_device    *p_dev;
210         dev_node_t node;
211         u16 advertising, partner;               /* NWay media advertisement */
212         unsigned char phys;                     /* MII device address */
213         unsigned int autoselect:1, default_media:3;     /* Read from the EEPROM/Wn3_Config. */
214         /* for transceiver monitoring */
215         struct timer_list media;
216         unsigned short media_status;
217         unsigned short fast_poll;
218         unsigned long last_irq;
219         spinlock_t window_lock;                 /* Guards the Window selection */
220 };
221
222 /* Set iff a MII transceiver on any interface requires mdio preamble.
223    This only set with the original DP83840 on older 3c905 boards, so the extra
224    code size of a per-interface flag is not worthwhile. */
225 static char mii_preamble_required = 0;
226
227 /* Index of functions. */
228
229 static int tc574_config(struct pcmcia_device *link);
230 static void tc574_release(struct pcmcia_device *link);
231
232 static void mdio_sync(unsigned int ioaddr, int bits);
233 static int mdio_read(unsigned int ioaddr, int phy_id, int location);
234 static void mdio_write(unsigned int ioaddr, int phy_id, int location,
235                        int value);
236 static unsigned short read_eeprom(unsigned int ioaddr, int index);
237 static void tc574_wait_for_completion(struct net_device *dev, int cmd);
238
239 static void tc574_reset(struct net_device *dev);
240 static void media_check(unsigned long arg);
241 static int el3_open(struct net_device *dev);
242 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
243 static irqreturn_t el3_interrupt(int irq, void *dev_id);
244 static void update_stats(struct net_device *dev);
245 static struct net_device_stats *el3_get_stats(struct net_device *dev);
246 static int el3_rx(struct net_device *dev, int worklimit);
247 static int el3_close(struct net_device *dev);
248 static void el3_tx_timeout(struct net_device *dev);
249 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
250 static const struct ethtool_ops netdev_ethtool_ops;
251 static void set_rx_mode(struct net_device *dev);
252
253 static void tc574_detach(struct pcmcia_device *p_dev);
254
255 /*
256         tc574_attach() creates an "instance" of the driver, allocating
257         local data structures for one device.  The device is registered
258         with Card Services.
259 */
260
261 static int tc574_probe(struct pcmcia_device *link)
262 {
263         struct el3_private *lp;
264         struct net_device *dev;
265
266         DEBUG(0, "3c574_attach()\n");
267
268         /* Create the PC card device object. */
269         dev = alloc_etherdev(sizeof(struct el3_private));
270         if (!dev)
271                 return -ENOMEM;
272         lp = netdev_priv(dev);
273         link->priv = dev;
274         lp->p_dev = link;
275
276         spin_lock_init(&lp->window_lock);
277         link->io.NumPorts1 = 32;
278         link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
279         link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING|IRQ_HANDLE_PRESENT;
280         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
281         link->irq.Handler = &el3_interrupt;
282         link->irq.Instance = dev;
283         link->conf.Attributes = CONF_ENABLE_IRQ;
284         link->conf.IntType = INT_MEMORY_AND_IO;
285         link->conf.ConfigIndex = 1;
286
287         /* The EL3-specific entries in the device structure. */
288         dev->hard_start_xmit = &el3_start_xmit;
289         dev->get_stats = &el3_get_stats;
290         dev->do_ioctl = &el3_ioctl;
291         SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
292         dev->set_multicast_list = &set_rx_mode;
293         dev->open = &el3_open;
294         dev->stop = &el3_close;
295 #ifdef HAVE_TX_TIMEOUT
296         dev->tx_timeout = el3_tx_timeout;
297         dev->watchdog_timeo = TX_TIMEOUT;
298 #endif
299
300         return tc574_config(link);
301 } /* tc574_attach */
302
303 /*
304
305         This deletes a driver "instance".  The device is de-registered
306         with Card Services.  If it has been released, all local data
307         structures are freed.  Otherwise, the structures will be freed
308         when the device is released.
309
310 */
311
312 static void tc574_detach(struct pcmcia_device *link)
313 {
314         struct net_device *dev = link->priv;
315
316         DEBUG(0, "3c574_detach(0x%p)\n", link);
317
318         if (link->dev_node)
319                 unregister_netdev(dev);
320
321         tc574_release(link);
322
323         free_netdev(dev);
324 } /* tc574_detach */
325
326 /*
327         tc574_config() is scheduled to run after a CARD_INSERTION event
328         is received, to configure the PCMCIA socket, and to make the
329         ethernet device available to the system.
330 */
331
332 #define CS_CHECK(fn, ret) \
333   do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
334
335 static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
336
337 static int tc574_config(struct pcmcia_device *link)
338 {
339         struct net_device *dev = link->priv;
340         struct el3_private *lp = netdev_priv(dev);
341         tuple_t tuple;
342         __le16 buf[32];
343         int last_fn, last_ret, i, j;
344         unsigned int ioaddr;
345         __be16 *phys_addr;
346         char *cardname;
347         __u32 config;
348         DECLARE_MAC_BUF(mac);
349
350         phys_addr = (__be16 *)dev->dev_addr;
351
352         DEBUG(0, "3c574_config(0x%p)\n", link);
353
354         link->io.IOAddrLines = 16;
355         for (i = j = 0; j < 0x400; j += 0x20) {
356                 link->io.BasePort1 = j ^ 0x300;
357                 i = pcmcia_request_io(link, &link->io);
358                 if (i == CS_SUCCESS) break;
359         }
360         if (i != CS_SUCCESS) {
361                 cs_error(link, RequestIO, i);
362                 goto failed;
363         }
364         CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
365         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
366
367         dev->irq = link->irq.AssignedIRQ;
368         dev->base_addr = link->io.BasePort1;
369
370         ioaddr = dev->base_addr;
371
372         /* The 3c574 normally uses an EEPROM for configuration info, including
373            the hardware address.  The future products may include a modem chip
374            and put the address in the CIS. */
375         tuple.Attributes = 0;
376         tuple.TupleData = (cisdata_t *)buf;
377         tuple.TupleDataMax = 64;
378         tuple.TupleOffset = 0;
379         tuple.DesiredTuple = 0x88;
380         if (pcmcia_get_first_tuple(link, &tuple) == CS_SUCCESS) {
381                 pcmcia_get_tuple_data(link, &tuple);
382                 for (i = 0; i < 3; i++)
383                         phys_addr[i] = htons(le16_to_cpu(buf[i]));
384         } else {
385                 EL3WINDOW(0);
386                 for (i = 0; i < 3; i++)
387                         phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
388                 if (phys_addr[0] == htons(0x6060)) {
389                         printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
390                                    "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
391                         goto failed;
392                 }
393         }
394         if (link->prod_id[1])
395                 cardname = link->prod_id[1];
396         else
397                 cardname = "3Com 3c574";
398
399         {
400                 u_char mcr;
401                 outw(2<<11, ioaddr + RunnerRdCtrl);
402                 mcr = inb(ioaddr + 2);
403                 outw(0<<11, ioaddr + RunnerRdCtrl);
404                 printk(KERN_INFO "  ASIC rev %d,", mcr>>3);
405                 EL3WINDOW(3);
406                 config = inl(ioaddr + Wn3_Config);
407                 lp->default_media = (config & Xcvr) >> Xcvr_shift;
408                 lp->autoselect = config & Autoselect ? 1 : 0;
409         }
410
411         init_timer(&lp->media);
412
413         {
414                 int phy;
415                 
416                 /* Roadrunner only: Turn on the MII transceiver */
417                 outw(0x8040, ioaddr + Wn3_Options);
418                 mdelay(1);
419                 outw(0xc040, ioaddr + Wn3_Options);
420                 tc574_wait_for_completion(dev, TxReset);
421                 tc574_wait_for_completion(dev, RxReset);
422                 mdelay(1);
423                 outw(0x8040, ioaddr + Wn3_Options);
424                 
425                 EL3WINDOW(4);
426                 for (phy = 1; phy <= 32; phy++) {
427                         int mii_status;
428                         mdio_sync(ioaddr, 32);
429                         mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
430                         if (mii_status != 0xffff) {
431                                 lp->phys = phy & 0x1f;
432                                 DEBUG(0, "  MII transceiver at index %d, status %x.\n",
433                                           phy, mii_status);
434                                 if ((mii_status & 0x0040) == 0)
435                                         mii_preamble_required = 1;
436                                 break;
437                         }
438                 }
439                 if (phy > 32) {
440                         printk(KERN_NOTICE "  No MII transceivers found!\n");
441                         goto failed;
442                 }
443                 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
444                 mdio_write(ioaddr, lp->phys, 16, i);
445                 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
446                 if (full_duplex) {
447                         /* Only advertise the FD media types. */
448                         lp->advertising &= ~0x02a0;
449                         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
450                 }
451         }
452
453         link->dev_node = &lp->node;
454         SET_NETDEV_DEV(dev, &handle_to_dev(link));
455
456         if (register_netdev(dev) != 0) {
457                 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
458                 link->dev_node = NULL;
459                 goto failed;
460         }
461
462         strcpy(lp->node.dev_name, dev->name);
463
464         printk(KERN_INFO "%s: %s at io %#3lx, irq %d, "
465                "hw_addr %s.\n",
466                dev->name, cardname, dev->base_addr, dev->irq,
467                print_mac(mac, dev->dev_addr));
468         printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
469                    8 << config & Ram_size,
470                    ram_split[(config & Ram_split) >> Ram_split_shift],
471                    config & Autoselect ? "autoselect " : "");
472
473         return 0;
474
475 cs_failed:
476         cs_error(link, last_fn, last_ret);
477 failed:
478         tc574_release(link);
479         return -ENODEV;
480
481 } /* tc574_config */
482
483 /*
484         After a card is removed, tc574_release() will unregister the net
485         device, and release the PCMCIA configuration.  If the device is
486         still open, this will be postponed until it is closed.
487 */
488
489 static void tc574_release(struct pcmcia_device *link)
490 {
491         pcmcia_disable_device(link);
492 }
493
494 static int tc574_suspend(struct pcmcia_device *link)
495 {
496         struct net_device *dev = link->priv;
497
498         if (link->open)
499                 netif_device_detach(dev);
500
501         return 0;
502 }
503
504 static int tc574_resume(struct pcmcia_device *link)
505 {
506         struct net_device *dev = link->priv;
507
508         if (link->open) {
509                 tc574_reset(dev);
510                 netif_device_attach(dev);
511         }
512
513         return 0;
514 }
515
516 static void dump_status(struct net_device *dev)
517 {
518         unsigned int ioaddr = dev->base_addr;
519         EL3WINDOW(1);
520         printk(KERN_INFO "  irq status %04x, rx status %04x, tx status "
521                    "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
522                    inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
523                    inw(ioaddr+TxFree));
524         EL3WINDOW(4);
525         printk(KERN_INFO "  diagnostics: fifo %04x net %04x ethernet %04x"
526                    " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
527                    inw(ioaddr+0x08), inw(ioaddr+0x0a));
528         EL3WINDOW(1);
529 }
530
531 /*
532   Use this for commands that may take time to finish
533 */
534 static void tc574_wait_for_completion(struct net_device *dev, int cmd)
535 {
536         int i = 1500;
537         outw(cmd, dev->base_addr + EL3_CMD);
538         while (--i > 0)
539                 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
540         if (i == 0)
541                 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
542 }
543
544 /* Read a word from the EEPROM using the regular EEPROM access register.
545    Assume that we are in register window zero.
546  */
547 static unsigned short read_eeprom(unsigned int ioaddr, int index)
548 {
549         int timer;
550         outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
551         /* Pause for at least 162 usec for the read to take place. */
552         for (timer = 1620; timer >= 0; timer--) {
553                 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
554                         break;
555         }
556         return inw(ioaddr + Wn0EepromData);
557 }
558
559 /* MII transceiver control section.
560    Read and write the MII registers using software-generated serial
561    MDIO protocol.  See the MII specifications or DP83840A data sheet
562    for details.
563    The maxium data clock rate is 2.5 Mhz.  The timing is easily met by the
564    slow PC card interface. */
565
566 #define MDIO_SHIFT_CLK  0x01
567 #define MDIO_DIR_WRITE  0x04
568 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
569 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
570 #define MDIO_DATA_READ  0x02
571 #define MDIO_ENB_IN             0x00
572
573 /* Generate the preamble required for initial synchronization and
574    a few older transceivers. */
575 static void mdio_sync(unsigned int ioaddr, int bits)
576 {
577         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
578
579         /* Establish sync by sending at least 32 logic ones. */
580         while (-- bits >= 0) {
581                 outw(MDIO_DATA_WRITE1, mdio_addr);
582                 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
583         }
584 }
585
586 static int mdio_read(unsigned int ioaddr, int phy_id, int location)
587 {
588         int i;
589         int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
590         unsigned int retval = 0;
591         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
592
593         if (mii_preamble_required)
594                 mdio_sync(ioaddr, 32);
595
596         /* Shift the read command bits out. */
597         for (i = 14; i >= 0; i--) {
598                 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
599                 outw(dataval, mdio_addr);
600                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
601         }
602         /* Read the two transition, 16 data, and wire-idle bits. */
603         for (i = 19; i > 0; i--) {
604                 outw(MDIO_ENB_IN, mdio_addr);
605                 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
606                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
607         }
608         return (retval>>1) & 0xffff;
609 }
610
611 static void mdio_write(unsigned int ioaddr, int phy_id, int location, int value)
612 {
613         int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
614         unsigned int mdio_addr = ioaddr + Wn4_PhysicalMgmt;
615         int i;
616
617         if (mii_preamble_required)
618                 mdio_sync(ioaddr, 32);
619
620         /* Shift the command bits out. */
621         for (i = 31; i >= 0; i--) {
622                 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
623                 outw(dataval, mdio_addr);
624                 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
625         }
626         /* Leave the interface idle. */
627         for (i = 1; i >= 0; i--) {
628                 outw(MDIO_ENB_IN, mdio_addr);
629                 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
630         }
631
632         return;
633 }
634
635 /* Reset and restore all of the 3c574 registers. */
636 static void tc574_reset(struct net_device *dev)
637 {
638         struct el3_private *lp = netdev_priv(dev);
639         int i;
640         unsigned int ioaddr = dev->base_addr;
641         unsigned long flags;
642
643         tc574_wait_for_completion(dev, TotalReset|0x10);
644
645         spin_lock_irqsave(&lp->window_lock, flags);
646         /* Clear any transactions in progress. */
647         outw(0, ioaddr + RunnerWrCtrl);
648         outw(0, ioaddr + RunnerRdCtrl);
649
650         /* Set the station address and mask. */
651         EL3WINDOW(2);
652         for (i = 0; i < 6; i++)
653                 outb(dev->dev_addr[i], ioaddr + i);
654         for (; i < 12; i+=2)
655                 outw(0, ioaddr + i);
656
657         /* Reset config options */
658         EL3WINDOW(3);
659         outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
660         outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
661                  ioaddr + Wn3_Config);
662         /* Roadrunner only: Turn on the MII transceiver. */
663         outw(0x8040, ioaddr + Wn3_Options);
664         mdelay(1);
665         outw(0xc040, ioaddr + Wn3_Options);
666         EL3WINDOW(1);
667         spin_unlock_irqrestore(&lp->window_lock, flags);
668         
669         tc574_wait_for_completion(dev, TxReset);
670         tc574_wait_for_completion(dev, RxReset);
671         mdelay(1);
672         spin_lock_irqsave(&lp->window_lock, flags);
673         EL3WINDOW(3);
674         outw(0x8040, ioaddr + Wn3_Options);
675
676         /* Switch to the stats window, and clear all stats by reading. */
677         outw(StatsDisable, ioaddr + EL3_CMD);
678         EL3WINDOW(6);
679         for (i = 0; i < 10; i++)
680                 inb(ioaddr + i);
681         inw(ioaddr + 10);
682         inw(ioaddr + 12);
683         EL3WINDOW(4);
684         inb(ioaddr + 12);
685         inb(ioaddr + 13);
686
687         /* .. enable any extra statistics bits.. */
688         outw(0x0040, ioaddr + Wn4_NetDiag);
689         
690         EL3WINDOW(1);
691         spin_unlock_irqrestore(&lp->window_lock, flags);
692         
693         /* .. re-sync MII and re-fill what NWay is advertising. */
694         mdio_sync(ioaddr, 32);
695         mdio_write(ioaddr, lp->phys, 4, lp->advertising);
696         if (!auto_polarity) {
697                 /* works for TDK 78Q2120 series MII's */
698                 i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
699                 mdio_write(ioaddr, lp->phys, 16, i);
700         }
701
702         spin_lock_irqsave(&lp->window_lock, flags);
703         /* Switch to register set 1 for normal use, just for TxFree. */
704         set_rx_mode(dev);
705         spin_unlock_irqrestore(&lp->window_lock, flags);
706         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
707         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
708         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
709         /* Allow status bits to be seen. */
710         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
711         /* Ack all pending events, and set active indicator mask. */
712         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
713                  ioaddr + EL3_CMD);
714         outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
715                  | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
716 }
717
718 static int el3_open(struct net_device *dev)
719 {
720         struct el3_private *lp = netdev_priv(dev);
721         struct pcmcia_device *link = lp->p_dev;
722
723         if (!pcmcia_dev_present(link))
724                 return -ENODEV;
725         
726         link->open++;
727         netif_start_queue(dev);
728         
729         tc574_reset(dev);
730         lp->media.function = &media_check;
731         lp->media.data = (unsigned long) dev;
732         lp->media.expires = jiffies + HZ;
733         add_timer(&lp->media);
734         
735         DEBUG(2, "%s: opened, status %4.4x.\n",
736                   dev->name, inw(dev->base_addr + EL3_STATUS));
737         
738         return 0;
739 }
740
741 static void el3_tx_timeout(struct net_device *dev)
742 {
743         unsigned int ioaddr = dev->base_addr;
744         
745         printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
746         dump_status(dev);
747         dev->stats.tx_errors++;
748         dev->trans_start = jiffies;
749         /* Issue TX_RESET and TX_START commands. */
750         tc574_wait_for_completion(dev, TxReset);
751         outw(TxEnable, ioaddr + EL3_CMD);
752         netif_wake_queue(dev);
753 }
754
755 static void pop_tx_status(struct net_device *dev)
756 {
757         unsigned int ioaddr = dev->base_addr;
758         int i;
759     
760         /* Clear the Tx status stack. */
761         for (i = 32; i > 0; i--) {
762                 u_char tx_status = inb(ioaddr + TxStatus);
763                 if (!(tx_status & 0x84))
764                         break;
765                 /* reset transmitter on jabber error or underrun */
766                 if (tx_status & 0x30)
767                         tc574_wait_for_completion(dev, TxReset);
768                 if (tx_status & 0x38) {
769                         DEBUG(1, "%s: transmit error: status 0x%02x\n",
770                                   dev->name, tx_status);
771                         outw(TxEnable, ioaddr + EL3_CMD);
772                         dev->stats.tx_aborted_errors++;
773                 }
774                 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
775         }
776 }
777
778 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
779 {
780         unsigned int ioaddr = dev->base_addr;
781         struct el3_private *lp = netdev_priv(dev);
782         unsigned long flags;
783
784         DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
785                   "status %4.4x.\n", dev->name, (long)skb->len,
786                   inw(ioaddr + EL3_STATUS));
787
788         spin_lock_irqsave(&lp->window_lock, flags);
789         outw(skb->len, ioaddr + TX_FIFO);
790         outw(0, ioaddr + TX_FIFO);
791         outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
792
793         dev->trans_start = jiffies;
794
795         /* TxFree appears only in Window 1, not offset 0x1c. */
796         if (inw(ioaddr + TxFree) <= 1536) {
797                 netif_stop_queue(dev);
798                 /* Interrupt us when the FIFO has room for max-sized packet. 
799                    The threshold is in units of dwords. */
800                 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
801         }
802
803         pop_tx_status(dev);
804         spin_unlock_irqrestore(&lp->window_lock, flags);
805         dev_kfree_skb(skb);
806         return 0;
807 }
808
809 /* The EL3 interrupt handler. */
810 static irqreturn_t el3_interrupt(int irq, void *dev_id)
811 {
812         struct net_device *dev = (struct net_device *) dev_id;
813         struct el3_private *lp = netdev_priv(dev);
814         unsigned int ioaddr;
815         unsigned status;
816         int work_budget = max_interrupt_work;
817         int handled = 0;
818
819         if (!netif_device_present(dev))
820                 return IRQ_NONE;
821         ioaddr = dev->base_addr;
822
823         DEBUG(3, "%s: interrupt, status %4.4x.\n",
824                   dev->name, inw(ioaddr + EL3_STATUS));
825
826         spin_lock(&lp->window_lock);
827         
828         while ((status = inw(ioaddr + EL3_STATUS)) &
829                    (IntLatch | RxComplete | RxEarly | StatsFull)) {
830                 if (!netif_device_present(dev) ||
831                         ((status & 0xe000) != 0x2000)) {
832                         DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
833                         break;
834                 }
835
836                 handled = 1;
837
838                 if (status & RxComplete)
839                         work_budget = el3_rx(dev, work_budget);
840
841                 if (status & TxAvailable) {
842                         DEBUG(3, "  TX room bit was handled.\n");
843                         /* There's room in the FIFO for a full-sized packet. */
844                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
845                         netif_wake_queue(dev);
846                 }
847
848                 if (status & TxComplete)
849                         pop_tx_status(dev);
850
851                 if (status & (AdapterFailure | RxEarly | StatsFull)) {
852                         /* Handle all uncommon interrupts. */
853                         if (status & StatsFull)
854                                 update_stats(dev);
855                         if (status & RxEarly) {
856                                 work_budget = el3_rx(dev, work_budget);
857                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
858                         }
859                         if (status & AdapterFailure) {
860                                 u16 fifo_diag;
861                                 EL3WINDOW(4);
862                                 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
863                                 EL3WINDOW(1);
864                                 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
865                                            " register %04x.\n", dev->name, fifo_diag);
866                                 if (fifo_diag & 0x0400) {
867                                         /* Tx overrun */
868                                         tc574_wait_for_completion(dev, TxReset);
869                                         outw(TxEnable, ioaddr + EL3_CMD);
870                                 }
871                                 if (fifo_diag & 0x2000) {
872                                         /* Rx underrun */
873                                         tc574_wait_for_completion(dev, RxReset);
874                                         set_rx_mode(dev);
875                                         outw(RxEnable, ioaddr + EL3_CMD);
876                                 }
877                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
878                         }
879                 }
880
881                 if (--work_budget < 0) {
882                         DEBUG(0, "%s: Too much work in interrupt, "
883                                   "status %4.4x.\n", dev->name, status);
884                         /* Clear all interrupts */
885                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
886                         break;
887                 }
888                 /* Acknowledge the IRQ. */
889                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
890         }
891
892         DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
893                   dev->name, inw(ioaddr + EL3_STATUS));
894                   
895         spin_unlock(&lp->window_lock);
896         return IRQ_RETVAL(handled);
897 }
898
899 /*
900     This timer serves two purposes: to check for missed interrupts
901         (and as a last resort, poll the NIC for events), and to monitor
902         the MII, reporting changes in cable status.
903 */
904 static void media_check(unsigned long arg)
905 {
906         struct net_device *dev = (struct net_device *) arg;
907         struct el3_private *lp = netdev_priv(dev);
908         unsigned int ioaddr = dev->base_addr;
909         unsigned long flags;
910         unsigned short /* cable, */ media, partner;
911
912         if (!netif_device_present(dev))
913                 goto reschedule;
914         
915         /* Check for pending interrupt with expired latency timer: with
916            this, we can limp along even if the interrupt is blocked */
917         if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
918                 if (!lp->fast_poll)
919                         printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
920                 el3_interrupt(dev->irq, dev);
921                 lp->fast_poll = HZ;
922         }
923         if (lp->fast_poll) {
924                 lp->fast_poll--;
925                 lp->media.expires = jiffies + 2*HZ/100;
926                 add_timer(&lp->media);
927                 return;
928         }
929
930         spin_lock_irqsave(&lp->window_lock, flags);
931         EL3WINDOW(4);
932         media = mdio_read(ioaddr, lp->phys, 1);
933         partner = mdio_read(ioaddr, lp->phys, 5);
934         EL3WINDOW(1);
935         
936         if (media != lp->media_status) {
937                 if ((media ^ lp->media_status) & 0x0004)
938                         printk(KERN_INFO "%s: %s link beat\n", dev->name,
939                                    (lp->media_status & 0x0004) ? "lost" : "found");
940                 if ((media ^ lp->media_status) & 0x0020) {
941                         lp->partner = 0;
942                         if (lp->media_status & 0x0020) {
943                                 printk(KERN_INFO "%s: autonegotiation restarted\n",
944                                            dev->name);
945                         } else if (partner) {
946                                 partner &= lp->advertising;
947                                 lp->partner = partner;
948                                 printk(KERN_INFO "%s: autonegotiation complete: "
949                                            "%sbaseT-%cD selected\n", dev->name,
950                                            ((partner & 0x0180) ? "100" : "10"),
951                                            ((partner & 0x0140) ? 'F' : 'H'));
952                         } else {
953                                 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
954                                            dev->name);
955                         }
956
957                         EL3WINDOW(3);
958                         outb((partner & 0x0140 ? 0x20 : 0) |
959                                  (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
960                         EL3WINDOW(1);
961
962                 }
963                 if (media & 0x0010)
964                         printk(KERN_INFO "%s: remote fault detected\n",
965                                    dev->name);
966                 if (media & 0x0002)
967                         printk(KERN_INFO "%s: jabber detected\n", dev->name);
968                 lp->media_status = media;
969         }
970         spin_unlock_irqrestore(&lp->window_lock, flags);
971
972 reschedule:
973         lp->media.expires = jiffies + HZ;
974         add_timer(&lp->media);
975 }
976
977 static struct net_device_stats *el3_get_stats(struct net_device *dev)
978 {
979         struct el3_private *lp = netdev_priv(dev);
980
981         if (netif_device_present(dev)) {
982                 unsigned long flags;
983                 spin_lock_irqsave(&lp->window_lock, flags);
984                 update_stats(dev);
985                 spin_unlock_irqrestore(&lp->window_lock, flags);
986         }
987         return &dev->stats;
988 }
989
990 /*  Update statistics.
991         Suprisingly this need not be run single-threaded, but it effectively is.
992         The counters clear when read, so the adds must merely be atomic.
993  */
994 static void update_stats(struct net_device *dev)
995 {
996         unsigned int ioaddr = dev->base_addr;
997         u8 rx, tx, up;
998
999         DEBUG(2, "%s: updating the statistics.\n", dev->name);
1000
1001         if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1002                 return;
1003                 
1004         /* Unlike the 3c509 we need not turn off stats updates while reading. */
1005         /* Switch to the stats window, and read everything. */
1006         EL3WINDOW(6);
1007         dev->stats.tx_carrier_errors            += inb(ioaddr + 0);
1008         dev->stats.tx_heartbeat_errors          += inb(ioaddr + 1);
1009         /* Multiple collisions. */              inb(ioaddr + 2);
1010         dev->stats.collisions                   += inb(ioaddr + 3);
1011         dev->stats.tx_window_errors             += inb(ioaddr + 4);
1012         dev->stats.rx_fifo_errors               += inb(ioaddr + 5);
1013         dev->stats.tx_packets                   += inb(ioaddr + 6);
1014         up                                       = inb(ioaddr + 9);
1015         dev->stats.tx_packets                   += (up&0x30) << 4;
1016         /* Rx packets   */                         inb(ioaddr + 7);
1017         /* Tx deferrals */                         inb(ioaddr + 8);
1018         rx                                       = inw(ioaddr + 10);
1019         tx                                       = inw(ioaddr + 12);
1020
1021         EL3WINDOW(4);
1022         /* BadSSD */                               inb(ioaddr + 12);
1023         up                                       = inb(ioaddr + 13);
1024
1025         dev->stats.tx_bytes                     += tx + ((up & 0xf0) << 12);
1026
1027         EL3WINDOW(1);
1028 }
1029
1030 static int el3_rx(struct net_device *dev, int worklimit)
1031 {
1032         unsigned int ioaddr = dev->base_addr;
1033         short rx_status;
1034         
1035         DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1036                   dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1037         while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1038                    (--worklimit >= 0)) {
1039                 if (rx_status & 0x4000) { /* Error, update stats. */
1040                         short error = rx_status & 0x3800;
1041                         dev->stats.rx_errors++;
1042                         switch (error) {
1043                         case 0x0000:    dev->stats.rx_over_errors++; break;
1044                         case 0x0800:    dev->stats.rx_length_errors++; break;
1045                         case 0x1000:    dev->stats.rx_frame_errors++; break;
1046                         case 0x1800:    dev->stats.rx_length_errors++; break;
1047                         case 0x2000:    dev->stats.rx_frame_errors++; break;
1048                         case 0x2800:    dev->stats.rx_crc_errors++; break;
1049                         }
1050                 } else {
1051                         short pkt_len = rx_status & 0x7ff;
1052                         struct sk_buff *skb;
1053
1054                         skb = dev_alloc_skb(pkt_len+5);
1055
1056                         DEBUG(3, "  Receiving packet size %d status %4.4x.\n",
1057                                   pkt_len, rx_status);
1058                         if (skb != NULL) {
1059                                 skb_reserve(skb, 2);
1060                                 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1061                                                 ((pkt_len+3)>>2));
1062                                 skb->protocol = eth_type_trans(skb, dev);
1063                                 netif_rx(skb);
1064                                 dev->last_rx = jiffies;
1065                                 dev->stats.rx_packets++;
1066                                 dev->stats.rx_bytes += pkt_len;
1067                         } else {
1068                                 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1069                                           " size %d.\n", dev->name, pkt_len);
1070                                 dev->stats.rx_dropped++;
1071                         }
1072                 }
1073                 tc574_wait_for_completion(dev, RxDiscard);
1074         }
1075
1076         return worklimit;
1077 }
1078
1079 static void netdev_get_drvinfo(struct net_device *dev,
1080                                struct ethtool_drvinfo *info)
1081 {
1082         strcpy(info->driver, "3c574_cs");
1083 }
1084
1085 static const struct ethtool_ops netdev_ethtool_ops = {
1086         .get_drvinfo            = netdev_get_drvinfo,
1087 };
1088
1089 /* Provide ioctl() calls to examine the MII xcvr state. */
1090 static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1091 {
1092         struct el3_private *lp = netdev_priv(dev);
1093         unsigned int ioaddr = dev->base_addr;
1094         u16 *data = (u16 *)&rq->ifr_ifru;
1095         int phy = lp->phys & 0x1f;
1096
1097         DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1098                   dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1099                   data[0], data[1], data[2], data[3]);
1100
1101         switch(cmd) {
1102         case SIOCGMIIPHY:               /* Get the address of the PHY in use. */
1103                 data[0] = phy;
1104         case SIOCGMIIREG:               /* Read the specified MII register. */
1105                 {
1106                         int saved_window;
1107                         unsigned long flags;
1108
1109                         spin_lock_irqsave(&lp->window_lock, flags);
1110                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1111                         EL3WINDOW(4);
1112                         data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1113                         EL3WINDOW(saved_window);
1114                         spin_unlock_irqrestore(&lp->window_lock, flags);
1115                         return 0;
1116                 }
1117         case SIOCSMIIREG:               /* Write the specified MII register */
1118                 {
1119                         int saved_window;
1120                        unsigned long flags;
1121
1122                         if (!capable(CAP_NET_ADMIN))
1123                                 return -EPERM;
1124                         spin_lock_irqsave(&lp->window_lock, flags);
1125                         saved_window = inw(ioaddr + EL3_CMD) >> 13;
1126                         EL3WINDOW(4);
1127                         mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1128                         EL3WINDOW(saved_window);
1129                         spin_unlock_irqrestore(&lp->window_lock, flags);
1130                         return 0;
1131                 }
1132         default:
1133                 return -EOPNOTSUPP;
1134         }
1135 }
1136
1137 /* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1138    documented.  Until it is we revert to receiving all multicast frames when
1139    any multicast reception is desired.
1140    Note: My other drivers emit a log message whenever promiscuous mode is
1141    entered to help detect password sniffers.  This is less desirable on
1142    typical PC card machines, so we omit the message.
1143    */
1144
1145 static void set_rx_mode(struct net_device *dev)
1146 {
1147         unsigned int ioaddr = dev->base_addr;
1148
1149         if (dev->flags & IFF_PROMISC)
1150                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1151                          ioaddr + EL3_CMD);
1152         else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1153                 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1154         else
1155                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1156 }
1157
1158 static int el3_close(struct net_device *dev)
1159 {
1160         unsigned int ioaddr = dev->base_addr;
1161         struct el3_private *lp = netdev_priv(dev);
1162         struct pcmcia_device *link = lp->p_dev;
1163
1164         DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1165         
1166         if (pcmcia_dev_present(link)) {
1167                 unsigned long flags;
1168
1169                 /* Turn off statistics ASAP.  We update lp->stats below. */
1170                 outw(StatsDisable, ioaddr + EL3_CMD);
1171                 
1172                 /* Disable the receiver and transmitter. */
1173                 outw(RxDisable, ioaddr + EL3_CMD);
1174                 outw(TxDisable, ioaddr + EL3_CMD);
1175                 
1176                 /* Note: Switching to window 0 may disable the IRQ. */
1177                 EL3WINDOW(0);
1178                 spin_lock_irqsave(&lp->window_lock, flags);
1179                 update_stats(dev);
1180                 spin_unlock_irqrestore(&lp->window_lock, flags);
1181
1182                 /* force interrupts off */
1183                 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1184         }
1185
1186         link->open--;
1187         netif_stop_queue(dev);
1188         del_timer_sync(&lp->media);
1189
1190         return 0;
1191 }
1192
1193 static struct pcmcia_device_id tc574_ids[] = {
1194         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0574),
1195         PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0556, "3CCFEM556.cis"),
1196         PCMCIA_DEVICE_NULL,
1197 };
1198 MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
1199
1200 static struct pcmcia_driver tc574_driver = {
1201         .owner          = THIS_MODULE,
1202         .drv            = {
1203                 .name   = "3c574_cs",
1204         },
1205         .probe          = tc574_probe,
1206         .remove         = tc574_detach,
1207         .id_table       = tc574_ids,
1208         .suspend        = tc574_suspend,
1209         .resume         = tc574_resume,
1210 };
1211
1212 static int __init init_tc574(void)
1213 {
1214         return pcmcia_register_driver(&tc574_driver);
1215 }
1216
1217 static void __exit exit_tc574(void)
1218 {
1219         pcmcia_unregister_driver(&tc574_driver);
1220 }
1221
1222 module_init(init_tc574);
1223 module_exit(exit_tc574);