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