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