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