blob: fbb3719219911f5a3b33fcc421ac58e3e4afa147 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040031 Alan Cox: Increased the eeprom delay. Regardless of
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 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
Francois Camie1f8e872008-10-15 22:01:59 -070043 v1.18 12Mar2001 Andrew Morton
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 - 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>
Ondrej Zaryac4bed12008-03-28 14:41:23 -070057 - Introduce driver model for EISA cards.
58 v1.20 04Feb2008 Ondrej Zary <linux@rainbow-software.org>
59 - convert to isa_driver and pnp_driver and some cleanups
Linus Torvalds1da177e2005-04-16 15:20:36 -070060*/
61
62#define DRV_NAME "3c509"
Ondrej Zaryac4bed12008-03-28 14:41:23 -070063#define DRV_VERSION "1.20"
64#define DRV_RELDATE "04Feb2008"
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66/* A few values that may be tweaked. */
67
68/* Time in jiffies before concluding the transmitter is hung. */
69#define TX_TIMEOUT (400*HZ/1000)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#include <linux/mca.h>
Ondrej Zaryac4bed12008-03-28 14:41:23 -070073#include <linux/isa.h>
74#include <linux/pnp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070075#include <linux/string.h>
76#include <linux/interrupt.h>
77#include <linux/errno.h>
78#include <linux/in.h>
79#include <linux/slab.h>
80#include <linux/ioport.h>
81#include <linux/init.h>
82#include <linux/netdevice.h>
83#include <linux/etherdevice.h>
84#include <linux/pm.h>
85#include <linux/skbuff.h>
86#include <linux/delay.h> /* for udelay() */
87#include <linux/spinlock.h>
88#include <linux/ethtool.h>
89#include <linux/device.h>
90#include <linux/eisa.h>
91#include <linux/bitops.h>
92
93#include <asm/uaccess.h>
94#include <asm/io.h>
95#include <asm/irq.h>
96
Al Viro37b2a172008-11-01 18:20:19 +000097static char version[] __devinitdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
99#ifdef EL3_DEBUG
100static int el3_debug = EL3_DEBUG;
101#else
102static int el3_debug = 2;
103#endif
104
105/* Used to do a global count of all the cards in the system. Must be
106 * a global variable so that the mca/eisa probe routines can increment
107 * it */
108static int el3_cards = 0;
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700109#define EL3_MAX_CARDS 8
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111/* To minimize the size of the driver source I only define operating
112 constants if they are used several times. You'll need the manual
113 anyway if you want to understand driver details. */
114/* Offsets from base I/O address. */
115#define EL3_DATA 0x00
116#define EL3_CMD 0x0e
117#define EL3_STATUS 0x0e
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700118#define EEPROM_READ 0x80
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
120#define EL3_IO_EXTENT 16
121
122#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
123
124
125/* The top five bits written to EL3_CMD are a command, the lower
126 11 bits are the parameter, if applicable. */
127enum c509cmd {
128 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
129 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
130 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
131 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
132 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
133 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
134 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
135 PowerDown = 28<<11, PowerAuto = 29<<11};
136
137enum c509status {
138 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
139 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
140 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
141
142/* The SetRxFilter command accepts the following classes: */
143enum RxFilter {
144 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
145
146/* Register window 1 offsets, the window used in normal operation. */
147#define TX_FIFO 0x00
148#define RX_FIFO 0x00
149#define RX_STATUS 0x08
150#define TX_STATUS 0x0B
151#define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
152
153#define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
154#define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
155#define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
156#define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
157#define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
158#define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400159#define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161/*
162 * Must be a power of two (we use a binary and in the
163 * circular queue)
164 */
165#define SKB_QUEUE_SIZE 64
166
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700167enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_MCA, EL3_EISA };
168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169struct el3_private {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 spinlock_t lock;
171 /* skb send-queue */
172 int head, size;
173 struct sk_buff *queue[SKB_QUEUE_SIZE];
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700174 enum el3_cardtype type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175};
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700176static int id_port;
177static int current_tag;
178static struct net_device *el3_devs[EL3_MAX_CARDS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700180/* Parameters that may be passed into the module. */
181static int debug = -1;
182static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
183/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
184static int max_interrupt_work = 10;
185#ifdef CONFIG_PNP
186static int nopnp;
187#endif
188
Al Viro37b2a172008-11-01 18:20:19 +0000189static int __devinit el3_common_init(struct net_device *dev);
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700190static void el3_common_remove(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191static ushort id_read_eeprom(int index);
192static ushort read_eeprom(int ioaddr, int index);
193static int el3_open(struct net_device *dev);
194static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100195static irqreturn_t el3_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196static void update_stats(struct net_device *dev);
197static struct net_device_stats *el3_get_stats(struct net_device *dev);
198static int el3_rx(struct net_device *dev);
199static int el3_close(struct net_device *dev);
200static void set_multicast_list(struct net_device *dev);
201static void el3_tx_timeout (struct net_device *dev);
202static void el3_down(struct net_device *dev);
203static void el3_up(struct net_device *dev);
Jeff Garzik7282d492006-09-13 14:30:00 -0400204static const struct ethtool_ops ethtool_ops;
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700205#ifdef CONFIG_PM
Pekka Enberg60a89ff2006-03-08 00:06:28 -0800206static int el3_suspend(struct device *, pm_message_t);
207static int el3_resume(struct device *);
208#else
209#define el3_suspend NULL
210#define el3_resume NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211#endif
Pekka Enberg60a89ff2006-03-08 00:06:28 -0800212
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214/* generic device remove for all device types */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215static int el3_device_remove (struct device *device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216#ifdef CONFIG_NET_POLL_CONTROLLER
217static void el3_poll_controller(struct net_device *dev);
218#endif
219
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700220/* Return 0 on success, 1 on error, 2 when found already detected PnP card */
221static int el3_isa_id_sequence(__be16 *phys_addr)
222{
223 short lrs_state = 0xff;
224 int i;
225
226 /* ISA boards are detected by sending the ID sequence to the
227 ID_PORT. We find cards past the first by setting the 'current_tag'
228 on cards as they are found. Cards with their tag set will not
229 respond to subsequent ID sequences. */
230
231 outb(0x00, id_port);
232 outb(0x00, id_port);
233 for (i = 0; i < 255; i++) {
234 outb(lrs_state, id_port);
235 lrs_state <<= 1;
236 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
237 }
238 /* For the first probe, clear all board's tag registers. */
239 if (current_tag == 0)
240 outb(0xd0, id_port);
241 else /* Otherwise kill off already-found boards. */
242 outb(0xd8, id_port);
243 if (id_read_eeprom(7) != 0x6d50)
244 return 1;
245 /* Read in EEPROM data, which does contention-select.
246 Only the lowest address board will stay "on-line".
247 3Com got the byte order backwards. */
248 for (i = 0; i < 3; i++)
249 phys_addr[i] = htons(id_read_eeprom(i));
250#ifdef CONFIG_PNP
251 if (!nopnp) {
252 /* The ISA PnP 3c509 cards respond to the ID sequence too.
253 This check is needed in order not to register them twice. */
254 for (i = 0; i < el3_cards; i++) {
255 struct el3_private *lp = netdev_priv(el3_devs[i]);
256 if (lp->type == EL3_PNP
257 && !memcmp(phys_addr, el3_devs[i]->dev_addr,
258 ETH_ALEN)) {
259 if (el3_debug > 3)
260 printk(KERN_DEBUG "3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
261 phys_addr[0] & 0xff, phys_addr[0] >> 8,
262 phys_addr[1] & 0xff, phys_addr[1] >> 8,
263 phys_addr[2] & 0xff, phys_addr[2] >> 8);
264 /* Set the adaptor tag so that the next card can be found. */
265 outb(0xd0 + ++current_tag, id_port);
266 return 2;
267 }
268 }
269 }
270#endif /* CONFIG_PNP */
271 return 0;
272
273}
274
275static void __devinit el3_dev_fill(struct net_device *dev, __be16 *phys_addr,
276 int ioaddr, int irq, int if_port,
277 enum el3_cardtype type)
278{
279 struct el3_private *lp = netdev_priv(dev);
280
281 memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
282 dev->base_addr = ioaddr;
283 dev->irq = irq;
284 dev->if_port = if_port;
285 lp->type = type;
286}
287
288static int __devinit el3_isa_match(struct device *pdev,
289 unsigned int ndev)
290{
291 struct net_device *dev;
292 int ioaddr, isa_irq, if_port, err;
293 unsigned int iobase;
294 __be16 phys_addr[3];
295
296 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
297 ; /* Skip to next card when PnP card found */
298 if (err == 1)
299 return 0;
300
301 iobase = id_read_eeprom(8);
302 if_port = iobase >> 14;
303 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
304 if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
305 isa_irq = irq[el3_cards];
306 else
307 isa_irq = id_read_eeprom(9) >> 12;
308
309 dev = alloc_etherdev(sizeof(struct el3_private));
310 if (!dev)
311 return -ENOMEM;
312
313 netdev_boot_setup_check(dev);
314
315 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
316 free_netdev(dev);
317 return 0;
318 }
319
320 /* Set the adaptor tag so that the next card can be found. */
321 outb(0xd0 + ++current_tag, id_port);
322
323 /* Activate the adaptor at the EEPROM location. */
324 outb((ioaddr >> 4) | 0xe0, id_port);
325
326 EL3WINDOW(0);
327 if (inw(ioaddr) != 0x6d50) {
328 free_netdev(dev);
329 return 0;
330 }
331
332 /* Free the interrupt so that some other card can use it. */
333 outw(0x0f00, ioaddr + WN0_IRQ);
334
335 el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
336 dev_set_drvdata(pdev, dev);
337 if (el3_common_init(dev)) {
338 free_netdev(dev);
339 return 0;
340 }
341
342 el3_devs[el3_cards++] = dev;
343 return 1;
344}
345
346static int __devexit el3_isa_remove(struct device *pdev,
347 unsigned int ndev)
348{
349 el3_device_remove(pdev);
350 dev_set_drvdata(pdev, NULL);
351 return 0;
352}
353
354#ifdef CONFIG_PM
355static int el3_isa_suspend(struct device *dev, unsigned int n,
356 pm_message_t state)
357{
358 current_tag = 0;
359 return el3_suspend(dev, state);
360}
361
362static int el3_isa_resume(struct device *dev, unsigned int n)
363{
364 struct net_device *ndev = dev_get_drvdata(dev);
365 int ioaddr = ndev->base_addr, err;
366 __be16 phys_addr[3];
367
368 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
369 ; /* Skip to next card when PnP card found */
370 if (err == 1)
371 return 0;
372 /* Set the adaptor tag so that the next card can be found. */
373 outb(0xd0 + ++current_tag, id_port);
374 /* Enable the card */
375 outb((ioaddr >> 4) | 0xe0, id_port);
376 EL3WINDOW(0);
377 if (inw(ioaddr) != 0x6d50)
378 return 1;
379 /* Free the interrupt so that some other card can use it. */
380 outw(0x0f00, ioaddr + WN0_IRQ);
381 return el3_resume(dev);
382}
383#endif
384
385static struct isa_driver el3_isa_driver = {
386 .match = el3_isa_match,
387 .remove = __devexit_p(el3_isa_remove),
388#ifdef CONFIG_PM
389 .suspend = el3_isa_suspend,
390 .resume = el3_isa_resume,
391#endif
392 .driver = {
393 .name = "3c509"
394 },
395};
396static int isa_registered;
397
398#ifdef CONFIG_PNP
399static struct pnp_device_id el3_pnp_ids[] = {
400 { .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
401 { .id = "TCM5091" }, /* 3Com Etherlink III */
402 { .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
403 { .id = "TCM5095" }, /* 3Com Etherlink III (TPO) */
404 { .id = "TCM5098" }, /* 3Com Etherlink III (TPC) */
405 { .id = "PNP80f7" }, /* 3Com Etherlink III compatible */
406 { .id = "PNP80f8" }, /* 3Com Etherlink III compatible */
407 { .id = "" }
408};
409MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
410
411static int __devinit el3_pnp_probe(struct pnp_dev *pdev,
412 const struct pnp_device_id *id)
413{
414 short i;
415 int ioaddr, irq, if_port;
Al Viro4ec7ffa2008-05-21 06:32:11 +0100416 __be16 phys_addr[3];
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700417 struct net_device *dev = NULL;
418 int err;
419
420 ioaddr = pnp_port_start(pdev, 0);
421 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
422 return -EBUSY;
423 irq = pnp_irq(pdev, 0);
424 EL3WINDOW(0);
425 for (i = 0; i < 3; i++)
426 phys_addr[i] = htons(read_eeprom(ioaddr, i));
427 if_port = read_eeprom(ioaddr, 8) >> 14;
428 dev = alloc_etherdev(sizeof(struct el3_private));
429 if (!dev) {
430 release_region(ioaddr, EL3_IO_EXTENT);
431 return -ENOMEM;
432 }
433 SET_NETDEV_DEV(dev, &pdev->dev);
434 netdev_boot_setup_check(dev);
435
436 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
437 pnp_set_drvdata(pdev, dev);
438 err = el3_common_init(dev);
439
440 if (err) {
441 pnp_set_drvdata(pdev, NULL);
442 free_netdev(dev);
443 return err;
444 }
445
446 el3_devs[el3_cards++] = dev;
447 return 0;
448}
449
450static void __devexit el3_pnp_remove(struct pnp_dev *pdev)
451{
452 el3_common_remove(pnp_get_drvdata(pdev));
453 pnp_set_drvdata(pdev, NULL);
454}
455
456#ifdef CONFIG_PM
457static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
458{
459 return el3_suspend(&pdev->dev, state);
460}
461
462static int el3_pnp_resume(struct pnp_dev *pdev)
463{
464 return el3_resume(&pdev->dev);
465}
466#endif
467
468static struct pnp_driver el3_pnp_driver = {
469 .name = "3c509",
470 .id_table = el3_pnp_ids,
471 .probe = el3_pnp_probe,
472 .remove = __devexit_p(el3_pnp_remove),
473#ifdef CONFIG_PM
474 .suspend = el3_pnp_suspend,
475 .resume = el3_pnp_resume,
476#endif
477};
478static int pnp_registered;
479#endif /* CONFIG_PNP */
480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481#ifdef CONFIG_EISA
482static struct eisa_device_id el3_eisa_ids[] = {
483 { "TCM5092" },
484 { "TCM5093" },
Adrian Bunkf04e3f02005-05-16 21:13:03 +0200485 { "TCM5095" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 { "" }
487};
Michael Tokarev07563c72006-09-27 01:50:56 -0700488MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490static int el3_eisa_probe (struct device *device);
491
492static struct eisa_driver el3_eisa_driver = {
493 .id_table = el3_eisa_ids,
494 .driver = {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700495 .name = "3c579",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 .probe = el3_eisa_probe,
Pekka Enberg60a89ff2006-03-08 00:06:28 -0800497 .remove = __devexit_p (el3_device_remove),
498 .suspend = el3_suspend,
499 .resume = el3_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 }
501};
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700502static int eisa_registered;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503#endif
504
505#ifdef CONFIG_MCA
506static int el3_mca_probe(struct device *dev);
507
508static short el3_mca_adapter_ids[] __initdata = {
509 0x627c,
510 0x627d,
511 0x62db,
512 0x62f6,
513 0x62f7,
514 0x0000
515};
516
517static char *el3_mca_adapter_names[] __initdata = {
518 "3Com 3c529 EtherLink III (10base2)",
519 "3Com 3c529 EtherLink III (10baseT)",
520 "3Com 3c529 EtherLink III (test mode)",
521 "3Com 3c529 EtherLink III (TP or coax)",
522 "3Com 3c529 EtherLink III (TP)",
523 NULL
524};
525
526static struct mca_driver el3_mca_driver = {
527 .id_table = el3_mca_adapter_ids,
528 .driver = {
529 .name = "3c529",
530 .bus = &mca_bus_type,
531 .probe = el3_mca_probe,
532 .remove = __devexit_p(el3_device_remove),
Pekka Enberg60a89ff2006-03-08 00:06:28 -0800533 .suspend = el3_suspend,
534 .resume = el3_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 },
536};
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700537static int mca_registered;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538#endif /* CONFIG_MCA */
539
Stephen Hemminger3186ae82009-01-09 13:01:14 +0000540static const struct net_device_ops netdev_ops = {
541 .ndo_open = el3_open,
542 .ndo_stop = el3_close,
543 .ndo_start_xmit = el3_start_xmit,
544 .ndo_get_stats = el3_get_stats,
545 .ndo_set_multicast_list = set_multicast_list,
546 .ndo_tx_timeout = el3_tx_timeout,
547 .ndo_change_mtu = eth_change_mtu,
548 .ndo_set_mac_address = eth_mac_addr,
549 .ndo_validate_addr = eth_validate_addr,
550#ifdef CONFIG_NET_POLL_CONTROLLER
551 .ndo_poll_controller = el3_poll_controller,
552#endif
553};
554
Al Viro37b2a172008-11-01 18:20:19 +0000555static int __devinit el3_common_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556{
557 struct el3_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 int err;
Joe Perches0795af52007-10-03 17:59:30 -0700559 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
561 spin_lock_init(&lp->lock);
562
563 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
564 dev->if_port = (dev->mem_start & 0x0f);
565 } else { /* xcvr codes 0/8 */
566 /* use eeprom value, but save user's full-duplex selection */
567 dev->if_port |= (dev->mem_start & 0x08);
568 }
569
570 /* The EL3-specific entries in the device structure. */
Stephen Hemminger3186ae82009-01-09 13:01:14 +0000571 dev->netdev_ops = &netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 dev->watchdog_timeo = TX_TIMEOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 SET_ETHTOOL_OPS(dev, &ethtool_ops);
574
575 err = register_netdev(dev);
576 if (err) {
577 printk(KERN_ERR "Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
578 dev->base_addr, dev->irq);
579 release_region(dev->base_addr, EL3_IO_EXTENT);
580 return err;
581 }
582
Joe Perches0795af52007-10-03 17:59:30 -0700583 printk(KERN_INFO "%s: 3c5x9 found at %#3.3lx, %s port, "
Johannes Berge1749612008-10-27 15:59:26 -0700584 "address %pM, IRQ %d.\n",
Joe Perches0795af52007-10-03 17:59:30 -0700585 dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
Johannes Berge1749612008-10-27 15:59:26 -0700586 dev->dev_addr, dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 if (el3_debug > 0)
Markus Dahms2c2a8c52007-05-09 07:58:10 +0200589 printk(KERN_INFO "%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 return 0;
591
592}
593
594static void el3_common_remove (struct net_device *dev)
595{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 unregister_netdev (dev);
597 release_region(dev->base_addr, EL3_IO_EXTENT);
598 free_netdev (dev);
599}
600
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601#ifdef CONFIG_MCA
602static int __init el3_mca_probe(struct device *device)
603{
604 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
605 * heavily modified by Chris Beauregard
606 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
607 * probing.
608 *
609 * redone for multi-card detection by ZP Gu (zpg@castle.net)
610 * now works as a module */
611
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 short i;
613 int ioaddr, irq, if_port;
Al Viro4ec7ffa2008-05-21 06:32:11 +0100614 __be16 phys_addr[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 struct net_device *dev = NULL;
616 u_char pos4, pos5;
617 struct mca_device *mdev = to_mca_device(device);
618 int slot = mdev->slot;
619 int err;
620
621 pos4 = mca_device_read_stored_pos(mdev, 4);
622 pos5 = mca_device_read_stored_pos(mdev, 5);
623
624 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
625 irq = pos5 & 0x0f;
626
627
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700628 printk(KERN_INFO "3c529: found %s at slot %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 el3_mca_adapter_names[mdev->index], slot + 1);
630
631 /* claim the slot */
632 strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
633 sizeof(mdev->name));
634 mca_device_set_claim(mdev, 1);
635
636 if_port = pos4 & 0x03;
637
638 irq = mca_device_transform_irq(mdev, irq);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400639 ioaddr = mca_device_transform_ioport(mdev, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 if (el3_debug > 2) {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700641 printk(KERN_DEBUG "3c529: irq %d ioaddr 0x%x ifport %d\n", irq, ioaddr, if_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 }
643 EL3WINDOW(0);
Al Viro4ec7ffa2008-05-21 06:32:11 +0100644 for (i = 0; i < 3; i++)
645 phys_addr[i] = htons(read_eeprom(ioaddr, i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
647 dev = alloc_etherdev(sizeof (struct el3_private));
648 if (dev == NULL) {
Al Viro4ec7ffa2008-05-21 06:32:11 +0100649 release_region(ioaddr, EL3_IO_EXTENT);
650 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 }
652
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 netdev_boot_setup_check(dev);
654
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700655 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_MCA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 device->driver_data = dev;
657 err = el3_common_init(dev);
658
659 if (err) {
660 device->driver_data = NULL;
661 free_netdev(dev);
662 return -ENOMEM;
663 }
664
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700665 el3_devs[el3_cards++] = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 return 0;
667}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400668
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669#endif /* CONFIG_MCA */
670
671#ifdef CONFIG_EISA
672static int __init el3_eisa_probe (struct device *device)
673{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 short i;
675 int ioaddr, irq, if_port;
Al Viro4ec7ffa2008-05-21 06:32:11 +0100676 __be16 phys_addr[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 struct net_device *dev = NULL;
678 struct eisa_device *edev;
679 int err;
680
681 /* Yeepee, The driver framework is calling us ! */
682 edev = to_eisa_device (device);
683 ioaddr = edev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400684
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700685 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 return -EBUSY;
687
688 /* Change the register set to the configuration window 0. */
689 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
690
691 irq = inw(ioaddr + WN0_IRQ) >> 12;
692 if_port = inw(ioaddr + 6)>>14;
693 for (i = 0; i < 3; i++)
694 phys_addr[i] = htons(read_eeprom(ioaddr, i));
695
696 /* Restore the "Product ID" to the EEPROM read register. */
697 read_eeprom(ioaddr, 3);
698
699 dev = alloc_etherdev(sizeof (struct el3_private));
700 if (dev == NULL) {
701 release_region(ioaddr, EL3_IO_EXTENT);
702 return -ENOMEM;
703 }
704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 netdev_boot_setup_check(dev);
706
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700707 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 eisa_set_drvdata (edev, dev);
709 err = el3_common_init(dev);
710
711 if (err) {
712 eisa_set_drvdata (edev, NULL);
713 free_netdev(dev);
714 return err;
715 }
716
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700717 el3_devs[el3_cards++] = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 return 0;
719}
720#endif
721
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722/* This remove works for all device types.
723 *
724 * The net dev must be stored in the driver_data field */
725static int __devexit el3_device_remove (struct device *device)
726{
727 struct net_device *dev;
728
729 dev = device->driver_data;
730
731 el3_common_remove (dev);
732 return 0;
733}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735/* Read a word from the EEPROM using the regular EEPROM access register.
736 Assume that we are in register window zero.
737 */
738static ushort read_eeprom(int ioaddr, int index)
739{
740 outw(EEPROM_READ + index, ioaddr + 10);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400741 /* Pause for at least 162 us. for the read to take place.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 Some chips seem to require much longer */
743 mdelay(2);
744 return inw(ioaddr + 12);
745}
746
747/* Read a word from the EEPROM when in the ISA ID probe state. */
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700748static ushort id_read_eeprom(int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749{
750 int bit, word = 0;
751
752 /* Issue read command, and pause for at least 162 us. for it to complete.
753 Assume extra-fast 16Mhz bus. */
754 outb(EEPROM_READ + index, id_port);
755
756 /* Pause for at least 162 us. for the read to take place. */
757 /* Some chips seem to require much longer */
758 mdelay(4);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400759
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 for (bit = 15; bit >= 0; bit--)
761 word = (word << 1) + (inb(id_port) & 0x01);
762
763 if (el3_debug > 3)
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700764 printk(KERN_DEBUG " 3c509 EEPROM word %d %#4.4x.\n", index, word);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
766 return word;
767}
768
769
770static int
771el3_open(struct net_device *dev)
772{
773 int ioaddr = dev->base_addr;
774 int i;
775
776 outw(TxReset, ioaddr + EL3_CMD);
777 outw(RxReset, ioaddr + EL3_CMD);
778 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
779
780 i = request_irq(dev->irq, &el3_interrupt, 0, dev->name, dev);
781 if (i)
782 return i;
783
784 EL3WINDOW(0);
785 if (el3_debug > 3)
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700786 printk(KERN_DEBUG "%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
788
789 el3_up(dev);
790
791 if (el3_debug > 3)
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700792 printk(KERN_DEBUG "%s: Opened 3c509 IRQ %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
794
795 return 0;
796}
797
798static void
799el3_tx_timeout (struct net_device *dev)
800{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 int ioaddr = dev->base_addr;
802
803 /* Transmitter timeout, serious problems. */
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700804 printk(KERN_WARNING "%s: transmit timed out, Tx_status %2.2x status %4.4x "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 "Tx FIFO room %d.\n",
806 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
807 inw(ioaddr + TX_FREE));
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300808 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 dev->trans_start = jiffies;
810 /* Issue TX_RESET and TX_START commands. */
811 outw(TxReset, ioaddr + EL3_CMD);
812 outw(TxEnable, ioaddr + EL3_CMD);
813 netif_wake_queue(dev);
814}
815
816
817static int
818el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
819{
820 struct el3_private *lp = netdev_priv(dev);
821 int ioaddr = dev->base_addr;
822 unsigned long flags;
823
824 netif_stop_queue (dev);
825
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300826 dev->stats.tx_bytes += skb->len;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400827
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 if (el3_debug > 4) {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700829 printk(KERN_DEBUG "%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
831 }
832#if 0
833#ifndef final_version
834 { /* Error-checking code, delete someday. */
835 ushort status = inw(ioaddr + EL3_STATUS);
836 if (status & 0x0001 /* IRQ line active, missed one. */
837 && inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700838 printk(KERN_DEBUG "%s: Missed interrupt, status then %04x now %04x"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
840 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
841 inw(ioaddr + RX_STATUS));
842 /* Fake interrupt trigger by masking, acknowledge interrupts. */
843 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
844 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
845 ioaddr + EL3_CMD);
846 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
847 }
848 }
849#endif
850#endif
851 /*
852 * We lock the driver against other processors. Note
853 * we don't need to lock versus the IRQ as we suspended
854 * that. This means that we lose the ability to take
855 * an RX during a TX upload. That sucks a bit with SMP
856 * on an original 3c509 (2K buffer)
857 *
858 * Using disable_irq stops us crapping on other
859 * time sensitive devices.
860 */
861
862 spin_lock_irqsave(&lp->lock, flags);
863
864 /* Put out the doubleword header... */
865 outw(skb->len, ioaddr + TX_FIFO);
866 outw(0x00, ioaddr + TX_FIFO);
867 /* ... and the packet rounded to a doubleword. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
870 dev->trans_start = jiffies;
871 if (inw(ioaddr + TX_FREE) > 1536)
872 netif_start_queue(dev);
873 else
874 /* Interrupt us when the FIFO has room for max-sized packet. */
875 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
876
877 spin_unlock_irqrestore(&lp->lock, flags);
878
879 dev_kfree_skb (skb);
880
881 /* Clear the Tx status stack. */
882 {
883 short tx_status;
884 int i = 4;
885
886 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300887 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
889 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
890 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
891 }
892 }
893 return 0;
894}
895
896/* The EL3 interrupt handler. */
897static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +0100898el3_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899{
Jeff Garzikc31f28e2006-10-06 14:56:04 -0400900 struct net_device *dev = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 struct el3_private *lp;
902 int ioaddr, status;
903 int i = max_interrupt_work;
904
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 lp = netdev_priv(dev);
906 spin_lock(&lp->lock);
907
908 ioaddr = dev->base_addr;
909
910 if (el3_debug > 4) {
911 status = inw(ioaddr + EL3_STATUS);
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700912 printk(KERN_DEBUG "%s: interrupt, status %4.4x.\n", dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 }
914
915 while ((status = inw(ioaddr + EL3_STATUS)) &
916 (IntLatch | RxComplete | StatsFull)) {
917
918 if (status & RxComplete)
919 el3_rx(dev);
920
921 if (status & TxAvailable) {
922 if (el3_debug > 5)
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700923 printk(KERN_DEBUG " TX room bit was handled.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 /* There's room in the FIFO for a full-sized packet. */
925 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
926 netif_wake_queue (dev);
927 }
928 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
929 /* Handle all uncommon interrupts. */
930 if (status & StatsFull) /* Empty statistics. */
931 update_stats(dev);
932 if (status & RxEarly) { /* Rx early is unused. */
933 el3_rx(dev);
934 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
935 }
936 if (status & TxComplete) { /* Really Tx error. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 short tx_status;
938 int i = 4;
939
940 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300941 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
943 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
944 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
945 }
946 }
947 if (status & AdapterFailure) {
948 /* Adapter failure requires Rx reset and reinit. */
949 outw(RxReset, ioaddr + EL3_CMD);
950 /* Set the Rx filter to the current state. */
951 outw(SetRxFilter | RxStation | RxBroadcast
952 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
953 | (dev->flags & IFF_PROMISC ? RxProm : 0),
954 ioaddr + EL3_CMD);
955 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
956 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
957 }
958 }
959
960 if (--i < 0) {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700961 printk(KERN_ERR "%s: Infinite loop in interrupt, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 dev->name, status);
963 /* Clear all interrupts. */
964 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
965 break;
966 }
967 /* Acknowledge the IRQ. */
968 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
969 }
970
971 if (el3_debug > 4) {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700972 printk(KERN_DEBUG "%s: exiting interrupt, status %4.4x.\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 inw(ioaddr + EL3_STATUS));
974 }
975 spin_unlock(&lp->lock);
976 return IRQ_HANDLED;
977}
978
979
980#ifdef CONFIG_NET_POLL_CONTROLLER
981/*
982 * Polling receive - used by netconsole and other diagnostic tools
983 * to allow network i/o with interrupts disabled.
984 */
985static void el3_poll_controller(struct net_device *dev)
986{
987 disable_irq(dev->irq);
David Howells7d12e782006-10-05 14:55:46 +0100988 el3_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 enable_irq(dev->irq);
990}
991#endif
992
993static struct net_device_stats *
994el3_get_stats(struct net_device *dev)
995{
996 struct el3_private *lp = netdev_priv(dev);
997 unsigned long flags;
998
999 /*
1000 * This is fast enough not to bother with disable IRQ
1001 * stuff.
1002 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001003
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 spin_lock_irqsave(&lp->lock, flags);
1005 update_stats(dev);
1006 spin_unlock_irqrestore(&lp->lock, flags);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001007 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008}
1009
1010/* Update statistics. We change to register window 6, so this should be run
1011 single-threaded if the device is active. This is expected to be a rare
1012 operation, and it's simpler for the rest of the driver to assume that
1013 window 1 is always valid rather than use a special window-state variable.
1014 */
1015static void update_stats(struct net_device *dev)
1016{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 int ioaddr = dev->base_addr;
1018
1019 if (el3_debug > 5)
1020 printk(" Updating the statistics.\n");
1021 /* Turn off statistics updates while reading. */
1022 outw(StatsDisable, ioaddr + EL3_CMD);
1023 /* Switch to the stats window, and read everything. */
1024 EL3WINDOW(6);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001025 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1026 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 /* Multiple collisions. */ inb(ioaddr + 2);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001028 dev->stats.collisions += inb(ioaddr + 3);
1029 dev->stats.tx_window_errors += inb(ioaddr + 4);
1030 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1031 dev->stats.tx_packets += inb(ioaddr + 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 /* Rx packets */ inb(ioaddr + 7);
1033 /* Tx deferrals */ inb(ioaddr + 8);
1034 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1035 inw(ioaddr + 12);
1036
1037 /* Back to window 1, and turn statistics back on. */
1038 EL3WINDOW(1);
1039 outw(StatsEnable, ioaddr + EL3_CMD);
1040 return;
1041}
1042
1043static int
1044el3_rx(struct net_device *dev)
1045{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 int ioaddr = dev->base_addr;
1047 short rx_status;
1048
1049 if (el3_debug > 5)
1050 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1051 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1052 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1053 if (rx_status & 0x4000) { /* Error, update stats. */
1054 short error = rx_status & 0x3800;
1055
1056 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001057 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 switch (error) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001059 case 0x0000: dev->stats.rx_over_errors++; break;
1060 case 0x0800: dev->stats.rx_length_errors++; break;
1061 case 0x1000: dev->stats.rx_frame_errors++; break;
1062 case 0x1800: dev->stats.rx_length_errors++; break;
1063 case 0x2000: dev->stats.rx_frame_errors++; break;
1064 case 0x2800: dev->stats.rx_crc_errors++; break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 }
1066 } else {
1067 short pkt_len = rx_status & 0x7ff;
1068 struct sk_buff *skb;
1069
1070 skb = dev_alloc_skb(pkt_len+5);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 if (el3_debug > 4)
1072 printk("Receiving packet size %d status %4.4x.\n",
1073 pkt_len, rx_status);
1074 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 skb_reserve(skb, 2); /* Align IP on 16 byte */
1076
1077 /* 'skb->data' points to the start of sk_buff data area. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1079 (pkt_len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
1081 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1082 skb->protocol = eth_type_trans(skb,dev);
1083 netif_rx(skb);
Wang Chenf7f312a2008-05-20 17:13:52 +08001084 dev->stats.rx_bytes += pkt_len;
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001085 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 continue;
1087 }
1088 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001089 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 if (el3_debug)
1091 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1092 dev->name, pkt_len);
1093 }
1094 inw(ioaddr + EL3_STATUS); /* Delay. */
1095 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1096 printk(KERN_DEBUG " Waiting for 3c509 to discard packet, status %x.\n",
1097 inw(ioaddr + EL3_STATUS) );
1098 }
1099
1100 return 0;
1101}
1102
1103/*
1104 * Set or clear the multicast filter for this adaptor.
1105 */
1106static void
1107set_multicast_list(struct net_device *dev)
1108{
1109 unsigned long flags;
1110 struct el3_private *lp = netdev_priv(dev);
1111 int ioaddr = dev->base_addr;
1112
1113 if (el3_debug > 1) {
1114 static int old;
1115 if (old != dev->mc_count) {
1116 old = dev->mc_count;
1117 printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1118 }
1119 }
1120 spin_lock_irqsave(&lp->lock, flags);
1121 if (dev->flags&IFF_PROMISC) {
1122 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1123 ioaddr + EL3_CMD);
1124 }
1125 else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1126 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1127 }
1128 else
1129 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1130 spin_unlock_irqrestore(&lp->lock, flags);
1131}
1132
1133static int
1134el3_close(struct net_device *dev)
1135{
1136 int ioaddr = dev->base_addr;
1137 struct el3_private *lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 if (el3_debug > 2)
1140 printk("%s: Shutting down ethercard.\n", dev->name);
1141
1142 el3_down(dev);
1143
1144 free_irq(dev->irq, dev);
1145 /* Switching back to window 0 disables the IRQ. */
1146 EL3WINDOW(0);
1147 if (lp->type != EL3_EISA) {
1148 /* But we explicitly zero the IRQ line select anyway. Don't do
1149 * it on EISA cards, it prevents the module from getting an
1150 * IRQ after unload+reload... */
1151 outw(0x0f00, ioaddr + WN0_IRQ);
1152 }
1153
1154 return 0;
1155}
1156
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001157static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158el3_link_ok(struct net_device *dev)
1159{
1160 int ioaddr = dev->base_addr;
1161 u16 tmp;
1162
1163 EL3WINDOW(4);
1164 tmp = inw(ioaddr + WN4_MEDIA);
1165 EL3WINDOW(1);
1166 return tmp & (1<<11);
1167}
1168
1169static int
1170el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1171{
1172 u16 tmp;
1173 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001174
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 EL3WINDOW(0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001176 /* obtain current transceiver via WN4_MEDIA? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 tmp = inw(ioaddr + WN0_ADDR_CONF);
1178 ecmd->transceiver = XCVR_INTERNAL;
1179 switch (tmp >> 14) {
1180 case 0:
1181 ecmd->port = PORT_TP;
1182 break;
1183 case 1:
1184 ecmd->port = PORT_AUI;
1185 ecmd->transceiver = XCVR_EXTERNAL;
1186 break;
1187 case 3:
1188 ecmd->port = PORT_BNC;
1189 default:
1190 break;
1191 }
1192
1193 ecmd->duplex = DUPLEX_HALF;
1194 ecmd->supported = 0;
1195 tmp = inw(ioaddr + WN0_CONF_CTRL);
1196 if (tmp & (1<<13))
1197 ecmd->supported |= SUPPORTED_AUI;
1198 if (tmp & (1<<12))
1199 ecmd->supported |= SUPPORTED_BNC;
1200 if (tmp & (1<<9)) {
1201 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1202 SUPPORTED_10baseT_Full; /* hmm... */
1203 EL3WINDOW(4);
1204 tmp = inw(ioaddr + WN4_NETDIAG);
1205 if (tmp & FD_ENABLE)
1206 ecmd->duplex = DUPLEX_FULL;
1207 }
1208
1209 ecmd->speed = SPEED_10;
1210 EL3WINDOW(1);
1211 return 0;
1212}
1213
1214static int
1215el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1216{
1217 u16 tmp;
1218 int ioaddr = dev->base_addr;
1219
1220 if (ecmd->speed != SPEED_10)
1221 return -EINVAL;
1222 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1223 return -EINVAL;
1224 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1225 return -EINVAL;
1226
1227 /* change XCVR type */
1228 EL3WINDOW(0);
1229 tmp = inw(ioaddr + WN0_ADDR_CONF);
1230 switch (ecmd->port) {
1231 case PORT_TP:
1232 tmp &= ~(3<<14);
1233 dev->if_port = 0;
1234 break;
1235 case PORT_AUI:
1236 tmp |= (1<<14);
1237 dev->if_port = 1;
1238 break;
1239 case PORT_BNC:
1240 tmp |= (3<<14);
1241 dev->if_port = 3;
1242 break;
1243 default:
1244 return -EINVAL;
1245 }
1246
1247 outw(tmp, ioaddr + WN0_ADDR_CONF);
1248 if (dev->if_port == 3) {
1249 /* fire up the DC-DC convertor if BNC gets enabled */
1250 tmp = inw(ioaddr + WN0_ADDR_CONF);
1251 if (tmp & (3 << 14)) {
1252 outw(StartCoax, ioaddr + EL3_CMD);
1253 udelay(800);
1254 } else
1255 return -EIO;
1256 }
1257
1258 EL3WINDOW(4);
1259 tmp = inw(ioaddr + WN4_NETDIAG);
1260 if (ecmd->duplex == DUPLEX_FULL)
1261 tmp |= FD_ENABLE;
1262 else
1263 tmp &= ~FD_ENABLE;
1264 outw(tmp, ioaddr + WN4_NETDIAG);
1265 EL3WINDOW(1);
1266
1267 return 0;
1268}
1269
1270static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1271{
1272 strcpy(info->driver, DRV_NAME);
1273 strcpy(info->version, DRV_VERSION);
1274}
1275
1276static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1277{
1278 struct el3_private *lp = netdev_priv(dev);
1279 int ret;
1280
1281 spin_lock_irq(&lp->lock);
1282 ret = el3_netdev_get_ecmd(dev, ecmd);
1283 spin_unlock_irq(&lp->lock);
1284 return ret;
1285}
1286
1287static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1288{
1289 struct el3_private *lp = netdev_priv(dev);
1290 int ret;
1291
1292 spin_lock_irq(&lp->lock);
1293 ret = el3_netdev_set_ecmd(dev, ecmd);
1294 spin_unlock_irq(&lp->lock);
1295 return ret;
1296}
1297
1298static u32 el3_get_link(struct net_device *dev)
1299{
1300 struct el3_private *lp = netdev_priv(dev);
1301 u32 ret;
1302
1303 spin_lock_irq(&lp->lock);
1304 ret = el3_link_ok(dev);
1305 spin_unlock_irq(&lp->lock);
1306 return ret;
1307}
1308
1309static u32 el3_get_msglevel(struct net_device *dev)
1310{
1311 return el3_debug;
1312}
1313
1314static void el3_set_msglevel(struct net_device *dev, u32 v)
1315{
1316 el3_debug = v;
1317}
1318
Jeff Garzik7282d492006-09-13 14:30:00 -04001319static const struct ethtool_ops ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 .get_drvinfo = el3_get_drvinfo,
1321 .get_settings = el3_get_settings,
1322 .set_settings = el3_set_settings,
1323 .get_link = el3_get_link,
1324 .get_msglevel = el3_get_msglevel,
1325 .set_msglevel = el3_set_msglevel,
1326};
1327
1328static void
1329el3_down(struct net_device *dev)
1330{
1331 int ioaddr = dev->base_addr;
1332
1333 netif_stop_queue(dev);
1334
1335 /* Turn off statistics ASAP. We update lp->stats below. */
1336 outw(StatsDisable, ioaddr + EL3_CMD);
1337
1338 /* Disable the receiver and transmitter. */
1339 outw(RxDisable, ioaddr + EL3_CMD);
1340 outw(TxDisable, ioaddr + EL3_CMD);
1341
1342 if (dev->if_port == 3)
1343 /* Turn off thinnet power. Green! */
1344 outw(StopCoax, ioaddr + EL3_CMD);
1345 else if (dev->if_port == 0) {
1346 /* Disable link beat and jabber, if_port may change here next open(). */
1347 EL3WINDOW(4);
1348 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1349 }
1350
1351 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1352
1353 update_stats(dev);
1354}
1355
1356static void
1357el3_up(struct net_device *dev)
1358{
1359 int i, sw_info, net_diag;
1360 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001361
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 /* Activating the board required and does no harm otherwise */
1363 outw(0x0001, ioaddr + 4);
1364
1365 /* Set the IRQ line. */
1366 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1367
1368 /* Set the station address in window 2 each time opened. */
1369 EL3WINDOW(2);
1370
1371 for (i = 0; i < 6; i++)
1372 outb(dev->dev_addr[i], ioaddr + i);
1373
1374 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1375 /* Start the thinnet transceiver. We should really wait 50ms...*/
1376 outw(StartCoax, ioaddr + EL3_CMD);
1377 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1378 /* Combine secondary sw_info word (the adapter level) and primary
1379 sw_info word (duplex setting plus other useless bits) */
1380 EL3WINDOW(0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001381 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1383
1384 EL3WINDOW(4);
1385 net_diag = inw(ioaddr + WN4_NETDIAG);
1386 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1387 printk("%s: ", dev->name);
1388 switch (dev->if_port & 0x0c) {
1389 case 12:
1390 /* force full-duplex mode if 3c5x9b */
1391 if (sw_info & 0x000f) {
1392 printk("Forcing 3c5x9b full-duplex mode");
1393 break;
1394 }
1395 case 8:
1396 /* set full-duplex mode based on eeprom config setting */
1397 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1398 printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1399 break;
1400 }
1401 default:
1402 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1403 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1404 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1405 }
1406
1407 outw(net_diag, ioaddr + WN4_NETDIAG);
1408 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1409 if (el3_debug > 3)
1410 printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1411 /* Enable link beat and jabber check. */
1412 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1413 }
1414
1415 /* Switch to the stats window, and clear all stats by reading. */
1416 outw(StatsDisable, ioaddr + EL3_CMD);
1417 EL3WINDOW(6);
1418 for (i = 0; i < 9; i++)
1419 inb(ioaddr + i);
1420 inw(ioaddr + 10);
1421 inw(ioaddr + 12);
1422
1423 /* Switch to register set 1 for normal use. */
1424 EL3WINDOW(1);
1425
1426 /* Accept b-case and phys addr only. */
1427 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1428 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1429
1430 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1431 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1432 /* Allow status bits to be seen. */
1433 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1434 /* Ack all pending events, and set active indicator mask. */
1435 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1436 ioaddr + EL3_CMD);
1437 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1438 ioaddr + EL3_CMD);
1439
1440 netif_start_queue(dev);
1441}
1442
1443/* Power Management support functions */
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001444#ifdef CONFIG_PM
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
1446static int
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001447el3_suspend(struct device *pdev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448{
1449 unsigned long flags;
1450 struct net_device *dev;
1451 struct el3_private *lp;
1452 int ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001453
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001454 dev = pdev->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 lp = netdev_priv(dev);
1456 ioaddr = dev->base_addr;
1457
1458 spin_lock_irqsave(&lp->lock, flags);
1459
1460 if (netif_running(dev))
1461 netif_device_detach(dev);
1462
1463 el3_down(dev);
1464 outw(PowerDown, ioaddr + EL3_CMD);
1465
1466 spin_unlock_irqrestore(&lp->lock, flags);
1467 return 0;
1468}
1469
1470static int
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001471el3_resume(struct device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472{
1473 unsigned long flags;
1474 struct net_device *dev;
1475 struct el3_private *lp;
1476 int ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001477
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001478 dev = pdev->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 lp = netdev_priv(dev);
1480 ioaddr = dev->base_addr;
1481
1482 spin_lock_irqsave(&lp->lock, flags);
1483
1484 outw(PowerUp, ioaddr + EL3_CMD);
Ondrej Zary152abd12009-02-06 22:04:08 -08001485 EL3WINDOW(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 el3_up(dev);
1487
1488 if (netif_running(dev))
1489 netif_device_attach(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001490
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 spin_unlock_irqrestore(&lp->lock, flags);
1492 return 0;
1493}
1494
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001495#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496
1497module_param(debug,int, 0);
1498module_param_array(irq, int, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499module_param(max_interrupt_work, int, 0);
1500MODULE_PARM_DESC(debug, "debug level (0-6)");
1501MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001503#ifdef CONFIG_PNP
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504module_param(nopnp, int, 0);
1505MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001506#endif /* CONFIG_PNP */
1507MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508MODULE_LICENSE("GPL");
1509
1510static int __init el3_init_module(void)
1511{
Andrew Morton0992a5d2006-03-08 00:06:27 -08001512 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
1514 if (debug >= 0)
1515 el3_debug = debug;
1516
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001517#ifdef CONFIG_PNP
1518 if (!nopnp) {
1519 ret = pnp_register_driver(&el3_pnp_driver);
1520 if (!ret)
1521 pnp_registered = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 }
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001523#endif
1524 /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1525 /* Start with 0x110 to avoid some sound cards.*/
1526 for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1527 if (!request_region(id_port, 1, "3c509-control"))
1528 continue;
1529 outb(0x00, id_port);
1530 outb(0xff, id_port);
1531 if (inb(id_port) & 0x01)
1532 break;
1533 else
1534 release_region(id_port, 1);
1535 }
1536 if (id_port >= 0x200) {
1537 id_port = 0;
1538 printk(KERN_ERR "No I/O port available for 3c509 activation.\n");
1539 } else {
1540 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1541 if (!ret)
1542 isa_registered = 1;
1543 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544#ifdef CONFIG_EISA
Andrew Morton0992a5d2006-03-08 00:06:27 -08001545 ret = eisa_driver_register(&el3_eisa_driver);
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001546 if (!ret)
1547 eisa_registered = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548#endif
1549#ifdef CONFIG_MCA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001550 ret = mca_register_driver(&el3_mca_driver);
1551 if (!ret)
1552 mca_registered = 1;
1553#endif
1554
1555#ifdef CONFIG_PNP
1556 if (pnp_registered)
1557 ret = 0;
1558#endif
1559 if (isa_registered)
1560 ret = 0;
1561#ifdef CONFIG_EISA
1562 if (eisa_registered)
1563 ret = 0;
1564#endif
1565#ifdef CONFIG_MCA
1566 if (mca_registered)
1567 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568#endif
Andrew Morton0992a5d2006-03-08 00:06:27 -08001569 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570}
1571
1572static void __exit el3_cleanup_module(void)
1573{
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001574#ifdef CONFIG_PNP
1575 if (pnp_registered)
1576 pnp_unregister_driver(&el3_pnp_driver);
1577#endif
1578 if (isa_registered)
1579 isa_unregister_driver(&el3_isa_driver);
1580 if (id_port)
1581 release_region(id_port, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582#ifdef CONFIG_EISA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001583 if (eisa_registered)
1584 eisa_driver_unregister(&el3_eisa_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585#endif
1586#ifdef CONFIG_MCA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001587 if (mca_registered)
1588 mca_unregister_driver(&el3_mca_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589#endif
1590}
1591
1592module_init (el3_init_module);
1593module_exit (el3_cleanup_module);