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