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