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