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