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