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