ia64/linux-2.6.18-xen.hg

view drivers/net/3c509.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 /* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
2 /*
3 Written 1993-2000 by Donald Becker.
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.
11 This driver is for the 3Com EtherLinkIII series.
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
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.
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.
28 FIXES:
29 Alan Cox: Removed the 'Unexpected interrupt' bug.
30 Michael Meskes: Upgraded to Donald Becker's version 1.07.
31 Alan Cox: Increased the eeprom delay. Regardless of
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 */
60 #define DRV_NAME "3c509"
61 #define DRV_VERSION "1.19b"
62 #define DRV_RELDATE "08Nov2002"
64 /* A few values that may be tweaked. */
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. */
69 static int max_interrupt_work = 10;
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>
86 #include <linux/pm_legacy.h>
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>
95 #include <asm/uaccess.h>
96 #include <asm/io.h>
97 #include <asm/irq.h>
99 static char versionA[] __initdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
100 static char versionB[] __initdata = "http://www.scyld.com/network/3c509.html\n";
102 #if defined(CONFIG_PM) && (defined(CONFIG_MCA) || defined(CONFIG_EISA))
103 #define EL3_SUSPEND
104 #endif
106 #ifdef EL3_DEBUG
107 static int el3_debug = EL3_DEBUG;
108 #else
109 static int el3_debug = 2;
110 #endif
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 */
115 static int el3_cards = 0;
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
126 #define EL3_IO_EXTENT 16
128 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
131 /* The top five bits written to EL3_CMD are a command, the lower
132 11 bits are the parameter, if applicable. */
133 enum 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};
143 enum c509status {
144 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
145 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
146 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
148 /* The SetRxFilter command accepts the following classes: */
149 enum RxFilter {
150 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
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. */
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 */
165 #define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
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
173 struct 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];
180 enum {
181 EL3_MCA,
182 EL3_PNP,
183 EL3_EISA,
184 } type; /* type of device */
185 struct device *dev;
186 };
187 static int id_port __initdata = 0x110; /* Start with 0x110 to avoid new sound cards.*/
188 static struct net_device *el3_root_dev;
190 static ushort id_read_eeprom(int index);
191 static ushort read_eeprom(int ioaddr, int index);
192 static int el3_open(struct net_device *dev);
193 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
194 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
195 static void update_stats(struct net_device *dev);
196 static struct net_device_stats *el3_get_stats(struct net_device *dev);
197 static int el3_rx(struct net_device *dev);
198 static int el3_close(struct net_device *dev);
199 static void set_multicast_list(struct net_device *dev);
200 static void el3_tx_timeout (struct net_device *dev);
201 static void el3_down(struct net_device *dev);
202 static void el3_up(struct net_device *dev);
203 static struct ethtool_ops ethtool_ops;
204 #ifdef EL3_SUSPEND
205 static int el3_suspend(struct device *, pm_message_t);
206 static int el3_resume(struct device *);
207 #else
208 #define el3_suspend NULL
209 #define el3_resume NULL
210 #endif
213 /* generic device remove for all device types */
214 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
215 static int el3_device_remove (struct device *device);
216 #endif
217 #ifdef CONFIG_NET_POLL_CONTROLLER
218 static void el3_poll_controller(struct net_device *dev);
219 #endif
221 #ifdef CONFIG_EISA
222 static struct eisa_device_id el3_eisa_ids[] = {
223 { "TCM5092" },
224 { "TCM5093" },
225 { "TCM5095" },
226 { "" }
227 };
229 static int el3_eisa_probe (struct device *device);
231 static struct eisa_driver el3_eisa_driver = {
232 .id_table = el3_eisa_ids,
233 .driver = {
234 .name = "3c509",
235 .probe = el3_eisa_probe,
236 .remove = __devexit_p (el3_device_remove),
237 .suspend = el3_suspend,
238 .resume = el3_resume,
239 }
240 };
241 #endif
243 #ifdef CONFIG_MCA
244 static int el3_mca_probe(struct device *dev);
246 static short el3_mca_adapter_ids[] __initdata = {
247 0x627c,
248 0x627d,
249 0x62db,
250 0x62f6,
251 0x62f7,
252 0x0000
253 };
255 static char *el3_mca_adapter_names[] __initdata = {
256 "3Com 3c529 EtherLink III (10base2)",
257 "3Com 3c529 EtherLink III (10baseT)",
258 "3Com 3c529 EtherLink III (test mode)",
259 "3Com 3c529 EtherLink III (TP or coax)",
260 "3Com 3c529 EtherLink III (TP)",
261 NULL
262 };
264 static struct mca_driver el3_mca_driver = {
265 .id_table = el3_mca_adapter_ids,
266 .driver = {
267 .name = "3c529",
268 .bus = &mca_bus_type,
269 .probe = el3_mca_probe,
270 .remove = __devexit_p(el3_device_remove),
271 .suspend = el3_suspend,
272 .resume = el3_resume,
273 },
274 };
275 #endif /* CONFIG_MCA */
277 #if defined(__ISAPNP__)
278 static struct isapnp_device_id el3_isapnp_adapters[] __initdata = {
279 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
280 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5090),
281 (long) "3Com Etherlink III (TP)" },
282 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
283 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5091),
284 (long) "3Com Etherlink III" },
285 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
286 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5094),
287 (long) "3Com Etherlink III (combo)" },
288 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
289 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5095),
290 (long) "3Com Etherlink III (TPO)" },
291 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
292 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5098),
293 (long) "3Com Etherlink III (TPC)" },
294 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
295 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f7),
296 (long) "3Com Etherlink III compatible" },
297 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
298 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f8),
299 (long) "3Com Etherlink III compatible" },
300 { } /* terminate list */
301 };
303 static u16 el3_isapnp_phys_addr[8][3];
304 static int nopnp;
305 #endif /* __ISAPNP__ */
307 /* With the driver model introduction for EISA devices, both init
308 * and cleanup have been split :
309 * - EISA devices probe/remove starts in el3_eisa_probe/el3_device_remove
310 * - MCA/ISA still use el3_probe
311 *
312 * Both call el3_common_init/el3_common_remove. */
314 static int __init el3_common_init(struct net_device *dev)
315 {
316 struct el3_private *lp = netdev_priv(dev);
317 short i;
318 int err;
320 spin_lock_init(&lp->lock);
322 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
323 dev->if_port = (dev->mem_start & 0x0f);
324 } else { /* xcvr codes 0/8 */
325 /* use eeprom value, but save user's full-duplex selection */
326 dev->if_port |= (dev->mem_start & 0x08);
327 }
329 /* The EL3-specific entries in the device structure. */
330 dev->open = &el3_open;
331 dev->hard_start_xmit = &el3_start_xmit;
332 dev->stop = &el3_close;
333 dev->get_stats = &el3_get_stats;
334 dev->set_multicast_list = &set_multicast_list;
335 dev->tx_timeout = el3_tx_timeout;
336 dev->watchdog_timeo = TX_TIMEOUT;
337 #ifdef CONFIG_NET_POLL_CONTROLLER
338 dev->poll_controller = el3_poll_controller;
339 #endif
340 SET_ETHTOOL_OPS(dev, &ethtool_ops);
342 err = register_netdev(dev);
343 if (err) {
344 printk(KERN_ERR "Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
345 dev->base_addr, dev->irq);
346 release_region(dev->base_addr, EL3_IO_EXTENT);
347 return err;
348 }
350 {
351 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
352 printk("%s: 3c5x9 found at %#3.3lx, %s port, address ",
353 dev->name, dev->base_addr,
354 if_names[(dev->if_port & 0x03)]);
355 }
357 /* Read in the station address. */
358 for (i = 0; i < 6; i++)
359 printk(" %2.2x", dev->dev_addr[i]);
360 printk(", IRQ %d.\n", dev->irq);
362 if (el3_debug > 0)
363 printk(KERN_INFO "%s" KERN_INFO "%s", versionA, versionB);
364 return 0;
366 }
368 static void el3_common_remove (struct net_device *dev)
369 {
370 struct el3_private *lp = netdev_priv(dev);
372 (void) lp; /* Keep gcc quiet... */
373 #if defined(__ISAPNP__)
374 if (lp->type == EL3_PNP)
375 pnp_device_detach(to_pnp_dev(lp->dev));
376 #endif
378 unregister_netdev (dev);
379 release_region(dev->base_addr, EL3_IO_EXTENT);
380 free_netdev (dev);
381 }
383 static int __init el3_probe(int card_idx)
384 {
385 struct net_device *dev;
386 struct el3_private *lp;
387 short lrs_state = 0xff, i;
388 int ioaddr, irq, if_port;
389 u16 phys_addr[3];
390 static int current_tag;
391 int err = -ENODEV;
392 #if defined(__ISAPNP__)
393 static int pnp_cards;
394 struct pnp_dev *idev = NULL;
396 if (nopnp == 1)
397 goto no_pnp;
399 for (i=0; el3_isapnp_adapters[i].vendor != 0; i++) {
400 int j;
401 while ((idev = pnp_find_dev(NULL,
402 el3_isapnp_adapters[i].vendor,
403 el3_isapnp_adapters[i].function,
404 idev))) {
405 if (pnp_device_attach(idev) < 0)
406 continue;
407 if (pnp_activate_dev(idev) < 0) {
408 __again:
409 pnp_device_detach(idev);
410 continue;
411 }
412 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
413 goto __again;
414 ioaddr = pnp_port_start(idev, 0);
415 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509 PnP")) {
416 pnp_device_detach(idev);
417 return -EBUSY;
418 }
419 irq = pnp_irq(idev, 0);
420 if (el3_debug > 3)
421 printk ("ISAPnP reports %s at i/o 0x%x, irq %d\n",
422 (char*) el3_isapnp_adapters[i].driver_data, ioaddr, irq);
423 EL3WINDOW(0);
424 for (j = 0; j < 3; j++)
425 el3_isapnp_phys_addr[pnp_cards][j] =
426 phys_addr[j] =
427 htons(read_eeprom(ioaddr, j));
428 if_port = read_eeprom(ioaddr, 8) >> 14;
429 dev = alloc_etherdev(sizeof (struct el3_private));
430 if (!dev) {
431 release_region(ioaddr, EL3_IO_EXTENT);
432 pnp_device_detach(idev);
433 return -ENOMEM;
434 }
436 SET_MODULE_OWNER(dev);
437 SET_NETDEV_DEV(dev, &idev->dev);
438 pnp_cards++;
440 netdev_boot_setup_check(dev);
441 goto found;
442 }
443 }
444 no_pnp:
445 #endif /* __ISAPNP__ */
447 /* Select an open I/O location at 0x1*0 to do contention select. */
448 for ( ; id_port < 0x200; id_port += 0x10) {
449 if (!request_region(id_port, 1, "3c509"))
450 continue;
451 outb(0x00, id_port);
452 outb(0xff, id_port);
453 if (inb(id_port) & 0x01){
454 release_region(id_port, 1);
455 break;
456 } else
457 release_region(id_port, 1);
458 }
459 if (id_port >= 0x200) {
460 /* Rare -- do we really need a warning? */
461 printk(" WARNING: No I/O port available for 3c509 activation.\n");
462 return -ENODEV;
463 }
465 /* Next check for all ISA bus boards by sending the ID sequence to the
466 ID_PORT. We find cards past the first by setting the 'current_tag'
467 on cards as they are found. Cards with their tag set will not
468 respond to subsequent ID sequences. */
470 outb(0x00, id_port);
471 outb(0x00, id_port);
472 for(i = 0; i < 255; i++) {
473 outb(lrs_state, id_port);
474 lrs_state <<= 1;
475 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
476 }
478 /* For the first probe, clear all board's tag registers. */
479 if (current_tag == 0)
480 outb(0xd0, id_port);
481 else /* Otherwise kill off already-found boards. */
482 outb(0xd8, id_port);
484 if (id_read_eeprom(7) != 0x6d50) {
485 return -ENODEV;
486 }
488 /* Read in EEPROM data, which does contention-select.
489 Only the lowest address board will stay "on-line".
490 3Com got the byte order backwards. */
491 for (i = 0; i < 3; i++) {
492 phys_addr[i] = htons(id_read_eeprom(i));
493 }
495 #if defined(__ISAPNP__)
496 if (nopnp == 0) {
497 /* The ISA PnP 3c509 cards respond to the ID sequence.
498 This check is needed in order not to register them twice. */
499 for (i = 0; i < pnp_cards; i++) {
500 if (phys_addr[0] == el3_isapnp_phys_addr[i][0] &&
501 phys_addr[1] == el3_isapnp_phys_addr[i][1] &&
502 phys_addr[2] == el3_isapnp_phys_addr[i][2])
503 {
504 if (el3_debug > 3)
505 printk("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
506 phys_addr[0] & 0xff, phys_addr[0] >> 8,
507 phys_addr[1] & 0xff, phys_addr[1] >> 8,
508 phys_addr[2] & 0xff, phys_addr[2] >> 8);
509 /* Set the adaptor tag so that the next card can be found. */
510 outb(0xd0 + ++current_tag, id_port);
511 goto no_pnp;
512 }
513 }
514 }
515 #endif /* __ISAPNP__ */
517 {
518 unsigned int iobase = id_read_eeprom(8);
519 if_port = iobase >> 14;
520 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
521 }
522 irq = id_read_eeprom(9) >> 12;
524 dev = alloc_etherdev(sizeof (struct el3_private));
525 if (!dev)
526 return -ENOMEM;
528 SET_MODULE_OWNER(dev);
530 netdev_boot_setup_check(dev);
532 /* Set passed-in IRQ or I/O Addr. */
533 if (dev->irq > 1 && dev->irq < 16)
534 irq = dev->irq;
536 if (dev->base_addr) {
537 if (dev->mem_end == 0x3c509 /* Magic key */
538 && dev->base_addr >= 0x200 && dev->base_addr <= 0x3e0)
539 ioaddr = dev->base_addr & 0x3f0;
540 else if (dev->base_addr != ioaddr)
541 goto out;
542 }
544 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509")) {
545 err = -EBUSY;
546 goto out;
547 }
549 /* Set the adaptor tag so that the next card can be found. */
550 outb(0xd0 + ++current_tag, id_port);
552 /* Activate the adaptor at the EEPROM location. */
553 outb((ioaddr >> 4) | 0xe0, id_port);
555 EL3WINDOW(0);
556 if (inw(ioaddr) != 0x6d50)
557 goto out1;
559 /* Free the interrupt so that some other card can use it. */
560 outw(0x0f00, ioaddr + WN0_IRQ);
562 #if defined(__ISAPNP__)
563 found: /* PNP jumps here... */
564 #endif /* __ISAPNP__ */
566 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
567 dev->base_addr = ioaddr;
568 dev->irq = irq;
569 dev->if_port = if_port;
570 lp = netdev_priv(dev);
571 #if defined(__ISAPNP__)
572 lp->dev = &idev->dev;
573 #endif
574 err = el3_common_init(dev);
576 if (err)
577 goto out1;
579 el3_cards++;
580 lp->next_dev = el3_root_dev;
581 el3_root_dev = dev;
582 return 0;
584 out1:
585 #if defined(__ISAPNP__)
586 if (idev)
587 pnp_device_detach(idev);
588 #endif
589 out:
590 free_netdev(dev);
591 return err;
592 }
594 #ifdef CONFIG_MCA
595 static int __init el3_mca_probe(struct device *device)
596 {
597 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
598 * heavily modified by Chris Beauregard
599 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
600 * probing.
601 *
602 * redone for multi-card detection by ZP Gu (zpg@castle.net)
603 * now works as a module */
605 struct el3_private *lp;
606 short i;
607 int ioaddr, irq, if_port;
608 u16 phys_addr[3];
609 struct net_device *dev = NULL;
610 u_char pos4, pos5;
611 struct mca_device *mdev = to_mca_device(device);
612 int slot = mdev->slot;
613 int err;
615 pos4 = mca_device_read_stored_pos(mdev, 4);
616 pos5 = mca_device_read_stored_pos(mdev, 5);
618 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
619 irq = pos5 & 0x0f;
622 printk("3c529: found %s at slot %d\n",
623 el3_mca_adapter_names[mdev->index], slot + 1);
625 /* claim the slot */
626 strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
627 sizeof(mdev->name));
628 mca_device_set_claim(mdev, 1);
630 if_port = pos4 & 0x03;
632 irq = mca_device_transform_irq(mdev, irq);
633 ioaddr = mca_device_transform_ioport(mdev, ioaddr);
634 if (el3_debug > 2) {
635 printk("3c529: irq %d ioaddr 0x%x ifport %d\n", irq, ioaddr, if_port);
636 }
637 EL3WINDOW(0);
638 for (i = 0; i < 3; i++) {
639 phys_addr[i] = htons(read_eeprom(ioaddr, i));
640 }
642 dev = alloc_etherdev(sizeof (struct el3_private));
643 if (dev == NULL) {
644 release_region(ioaddr, EL3_IO_EXTENT);
645 return -ENOMEM;
646 }
648 SET_MODULE_OWNER(dev);
649 netdev_boot_setup_check(dev);
651 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
652 dev->base_addr = ioaddr;
653 dev->irq = irq;
654 dev->if_port = if_port;
655 lp = netdev_priv(dev);
656 lp->dev = device;
657 lp->type = EL3_MCA;
658 device->driver_data = dev;
659 err = el3_common_init(dev);
661 if (err) {
662 device->driver_data = NULL;
663 free_netdev(dev);
664 return -ENOMEM;
665 }
667 el3_cards++;
668 return 0;
669 }
671 #endif /* CONFIG_MCA */
673 #ifdef CONFIG_EISA
674 static int __init el3_eisa_probe (struct device *device)
675 {
676 struct el3_private *lp;
677 short i;
678 int ioaddr, irq, if_port;
679 u16 phys_addr[3];
680 struct net_device *dev = NULL;
681 struct eisa_device *edev;
682 int err;
684 /* Yeepee, The driver framework is calling us ! */
685 edev = to_eisa_device (device);
686 ioaddr = edev->base_addr;
688 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509"))
689 return -EBUSY;
691 /* Change the register set to the configuration window 0. */
692 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
694 irq = inw(ioaddr + WN0_IRQ) >> 12;
695 if_port = inw(ioaddr + 6)>>14;
696 for (i = 0; i < 3; i++)
697 phys_addr[i] = htons(read_eeprom(ioaddr, i));
699 /* Restore the "Product ID" to the EEPROM read register. */
700 read_eeprom(ioaddr, 3);
702 dev = alloc_etherdev(sizeof (struct el3_private));
703 if (dev == NULL) {
704 release_region(ioaddr, EL3_IO_EXTENT);
705 return -ENOMEM;
706 }
708 SET_MODULE_OWNER(dev);
710 netdev_boot_setup_check(dev);
712 memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
713 dev->base_addr = ioaddr;
714 dev->irq = irq;
715 dev->if_port = if_port;
716 lp = netdev_priv(dev);
717 lp->dev = device;
718 lp->type = EL3_EISA;
719 eisa_set_drvdata (edev, dev);
720 err = el3_common_init(dev);
722 if (err) {
723 eisa_set_drvdata (edev, NULL);
724 free_netdev(dev);
725 return err;
726 }
728 el3_cards++;
729 return 0;
730 }
731 #endif
733 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
734 /* This remove works for all device types.
735 *
736 * The net dev must be stored in the driver_data field */
737 static int __devexit el3_device_remove (struct device *device)
738 {
739 struct net_device *dev;
741 dev = device->driver_data;
743 el3_common_remove (dev);
744 return 0;
745 }
746 #endif
748 /* Read a word from the EEPROM using the regular EEPROM access register.
749 Assume that we are in register window zero.
750 */
751 static ushort read_eeprom(int ioaddr, int index)
752 {
753 outw(EEPROM_READ + index, ioaddr + 10);
754 /* Pause for at least 162 us. for the read to take place.
755 Some chips seem to require much longer */
756 mdelay(2);
757 return inw(ioaddr + 12);
758 }
760 /* Read a word from the EEPROM when in the ISA ID probe state. */
761 static ushort __init id_read_eeprom(int index)
762 {
763 int bit, word = 0;
765 /* Issue read command, and pause for at least 162 us. for it to complete.
766 Assume extra-fast 16Mhz bus. */
767 outb(EEPROM_READ + index, id_port);
769 /* Pause for at least 162 us. for the read to take place. */
770 /* Some chips seem to require much longer */
771 mdelay(4);
773 for (bit = 15; bit >= 0; bit--)
774 word = (word << 1) + (inb(id_port) & 0x01);
776 if (el3_debug > 3)
777 printk(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
779 return word;
780 }
783 static int
784 el3_open(struct net_device *dev)
785 {
786 int ioaddr = dev->base_addr;
787 int i;
789 outw(TxReset, ioaddr + EL3_CMD);
790 outw(RxReset, ioaddr + EL3_CMD);
791 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
793 i = request_irq(dev->irq, &el3_interrupt, 0, dev->name, dev);
794 if (i)
795 return i;
797 EL3WINDOW(0);
798 if (el3_debug > 3)
799 printk("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
800 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
802 el3_up(dev);
804 if (el3_debug > 3)
805 printk("%s: Opened 3c509 IRQ %d status %4.4x.\n",
806 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
808 return 0;
809 }
811 static void
812 el3_tx_timeout (struct net_device *dev)
813 {
814 struct el3_private *lp = netdev_priv(dev);
815 int ioaddr = dev->base_addr;
817 /* Transmitter timeout, serious problems. */
818 printk("%s: transmit timed out, Tx_status %2.2x status %4.4x "
819 "Tx FIFO room %d.\n",
820 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
821 inw(ioaddr + TX_FREE));
822 lp->stats.tx_errors++;
823 dev->trans_start = jiffies;
824 /* Issue TX_RESET and TX_START commands. */
825 outw(TxReset, ioaddr + EL3_CMD);
826 outw(TxEnable, ioaddr + EL3_CMD);
827 netif_wake_queue(dev);
828 }
831 static int
832 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
833 {
834 struct el3_private *lp = netdev_priv(dev);
835 int ioaddr = dev->base_addr;
836 unsigned long flags;
838 netif_stop_queue (dev);
840 lp->stats.tx_bytes += skb->len;
842 if (el3_debug > 4) {
843 printk("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
844 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
845 }
846 #if 0
847 #ifndef final_version
848 { /* Error-checking code, delete someday. */
849 ushort status = inw(ioaddr + EL3_STATUS);
850 if (status & 0x0001 /* IRQ line active, missed one. */
851 && inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
852 printk("%s: Missed interrupt, status then %04x now %04x"
853 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
854 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
855 inw(ioaddr + RX_STATUS));
856 /* Fake interrupt trigger by masking, acknowledge interrupts. */
857 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
858 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
859 ioaddr + EL3_CMD);
860 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
861 }
862 }
863 #endif
864 #endif
865 /*
866 * We lock the driver against other processors. Note
867 * we don't need to lock versus the IRQ as we suspended
868 * that. This means that we lose the ability to take
869 * an RX during a TX upload. That sucks a bit with SMP
870 * on an original 3c509 (2K buffer)
871 *
872 * Using disable_irq stops us crapping on other
873 * time sensitive devices.
874 */
876 spin_lock_irqsave(&lp->lock, flags);
878 /* Put out the doubleword header... */
879 outw(skb->len, ioaddr + TX_FIFO);
880 outw(0x00, ioaddr + TX_FIFO);
881 /* ... and the packet rounded to a doubleword. */
882 #ifdef __powerpc__
883 outsl_ns(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
884 #else
885 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
886 #endif
888 dev->trans_start = jiffies;
889 if (inw(ioaddr + TX_FREE) > 1536)
890 netif_start_queue(dev);
891 else
892 /* Interrupt us when the FIFO has room for max-sized packet. */
893 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
895 spin_unlock_irqrestore(&lp->lock, flags);
897 dev_kfree_skb (skb);
899 /* Clear the Tx status stack. */
900 {
901 short tx_status;
902 int i = 4;
904 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
905 if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
906 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
907 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
908 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
909 }
910 }
911 return 0;
912 }
914 /* The EL3 interrupt handler. */
915 static irqreturn_t
916 el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
917 {
918 struct net_device *dev = (struct net_device *)dev_id;
919 struct el3_private *lp;
920 int ioaddr, status;
921 int i = max_interrupt_work;
923 if (dev == NULL) {
924 printk ("el3_interrupt(): irq %d for unknown device.\n", irq);
925 return IRQ_NONE;
926 }
928 lp = netdev_priv(dev);
929 spin_lock(&lp->lock);
931 ioaddr = dev->base_addr;
933 if (el3_debug > 4) {
934 status = inw(ioaddr + EL3_STATUS);
935 printk("%s: interrupt, status %4.4x.\n", dev->name, status);
936 }
938 while ((status = inw(ioaddr + EL3_STATUS)) &
939 (IntLatch | RxComplete | StatsFull)) {
941 if (status & RxComplete)
942 el3_rx(dev);
944 if (status & TxAvailable) {
945 if (el3_debug > 5)
946 printk(" TX room bit was handled.\n");
947 /* There's room in the FIFO for a full-sized packet. */
948 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
949 netif_wake_queue (dev);
950 }
951 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
952 /* Handle all uncommon interrupts. */
953 if (status & StatsFull) /* Empty statistics. */
954 update_stats(dev);
955 if (status & RxEarly) { /* Rx early is unused. */
956 el3_rx(dev);
957 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
958 }
959 if (status & TxComplete) { /* Really Tx error. */
960 struct el3_private *lp = netdev_priv(dev);
961 short tx_status;
962 int i = 4;
964 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
965 if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
966 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
967 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
968 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
969 }
970 }
971 if (status & AdapterFailure) {
972 /* Adapter failure requires Rx reset and reinit. */
973 outw(RxReset, ioaddr + EL3_CMD);
974 /* Set the Rx filter to the current state. */
975 outw(SetRxFilter | RxStation | RxBroadcast
976 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
977 | (dev->flags & IFF_PROMISC ? RxProm : 0),
978 ioaddr + EL3_CMD);
979 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
980 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
981 }
982 }
984 if (--i < 0) {
985 printk("%s: Infinite loop in interrupt, status %4.4x.\n",
986 dev->name, status);
987 /* Clear all interrupts. */
988 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
989 break;
990 }
991 /* Acknowledge the IRQ. */
992 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
993 }
995 if (el3_debug > 4) {
996 printk("%s: exiting interrupt, status %4.4x.\n", dev->name,
997 inw(ioaddr + EL3_STATUS));
998 }
999 spin_unlock(&lp->lock);
1000 return IRQ_HANDLED;
1004 #ifdef CONFIG_NET_POLL_CONTROLLER
1005 /*
1006 * Polling receive - used by netconsole and other diagnostic tools
1007 * to allow network i/o with interrupts disabled.
1008 */
1009 static void el3_poll_controller(struct net_device *dev)
1011 disable_irq(dev->irq);
1012 el3_interrupt(dev->irq, dev, NULL);
1013 enable_irq(dev->irq);
1015 #endif
1017 static struct net_device_stats *
1018 el3_get_stats(struct net_device *dev)
1020 struct el3_private *lp = netdev_priv(dev);
1021 unsigned long flags;
1023 /*
1024 * This is fast enough not to bother with disable IRQ
1025 * stuff.
1026 */
1028 spin_lock_irqsave(&lp->lock, flags);
1029 update_stats(dev);
1030 spin_unlock_irqrestore(&lp->lock, flags);
1031 return &lp->stats;
1034 /* Update statistics. We change to register window 6, so this should be run
1035 single-threaded if the device is active. This is expected to be a rare
1036 operation, and it's simpler for the rest of the driver to assume that
1037 window 1 is always valid rather than use a special window-state variable.
1038 */
1039 static void update_stats(struct net_device *dev)
1041 struct el3_private *lp = netdev_priv(dev);
1042 int ioaddr = dev->base_addr;
1044 if (el3_debug > 5)
1045 printk(" Updating the statistics.\n");
1046 /* Turn off statistics updates while reading. */
1047 outw(StatsDisable, ioaddr + EL3_CMD);
1048 /* Switch to the stats window, and read everything. */
1049 EL3WINDOW(6);
1050 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
1051 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1052 /* Multiple collisions. */ inb(ioaddr + 2);
1053 lp->stats.collisions += inb(ioaddr + 3);
1054 lp->stats.tx_window_errors += inb(ioaddr + 4);
1055 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
1056 lp->stats.tx_packets += inb(ioaddr + 6);
1057 /* Rx packets */ inb(ioaddr + 7);
1058 /* Tx deferrals */ inb(ioaddr + 8);
1059 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1060 inw(ioaddr + 12);
1062 /* Back to window 1, and turn statistics back on. */
1063 EL3WINDOW(1);
1064 outw(StatsEnable, ioaddr + EL3_CMD);
1065 return;
1068 static int
1069 el3_rx(struct net_device *dev)
1071 struct el3_private *lp = netdev_priv(dev);
1072 int ioaddr = dev->base_addr;
1073 short rx_status;
1075 if (el3_debug > 5)
1076 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1077 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1078 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1079 if (rx_status & 0x4000) { /* Error, update stats. */
1080 short error = rx_status & 0x3800;
1082 outw(RxDiscard, ioaddr + EL3_CMD);
1083 lp->stats.rx_errors++;
1084 switch (error) {
1085 case 0x0000: lp->stats.rx_over_errors++; break;
1086 case 0x0800: lp->stats.rx_length_errors++; break;
1087 case 0x1000: lp->stats.rx_frame_errors++; break;
1088 case 0x1800: lp->stats.rx_length_errors++; break;
1089 case 0x2000: lp->stats.rx_frame_errors++; break;
1090 case 0x2800: lp->stats.rx_crc_errors++; break;
1092 } else {
1093 short pkt_len = rx_status & 0x7ff;
1094 struct sk_buff *skb;
1096 skb = dev_alloc_skb(pkt_len+5);
1097 lp->stats.rx_bytes += pkt_len;
1098 if (el3_debug > 4)
1099 printk("Receiving packet size %d status %4.4x.\n",
1100 pkt_len, rx_status);
1101 if (skb != NULL) {
1102 skb->dev = dev;
1103 skb_reserve(skb, 2); /* Align IP on 16 byte */
1105 /* 'skb->data' points to the start of sk_buff data area. */
1106 #ifdef __powerpc__
1107 insl_ns(ioaddr+RX_FIFO, skb_put(skb,pkt_len),
1108 (pkt_len + 3) >> 2);
1109 #else
1110 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1111 (pkt_len + 3) >> 2);
1112 #endif
1114 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1115 skb->protocol = eth_type_trans(skb,dev);
1116 netif_rx(skb);
1117 dev->last_rx = jiffies;
1118 lp->stats.rx_packets++;
1119 continue;
1121 outw(RxDiscard, ioaddr + EL3_CMD);
1122 lp->stats.rx_dropped++;
1123 if (el3_debug)
1124 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1125 dev->name, pkt_len);
1127 inw(ioaddr + EL3_STATUS); /* Delay. */
1128 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1129 printk(KERN_DEBUG " Waiting for 3c509 to discard packet, status %x.\n",
1130 inw(ioaddr + EL3_STATUS) );
1133 return 0;
1136 /*
1137 * Set or clear the multicast filter for this adaptor.
1138 */
1139 static void
1140 set_multicast_list(struct net_device *dev)
1142 unsigned long flags;
1143 struct el3_private *lp = netdev_priv(dev);
1144 int ioaddr = dev->base_addr;
1146 if (el3_debug > 1) {
1147 static int old;
1148 if (old != dev->mc_count) {
1149 old = dev->mc_count;
1150 printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1153 spin_lock_irqsave(&lp->lock, flags);
1154 if (dev->flags&IFF_PROMISC) {
1155 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1156 ioaddr + EL3_CMD);
1158 else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1159 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1161 else
1162 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1163 spin_unlock_irqrestore(&lp->lock, flags);
1166 static int
1167 el3_close(struct net_device *dev)
1169 int ioaddr = dev->base_addr;
1170 struct el3_private *lp = netdev_priv(dev);
1172 if (el3_debug > 2)
1173 printk("%s: Shutting down ethercard.\n", dev->name);
1175 el3_down(dev);
1177 free_irq(dev->irq, dev);
1178 /* Switching back to window 0 disables the IRQ. */
1179 EL3WINDOW(0);
1180 if (lp->type != EL3_EISA) {
1181 /* But we explicitly zero the IRQ line select anyway. Don't do
1182 * it on EISA cards, it prevents the module from getting an
1183 * IRQ after unload+reload... */
1184 outw(0x0f00, ioaddr + WN0_IRQ);
1187 return 0;
1190 static int
1191 el3_link_ok(struct net_device *dev)
1193 int ioaddr = dev->base_addr;
1194 u16 tmp;
1196 EL3WINDOW(4);
1197 tmp = inw(ioaddr + WN4_MEDIA);
1198 EL3WINDOW(1);
1199 return tmp & (1<<11);
1202 static int
1203 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1205 u16 tmp;
1206 int ioaddr = dev->base_addr;
1208 EL3WINDOW(0);
1209 /* obtain current transceiver via WN4_MEDIA? */
1210 tmp = inw(ioaddr + WN0_ADDR_CONF);
1211 ecmd->transceiver = XCVR_INTERNAL;
1212 switch (tmp >> 14) {
1213 case 0:
1214 ecmd->port = PORT_TP;
1215 break;
1216 case 1:
1217 ecmd->port = PORT_AUI;
1218 ecmd->transceiver = XCVR_EXTERNAL;
1219 break;
1220 case 3:
1221 ecmd->port = PORT_BNC;
1222 default:
1223 break;
1226 ecmd->duplex = DUPLEX_HALF;
1227 ecmd->supported = 0;
1228 tmp = inw(ioaddr + WN0_CONF_CTRL);
1229 if (tmp & (1<<13))
1230 ecmd->supported |= SUPPORTED_AUI;
1231 if (tmp & (1<<12))
1232 ecmd->supported |= SUPPORTED_BNC;
1233 if (tmp & (1<<9)) {
1234 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1235 SUPPORTED_10baseT_Full; /* hmm... */
1236 EL3WINDOW(4);
1237 tmp = inw(ioaddr + WN4_NETDIAG);
1238 if (tmp & FD_ENABLE)
1239 ecmd->duplex = DUPLEX_FULL;
1242 ecmd->speed = SPEED_10;
1243 EL3WINDOW(1);
1244 return 0;
1247 static int
1248 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1250 u16 tmp;
1251 int ioaddr = dev->base_addr;
1253 if (ecmd->speed != SPEED_10)
1254 return -EINVAL;
1255 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1256 return -EINVAL;
1257 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1258 return -EINVAL;
1260 /* change XCVR type */
1261 EL3WINDOW(0);
1262 tmp = inw(ioaddr + WN0_ADDR_CONF);
1263 switch (ecmd->port) {
1264 case PORT_TP:
1265 tmp &= ~(3<<14);
1266 dev->if_port = 0;
1267 break;
1268 case PORT_AUI:
1269 tmp |= (1<<14);
1270 dev->if_port = 1;
1271 break;
1272 case PORT_BNC:
1273 tmp |= (3<<14);
1274 dev->if_port = 3;
1275 break;
1276 default:
1277 return -EINVAL;
1280 outw(tmp, ioaddr + WN0_ADDR_CONF);
1281 if (dev->if_port == 3) {
1282 /* fire up the DC-DC convertor if BNC gets enabled */
1283 tmp = inw(ioaddr + WN0_ADDR_CONF);
1284 if (tmp & (3 << 14)) {
1285 outw(StartCoax, ioaddr + EL3_CMD);
1286 udelay(800);
1287 } else
1288 return -EIO;
1291 EL3WINDOW(4);
1292 tmp = inw(ioaddr + WN4_NETDIAG);
1293 if (ecmd->duplex == DUPLEX_FULL)
1294 tmp |= FD_ENABLE;
1295 else
1296 tmp &= ~FD_ENABLE;
1297 outw(tmp, ioaddr + WN4_NETDIAG);
1298 EL3WINDOW(1);
1300 return 0;
1303 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1305 strcpy(info->driver, DRV_NAME);
1306 strcpy(info->version, DRV_VERSION);
1309 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1311 struct el3_private *lp = netdev_priv(dev);
1312 int ret;
1314 spin_lock_irq(&lp->lock);
1315 ret = el3_netdev_get_ecmd(dev, ecmd);
1316 spin_unlock_irq(&lp->lock);
1317 return ret;
1320 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1322 struct el3_private *lp = netdev_priv(dev);
1323 int ret;
1325 spin_lock_irq(&lp->lock);
1326 ret = el3_netdev_set_ecmd(dev, ecmd);
1327 spin_unlock_irq(&lp->lock);
1328 return ret;
1331 static u32 el3_get_link(struct net_device *dev)
1333 struct el3_private *lp = netdev_priv(dev);
1334 u32 ret;
1336 spin_lock_irq(&lp->lock);
1337 ret = el3_link_ok(dev);
1338 spin_unlock_irq(&lp->lock);
1339 return ret;
1342 static u32 el3_get_msglevel(struct net_device *dev)
1344 return el3_debug;
1347 static void el3_set_msglevel(struct net_device *dev, u32 v)
1349 el3_debug = v;
1352 static struct ethtool_ops ethtool_ops = {
1353 .get_drvinfo = el3_get_drvinfo,
1354 .get_settings = el3_get_settings,
1355 .set_settings = el3_set_settings,
1356 .get_link = el3_get_link,
1357 .get_msglevel = el3_get_msglevel,
1358 .set_msglevel = el3_set_msglevel,
1359 };
1361 static void
1362 el3_down(struct net_device *dev)
1364 int ioaddr = dev->base_addr;
1366 netif_stop_queue(dev);
1368 /* Turn off statistics ASAP. We update lp->stats below. */
1369 outw(StatsDisable, ioaddr + EL3_CMD);
1371 /* Disable the receiver and transmitter. */
1372 outw(RxDisable, ioaddr + EL3_CMD);
1373 outw(TxDisable, ioaddr + EL3_CMD);
1375 if (dev->if_port == 3)
1376 /* Turn off thinnet power. Green! */
1377 outw(StopCoax, ioaddr + EL3_CMD);
1378 else if (dev->if_port == 0) {
1379 /* Disable link beat and jabber, if_port may change here next open(). */
1380 EL3WINDOW(4);
1381 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1384 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1386 update_stats(dev);
1389 static void
1390 el3_up(struct net_device *dev)
1392 int i, sw_info, net_diag;
1393 int ioaddr = dev->base_addr;
1395 /* Activating the board required and does no harm otherwise */
1396 outw(0x0001, ioaddr + 4);
1398 /* Set the IRQ line. */
1399 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1401 /* Set the station address in window 2 each time opened. */
1402 EL3WINDOW(2);
1404 for (i = 0; i < 6; i++)
1405 outb(dev->dev_addr[i], ioaddr + i);
1407 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1408 /* Start the thinnet transceiver. We should really wait 50ms...*/
1409 outw(StartCoax, ioaddr + EL3_CMD);
1410 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1411 /* Combine secondary sw_info word (the adapter level) and primary
1412 sw_info word (duplex setting plus other useless bits) */
1413 EL3WINDOW(0);
1414 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1415 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1417 EL3WINDOW(4);
1418 net_diag = inw(ioaddr + WN4_NETDIAG);
1419 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1420 printk("%s: ", dev->name);
1421 switch (dev->if_port & 0x0c) {
1422 case 12:
1423 /* force full-duplex mode if 3c5x9b */
1424 if (sw_info & 0x000f) {
1425 printk("Forcing 3c5x9b full-duplex mode");
1426 break;
1428 case 8:
1429 /* set full-duplex mode based on eeprom config setting */
1430 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1431 printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1432 break;
1434 default:
1435 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1436 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1437 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1440 outw(net_diag, ioaddr + WN4_NETDIAG);
1441 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1442 if (el3_debug > 3)
1443 printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1444 /* Enable link beat and jabber check. */
1445 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1448 /* Switch to the stats window, and clear all stats by reading. */
1449 outw(StatsDisable, ioaddr + EL3_CMD);
1450 EL3WINDOW(6);
1451 for (i = 0; i < 9; i++)
1452 inb(ioaddr + i);
1453 inw(ioaddr + 10);
1454 inw(ioaddr + 12);
1456 /* Switch to register set 1 for normal use. */
1457 EL3WINDOW(1);
1459 /* Accept b-case and phys addr only. */
1460 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1461 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1463 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1464 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1465 /* Allow status bits to be seen. */
1466 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1467 /* Ack all pending events, and set active indicator mask. */
1468 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1469 ioaddr + EL3_CMD);
1470 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1471 ioaddr + EL3_CMD);
1473 netif_start_queue(dev);
1476 /* Power Management support functions */
1477 #ifdef EL3_SUSPEND
1479 static int
1480 el3_suspend(struct device *pdev, pm_message_t state)
1482 unsigned long flags;
1483 struct net_device *dev;
1484 struct el3_private *lp;
1485 int ioaddr;
1487 dev = pdev->driver_data;
1488 lp = netdev_priv(dev);
1489 ioaddr = dev->base_addr;
1491 spin_lock_irqsave(&lp->lock, flags);
1493 if (netif_running(dev))
1494 netif_device_detach(dev);
1496 el3_down(dev);
1497 outw(PowerDown, ioaddr + EL3_CMD);
1499 spin_unlock_irqrestore(&lp->lock, flags);
1500 return 0;
1503 static int
1504 el3_resume(struct device *pdev)
1506 unsigned long flags;
1507 struct net_device *dev;
1508 struct el3_private *lp;
1509 int ioaddr;
1511 dev = pdev->driver_data;
1512 lp = netdev_priv(dev);
1513 ioaddr = dev->base_addr;
1515 spin_lock_irqsave(&lp->lock, flags);
1517 outw(PowerUp, ioaddr + EL3_CMD);
1518 el3_up(dev);
1520 if (netif_running(dev))
1521 netif_device_attach(dev);
1523 spin_unlock_irqrestore(&lp->lock, flags);
1524 return 0;
1527 #endif /* EL3_SUSPEND */
1529 /* Parameters that may be passed into the module. */
1530 static int debug = -1;
1531 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
1532 static int xcvr[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1534 module_param(debug,int, 0);
1535 module_param_array(irq, int, NULL, 0);
1536 module_param_array(xcvr, int, NULL, 0);
1537 module_param(max_interrupt_work, int, 0);
1538 MODULE_PARM_DESC(debug, "debug level (0-6)");
1539 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1540 MODULE_PARM_DESC(xcvr,"transceiver(s) (0=internal, 1=external)");
1541 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1542 #if defined(__ISAPNP__)
1543 module_param(nopnp, int, 0);
1544 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1545 MODULE_DEVICE_TABLE(isapnp, el3_isapnp_adapters);
1546 #endif /* __ISAPNP__ */
1547 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B) ISA/PnP ethernet driver");
1548 MODULE_LICENSE("GPL");
1550 static int __init el3_init_module(void)
1552 int ret = 0;
1553 el3_cards = 0;
1555 if (debug >= 0)
1556 el3_debug = debug;
1558 el3_root_dev = NULL;
1559 while (el3_probe(el3_cards) == 0) {
1560 if (irq[el3_cards] > 1)
1561 el3_root_dev->irq = irq[el3_cards];
1562 if (xcvr[el3_cards] >= 0)
1563 el3_root_dev->if_port = xcvr[el3_cards];
1564 el3_cards++;
1567 #ifdef CONFIG_EISA
1568 ret = eisa_driver_register(&el3_eisa_driver);
1569 #endif
1570 #ifdef CONFIG_MCA
1572 int err = mca_register_driver(&el3_mca_driver);
1573 if (ret == 0)
1574 ret = err;
1576 #endif
1577 return ret;
1580 static void __exit el3_cleanup_module(void)
1582 struct net_device *next_dev;
1584 while (el3_root_dev) {
1585 struct el3_private *lp = netdev_priv(el3_root_dev);
1587 next_dev = lp->next_dev;
1588 el3_common_remove (el3_root_dev);
1589 el3_root_dev = next_dev;
1592 #ifdef CONFIG_EISA
1593 eisa_driver_unregister (&el3_eisa_driver);
1594 #endif
1595 #ifdef CONFIG_MCA
1596 mca_unregister_driver(&el3_mca_driver);
1597 #endif
1600 module_init (el3_init_module);
1601 module_exit (el3_cleanup_module);