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