projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
arch/i386/kernel/time: don't shadow 'irq' function arg
[deliverable/linux.git] / drivers / net / 3c509.c
CommitLineData
1da177e4
LT		 1/* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
2/*
3 Written 1993-2000 by Donald Becker.
4
5 Copyright 1994-2000 by Donald Becker.
6 Copyright 1993 United States Government as represented by the
7 Director, National Security Agency. This software may be used and
8 distributed according to the terms of the GNU General Public License,
9 incorporated herein by reference.
10
11 This driver is for the 3Com EtherLinkIII series.
12
13 The author may be reached as becker@scyld.com, or C/O
14 Scyld Computing Corporation
15 410 Severn Ave., Suite 210
16 Annapolis MD 21403
17
18 Known limitations:
19 Because of the way 3c509 ISA detection works it's difficult to predict
20 a priori which of several ISA-mode cards will be detected first.
21
22 This driver does not use predictive interrupt mode, resulting in higher
23 packet latency but lower overhead. If interrupts are disabled for an
24 unusually long time it could also result in missed packets, but in
25 practice this rarely happens.
26
27
28 FIXES:
29 Alan Cox: Removed the 'Unexpected interrupt' bug.
30 Michael Meskes: Upgraded to Donald Becker's version 1.07.
6aa20a22 31 Alan Cox: Increased the eeprom delay. Regardless of
1da177e4
LT		 32 what the docs say some people definitely
33 get problems with lower (but in card spec)
34 delays
35 v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
36 other cleanups. -djb
37 Andrea Arcangeli: Upgraded to Donald Becker's version 1.12.
38 Rick Payne: Fixed SMP race condition
39 v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
40 v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
41 v1.15 1/31/98 Faster recovery for Tx errors. -djb
42 v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
43 v1.18 12Mar2001 Andrew Morton <andrewm@uow.edu.au>
44 - Avoid bogus detect of 3c590's (Andrzej Krzysztofowicz)
45 - Reviewed against 1.18 from scyld.com
46 v1.18a 17Nov2001 Jeff Garzik <jgarzik@pobox.com>
47 - ethtool support
48 v1.18b 1Mar2002 Zwane Mwaikambo <zwane@commfireservices.com>
49 - Power Management support
50 v1.18c 1Mar2002 David Ruggiero <jdr@farfalle.com>
51 - Full duplex support
52 v1.19 16Oct2002 Zwane Mwaikambo <zwane@linuxpower.ca>
53 - Additional ethtool features
54 v1.19a 28Oct2002 Davud Ruggiero <jdr@farfalle.com>
55 - Increase *read_eeprom udelay to workaround oops with 2 cards.
56 v1.19b 08Nov2002 Marc Zyngier <maz@wild-wind.fr.eu.org>
57 - Introduce driver model for EISA cards.
58*/
59
60#define DRV_NAME "3c509"
61#define DRV_VERSION "1.19b"
62#define DRV_RELDATE "08Nov2002"
63
64/* A few values that may be tweaked. */
65
66/* Time in jiffies before concluding the transmitter is hung. */
67#define TX_TIMEOUT (400*HZ/1000)
68/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
69static int max_interrupt_work = 10;
70
1da177e4
LT		 71#include <linux/module.h>
72#ifdef CONFIG_MCA
73#include <linux/mca.h>
74#endif
75#include <linux/isapnp.h>
76#include <linux/string.h>
77#include <linux/interrupt.h>
78#include <linux/errno.h>
79#include <linux/in.h>
80#include <linux/slab.h>
81#include <linux/ioport.h>
82#include <linux/init.h>
83#include <linux/netdevice.h>
84#include <linux/etherdevice.h>
85#include <linux/pm.h>
bca73e4b 86#include <linux/pm_legacy.h>
1da177e4
LT		 87#include <linux/skbuff.h>
88#include <linux/delay.h> /* for udelay() */
89#include <linux/spinlock.h>
90#include <linux/ethtool.h>
91#include <linux/device.h>
92#include <linux/eisa.h>
93#include <linux/bitops.h>
94
95#include <asm/uaccess.h>
96#include <asm/io.h>
97#include <asm/irq.h>
98
99static char versionA[] __initdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
100static char versionB[] __initdata = "http://www.scyld.com/network/3c509.html\n";
101
60a89ff6
PE		 102#if defined(CONFIG_PM) && (defined(CONFIG_MCA) || defined(CONFIG_EISA))
103#define EL3_SUSPEND
104#endif
105
1da177e4
LT		 106#ifdef EL3_DEBUG
107static int el3_debug = EL3_DEBUG;
108#else
109static int el3_debug = 2;
110#endif
111
112/* Used to do a global count of all the cards in the system. Must be
113 * a global variable so that the mca/eisa probe routines can increment
114 * it */
115static int el3_cards = 0;
116
117/* To minimize the size of the driver source I only define operating
118 constants if they are used several times. You'll need the manual
119 anyway if you want to understand driver details. */
120/* Offsets from base I/O address. */
121#define EL3_DATA 0x00
122#define EL3_CMD 0x0e
123#define EL3_STATUS 0x0e
124#define EEPROM_READ 0x80
125
126#define EL3_IO_EXTENT 16
127
128#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
129
130
131/* The top five bits written to EL3_CMD are a command, the lower
132 11 bits are the parameter, if applicable. */
133enum c509cmd {
134 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
135 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
136 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
137 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
138 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
139 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
140 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
141 PowerDown = 28<<11, PowerAuto = 29<<11};
142
143enum c509status {
144 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
145 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
146 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
147
148/* The SetRxFilter command accepts the following classes: */
149enum RxFilter {
150 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
151
152/* Register window 1 offsets, the window used in normal operation. */
153#define TX_FIFO 0x00
154#define RX_FIFO 0x00
155#define RX_STATUS 0x08
156#define TX_STATUS 0x0B
157#define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
158
159#define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
160#define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
161#define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
162#define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
163#define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
164#define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
6aa20a22 165#define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
1da177e4
LT		 166
167/*
168 * Must be a power of two (we use a binary and in the
169 * circular queue)
170 */
171#define SKB_QUEUE_SIZE 64
172
173struct el3_private {
174 struct net_device_stats stats;
175 struct net_device *next_dev;
176 spinlock_t lock;
177 /* skb send-queue */
178 int head, size;
179 struct sk_buff *queue[SKB_QUEUE_SIZE];
1da177e4
LT		 180 enum {
181 EL3_MCA,
182 EL3_PNP,
183 EL3_EISA,
184 } type; /* type of device */
185 struct device *dev;
186};
187static int id_port __initdata = 0x110; /* Start with 0x110 to avoid new sound cards.*/
188static struct net_device *el3_root_dev;
189
190static ushort id_read_eeprom(int index);
191static ushort read_eeprom(int ioaddr, int index);
192static int el3_open(struct net_device *dev);
193static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
7d12e780 194static irqreturn_t el3_interrupt(int irq, void *dev_id);
1da177e4
LT		 195static void update_stats(struct net_device *dev);
196static struct net_device_stats *el3_get_stats(struct net_device *dev);
197static int el3_rx(struct net_device *dev);
198static int el3_close(struct net_device *dev);
199static void set_multicast_list(struct net_device *dev);
200static void el3_tx_timeout (struct net_device *dev);
201static void el3_down(struct net_device *dev);
202static void el3_up(struct net_device *dev);
7282d491 203static const struct ethtool_ops ethtool_ops;
60a89ff6
PE		 204#ifdef EL3_SUSPEND
205static int el3_suspend(struct device *, pm_message_t);
206static int el3_resume(struct device *);
207#else
208#define el3_suspend NULL
209#define el3_resume NULL
1da177e4 210#endif
60a89ff6
PE		 211
212
1da177e4
LT		 213/* generic device remove for all device types */
214#if defined(CONFIG_EISA) || defined(CONFIG_MCA)
215static int el3_device_remove (struct device *device);
216#endif
217#ifdef CONFIG_NET_POLL_CONTROLLER
218static void el3_poll_controller(struct net_device *dev);
219#endif
220
221#ifdef CONFIG_EISA
222static struct eisa_device_id el3_eisa_ids[] = {
223 { "TCM5092" },
224 { "TCM5093" },
f04e3f09 225 { "TCM5095" },
1da177e4
LT		 226 { "" }
227};
07563c71 228MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
1da177e4
LT		 229
230static int el3_eisa_probe (struct device *device);
231
232static struct eisa_driver el3_eisa_driver = {
233 .id_table = el3_eisa_ids,
234 .driver = {
235 .name = "3c509",
236 .probe = el3_eisa_probe,
60a89ff6
PE		 237 .remove = __devexit_p (el3_device_remove),
238 .suspend = el3_suspend,
239 .resume = el3_resume,
1da177e4
LT		 240 }
241};
242#endif
243
244#ifdef CONFIG_MCA
245static int el3_mca_probe(struct device *dev);
246
247static short el3_mca_adapter_ids[] __initdata = {
248 0x627c,
249 0x627d,
250 0x62db,
251 0x62f6,
252 0x62f7,
253 0x0000
254};
255
256static char *el3_mca_adapter_names[] __initdata = {
257 "3Com 3c529 EtherLink III (10base2)",
258 "3Com 3c529 EtherLink III (10baseT)",
259 "3Com 3c529 EtherLink III (test mode)",
260 "3Com 3c529 EtherLink III (TP or coax)",
261 "3Com 3c529 EtherLink III (TP)",
262 NULL
263};
264
265static struct mca_driver el3_mca_driver = {
266 .id_table = el3_mca_adapter_ids,
267 .driver = {
268 .name = "3c529",
269 .bus = &mca_bus_type,
270 .probe = el3_mca_probe,
271 .remove = __devexit_p(el3_device_remove),
60a89ff6
PE		 272 .suspend = el3_suspend,
273 .resume = el3_resume,
1da177e4
LT		 274 },
275};
276#endif /* CONFIG_MCA */
277
278#if defined(__ISAPNP__)
279static struct isapnp_device_id el3_isapnp_adapters[] __initdata = {
280 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
281 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5090),
282 (long) "3Com Etherlink III (TP)" },
283 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
284 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5091),
285 (long) "3Com Etherlink III" },
286 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
287 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5094),
288 (long) "3Com Etherlink III (combo)" },
289 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
290 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5095),
291 (long) "3Com Etherlink III (TPO)" },
292 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
293 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5098),
294 (long) "3Com Etherlink III (TPC)" },
295 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
296 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f7),
297 (long) "3Com Etherlink III compatible" },
298 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
299 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f8),
300 (long) "3Com Etherlink III compatible" },
301 { } /* terminate list */
302};
303
304static u16 el3_isapnp_phys_addr[8][3];
305static int nopnp;
306#endif /* __ISAPNP__ */
307
308/* With the driver model introduction for EISA devices, both init
309 * and cleanup have been split :
310 * - EISA devices probe/remove starts in el3_eisa_probe/el3_device_remove
311 * - MCA/ISA still use el3_probe
312 *
313 * Both call el3_common_init/el3_common_remove. */
314
315static int __init el3_common_init(struct net_device *dev)
316{
317 struct el3_private *lp = netdev_priv(dev);
318 short i;
319 int err;
320
321 spin_lock_init(&lp->lock);
322
323 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
324 dev->if_port = (dev->mem_start & 0x0f);
325 } else { /* xcvr codes 0/8 */
326 /* use eeprom value, but save user's full-duplex selection */
327 dev->if_port |= (dev->mem_start & 0x08);
328 }
329
330 /* The EL3-specific entries in the device structure. */
331 dev->open = &el3_open;
332 dev->hard_start_xmit = &el3_start_xmit;
333 dev->stop = &el3_close;
334 dev->get_stats = &el3_get_stats;
335 dev->set_multicast_list = &set_multicast_list;
336 dev->tx_timeout = el3_tx_timeout;
337 dev->watchdog_timeo = TX_TIMEOUT;
338#ifdef CONFIG_NET_POLL_CONTROLLER
339 dev->poll_controller = el3_poll_controller;
340#endif
341 SET_ETHTOOL_OPS(dev, &ethtool_ops);
342
343 err = register_netdev(dev);
344 if (err) {
345 printk(KERN_ERR "Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
346 dev->base_addr, dev->irq);
347 release_region(dev->base_addr, EL3_IO_EXTENT);
348 return err;
349 }
350
351 {
352 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
353 printk("%s: 3c5x9 found at %#3.3lx, %s port, address ",
6aa20a22 354 dev->name, dev->base_addr,
1da177e4
LT		 355 if_names[(dev->if_port & 0x03)]);
356 }
357
358 /* Read in the station address. */
359 for (i = 0; i < 6; i++)
360 printk(" %2.2x", dev->dev_addr[i]);
361 printk(", IRQ %d.\n", dev->irq);
362
363 if (el3_debug > 0)
364 printk(KERN_INFO "%s" KERN_INFO "%s", versionA, versionB);
365 return 0;
366
367}
368
369static void el3_common_remove (struct net_device *dev)
370{
371 struct el3_private *lp = netdev_priv(dev);
372
373 (void) lp; /* Keep gcc quiet... */
1da177e4
LT		 374#if defined(__ISAPNP__)
375 if (lp->type == EL3_PNP)
376 pnp_device_detach(to_pnp_dev(lp->dev));
377#endif
378
379 unregister_netdev (dev);
380 release_region(dev->base_addr, EL3_IO_EXTENT);
381 free_netdev (dev);
382}
383
384static int __init el3_probe(int card_idx)
385{
386 struct net_device *dev;
387 struct el3_private *lp;
388 short lrs_state = 0xff, i;
389 int ioaddr, irq, if_port;
390 u16 phys_addr[3];
391 static int current_tag;
392 int err = -ENODEV;
393#if defined(__ISAPNP__)
394 static int pnp_cards;
395 struct pnp_dev *idev = NULL;
396
397 if (nopnp == 1)
398 goto no_pnp;
399
400 for (i=0; el3_isapnp_adapters[i].vendor != 0; i++) {
401 int j;
402 while ((idev = pnp_find_dev(NULL,
403 el3_isapnp_adapters[i].vendor,
404 el3_isapnp_adapters[i].function,
405 idev))) {
406 if (pnp_device_attach(idev) < 0)
407 continue;
408 if (pnp_activate_dev(idev) < 0) {
409__again:
410 pnp_device_detach(idev);
411 continue;
412 }
413 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
414 goto __again;
415 ioaddr = pnp_port_start(idev, 0);
416 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509 PnP")) {
417 pnp_device_detach(idev);
418 return -EBUSY;
419 }
420 irq = pnp_irq(idev, 0);
421 if (el3_debug > 3)
422 printk ("ISAPnP reports %s at i/o 0x%x, irq %d\n",
423 (char*) el3_isapnp_adapters[i].driver_data, ioaddr, irq);
424 EL3WINDOW(0);
425 for (j = 0; j < 3; j++)
426 el3_isapnp_phys_addr[pnp_cards][j] =
427 phys_addr[j] =
428 htons(read_eeprom(ioaddr, j));
429 if_port = read_eeprom(ioaddr, 8) >> 14;
430 dev = alloc_etherdev(sizeof (struct el3_private));
431 if (!dev) {
432 release_region(ioaddr, EL3_IO_EXTENT);
433 pnp_device_detach(idev);
434 return -ENOMEM;
435 }
436
437 SET_MODULE_OWNER(dev);
438 SET_NETDEV_DEV(dev, &idev->dev);
439 pnp_cards++;
440
441 netdev_boot_setup_check(dev);
442 goto found;
443 }
444 }
445no_pnp:
446#endif /* __ISAPNP__ */
447
448 /* Select an open I/O location at 0x1*0 to do contention select. */
449 for ( ; id_port < 0x200; id_port += 0x10) {
450 if (!request_region(id_port, 1, "3c509"))
451 continue;
452 outb(0x00, id_port);
453 outb(0xff, id_port);
454 if (inb(id_port) & 0x01){
455 release_region(id_port, 1);
456 break;
457 } else
458 release_region(id_port, 1);
459 }
460 if (id_port >= 0x200) {
461 /* Rare -- do we really need a warning? */
462 printk(" WARNING: No I/O port available for 3c509 activation.\n");
463 return -ENODEV;
464 }
465
466 /* Next check for all ISA bus boards by sending the ID sequence to the
467 ID_PORT. We find cards past the first by setting the 'current_tag'
468 on cards as they are found. Cards with their tag set will not
469 respond to subsequent ID sequences. */
470
471 outb(0x00, id_port);
472 outb(0x00, id_port);
473 for(i = 0; i < 255; i++) {
474 outb(lrs_state, id_port);
475 lrs_state <<= 1;
476 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
477 }
478
479 /* For the first probe, clear all board's tag registers. */
480 if (current_tag == 0)
481 outb(0xd0, id_port);
482 else /* Otherwise kill off already-found boards. */
483 outb(0xd8, id_port);
484
485 if (id_read_eeprom(7) != 0x6d50) {
486 return -ENODEV;
487 }
488
489 /* Read in EEPROM data, which does contention-select.
490 Only the lowest address board will stay "on-line".
491 3Com got the byte order backwards. */
492 for (i = 0; i < 3; i++) {
493 phys_addr[i] = htons(id_read_eeprom(i));
494 }
495
496#if defined(__ISAPNP__)
497 if (nopnp == 0) {
498 /* The ISA PnP 3c509 cards respond to the ID sequence.
499 This check is needed in order not to register them twice. */
500 for (i = 0; i < pnp_cards; i++) {
501 if (phys_addr[0] == el3_isapnp_phys_addr[i][0] &&
502 phys_addr[1] == el3_isapnp_phys_addr[i][1] &&
503 phys_addr[2] == el3_isapnp_phys_addr[i][2])
504 {
505 if (el3_debug > 3)
506 printk("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
507 phys_addr[0] & 0xff, phys_addr[0] >> 8,
508 phys_addr[1] & 0xff, phys_addr[1] >> 8,
509 phys_addr[2] & 0xff, phys_addr[2] >> 8);
510 /* Set the adaptor tag so that the next card can be found. */
511 outb(0xd0 + ++current_tag, id_port);
512 goto no_pnp;
513 }
514 }
515 }
516#endif /* __ISAPNP__ */
517
518 {
519 unsigned int iobase = id_read_eeprom(8);
520 if_port = iobase >> 14;
521 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
522 }
523 irq = id_read_eeprom(9) >> 12;
524
525 dev = alloc_etherdev(sizeof (struct el3_private));
526 if (!dev)
527 return -ENOMEM;
528
529 SET_MODULE_OWNER(dev);
530
531 netdev_boot_setup_check(dev);
6aa20a22 532
1da177e4
LT		 533 /* Set passed-in IRQ or I/O Addr. */
534 if (dev->irq > 1 && dev->irq < 16)
535 irq = dev->irq;
536
537 if (dev->base_addr) {
538 if (dev->mem_end == 0x3c509 /* Magic key */
539 && dev->base_addr >= 0x200 && dev->base_addr <= 0x3e0)
540 ioaddr = dev->base_addr & 0x3f0;
541 else if (dev->base_addr != ioaddr)
542 goto out;
543 }
544
545 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509")) {
546 err = -EBUSY;
547 goto out;
548 }
549
550 /* Set the adaptor tag so that the next card can be found. */
551 outb(0xd0 + ++current_tag, id_port);
552
553 /* Activate the adaptor at the EEPROM location. */
554 outb((ioaddr >> 4) | 0xe0, id_port);
555
556 EL3WINDOW(0);
557 if (inw(ioaddr) != 0x6d50)
558 goto out1;
559
560 /* Free the interrupt so that some other card can use it. */
561 outw(0x0f00, ioaddr + WN0_IRQ);
562
563#if defined(__ISAPNP__)
564 found: /* PNP jumps here... */
565#endif /* __ISAPNP__ */
566
567 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
568 dev->base_addr = ioaddr;
569 dev->irq = irq;
570 dev->if_port = if_port;
571 lp = netdev_priv(dev);
572#if defined(__ISAPNP__)
573 lp->dev = &idev->dev;
574#endif
575 err = el3_common_init(dev);
576
577 if (err)
578 goto out1;
579
1da177e4
LT		 580 el3_cards++;
581 lp->next_dev = el3_root_dev;
582 el3_root_dev = dev;
583 return 0;
584
585out1:
586#if defined(__ISAPNP__)
587 if (idev)
588 pnp_device_detach(idev);
589#endif
590out:
591 free_netdev(dev);
592 return err;
593}
594
595#ifdef CONFIG_MCA
596static int __init el3_mca_probe(struct device *device)
597{
598 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
599 * heavily modified by Chris Beauregard
600 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
601 * probing.
602 *
603 * redone for multi-card detection by ZP Gu (zpg@castle.net)
604 * now works as a module */
605
606 struct el3_private *lp;
607 short i;
608 int ioaddr, irq, if_port;
609 u16 phys_addr[3];
610 struct net_device *dev = NULL;
611 u_char pos4, pos5;
612 struct mca_device *mdev = to_mca_device(device);
613 int slot = mdev->slot;
614 int err;
615
616 pos4 = mca_device_read_stored_pos(mdev, 4);
617 pos5 = mca_device_read_stored_pos(mdev, 5);
618
619 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
620 irq = pos5 & 0x0f;
621
622
623 printk("3c529: found %s at slot %d\n",
624 el3_mca_adapter_names[mdev->index], slot + 1);
625
626 /* claim the slot */
627 strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
628 sizeof(mdev->name));
629 mca_device_set_claim(mdev, 1);
630
631 if_port = pos4 & 0x03;
632
633 irq = mca_device_transform_irq(mdev, irq);
6aa20a22 634 ioaddr = mca_device_transform_ioport(mdev, ioaddr);
1da177e4
LT		 635 if (el3_debug > 2) {
636 printk("3c529: irq %d ioaddr 0x%x ifport %d\n", irq, ioaddr, if_port);
637 }
638 EL3WINDOW(0);
639 for (i = 0; i < 3; i++) {
640 phys_addr[i] = htons(read_eeprom(ioaddr, i));
641 }
642
643 dev = alloc_etherdev(sizeof (struct el3_private));
644 if (dev == NULL) {
645 release_region(ioaddr, EL3_IO_EXTENT);
646 return -ENOMEM;
647 }
648
649 SET_MODULE_OWNER(dev);
650 netdev_boot_setup_check(dev);
651
652 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
653 dev->base_addr = ioaddr;
654 dev->irq = irq;
655 dev->if_port = if_port;
656 lp = netdev_priv(dev);
657 lp->dev = device;
658 lp->type = EL3_MCA;
659 device->driver_data = dev;
660 err = el3_common_init(dev);
661
662 if (err) {
663 device->driver_data = NULL;
664 free_netdev(dev);
665 return -ENOMEM;
666 }
667
668 el3_cards++;
669 return 0;
670}
6aa20a22 671
1da177e4
LT		 672#endif /* CONFIG_MCA */
673
674#ifdef CONFIG_EISA
675static int __init el3_eisa_probe (struct device *device)
676{
677 struct el3_private *lp;
678 short i;
679 int ioaddr, irq, if_port;
680 u16 phys_addr[3];
681 struct net_device *dev = NULL;
682 struct eisa_device *edev;
683 int err;
684
685 /* Yeepee, The driver framework is calling us ! */
686 edev = to_eisa_device (device);
687 ioaddr = edev->base_addr;
6aa20a22 688
1da177e4
LT		 689 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509"))
690 return -EBUSY;
691
692 /* Change the register set to the configuration window 0. */
693 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
694
695 irq = inw(ioaddr + WN0_IRQ) >> 12;
696 if_port = inw(ioaddr + 6)>>14;
697 for (i = 0; i < 3; i++)
698 phys_addr[i] = htons(read_eeprom(ioaddr, i));
699
700 /* Restore the "Product ID" to the EEPROM read register. */
701 read_eeprom(ioaddr, 3);
702
703 dev = alloc_etherdev(sizeof (struct el3_private));
704 if (dev == NULL) {
705 release_region(ioaddr, EL3_IO_EXTENT);
706 return -ENOMEM;
707 }
708
709 SET_MODULE_OWNER(dev);
710
711 netdev_boot_setup_check(dev);
712
713 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
714 dev->base_addr = ioaddr;
715 dev->irq = irq;
716 dev->if_port = if_port;
717 lp = netdev_priv(dev);
718 lp->dev = device;
719 lp->type = EL3_EISA;
720 eisa_set_drvdata (edev, dev);
721 err = el3_common_init(dev);
722
723 if (err) {
724 eisa_set_drvdata (edev, NULL);
725 free_netdev(dev);
726 return err;
727 }
728
729 el3_cards++;
730 return 0;
731}
732#endif
733
734#if defined(CONFIG_EISA) || defined(CONFIG_MCA)
735/* This remove works for all device types.
736 *
737 * The net dev must be stored in the driver_data field */
738static int __devexit el3_device_remove (struct device *device)
739{
740 struct net_device *dev;
741
742 dev = device->driver_data;
743
744 el3_common_remove (dev);
745 return 0;
746}
747#endif
748
749/* Read a word from the EEPROM using the regular EEPROM access register.
750 Assume that we are in register window zero.
751 */
752static ushort read_eeprom(int ioaddr, int index)
753{
754 outw(EEPROM_READ + index, ioaddr + 10);
6aa20a22 755 /* Pause for at least 162 us. for the read to take place.
1da177e4
LT		 756 Some chips seem to require much longer */
757 mdelay(2);
758 return inw(ioaddr + 12);
759}
760
761/* Read a word from the EEPROM when in the ISA ID probe state. */
762static ushort __init id_read_eeprom(int index)
763{
764 int bit, word = 0;
765
766 /* Issue read command, and pause for at least 162 us. for it to complete.
767 Assume extra-fast 16Mhz bus. */
768 outb(EEPROM_READ + index, id_port);
769
770 /* Pause for at least 162 us. for the read to take place. */
771 /* Some chips seem to require much longer */
772 mdelay(4);
6aa20a22 773
1da177e4
LT		 774 for (bit = 15; bit >= 0; bit--)
775 word = (word << 1) + (inb(id_port) & 0x01);
776
777 if (el3_debug > 3)
778 printk(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
779
780 return word;
781}
782
783
784static int
785el3_open(struct net_device *dev)
786{
787 int ioaddr = dev->base_addr;
788 int i;
789
790 outw(TxReset, ioaddr + EL3_CMD);
791 outw(RxReset, ioaddr + EL3_CMD);
792 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
793
794 i = request_irq(dev->irq, &el3_interrupt, 0, dev->name, dev);
795 if (i)
796 return i;
797
798 EL3WINDOW(0);
799 if (el3_debug > 3)
800 printk("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
801 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
802
803 el3_up(dev);
804
805 if (el3_debug > 3)
806 printk("%s: Opened 3c509 IRQ %d status %4.4x.\n",
807 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
808
809 return 0;
810}
811
812static void
813el3_tx_timeout (struct net_device *dev)
814{
815 struct el3_private *lp = netdev_priv(dev);
816 int ioaddr = dev->base_addr;
817
818 /* Transmitter timeout, serious problems. */
819 printk("%s: transmit timed out, Tx_status %2.2x status %4.4x "
820 "Tx FIFO room %d.\n",
821 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
822 inw(ioaddr + TX_FREE));
823 lp->stats.tx_errors++;
824 dev->trans_start = jiffies;
825 /* Issue TX_RESET and TX_START commands. */
826 outw(TxReset, ioaddr + EL3_CMD);
827 outw(TxEnable, ioaddr + EL3_CMD);
828 netif_wake_queue(dev);
829}
830
831
832static int
833el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
834{
835 struct el3_private *lp = netdev_priv(dev);
836 int ioaddr = dev->base_addr;
837 unsigned long flags;
838
839 netif_stop_queue (dev);
840
841 lp->stats.tx_bytes += skb->len;
6aa20a22 842
1da177e4
LT		 843 if (el3_debug > 4) {
844 printk("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
845 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
846 }
847#if 0
848#ifndef final_version
849 { /* Error-checking code, delete someday. */
850 ushort status = inw(ioaddr + EL3_STATUS);
851 if (status & 0x0001 /* IRQ line active, missed one. */
852 && inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
853 printk("%s: Missed interrupt, status then %04x now %04x"
854 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
855 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
856 inw(ioaddr + RX_STATUS));
857 /* Fake interrupt trigger by masking, acknowledge interrupts. */
858 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
859 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
860 ioaddr + EL3_CMD);
861 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
862 }
863 }
864#endif
865#endif
866 /*
867 * We lock the driver against other processors. Note
868 * we don't need to lock versus the IRQ as we suspended
869 * that. This means that we lose the ability to take
870 * an RX during a TX upload. That sucks a bit with SMP
871 * on an original 3c509 (2K buffer)
872 *
873 * Using disable_irq stops us crapping on other
874 * time sensitive devices.
875 */
876
877 spin_lock_irqsave(&lp->lock, flags);
878
879 /* Put out the doubleword header... */
880 outw(skb->len, ioaddr + TX_FIFO);
881 outw(0x00, ioaddr + TX_FIFO);
882 /* ... and the packet rounded to a doubleword. */
1da177e4 883 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
1da177e4
LT		 884
885 dev->trans_start = jiffies;
886 if (inw(ioaddr + TX_FREE) > 1536)
887 netif_start_queue(dev);
888 else
889 /* Interrupt us when the FIFO has room for max-sized packet. */
890 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
891
892 spin_unlock_irqrestore(&lp->lock, flags);
893
894 dev_kfree_skb (skb);
895
896 /* Clear the Tx status stack. */
897 {
898 short tx_status;
899 int i = 4;
900
901 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
902 if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
903 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
904 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
905 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
906 }
907 }
908 return 0;
909}
910
911/* The EL3 interrupt handler. */
912static irqreturn_t
7d12e780 913el3_interrupt(int irq, void *dev_id)
1da177e4
LT		 914{
915 struct net_device *dev = (struct net_device *)dev_id;
916 struct el3_private *lp;
917 int ioaddr, status;
918 int i = max_interrupt_work;
919
920 if (dev == NULL) {
921 printk ("el3_interrupt(): irq %d for unknown device.\n", irq);
922 return IRQ_NONE;
923 }
924
925 lp = netdev_priv(dev);
926 spin_lock(&lp->lock);
927
928 ioaddr = dev->base_addr;
929
930 if (el3_debug > 4) {
931 status = inw(ioaddr + EL3_STATUS);
932 printk("%s: interrupt, status %4.4x.\n", dev->name, status);
933 }
934
935 while ((status = inw(ioaddr + EL3_STATUS)) &
936 (IntLatch | RxComplete | StatsFull)) {
937
938 if (status & RxComplete)
939 el3_rx(dev);
940
941 if (status & TxAvailable) {
942 if (el3_debug > 5)
943 printk(" TX room bit was handled.\n");
944 /* There's room in the FIFO for a full-sized packet. */
945 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
946 netif_wake_queue (dev);
947 }
948 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
949 /* Handle all uncommon interrupts. */
950 if (status & StatsFull) /* Empty statistics. */
951 update_stats(dev);
952 if (status & RxEarly) { /* Rx early is unused. */
953 el3_rx(dev);
954 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
955 }
956 if (status & TxComplete) { /* Really Tx error. */
957 struct el3_private *lp = netdev_priv(dev);
958 short tx_status;
959 int i = 4;
960
961 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
962 if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
963 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
964 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
965 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
966 }
967 }
968 if (status & AdapterFailure) {
969 /* Adapter failure requires Rx reset and reinit. */
970 outw(RxReset, ioaddr + EL3_CMD);
971 /* Set the Rx filter to the current state. */
972 outw(SetRxFilter | RxStation | RxBroadcast
973 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
974 | (dev->flags & IFF_PROMISC ? RxProm : 0),
975 ioaddr + EL3_CMD);
976 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
977 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
978 }
979 }
980
981 if (--i < 0) {
982 printk("%s: Infinite loop in interrupt, status %4.4x.\n",
983 dev->name, status);
984 /* Clear all interrupts. */
985 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
986 break;
987 }
988 /* Acknowledge the IRQ. */
989 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
990 }
991
992 if (el3_debug > 4) {
993 printk("%s: exiting interrupt, status %4.4x.\n", dev->name,
994 inw(ioaddr + EL3_STATUS));
995 }
996 spin_unlock(&lp->lock);
997 return IRQ_HANDLED;
998}
999
1000
1001#ifdef CONFIG_NET_POLL_CONTROLLER
1002/*
1003 * Polling receive - used by netconsole and other diagnostic tools
1004 * to allow network i/o with interrupts disabled.
1005 */
1006static void el3_poll_controller(struct net_device *dev)
1007{
1008 disable_irq(dev->irq);
7d12e780 1009 el3_interrupt(dev->irq, dev);
1da177e4
LT		 1010 enable_irq(dev->irq);
1011}
1012#endif
1013
1014static struct net_device_stats *
1015el3_get_stats(struct net_device *dev)
1016{
1017 struct el3_private *lp = netdev_priv(dev);
1018 unsigned long flags;
1019
1020 /*
1021 * This is fast enough not to bother with disable IRQ
1022 * stuff.
1023 */
6aa20a22 1024
1da177e4
LT		 1025 spin_lock_irqsave(&lp->lock, flags);
1026 update_stats(dev);
1027 spin_unlock_irqrestore(&lp->lock, flags);
1028 return &lp->stats;
1029}
1030
1031/* Update statistics. We change to register window 6, so this should be run
1032 single-threaded if the device is active. This is expected to be a rare
1033 operation, and it's simpler for the rest of the driver to assume that
1034 window 1 is always valid rather than use a special window-state variable.
1035 */
1036static void update_stats(struct net_device *dev)
1037{
1038 struct el3_private *lp = netdev_priv(dev);
1039 int ioaddr = dev->base_addr;
1040
1041 if (el3_debug > 5)
1042 printk(" Updating the statistics.\n");
1043 /* Turn off statistics updates while reading. */
1044 outw(StatsDisable, ioaddr + EL3_CMD);
1045 /* Switch to the stats window, and read everything. */
1046 EL3WINDOW(6);
1047 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
1048 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1049 /* Multiple collisions. */ inb(ioaddr + 2);
1050 lp->stats.collisions += inb(ioaddr + 3);
1051 lp->stats.tx_window_errors += inb(ioaddr + 4);
1052 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
1053 lp->stats.tx_packets += inb(ioaddr + 6);
1054 /* Rx packets */ inb(ioaddr + 7);
1055 /* Tx deferrals */ inb(ioaddr + 8);
1056 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1057 inw(ioaddr + 12);
1058
1059 /* Back to window 1, and turn statistics back on. */
1060 EL3WINDOW(1);
1061 outw(StatsEnable, ioaddr + EL3_CMD);
1062 return;
1063}
1064
1065static int
1066el3_rx(struct net_device *dev)
1067{
1068 struct el3_private *lp = netdev_priv(dev);
1069 int ioaddr = dev->base_addr;
1070 short rx_status;
1071
1072 if (el3_debug > 5)
1073 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1074 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1075 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1076 if (rx_status & 0x4000) { /* Error, update stats. */
1077 short error = rx_status & 0x3800;
1078
1079 outw(RxDiscard, ioaddr + EL3_CMD);
1080 lp->stats.rx_errors++;
1081 switch (error) {
1082 case 0x0000: lp->stats.rx_over_errors++; break;
1083 case 0x0800: lp->stats.rx_length_errors++; break;
1084 case 0x1000: lp->stats.rx_frame_errors++; break;
1085 case 0x1800: lp->stats.rx_length_errors++; break;
1086 case 0x2000: lp->stats.rx_frame_errors++; break;
1087 case 0x2800: lp->stats.rx_crc_errors++; break;
1088 }
1089 } else {
1090 short pkt_len = rx_status & 0x7ff;
1091 struct sk_buff *skb;
1092
1093 skb = dev_alloc_skb(pkt_len+5);
1094 lp->stats.rx_bytes += pkt_len;
1095 if (el3_debug > 4)
1096 printk("Receiving packet size %d status %4.4x.\n",
1097 pkt_len, rx_status);
1098 if (skb != NULL) {
1099 skb->dev = dev;
1100 skb_reserve(skb, 2); /* Align IP on 16 byte */
1101
1102 /* 'skb->data' points to the start of sk_buff data area. */
1da177e4
LT		 1103 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1104 (pkt_len + 3) >> 2);
1da177e4
LT		 1105
1106 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1107 skb->protocol = eth_type_trans(skb,dev);
1108 netif_rx(skb);
1109 dev->last_rx = jiffies;
1110 lp->stats.rx_packets++;
1111 continue;
1112 }
1113 outw(RxDiscard, ioaddr + EL3_CMD);
1114 lp->stats.rx_dropped++;
1115 if (el3_debug)
1116 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1117 dev->name, pkt_len);
1118 }
1119 inw(ioaddr + EL3_STATUS); /* Delay. */
1120 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1121 printk(KERN_DEBUG " Waiting for 3c509 to discard packet, status %x.\n",
1122 inw(ioaddr + EL3_STATUS) );
1123 }
1124
1125 return 0;
1126}
1127
1128/*
1129 * Set or clear the multicast filter for this adaptor.
1130 */
1131static void
1132set_multicast_list(struct net_device *dev)
1133{
1134 unsigned long flags;
1135 struct el3_private *lp = netdev_priv(dev);
1136 int ioaddr = dev->base_addr;
1137
1138 if (el3_debug > 1) {
1139 static int old;
1140 if (old != dev->mc_count) {
1141 old = dev->mc_count;
1142 printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1143 }
1144 }
1145 spin_lock_irqsave(&lp->lock, flags);
1146 if (dev->flags&IFF_PROMISC) {
1147 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1148 ioaddr + EL3_CMD);
1149 }
1150 else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1151 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1152 }
1153 else
1154 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1155 spin_unlock_irqrestore(&lp->lock, flags);
1156}
1157
1158static int
1159el3_close(struct net_device *dev)
1160{
1161 int ioaddr = dev->base_addr;
1162 struct el3_private *lp = netdev_priv(dev);
6aa20a22 1163
1da177e4
LT		 1164 if (el3_debug > 2)
1165 printk("%s: Shutting down ethercard.\n", dev->name);
1166
1167 el3_down(dev);
1168
1169 free_irq(dev->irq, dev);
1170 /* Switching back to window 0 disables the IRQ. */
1171 EL3WINDOW(0);
1172 if (lp->type != EL3_EISA) {
1173 /* But we explicitly zero the IRQ line select anyway. Don't do
1174 * it on EISA cards, it prevents the module from getting an
1175 * IRQ after unload+reload... */
1176 outw(0x0f00, ioaddr + WN0_IRQ);
1177 }
1178
1179 return 0;
1180}
1181
6aa20a22 1182static int
1da177e4
LT		 1183el3_link_ok(struct net_device *dev)
1184{
1185 int ioaddr = dev->base_addr;
1186 u16 tmp;
1187
1188 EL3WINDOW(4);
1189 tmp = inw(ioaddr + WN4_MEDIA);
1190 EL3WINDOW(1);
1191 return tmp & (1<<11);
1192}
1193
1194static int
1195el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1196{
1197 u16 tmp;
1198 int ioaddr = dev->base_addr;
6aa20a22 1199
1da177e4 1200 EL3WINDOW(0);
6aa20a22 1201 /* obtain current transceiver via WN4_MEDIA? */
1da177e4
LT		 1202 tmp = inw(ioaddr + WN0_ADDR_CONF);
1203 ecmd->transceiver = XCVR_INTERNAL;
1204 switch (tmp >> 14) {
1205 case 0:
1206 ecmd->port = PORT_TP;
1207 break;
1208 case 1:
1209 ecmd->port = PORT_AUI;
1210 ecmd->transceiver = XCVR_EXTERNAL;
1211 break;
1212 case 3:
1213 ecmd->port = PORT_BNC;
1214 default:
1215 break;
1216 }
1217
1218 ecmd->duplex = DUPLEX_HALF;
1219 ecmd->supported = 0;
1220 tmp = inw(ioaddr + WN0_CONF_CTRL);
1221 if (tmp & (1<<13))
1222 ecmd->supported |= SUPPORTED_AUI;
1223 if (tmp & (1<<12))
1224 ecmd->supported |= SUPPORTED_BNC;
1225 if (tmp & (1<<9)) {
1226 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1227 SUPPORTED_10baseT_Full; /* hmm... */
1228 EL3WINDOW(4);
1229 tmp = inw(ioaddr + WN4_NETDIAG);
1230 if (tmp & FD_ENABLE)
1231 ecmd->duplex = DUPLEX_FULL;
1232 }
1233
1234 ecmd->speed = SPEED_10;
1235 EL3WINDOW(1);
1236 return 0;
1237}
1238
1239static int
1240el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1241{
1242 u16 tmp;
1243 int ioaddr = dev->base_addr;
1244
1245 if (ecmd->speed != SPEED_10)
1246 return -EINVAL;
1247 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1248 return -EINVAL;
1249 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1250 return -EINVAL;
1251
1252 /* change XCVR type */
1253 EL3WINDOW(0);
1254 tmp = inw(ioaddr + WN0_ADDR_CONF);
1255 switch (ecmd->port) {
1256 case PORT_TP:
1257 tmp &= ~(3<<14);
1258 dev->if_port = 0;
1259 break;
1260 case PORT_AUI:
1261 tmp |= (1<<14);
1262 dev->if_port = 1;
1263 break;
1264 case PORT_BNC:
1265 tmp |= (3<<14);
1266 dev->if_port = 3;
1267 break;
1268 default:
1269 return -EINVAL;
1270 }
1271
1272 outw(tmp, ioaddr + WN0_ADDR_CONF);
1273 if (dev->if_port == 3) {
1274 /* fire up the DC-DC convertor if BNC gets enabled */
1275 tmp = inw(ioaddr + WN0_ADDR_CONF);
1276 if (tmp & (3 << 14)) {
1277 outw(StartCoax, ioaddr + EL3_CMD);
1278 udelay(800);
1279 } else
1280 return -EIO;
1281 }
1282
1283 EL3WINDOW(4);
1284 tmp = inw(ioaddr + WN4_NETDIAG);
1285 if (ecmd->duplex == DUPLEX_FULL)
1286 tmp |= FD_ENABLE;
1287 else
1288 tmp &= ~FD_ENABLE;
1289 outw(tmp, ioaddr + WN4_NETDIAG);
1290 EL3WINDOW(1);
1291
1292 return 0;
1293}
1294
1295static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1296{
1297 strcpy(info->driver, DRV_NAME);
1298 strcpy(info->version, DRV_VERSION);
1299}
1300
1301static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1302{
1303 struct el3_private *lp = netdev_priv(dev);
1304 int ret;
1305
1306 spin_lock_irq(&lp->lock);
1307 ret = el3_netdev_get_ecmd(dev, ecmd);
1308 spin_unlock_irq(&lp->lock);
1309 return ret;
1310}
1311
1312static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1313{
1314 struct el3_private *lp = netdev_priv(dev);
1315 int ret;
1316
1317 spin_lock_irq(&lp->lock);
1318 ret = el3_netdev_set_ecmd(dev, ecmd);
1319 spin_unlock_irq(&lp->lock);
1320 return ret;
1321}
1322
1323static u32 el3_get_link(struct net_device *dev)
1324{
1325 struct el3_private *lp = netdev_priv(dev);
1326 u32 ret;
1327
1328 spin_lock_irq(&lp->lock);
1329 ret = el3_link_ok(dev);
1330 spin_unlock_irq(&lp->lock);
1331 return ret;
1332}
1333
1334static u32 el3_get_msglevel(struct net_device *dev)
1335{
1336 return el3_debug;
1337}
1338
1339static void el3_set_msglevel(struct net_device *dev, u32 v)
1340{
1341 el3_debug = v;
1342}
1343
7282d491 1344static const struct ethtool_ops ethtool_ops = {
1da177e4
LT		 1345 .get_drvinfo = el3_get_drvinfo,
1346 .get_settings = el3_get_settings,
1347 .set_settings = el3_set_settings,
1348 .get_link = el3_get_link,
1349 .get_msglevel = el3_get_msglevel,
1350 .set_msglevel = el3_set_msglevel,
1351};
1352
1353static void
1354el3_down(struct net_device *dev)
1355{
1356 int ioaddr = dev->base_addr;
1357
1358 netif_stop_queue(dev);
1359
1360 /* Turn off statistics ASAP. We update lp->stats below. */
1361 outw(StatsDisable, ioaddr + EL3_CMD);
1362
1363 /* Disable the receiver and transmitter. */
1364 outw(RxDisable, ioaddr + EL3_CMD);
1365 outw(TxDisable, ioaddr + EL3_CMD);
1366
1367 if (dev->if_port == 3)
1368 /* Turn off thinnet power. Green! */
1369 outw(StopCoax, ioaddr + EL3_CMD);
1370 else if (dev->if_port == 0) {
1371 /* Disable link beat and jabber, if_port may change here next open(). */
1372 EL3WINDOW(4);
1373 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1374 }
1375
1376 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1377
1378 update_stats(dev);
1379}
1380
1381static void
1382el3_up(struct net_device *dev)
1383{
1384 int i, sw_info, net_diag;
1385 int ioaddr = dev->base_addr;
6aa20a22 1386
1da177e4
LT		 1387 /* Activating the board required and does no harm otherwise */
1388 outw(0x0001, ioaddr + 4);
1389
1390 /* Set the IRQ line. */
1391 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1392
1393 /* Set the station address in window 2 each time opened. */
1394 EL3WINDOW(2);
1395
1396 for (i = 0; i < 6; i++)
1397 outb(dev->dev_addr[i], ioaddr + i);
1398
1399 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1400 /* Start the thinnet transceiver. We should really wait 50ms...*/
1401 outw(StartCoax, ioaddr + EL3_CMD);
1402 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1403 /* Combine secondary sw_info word (the adapter level) and primary
1404 sw_info word (duplex setting plus other useless bits) */
1405 EL3WINDOW(0);
6aa20a22 1406 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1da177e4
LT		 1407 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1408
1409 EL3WINDOW(4);
1410 net_diag = inw(ioaddr + WN4_NETDIAG);
1411 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1412 printk("%s: ", dev->name);
1413 switch (dev->if_port & 0x0c) {
1414 case 12:
1415 /* force full-duplex mode if 3c5x9b */
1416 if (sw_info & 0x000f) {
1417 printk("Forcing 3c5x9b full-duplex mode");
1418 break;
1419 }
1420 case 8:
1421 /* set full-duplex mode based on eeprom config setting */
1422 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1423 printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1424 break;
1425 }
1426 default:
1427 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1428 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1429 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1430 }
1431
1432 outw(net_diag, ioaddr + WN4_NETDIAG);
1433 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1434 if (el3_debug > 3)
1435 printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1436 /* Enable link beat and jabber check. */
1437 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1438 }
1439
1440 /* Switch to the stats window, and clear all stats by reading. */
1441 outw(StatsDisable, ioaddr + EL3_CMD);
1442 EL3WINDOW(6);
1443 for (i = 0; i < 9; i++)
1444 inb(ioaddr + i);
1445 inw(ioaddr + 10);
1446 inw(ioaddr + 12);
1447
1448 /* Switch to register set 1 for normal use. */
1449 EL3WINDOW(1);
1450
1451 /* Accept b-case and phys addr only. */
1452 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1453 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1454
1455 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1456 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1457 /* Allow status bits to be seen. */
1458 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1459 /* Ack all pending events, and set active indicator mask. */
1460 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1461 ioaddr + EL3_CMD);
1462 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1463 ioaddr + EL3_CMD);
1464
1465 netif_start_queue(dev);
1466}
1467
1468/* Power Management support functions */
60a89ff6 1469#ifdef EL3_SUSPEND
1da177e4
LT		 1470
1471static int
60a89ff6 1472el3_suspend(struct device *pdev, pm_message_t state)
1da177e4
LT		 1473{
1474 unsigned long flags;
1475 struct net_device *dev;
1476 struct el3_private *lp;
1477 int ioaddr;
6aa20a22 1478
60a89ff6 1479 dev = pdev->driver_data;
1da177e4
LT		 1480 lp = netdev_priv(dev);
1481 ioaddr = dev->base_addr;
1482
1483 spin_lock_irqsave(&lp->lock, flags);
1484
1485 if (netif_running(dev))
1486 netif_device_detach(dev);
1487
1488 el3_down(dev);
1489 outw(PowerDown, ioaddr + EL3_CMD);
1490
1491 spin_unlock_irqrestore(&lp->lock, flags);
1492 return 0;
1493}
1494
1495static int
60a89ff6 1496el3_resume(struct device *pdev)
1da177e4
LT		 1497{
1498 unsigned long flags;
1499 struct net_device *dev;
1500 struct el3_private *lp;
1501 int ioaddr;
6aa20a22 1502
60a89ff6 1503 dev = pdev->driver_data;
1da177e4
LT		 1504 lp = netdev_priv(dev);
1505 ioaddr = dev->base_addr;
1506
1507 spin_lock_irqsave(&lp->lock, flags);
1508
1509 outw(PowerUp, ioaddr + EL3_CMD);
1510 el3_up(dev);
1511
1512 if (netif_running(dev))
1513 netif_device_attach(dev);
6aa20a22 1514
1da177e4
LT		 1515 spin_unlock_irqrestore(&lp->lock, flags);
1516 return 0;
1517}
1518
60a89ff6 1519#endif /* EL3_SUSPEND */
1da177e4
LT		 1520
1521/* Parameters that may be passed into the module. */
1522static int debug = -1;
1523static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
1524static int xcvr[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1525
1526module_param(debug,int, 0);
1527module_param_array(irq, int, NULL, 0);
1528module_param_array(xcvr, int, NULL, 0);
1529module_param(max_interrupt_work, int, 0);
1530MODULE_PARM_DESC(debug, "debug level (0-6)");
1531MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1532MODULE_PARM_DESC(xcvr,"transceiver(s) (0=internal, 1=external)");
1533MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1534#if defined(__ISAPNP__)
1535module_param(nopnp, int, 0);
1536MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1537MODULE_DEVICE_TABLE(isapnp, el3_isapnp_adapters);
1538#endif /* __ISAPNP__ */
1539MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B) ISA/PnP ethernet driver");
1540MODULE_LICENSE("GPL");
1541
1542static int __init el3_init_module(void)
1543{
0992a5d0 1544 int ret = 0;
1da177e4
LT		 1545 el3_cards = 0;
1546
1547 if (debug >= 0)
1548 el3_debug = debug;
1549
1550 el3_root_dev = NULL;
1551 while (el3_probe(el3_cards) == 0) {
1552 if (irq[el3_cards] > 1)
1553 el3_root_dev->irq = irq[el3_cards];
1554 if (xcvr[el3_cards] >= 0)
1555 el3_root_dev->if_port = xcvr[el3_cards];
1556 el3_cards++;
1557 }
1558
1559#ifdef CONFIG_EISA
0992a5d0 1560 ret = eisa_driver_register(&el3_eisa_driver);
1da177e4
LT		 1561#endif
1562#ifdef CONFIG_MCA
0992a5d0
AM		 1563 {
1564 int err = mca_register_driver(&el3_mca_driver);
1565 if (ret == 0)
1566 ret = err;
1567 }
1da177e4 1568#endif
0992a5d0 1569 return ret;
1da177e4
LT		 1570}
1571
1572static void __exit el3_cleanup_module(void)
1573{
1574 struct net_device *next_dev;
1575
1576 while (el3_root_dev) {
1577 struct el3_private *lp = netdev_priv(el3_root_dev);
1578
1579 next_dev = lp->next_dev;
1580 el3_common_remove (el3_root_dev);
1581 el3_root_dev = next_dev;
1582 }
1583
1584#ifdef CONFIG_EISA
1585 eisa_driver_unregister (&el3_eisa_driver);
1586#endif
1587#ifdef CONFIG_MCA
1588 mca_unregister_driver(&el3_mca_driver);
1589#endif
1590}
1591
1592module_init (el3_init_module);
1593module_exit (el3_cleanup_module);
1594
Linux kernel - Deliverables
This page took 0.225355 seconds and 5 git commands to generate.