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