aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/pcmcia/3c574_cs.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/pcmcia/3c574_cs.c')
-rw-r--r--drivers/net/pcmcia/3c574_cs.c1307
1 files changed, 1307 insertions, 0 deletions
diff --git a/drivers/net/pcmcia/3c574_cs.c b/drivers/net/pcmcia/3c574_cs.c
new file mode 100644
index 000000000000..41e517114807
--- /dev/null
+++ b/drivers/net/pcmcia/3c574_cs.c
@@ -0,0 +1,1307 @@
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
89#include <pcmcia/version.h>
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};
191union wn3_config {
192 int i;
193 struct w3_config_fields {
194 unsigned int ram_size:3, ram_width:1, ram_speed:2, rom_size:2;
195 int pad8:8;
196 unsigned int ram_split:2, pad18:2, xcvr:3, pad21:1, autoselect:1;
197 int pad24:7;
198 } u;
199};
200
201enum Window4 { /* Window 4: Xcvr/media bits. */
202 Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
203};
204
205#define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
206
207struct el3_private {
208 dev_link_t link;
209 dev_node_t node;
210 struct net_device_stats stats;
211 u16 advertising, partner; /* NWay media advertisement */
212 unsigned char phys; /* MII device address */
213 unsigned int autoselect:1, default_media:3; /* Read from the EEPROM/Wn3_Config. */
214 /* for transceiver monitoring */
215 struct timer_list media;
216 unsigned short media_status;
217 unsigned short fast_poll;
218 unsigned long last_irq;
219 spinlock_t window_lock; /* Guards the Window selection */
220};
221
222/* Set iff a MII transceiver on any interface requires mdio preamble.
223 This only set with the original DP83840 on older 3c905 boards, so the extra
224 code size of a per-interface flag is not worthwhile. */
225static char mii_preamble_required = 0;
226
227/* Index of functions. */
228
229static void tc574_config(dev_link_t *link);
230static void tc574_release(dev_link_t *link);
231static int tc574_event(event_t event, int priority,
232 event_callback_args_t *args);
233
234static void mdio_sync(kio_addr_t ioaddr, int bits);
235static int mdio_read(kio_addr_t ioaddr, int phy_id, int location);
236static void mdio_write(kio_addr_t ioaddr, int phy_id, int location, int value);
237static unsigned short read_eeprom(kio_addr_t ioaddr, int index);
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);
244static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
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);
251static struct ethtool_ops netdev_ethtool_ops;
252static void set_rx_mode(struct net_device *dev);
253
254static dev_info_t dev_info = "3c574_cs";
255
256static dev_link_t *tc574_attach(void);
257static void tc574_detach(dev_link_t *);
258
259static dev_link_t *dev_list;
260
261/*
262 tc574_attach() creates an "instance" of the driver, allocating
263 local data structures for one device. The device is registered
264 with Card Services.
265*/
266
267static dev_link_t *tc574_attach(void)
268{
269 struct el3_private *lp;
270 client_reg_t client_reg;
271 dev_link_t *link;
272 struct net_device *dev;
273 int ret;
274
275 DEBUG(0, "3c574_attach()\n");
276
277 /* Create the PC card device object. */
278 dev = alloc_etherdev(sizeof(struct el3_private));
279 if (!dev)
280 return NULL;
281 lp = netdev_priv(dev);
282 link = &lp->link;
283 link->priv = dev;
284
285 spin_lock_init(&lp->window_lock);
286 link->io.NumPorts1 = 32;
287 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
288 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
289 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
290 link->irq.Handler = &el3_interrupt;
291 link->irq.Instance = dev;
292 link->conf.Attributes = CONF_ENABLE_IRQ;
293 link->conf.Vcc = 50;
294 link->conf.IntType = INT_MEMORY_AND_IO;
295 link->conf.ConfigIndex = 1;
296 link->conf.Present = PRESENT_OPTION;
297
298 /* The EL3-specific entries in the device structure. */
299 dev->hard_start_xmit = &el3_start_xmit;
300 dev->get_stats = &el3_get_stats;
301 dev->do_ioctl = &el3_ioctl;
302 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
303 dev->set_multicast_list = &set_rx_mode;
304 dev->open = &el3_open;
305 dev->stop = &el3_close;
306#ifdef HAVE_TX_TIMEOUT
307 dev->tx_timeout = el3_tx_timeout;
308 dev->watchdog_timeo = TX_TIMEOUT;
309#endif
310
311 /* Register with Card Services */
312 link->next = dev_list;
313 dev_list = link;
314 client_reg.dev_info = &dev_info;
315 client_reg.EventMask =
316 CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
317 CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
318 CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
319 client_reg.event_handler = &tc574_event;
320 client_reg.Version = 0x0210;
321 client_reg.event_callback_args.client_data = link;
322 ret = pcmcia_register_client(&link->handle, &client_reg);
323 if (ret != 0) {
324 cs_error(link->handle, RegisterClient, ret);
325 tc574_detach(link);
326 return NULL;
327 }
328
329 return link;
330} /* tc574_attach */
331
332/*
333
334 This deletes a driver "instance". The device is de-registered
335 with Card Services. If it has been released, all local data
336 structures are freed. Otherwise, the structures will be freed
337 when the device is released.
338
339*/
340
341static void tc574_detach(dev_link_t *link)
342{
343 struct net_device *dev = link->priv;
344 dev_link_t **linkp;
345
346 DEBUG(0, "3c574_detach(0x%p)\n", link);
347
348 /* Locate device structure */
349 for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
350 if (*linkp == link) break;
351 if (*linkp == NULL)
352 return;
353
354 if (link->dev)
355 unregister_netdev(dev);
356
357 if (link->state & DEV_CONFIG)
358 tc574_release(link);
359
360 if (link->handle)
361 pcmcia_deregister_client(link->handle);
362
363 /* Unlink device structure, free bits */
364 *linkp = link->next;
365 free_netdev(dev);
366} /* tc574_detach */
367
368/*
369 tc574_config() is scheduled to run after a CARD_INSERTION event
370 is received, to configure the PCMCIA socket, and to make the
371 ethernet device available to the system.
372*/
373
374#define CS_CHECK(fn, ret) \
375 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
376
377static char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
378
379static void tc574_config(dev_link_t *link)
380{
381 client_handle_t handle = link->handle;
382 struct net_device *dev = link->priv;
383 struct el3_private *lp = netdev_priv(dev);
384 tuple_t tuple;
385 cisparse_t parse;
386 unsigned short buf[32];
387 int last_fn, last_ret, i, j;
388 kio_addr_t ioaddr;
389 u16 *phys_addr;
390 char *cardname;
391 union wn3_config config;
392
393 phys_addr = (u16 *)dev->dev_addr;
394
395 DEBUG(0, "3c574_config(0x%p)\n", link);
396
397 tuple.Attributes = 0;
398 tuple.DesiredTuple = CISTPL_CONFIG;
399 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
400 tuple.TupleData = (cisdata_t *)buf;
401 tuple.TupleDataMax = 64;
402 tuple.TupleOffset = 0;
403 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
404 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
405 link->conf.ConfigBase = parse.config.base;
406 link->conf.Present = parse.config.rmask[0];
407
408 /* Configure card */
409 link->state |= DEV_CONFIG;
410
411 link->io.IOAddrLines = 16;
412 for (i = j = 0; j < 0x400; j += 0x20) {
413 link->io.BasePort1 = j ^ 0x300;
414 i = pcmcia_request_io(link->handle, &link->io);
415 if (i == CS_SUCCESS) break;
416 }
417 if (i != CS_SUCCESS) {
418 cs_error(link->handle, RequestIO, i);
419 goto failed;
420 }
421 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
422 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
423
424 dev->irq = link->irq.AssignedIRQ;
425 dev->base_addr = link->io.BasePort1;
426
427 ioaddr = dev->base_addr;
428
429 /* The 3c574 normally uses an EEPROM for configuration info, including
430 the hardware address. The future products may include a modem chip
431 and put the address in the CIS. */
432 tuple.DesiredTuple = 0x88;
433 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS) {
434 pcmcia_get_tuple_data(handle, &tuple);
435 for (i = 0; i < 3; i++)
436 phys_addr[i] = htons(buf[i]);
437 } else {
438 EL3WINDOW(0);
439 for (i = 0; i < 3; i++)
440 phys_addr[i] = htons(read_eeprom(ioaddr, i + 10));
441 if (phys_addr[0] == 0x6060) {
442 printk(KERN_NOTICE "3c574_cs: IO port conflict at 0x%03lx"
443 "-0x%03lx\n", dev->base_addr, dev->base_addr+15);
444 goto failed;
445 }
446 }
447 tuple.DesiredTuple = CISTPL_VERS_1;
448 if (pcmcia_get_first_tuple(handle, &tuple) == CS_SUCCESS &&
449 pcmcia_get_tuple_data(handle, &tuple) == CS_SUCCESS &&
450 pcmcia_parse_tuple(handle, &tuple, &parse) == CS_SUCCESS) {
451 cardname = parse.version_1.str + parse.version_1.ofs[1];
452 } else
453 cardname = "3Com 3c574";
454
455 {
456 u_char mcr;
457 outw(2<<11, ioaddr + RunnerRdCtrl);
458 mcr = inb(ioaddr + 2);
459 outw(0<<11, ioaddr + RunnerRdCtrl);
460 printk(KERN_INFO " ASIC rev %d,", mcr>>3);
461 EL3WINDOW(3);
462 config.i = inl(ioaddr + Wn3_Config);
463 lp->default_media = config.u.xcvr;
464 lp->autoselect = config.u.autoselect;
465 }
466
467 init_timer(&lp->media);
468
469 {
470 int phy;
471
472 /* Roadrunner only: Turn on the MII transceiver */
473 outw(0x8040, ioaddr + Wn3_Options);
474 mdelay(1);
475 outw(0xc040, ioaddr + Wn3_Options);
476 tc574_wait_for_completion(dev, TxReset);
477 tc574_wait_for_completion(dev, RxReset);
478 mdelay(1);
479 outw(0x8040, ioaddr + Wn3_Options);
480
481 EL3WINDOW(4);
482 for (phy = 1; phy <= 32; phy++) {
483 int mii_status;
484 mdio_sync(ioaddr, 32);
485 mii_status = mdio_read(ioaddr, phy & 0x1f, 1);
486 if (mii_status != 0xffff) {
487 lp->phys = phy & 0x1f;
488 DEBUG(0, " MII transceiver at index %d, status %x.\n",
489 phy, mii_status);
490 if ((mii_status & 0x0040) == 0)
491 mii_preamble_required = 1;
492 break;
493 }
494 }
495 if (phy > 32) {
496 printk(KERN_NOTICE " No MII transceivers found!\n");
497 goto failed;
498 }
499 i = mdio_read(ioaddr, lp->phys, 16) | 0x40;
500 mdio_write(ioaddr, lp->phys, 16, i);
501 lp->advertising = mdio_read(ioaddr, lp->phys, 4);
502 if (full_duplex) {
503 /* Only advertise the FD media types. */
504 lp->advertising &= ~0x02a0;
505 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
506 }
507 }
508
509 link->state &= ~DEV_CONFIG_PENDING;
510 link->dev = &lp->node;
511 SET_NETDEV_DEV(dev, &handle_to_dev(handle));
512
513 if (register_netdev(dev) != 0) {
514 printk(KERN_NOTICE "3c574_cs: register_netdev() failed\n");
515 link->dev = NULL;
516 goto failed;
517 }
518
519 strcpy(lp->node.dev_name, dev->name);
520
521 printk(KERN_INFO "%s: %s at io %#3lx, irq %d, hw_addr ",
522 dev->name, cardname, dev->base_addr, dev->irq);
523 for (i = 0; i < 6; i++)
524 printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : ".\n"));
525 printk(" %dK FIFO split %s Rx:Tx, %sMII interface.\n",
526 8 << config.u.ram_size, ram_split[config.u.ram_split],
527 config.u.autoselect ? "autoselect " : "");
528
529 return;
530
531cs_failed:
532 cs_error(link->handle, last_fn, last_ret);
533failed:
534 tc574_release(link);
535 return;
536
537} /* tc574_config */
538
539/*
540 After a card is removed, tc574_release() will unregister the net
541 device, and release the PCMCIA configuration. If the device is
542 still open, this will be postponed until it is closed.
543*/
544
545static void tc574_release(dev_link_t *link)
546{
547 DEBUG(0, "3c574_release(0x%p)\n", link);
548
549 pcmcia_release_configuration(link->handle);
550 pcmcia_release_io(link->handle, &link->io);
551 pcmcia_release_irq(link->handle, &link->irq);
552
553 link->state &= ~DEV_CONFIG;
554}
555
556/*
557 The card status event handler. Mostly, this schedules other
558 stuff to run after an event is received. A CARD_REMOVAL event
559 also sets some flags to discourage the net drivers from trying
560 to talk to the card any more.
561*/
562
563static int tc574_event(event_t event, int priority,
564 event_callback_args_t *args)
565{
566 dev_link_t *link = args->client_data;
567 struct net_device *dev = link->priv;
568
569 DEBUG(1, "3c574_event(0x%06x)\n", event);
570
571 switch (event) {
572 case CS_EVENT_CARD_REMOVAL:
573 link->state &= ~DEV_PRESENT;
574 if (link->state & DEV_CONFIG)
575 netif_device_detach(dev);
576 break;
577 case CS_EVENT_CARD_INSERTION:
578 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
579 tc574_config(link);
580 break;
581 case CS_EVENT_PM_SUSPEND:
582 link->state |= DEV_SUSPEND;
583 /* Fall through... */
584 case CS_EVENT_RESET_PHYSICAL:
585 if (link->state & DEV_CONFIG) {
586 if (link->open)
587 netif_device_detach(dev);
588 pcmcia_release_configuration(link->handle);
589 }
590 break;
591 case CS_EVENT_PM_RESUME:
592 link->state &= ~DEV_SUSPEND;
593 /* Fall through... */
594 case CS_EVENT_CARD_RESET:
595 if (link->state & DEV_CONFIG) {
596 pcmcia_request_configuration(link->handle, &link->conf);
597 if (link->open) {
598 tc574_reset(dev);
599 netif_device_attach(dev);
600 }
601 }
602 break;
603 }
604 return 0;
605} /* tc574_event */
606
607static void dump_status(struct net_device *dev)
608{
609 kio_addr_t ioaddr = dev->base_addr;
610 EL3WINDOW(1);
611 printk(KERN_INFO " irq status %04x, rx status %04x, tx status "
612 "%02x, tx free %04x\n", inw(ioaddr+EL3_STATUS),
613 inw(ioaddr+RxStatus), inb(ioaddr+TxStatus),
614 inw(ioaddr+TxFree));
615 EL3WINDOW(4);
616 printk(KERN_INFO " diagnostics: fifo %04x net %04x ethernet %04x"
617 " media %04x\n", inw(ioaddr+0x04), inw(ioaddr+0x06),
618 inw(ioaddr+0x08), inw(ioaddr+0x0a));
619 EL3WINDOW(1);
620}
621
622/*
623 Use this for commands that may take time to finish
624*/
625static void tc574_wait_for_completion(struct net_device *dev, int cmd)
626{
627 int i = 1500;
628 outw(cmd, dev->base_addr + EL3_CMD);
629 while (--i > 0)
630 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) break;
631 if (i == 0)
632 printk(KERN_NOTICE "%s: command 0x%04x did not complete!\n", dev->name, cmd);
633}
634
635/* Read a word from the EEPROM using the regular EEPROM access register.
636 Assume that we are in register window zero.
637 */
638static unsigned short read_eeprom(kio_addr_t ioaddr, int index)
639{
640 int timer;
641 outw(EEPROM_Read + index, ioaddr + Wn0EepromCmd);
642 /* Pause for at least 162 usec for the read to take place. */
643 for (timer = 1620; timer >= 0; timer--) {
644 if ((inw(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
645 break;
646 }
647 return inw(ioaddr + Wn0EepromData);
648}
649
650/* MII transceiver control section.
651 Read and write the MII registers using software-generated serial
652 MDIO protocol. See the MII specifications or DP83840A data sheet
653 for details.
654 The maxium data clock rate is 2.5 Mhz. The timing is easily met by the
655 slow PC card interface. */
656
657#define MDIO_SHIFT_CLK 0x01
658#define MDIO_DIR_WRITE 0x04
659#define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
660#define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
661#define MDIO_DATA_READ 0x02
662#define MDIO_ENB_IN 0x00
663
664/* Generate the preamble required for initial synchronization and
665 a few older transceivers. */
666static void mdio_sync(kio_addr_t ioaddr, int bits)
667{
668 kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
669
670 /* Establish sync by sending at least 32 logic ones. */
671 while (-- bits >= 0) {
672 outw(MDIO_DATA_WRITE1, mdio_addr);
673 outw(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
674 }
675}
676
677static int mdio_read(kio_addr_t ioaddr, int phy_id, int location)
678{
679 int i;
680 int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
681 unsigned int retval = 0;
682 kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
683
684 if (mii_preamble_required)
685 mdio_sync(ioaddr, 32);
686
687 /* Shift the read command bits out. */
688 for (i = 14; i >= 0; i--) {
689 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
690 outw(dataval, mdio_addr);
691 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
692 }
693 /* Read the two transition, 16 data, and wire-idle bits. */
694 for (i = 19; i > 0; i--) {
695 outw(MDIO_ENB_IN, mdio_addr);
696 retval = (retval << 1) | ((inw(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
697 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
698 }
699 return (retval>>1) & 0xffff;
700}
701
702static void mdio_write(kio_addr_t ioaddr, int phy_id, int location, int value)
703{
704 int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
705 kio_addr_t mdio_addr = ioaddr + Wn4_PhysicalMgmt;
706 int i;
707
708 if (mii_preamble_required)
709 mdio_sync(ioaddr, 32);
710
711 /* Shift the command bits out. */
712 for (i = 31; i >= 0; i--) {
713 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
714 outw(dataval, mdio_addr);
715 outw(dataval | MDIO_SHIFT_CLK, mdio_addr);
716 }
717 /* Leave the interface idle. */
718 for (i = 1; i >= 0; i--) {
719 outw(MDIO_ENB_IN, mdio_addr);
720 outw(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
721 }
722
723 return;
724}
725
726/* Reset and restore all of the 3c574 registers. */
727static void tc574_reset(struct net_device *dev)
728{
729 struct el3_private *lp = netdev_priv(dev);
730 int i;
731 kio_addr_t ioaddr = dev->base_addr;
732 unsigned long flags;
733
734 tc574_wait_for_completion(dev, TotalReset|0x10);
735
736 spin_lock_irqsave(&lp->window_lock, flags);
737 /* Clear any transactions in progress. */
738 outw(0, ioaddr + RunnerWrCtrl);
739 outw(0, ioaddr + RunnerRdCtrl);
740
741 /* Set the station address and mask. */
742 EL3WINDOW(2);
743 for (i = 0; i < 6; i++)
744 outb(dev->dev_addr[i], ioaddr + i);
745 for (; i < 12; i+=2)
746 outw(0, ioaddr + i);
747
748 /* Reset config options */
749 EL3WINDOW(3);
750 outb((dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
751 outl((lp->autoselect ? 0x01000000 : 0) | 0x0062001b,
752 ioaddr + Wn3_Config);
753 /* Roadrunner only: Turn on the MII transceiver. */
754 outw(0x8040, ioaddr + Wn3_Options);
755 mdelay(1);
756 outw(0xc040, ioaddr + Wn3_Options);
757 EL3WINDOW(1);
758 spin_unlock_irqrestore(&lp->window_lock, flags);
759
760 tc574_wait_for_completion(dev, TxReset);
761 tc574_wait_for_completion(dev, RxReset);
762 mdelay(1);
763 spin_lock_irqsave(&lp->window_lock, flags);
764 EL3WINDOW(3);
765 outw(0x8040, ioaddr + Wn3_Options);
766
767 /* Switch to the stats window, and clear all stats by reading. */
768 outw(StatsDisable, ioaddr + EL3_CMD);
769 EL3WINDOW(6);
770 for (i = 0; i < 10; i++)
771 inb(ioaddr + i);
772 inw(ioaddr + 10);
773 inw(ioaddr + 12);
774 EL3WINDOW(4);
775 inb(ioaddr + 12);
776 inb(ioaddr + 13);
777
778 /* .. enable any extra statistics bits.. */
779 outw(0x0040, ioaddr + Wn4_NetDiag);
780
781 EL3WINDOW(1);
782 spin_unlock_irqrestore(&lp->window_lock, flags);
783
784 /* .. re-sync MII and re-fill what NWay is advertising. */
785 mdio_sync(ioaddr, 32);
786 mdio_write(ioaddr, lp->phys, 4, lp->advertising);
787 if (!auto_polarity) {
788 /* works for TDK 78Q2120 series MII's */
789 int i = mdio_read(ioaddr, lp->phys, 16) | 0x20;
790 mdio_write(ioaddr, lp->phys, 16, i);
791 }
792
793 spin_lock_irqsave(&lp->window_lock, flags);
794 /* Switch to register set 1 for normal use, just for TxFree. */
795 set_rx_mode(dev);
796 spin_unlock_irqrestore(&lp->window_lock, flags);
797 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
798 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
799 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
800 /* Allow status bits to be seen. */
801 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
802 /* Ack all pending events, and set active indicator mask. */
803 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
804 ioaddr + EL3_CMD);
805 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
806 | AdapterFailure | RxEarly, ioaddr + EL3_CMD);
807}
808
809static int el3_open(struct net_device *dev)
810{
811 struct el3_private *lp = netdev_priv(dev);
812 dev_link_t *link = &lp->link;
813
814 if (!DEV_OK(link))
815 return -ENODEV;
816
817 link->open++;
818 netif_start_queue(dev);
819
820 tc574_reset(dev);
821 lp->media.function = &media_check;
822 lp->media.data = (unsigned long) dev;
823 lp->media.expires = jiffies + HZ;
824 add_timer(&lp->media);
825
826 DEBUG(2, "%s: opened, status %4.4x.\n",
827 dev->name, inw(dev->base_addr + EL3_STATUS));
828
829 return 0;
830}
831
832static void el3_tx_timeout(struct net_device *dev)
833{
834 struct el3_private *lp = netdev_priv(dev);
835 kio_addr_t ioaddr = dev->base_addr;
836
837 printk(KERN_NOTICE "%s: Transmit timed out!\n", dev->name);
838 dump_status(dev);
839 lp->stats.tx_errors++;
840 dev->trans_start = jiffies;
841 /* Issue TX_RESET and TX_START commands. */
842 tc574_wait_for_completion(dev, TxReset);
843 outw(TxEnable, ioaddr + EL3_CMD);
844 netif_wake_queue(dev);
845}
846
847static void pop_tx_status(struct net_device *dev)
848{
849 struct el3_private *lp = netdev_priv(dev);
850 kio_addr_t ioaddr = dev->base_addr;
851 int i;
852
853 /* Clear the Tx status stack. */
854 for (i = 32; i > 0; i--) {
855 u_char tx_status = inb(ioaddr + TxStatus);
856 if (!(tx_status & 0x84))
857 break;
858 /* reset transmitter on jabber error or underrun */
859 if (tx_status & 0x30)
860 tc574_wait_for_completion(dev, TxReset);
861 if (tx_status & 0x38) {
862 DEBUG(1, "%s: transmit error: status 0x%02x\n",
863 dev->name, tx_status);
864 outw(TxEnable, ioaddr + EL3_CMD);
865 lp->stats.tx_aborted_errors++;
866 }
867 outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
868 }
869}
870
871static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
872{
873 kio_addr_t ioaddr = dev->base_addr;
874 struct el3_private *lp = netdev_priv(dev);
875 unsigned long flags;
876
877 DEBUG(3, "%s: el3_start_xmit(length = %ld) called, "
878 "status %4.4x.\n", dev->name, (long)skb->len,
879 inw(ioaddr + EL3_STATUS));
880
881 spin_lock_irqsave(&lp->window_lock, flags);
882 outw(skb->len, ioaddr + TX_FIFO);
883 outw(0, ioaddr + TX_FIFO);
884 outsl(ioaddr + TX_FIFO, skb->data, (skb->len+3)>>2);
885
886 dev->trans_start = jiffies;
887
888 /* TxFree appears only in Window 1, not offset 0x1c. */
889 if (inw(ioaddr + TxFree) <= 1536) {
890 netif_stop_queue(dev);
891 /* Interrupt us when the FIFO has room for max-sized packet.
892 The threshold is in units of dwords. */
893 outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
894 }
895
896 pop_tx_status(dev);
897 spin_unlock_irqrestore(&lp->window_lock, flags);
898 dev_kfree_skb(skb);
899 return 0;
900}
901
902/* The EL3 interrupt handler. */
903static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
904{
905 struct net_device *dev = (struct net_device *) dev_id;
906 struct el3_private *lp = netdev_priv(dev);
907 kio_addr_t ioaddr;
908 unsigned status;
909 int work_budget = max_interrupt_work;
910 int handled = 0;
911
912 if (!netif_device_present(dev))
913 return IRQ_NONE;
914 ioaddr = dev->base_addr;
915
916 DEBUG(3, "%s: interrupt, status %4.4x.\n",
917 dev->name, inw(ioaddr + EL3_STATUS));
918
919 spin_lock(&lp->window_lock);
920
921 while ((status = inw(ioaddr + EL3_STATUS)) &
922 (IntLatch | RxComplete | RxEarly | StatsFull)) {
923 if (!netif_device_present(dev) ||
924 ((status & 0xe000) != 0x2000)) {
925 DEBUG(1, "%s: Interrupt from dead card\n", dev->name);
926 break;
927 }
928
929 handled = 1;
930
931 if (status & RxComplete)
932 work_budget = el3_rx(dev, work_budget);
933
934 if (status & TxAvailable) {
935 DEBUG(3, " TX room bit was handled.\n");
936 /* There's room in the FIFO for a full-sized packet. */
937 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
938 netif_wake_queue(dev);
939 }
940
941 if (status & TxComplete)
942 pop_tx_status(dev);
943
944 if (status & (AdapterFailure | RxEarly | StatsFull)) {
945 /* Handle all uncommon interrupts. */
946 if (status & StatsFull)
947 update_stats(dev);
948 if (status & RxEarly) {
949 work_budget = el3_rx(dev, work_budget);
950 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
951 }
952 if (status & AdapterFailure) {
953 u16 fifo_diag;
954 EL3WINDOW(4);
955 fifo_diag = inw(ioaddr + Wn4_FIFODiag);
956 EL3WINDOW(1);
957 printk(KERN_NOTICE "%s: adapter failure, FIFO diagnostic"
958 " register %04x.\n", dev->name, fifo_diag);
959 if (fifo_diag & 0x0400) {
960 /* Tx overrun */
961 tc574_wait_for_completion(dev, TxReset);
962 outw(TxEnable, ioaddr + EL3_CMD);
963 }
964 if (fifo_diag & 0x2000) {
965 /* Rx underrun */
966 tc574_wait_for_completion(dev, RxReset);
967 set_rx_mode(dev);
968 outw(RxEnable, ioaddr + EL3_CMD);
969 }
970 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
971 }
972 }
973
974 if (--work_budget < 0) {
975 DEBUG(0, "%s: Too much work in interrupt, "
976 "status %4.4x.\n", dev->name, status);
977 /* Clear all interrupts */
978 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
979 break;
980 }
981 /* Acknowledge the IRQ. */
982 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
983 }
984
985 DEBUG(3, "%s: exiting interrupt, status %4.4x.\n",
986 dev->name, inw(ioaddr + EL3_STATUS));
987
988 spin_unlock(&lp->window_lock);
989 return IRQ_RETVAL(handled);
990}
991
992/*
993 This timer serves two purposes: to check for missed interrupts
994 (and as a last resort, poll the NIC for events), and to monitor
995 the MII, reporting changes in cable status.
996*/
997static void media_check(unsigned long arg)
998{
999 struct net_device *dev = (struct net_device *) arg;
1000 struct el3_private *lp = netdev_priv(dev);
1001 kio_addr_t ioaddr = dev->base_addr;
1002 unsigned long flags;
1003 unsigned short /* cable, */ media, partner;
1004
1005 if (!netif_device_present(dev))
1006 goto reschedule;
1007
1008 /* Check for pending interrupt with expired latency timer: with
1009 this, we can limp along even if the interrupt is blocked */
1010 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && (inb(ioaddr + Timer) == 0xff)) {
1011 if (!lp->fast_poll)
1012 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
1013 el3_interrupt(dev->irq, lp, NULL);
1014 lp->fast_poll = HZ;
1015 }
1016 if (lp->fast_poll) {
1017 lp->fast_poll--;
1018 lp->media.expires = jiffies + 2*HZ/100;
1019 add_timer(&lp->media);
1020 return;
1021 }
1022
1023 spin_lock_irqsave(&lp->window_lock, flags);
1024 EL3WINDOW(4);
1025 media = mdio_read(ioaddr, lp->phys, 1);
1026 partner = mdio_read(ioaddr, lp->phys, 5);
1027 EL3WINDOW(1);
1028
1029 if (media != lp->media_status) {
1030 if ((media ^ lp->media_status) & 0x0004)
1031 printk(KERN_INFO "%s: %s link beat\n", dev->name,
1032 (lp->media_status & 0x0004) ? "lost" : "found");
1033 if ((media ^ lp->media_status) & 0x0020) {
1034 lp->partner = 0;
1035 if (lp->media_status & 0x0020) {
1036 printk(KERN_INFO "%s: autonegotiation restarted\n",
1037 dev->name);
1038 } else if (partner) {
1039 partner &= lp->advertising;
1040 lp->partner = partner;
1041 printk(KERN_INFO "%s: autonegotiation complete: "
1042 "%sbaseT-%cD selected\n", dev->name,
1043 ((partner & 0x0180) ? "100" : "10"),
1044 ((partner & 0x0140) ? 'F' : 'H'));
1045 } else {
1046 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
1047 dev->name);
1048 }
1049
1050 EL3WINDOW(3);
1051 outb((partner & 0x0140 ? 0x20 : 0) |
1052 (dev->mtu > 1500 ? 0x40 : 0), ioaddr + Wn3_MAC_Ctrl);
1053 EL3WINDOW(1);
1054
1055 }
1056 if (media & 0x0010)
1057 printk(KERN_INFO "%s: remote fault detected\n",
1058 dev->name);
1059 if (media & 0x0002)
1060 printk(KERN_INFO "%s: jabber detected\n", dev->name);
1061 lp->media_status = media;
1062 }
1063 spin_unlock_irqrestore(&lp->window_lock, flags);
1064
1065reschedule:
1066 lp->media.expires = jiffies + HZ;
1067 add_timer(&lp->media);
1068}
1069
1070static struct net_device_stats *el3_get_stats(struct net_device *dev)
1071{
1072 struct el3_private *lp = netdev_priv(dev);
1073
1074 if (netif_device_present(dev)) {
1075 unsigned long flags;
1076 spin_lock_irqsave(&lp->window_lock, flags);
1077 update_stats(dev);
1078 spin_unlock_irqrestore(&lp->window_lock, flags);
1079 }
1080 return &lp->stats;
1081}
1082
1083/* Update statistics.
1084 Suprisingly this need not be run single-threaded, but it effectively is.
1085 The counters clear when read, so the adds must merely be atomic.
1086 */
1087static void update_stats(struct net_device *dev)
1088{
1089 struct el3_private *lp = netdev_priv(dev);
1090 kio_addr_t ioaddr = dev->base_addr;
1091 u8 rx, tx, up;
1092
1093 DEBUG(2, "%s: updating the statistics.\n", dev->name);
1094
1095 if (inw(ioaddr+EL3_STATUS) == 0xffff) /* No card. */
1096 return;
1097
1098 /* Unlike the 3c509 we need not turn off stats updates while reading. */
1099 /* Switch to the stats window, and read everything. */
1100 EL3WINDOW(6);
1101 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
1102 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1103 /* Multiple collisions. */ inb(ioaddr + 2);
1104 lp->stats.collisions += inb(ioaddr + 3);
1105 lp->stats.tx_window_errors += inb(ioaddr + 4);
1106 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
1107 lp->stats.tx_packets += inb(ioaddr + 6);
1108 up = inb(ioaddr + 9);
1109 lp->stats.tx_packets += (up&0x30) << 4;
1110 /* Rx packets */ inb(ioaddr + 7);
1111 /* Tx deferrals */ inb(ioaddr + 8);
1112 rx = inw(ioaddr + 10);
1113 tx = inw(ioaddr + 12);
1114
1115 EL3WINDOW(4);
1116 /* BadSSD */ inb(ioaddr + 12);
1117 up = inb(ioaddr + 13);
1118
1119 lp->stats.tx_bytes += tx + ((up & 0xf0) << 12);
1120
1121 EL3WINDOW(1);
1122}
1123
1124static int el3_rx(struct net_device *dev, int worklimit)
1125{
1126 struct el3_private *lp = netdev_priv(dev);
1127 kio_addr_t ioaddr = dev->base_addr;
1128 short rx_status;
1129
1130 DEBUG(3, "%s: in rx_packet(), status %4.4x, rx_status %4.4x.\n",
1131 dev->name, inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
1132 while (!((rx_status = inw(ioaddr + RxStatus)) & 0x8000) &&
1133 (--worklimit >= 0)) {
1134 if (rx_status & 0x4000) { /* Error, update stats. */
1135 short error = rx_status & 0x3800;
1136 lp->stats.rx_errors++;
1137 switch (error) {
1138 case 0x0000: lp->stats.rx_over_errors++; break;
1139 case 0x0800: lp->stats.rx_length_errors++; break;
1140 case 0x1000: lp->stats.rx_frame_errors++; break;
1141 case 0x1800: lp->stats.rx_length_errors++; break;
1142 case 0x2000: lp->stats.rx_frame_errors++; break;
1143 case 0x2800: lp->stats.rx_crc_errors++; break;
1144 }
1145 } else {
1146 short pkt_len = rx_status & 0x7ff;
1147 struct sk_buff *skb;
1148
1149 skb = dev_alloc_skb(pkt_len+5);
1150
1151 DEBUG(3, " Receiving packet size %d status %4.4x.\n",
1152 pkt_len, rx_status);
1153 if (skb != NULL) {
1154 skb->dev = dev;
1155 skb_reserve(skb, 2);
1156 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len),
1157 ((pkt_len+3)>>2));
1158 skb->protocol = eth_type_trans(skb, dev);
1159 netif_rx(skb);
1160 dev->last_rx = jiffies;
1161 lp->stats.rx_packets++;
1162 lp->stats.rx_bytes += pkt_len;
1163 } else {
1164 DEBUG(1, "%s: couldn't allocate a sk_buff of"
1165 " size %d.\n", dev->name, pkt_len);
1166 lp->stats.rx_dropped++;
1167 }
1168 }
1169 tc574_wait_for_completion(dev, RxDiscard);
1170 }
1171
1172 return worklimit;
1173}
1174
1175static void netdev_get_drvinfo(struct net_device *dev,
1176 struct ethtool_drvinfo *info)
1177{
1178 strcpy(info->driver, "3c574_cs");
1179}
1180
1181static struct ethtool_ops netdev_ethtool_ops = {
1182 .get_drvinfo = netdev_get_drvinfo,
1183};
1184
1185/* Provide ioctl() calls to examine the MII xcvr state. */
1186static int el3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1187{
1188 struct el3_private *lp = netdev_priv(dev);
1189 kio_addr_t ioaddr = dev->base_addr;
1190 u16 *data = (u16 *)&rq->ifr_ifru;
1191 int phy = lp->phys & 0x1f;
1192
1193 DEBUG(2, "%s: In ioct(%-.6s, %#4.4x) %4.4x %4.4x %4.4x %4.4x.\n",
1194 dev->name, rq->ifr_ifrn.ifrn_name, cmd,
1195 data[0], data[1], data[2], data[3]);
1196
1197 switch(cmd) {
1198 case SIOCGMIIPHY: /* Get the address of the PHY in use. */
1199 data[0] = phy;
1200 case SIOCGMIIREG: /* Read the specified MII register. */
1201 {
1202 int saved_window;
1203 unsigned long flags;
1204
1205 spin_lock_irqsave(&lp->window_lock, flags);
1206 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1207 EL3WINDOW(4);
1208 data[3] = mdio_read(ioaddr, data[0] & 0x1f, data[1] & 0x1f);
1209 EL3WINDOW(saved_window);
1210 spin_unlock_irqrestore(&lp->window_lock, flags);
1211 return 0;
1212 }
1213 case SIOCSMIIREG: /* Write the specified MII register */
1214 {
1215 int saved_window;
1216 unsigned long flags;
1217
1218 if (!capable(CAP_NET_ADMIN))
1219 return -EPERM;
1220 spin_lock_irqsave(&lp->window_lock, flags);
1221 saved_window = inw(ioaddr + EL3_CMD) >> 13;
1222 EL3WINDOW(4);
1223 mdio_write(ioaddr, data[0] & 0x1f, data[1] & 0x1f, data[2]);
1224 EL3WINDOW(saved_window);
1225 spin_unlock_irqrestore(&lp->window_lock, flags);
1226 return 0;
1227 }
1228 default:
1229 return -EOPNOTSUPP;
1230 }
1231}
1232
1233/* The Odie chip has a 64 bin multicast filter, but the bit layout is not
1234 documented. Until it is we revert to receiving all multicast frames when
1235 any multicast reception is desired.
1236 Note: My other drivers emit a log message whenever promiscuous mode is
1237 entered to help detect password sniffers. This is less desirable on
1238 typical PC card machines, so we omit the message.
1239 */
1240
1241static void set_rx_mode(struct net_device *dev)
1242{
1243 kio_addr_t ioaddr = dev->base_addr;
1244
1245 if (dev->flags & IFF_PROMISC)
1246 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1247 ioaddr + EL3_CMD);
1248 else if (dev->mc_count || (dev->flags & IFF_ALLMULTI))
1249 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
1250 else
1251 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1252}
1253
1254static int el3_close(struct net_device *dev)
1255{
1256 kio_addr_t ioaddr = dev->base_addr;
1257 struct el3_private *lp = netdev_priv(dev);
1258 dev_link_t *link = &lp->link;
1259
1260 DEBUG(2, "%s: shutting down ethercard.\n", dev->name);
1261
1262 if (DEV_OK(link)) {
1263 unsigned long flags;
1264
1265 /* Turn off statistics ASAP. We update lp->stats below. */
1266 outw(StatsDisable, ioaddr + EL3_CMD);
1267
1268 /* Disable the receiver and transmitter. */
1269 outw(RxDisable, ioaddr + EL3_CMD);
1270 outw(TxDisable, ioaddr + EL3_CMD);
1271
1272 /* Note: Switching to window 0 may disable the IRQ. */
1273 EL3WINDOW(0);
1274 spin_lock_irqsave(&lp->window_lock, flags);
1275 update_stats(dev);
1276 spin_unlock_irqrestore(&lp->window_lock, flags);
1277 }
1278
1279 link->open--;
1280 netif_stop_queue(dev);
1281 del_timer_sync(&lp->media);
1282
1283 return 0;
1284}
1285
1286static struct pcmcia_driver tc574_driver = {
1287 .owner = THIS_MODULE,
1288 .drv = {
1289 .name = "3c574_cs",
1290 },
1291 .attach = tc574_attach,
1292 .detach = tc574_detach,
1293};
1294
1295static int __init init_tc574(void)
1296{
1297 return pcmcia_register_driver(&tc574_driver);
1298}
1299
1300static void __exit exit_tc574(void)
1301{
1302 pcmcia_unregister_driver(&tc574_driver);
1303 BUG_ON(dev_list != NULL);
1304}
1305
1306module_init(init_tc574);
1307module_exit(exit_tc574);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-15 01:47:58 -0500