blob: 87d8795823d7a9e53d2ff8bddc762e29d6a37b69 [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
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>
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
Markus Dahms2c2a8c52007-05-09 07:58:10 +020097static char version[] __initdata = 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
189static int __init el3_common_init(struct net_device *dev);
190static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540static int __init el3_common_init(struct net_device *dev)
541{
542 struct el3_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 int err;
Joe Perches0795af52007-10-03 17:59:30 -0700544 DECLARE_MAC_BUF(mac);
545 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
547 spin_lock_init(&lp->lock);
548
549 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
550 dev->if_port = (dev->mem_start & 0x0f);
551 } else { /* xcvr codes 0/8 */
552 /* use eeprom value, but save user's full-duplex selection */
553 dev->if_port |= (dev->mem_start & 0x08);
554 }
555
556 /* The EL3-specific entries in the device structure. */
557 dev->open = &el3_open;
558 dev->hard_start_xmit = &el3_start_xmit;
559 dev->stop = &el3_close;
560 dev->get_stats = &el3_get_stats;
561 dev->set_multicast_list = &set_multicast_list;
562 dev->tx_timeout = el3_tx_timeout;
563 dev->watchdog_timeo = TX_TIMEOUT;
564#ifdef CONFIG_NET_POLL_CONTROLLER
565 dev->poll_controller = el3_poll_controller;
566#endif
567 SET_ETHTOOL_OPS(dev, &ethtool_ops);
568
569 err = register_netdev(dev);
570 if (err) {
571 printk(KERN_ERR "Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
572 dev->base_addr, dev->irq);
573 release_region(dev->base_addr, EL3_IO_EXTENT);
574 return err;
575 }
576
Joe Perches0795af52007-10-03 17:59:30 -0700577 printk(KERN_INFO "%s: 3c5x9 found at %#3.3lx, %s port, "
578 "address %s, IRQ %d.\n",
579 dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
580 print_mac(mac, dev->dev_addr), dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 if (el3_debug > 0)
Markus Dahms2c2a8c52007-05-09 07:58:10 +0200583 printk(KERN_INFO "%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 return 0;
585
586}
587
588static void el3_common_remove (struct net_device *dev)
589{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 unregister_netdev (dev);
591 release_region(dev->base_addr, EL3_IO_EXTENT);
592 free_netdev (dev);
593}
594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595#ifdef CONFIG_MCA
596static int __init el3_mca_probe(struct device *device)
597{
598 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
599 * heavily modified by Chris Beauregard
600 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
601 * probing.
602 *
603 * redone for multi-card detection by ZP Gu (zpg@castle.net)
604 * now works as a module */
605
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 short i;
607 int ioaddr, irq, if_port;
Al Viro4ec7ffa2008-05-21 06:32:11 +0100608 __be16 phys_addr[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 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;
614
615 pos4 = mca_device_read_stored_pos(mdev, 4);
616 pos5 = mca_device_read_stored_pos(mdev, 5);
617
618 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
619 irq = pos5 & 0x0f;
620
621
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700622 printk(KERN_INFO "3c529: found %s at slot %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 el3_mca_adapter_names[mdev->index], slot + 1);
624
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);
629
630 if_port = pos4 & 0x03;
631
632 irq = mca_device_transform_irq(mdev, irq);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400633 ioaddr = mca_device_transform_ioport(mdev, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 if (el3_debug > 2) {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700635 printk(KERN_DEBUG "3c529: irq %d ioaddr 0x%x ifport %d\n", irq, ioaddr, if_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 }
637 EL3WINDOW(0);
Al Viro4ec7ffa2008-05-21 06:32:11 +0100638 for (i = 0; i < 3; i++)
639 phys_addr[i] = htons(read_eeprom(ioaddr, i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
641 dev = alloc_etherdev(sizeof (struct el3_private));
642 if (dev == NULL) {
Al Viro4ec7ffa2008-05-21 06:32:11 +0100643 release_region(ioaddr, EL3_IO_EXTENT);
644 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 }
646
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 netdev_boot_setup_check(dev);
648
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700649 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_MCA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 device->driver_data = dev;
651 err = el3_common_init(dev);
652
653 if (err) {
654 device->driver_data = NULL;
655 free_netdev(dev);
656 return -ENOMEM;
657 }
658
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700659 el3_devs[el3_cards++] = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 return 0;
661}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663#endif /* CONFIG_MCA */
664
665#ifdef CONFIG_EISA
666static int __init el3_eisa_probe (struct device *device)
667{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 short i;
669 int ioaddr, irq, if_port;
Al Viro4ec7ffa2008-05-21 06:32:11 +0100670 __be16 phys_addr[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 struct net_device *dev = NULL;
672 struct eisa_device *edev;
673 int err;
674
675 /* Yeepee, The driver framework is calling us ! */
676 edev = to_eisa_device (device);
677 ioaddr = edev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400678
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700679 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 return -EBUSY;
681
682 /* Change the register set to the configuration window 0. */
683 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
684
685 irq = inw(ioaddr + WN0_IRQ) >> 12;
686 if_port = inw(ioaddr + 6)>>14;
687 for (i = 0; i < 3; i++)
688 phys_addr[i] = htons(read_eeprom(ioaddr, i));
689
690 /* Restore the "Product ID" to the EEPROM read register. */
691 read_eeprom(ioaddr, 3);
692
693 dev = alloc_etherdev(sizeof (struct el3_private));
694 if (dev == NULL) {
695 release_region(ioaddr, EL3_IO_EXTENT);
696 return -ENOMEM;
697 }
698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 netdev_boot_setup_check(dev);
700
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700701 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 eisa_set_drvdata (edev, dev);
703 err = el3_common_init(dev);
704
705 if (err) {
706 eisa_set_drvdata (edev, NULL);
707 free_netdev(dev);
708 return err;
709 }
710
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700711 el3_devs[el3_cards++] = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 return 0;
713}
714#endif
715
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716/* This remove works for all device types.
717 *
718 * The net dev must be stored in the driver_data field */
719static int __devexit el3_device_remove (struct device *device)
720{
721 struct net_device *dev;
722
723 dev = device->driver_data;
724
725 el3_common_remove (dev);
726 return 0;
727}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729/* Read a word from the EEPROM using the regular EEPROM access register.
730 Assume that we are in register window zero.
731 */
732static ushort read_eeprom(int ioaddr, int index)
733{
734 outw(EEPROM_READ + index, ioaddr + 10);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400735 /* Pause for at least 162 us. for the read to take place.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 Some chips seem to require much longer */
737 mdelay(2);
738 return inw(ioaddr + 12);
739}
740
741/* Read a word from the EEPROM when in the ISA ID probe state. */
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700742static ushort id_read_eeprom(int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743{
744 int bit, word = 0;
745
746 /* Issue read command, and pause for at least 162 us. for it to complete.
747 Assume extra-fast 16Mhz bus. */
748 outb(EEPROM_READ + index, id_port);
749
750 /* Pause for at least 162 us. for the read to take place. */
751 /* Some chips seem to require much longer */
752 mdelay(4);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 for (bit = 15; bit >= 0; bit--)
755 word = (word << 1) + (inb(id_port) & 0x01);
756
757 if (el3_debug > 3)
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700758 printk(KERN_DEBUG " 3c509 EEPROM word %d %#4.4x.\n", index, word);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
760 return word;
761}
762
763
764static int
765el3_open(struct net_device *dev)
766{
767 int ioaddr = dev->base_addr;
768 int i;
769
770 outw(TxReset, ioaddr + EL3_CMD);
771 outw(RxReset, ioaddr + EL3_CMD);
772 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
773
774 i = request_irq(dev->irq, &el3_interrupt, 0, dev->name, dev);
775 if (i)
776 return i;
777
778 EL3WINDOW(0);
779 if (el3_debug > 3)
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700780 printk(KERN_DEBUG "%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
782
783 el3_up(dev);
784
785 if (el3_debug > 3)
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700786 printk(KERN_DEBUG "%s: Opened 3c509 IRQ %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
788
789 return 0;
790}
791
792static void
793el3_tx_timeout (struct net_device *dev)
794{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 int ioaddr = dev->base_addr;
796
797 /* Transmitter timeout, serious problems. */
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700798 printk(KERN_WARNING "%s: transmit timed out, Tx_status %2.2x status %4.4x "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 "Tx FIFO room %d.\n",
800 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
801 inw(ioaddr + TX_FREE));
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300802 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 dev->trans_start = jiffies;
804 /* Issue TX_RESET and TX_START commands. */
805 outw(TxReset, ioaddr + EL3_CMD);
806 outw(TxEnable, ioaddr + EL3_CMD);
807 netif_wake_queue(dev);
808}
809
810
811static int
812el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
813{
814 struct el3_private *lp = netdev_priv(dev);
815 int ioaddr = dev->base_addr;
816 unsigned long flags;
817
818 netif_stop_queue (dev);
819
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300820 dev->stats.tx_bytes += skb->len;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400821
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 if (el3_debug > 4) {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700823 printk(KERN_DEBUG "%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
825 }
826#if 0
827#ifndef final_version
828 { /* Error-checking code, delete someday. */
829 ushort status = inw(ioaddr + EL3_STATUS);
830 if (status & 0x0001 /* IRQ line active, missed one. */
831 && inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700832 printk(KERN_DEBUG "%s: Missed interrupt, status then %04x now %04x"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
834 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
835 inw(ioaddr + RX_STATUS));
836 /* Fake interrupt trigger by masking, acknowledge interrupts. */
837 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
838 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
839 ioaddr + EL3_CMD);
840 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
841 }
842 }
843#endif
844#endif
845 /*
846 * We lock the driver against other processors. Note
847 * we don't need to lock versus the IRQ as we suspended
848 * that. This means that we lose the ability to take
849 * an RX during a TX upload. That sucks a bit with SMP
850 * on an original 3c509 (2K buffer)
851 *
852 * Using disable_irq stops us crapping on other
853 * time sensitive devices.
854 */
855
856 spin_lock_irqsave(&lp->lock, flags);
857
858 /* Put out the doubleword header... */
859 outw(skb->len, ioaddr + TX_FIFO);
860 outw(0x00, ioaddr + TX_FIFO);
861 /* ... and the packet rounded to a doubleword. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
864 dev->trans_start = jiffies;
865 if (inw(ioaddr + TX_FREE) > 1536)
866 netif_start_queue(dev);
867 else
868 /* Interrupt us when the FIFO has room for max-sized packet. */
869 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
870
871 spin_unlock_irqrestore(&lp->lock, flags);
872
873 dev_kfree_skb (skb);
874
875 /* Clear the Tx status stack. */
876 {
877 short tx_status;
878 int i = 4;
879
880 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300881 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
883 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
884 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
885 }
886 }
887 return 0;
888}
889
890/* The EL3 interrupt handler. */
891static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +0100892el3_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893{
Jeff Garzikc31f28e2006-10-06 14:56:04 -0400894 struct net_device *dev = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 struct el3_private *lp;
896 int ioaddr, status;
897 int i = max_interrupt_work;
898
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 lp = netdev_priv(dev);
900 spin_lock(&lp->lock);
901
902 ioaddr = dev->base_addr;
903
904 if (el3_debug > 4) {
905 status = inw(ioaddr + EL3_STATUS);
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700906 printk(KERN_DEBUG "%s: interrupt, status %4.4x.\n", dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 }
908
909 while ((status = inw(ioaddr + EL3_STATUS)) &
910 (IntLatch | RxComplete | StatsFull)) {
911
912 if (status & RxComplete)
913 el3_rx(dev);
914
915 if (status & TxAvailable) {
916 if (el3_debug > 5)
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700917 printk(KERN_DEBUG " TX room bit was handled.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 /* There's room in the FIFO for a full-sized packet. */
919 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
920 netif_wake_queue (dev);
921 }
922 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
923 /* Handle all uncommon interrupts. */
924 if (status & StatsFull) /* Empty statistics. */
925 update_stats(dev);
926 if (status & RxEarly) { /* Rx early is unused. */
927 el3_rx(dev);
928 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
929 }
930 if (status & TxComplete) { /* Really Tx error. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 short tx_status;
932 int i = 4;
933
934 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300935 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
937 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
938 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
939 }
940 }
941 if (status & AdapterFailure) {
942 /* Adapter failure requires Rx reset and reinit. */
943 outw(RxReset, ioaddr + EL3_CMD);
944 /* Set the Rx filter to the current state. */
945 outw(SetRxFilter | RxStation | RxBroadcast
946 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
947 | (dev->flags & IFF_PROMISC ? RxProm : 0),
948 ioaddr + EL3_CMD);
949 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
950 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
951 }
952 }
953
954 if (--i < 0) {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700955 printk(KERN_ERR "%s: Infinite loop in interrupt, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 dev->name, status);
957 /* Clear all interrupts. */
958 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
959 break;
960 }
961 /* Acknowledge the IRQ. */
962 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
963 }
964
965 if (el3_debug > 4) {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700966 printk(KERN_DEBUG "%s: exiting interrupt, status %4.4x.\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 inw(ioaddr + EL3_STATUS));
968 }
969 spin_unlock(&lp->lock);
970 return IRQ_HANDLED;
971}
972
973
974#ifdef CONFIG_NET_POLL_CONTROLLER
975/*
976 * Polling receive - used by netconsole and other diagnostic tools
977 * to allow network i/o with interrupts disabled.
978 */
979static void el3_poll_controller(struct net_device *dev)
980{
981 disable_irq(dev->irq);
David Howells7d12e782006-10-05 14:55:46 +0100982 el3_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 enable_irq(dev->irq);
984}
985#endif
986
987static struct net_device_stats *
988el3_get_stats(struct net_device *dev)
989{
990 struct el3_private *lp = netdev_priv(dev);
991 unsigned long flags;
992
993 /*
994 * This is fast enough not to bother with disable IRQ
995 * stuff.
996 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400997
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 spin_lock_irqsave(&lp->lock, flags);
999 update_stats(dev);
1000 spin_unlock_irqrestore(&lp->lock, flags);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001001 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002}
1003
1004/* Update statistics. We change to register window 6, so this should be run
1005 single-threaded if the device is active. This is expected to be a rare
1006 operation, and it's simpler for the rest of the driver to assume that
1007 window 1 is always valid rather than use a special window-state variable.
1008 */
1009static void update_stats(struct net_device *dev)
1010{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 int ioaddr = dev->base_addr;
1012
1013 if (el3_debug > 5)
1014 printk(" Updating the statistics.\n");
1015 /* Turn off statistics updates while reading. */
1016 outw(StatsDisable, ioaddr + EL3_CMD);
1017 /* Switch to the stats window, and read everything. */
1018 EL3WINDOW(6);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001019 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1020 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 /* Multiple collisions. */ inb(ioaddr + 2);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001022 dev->stats.collisions += inb(ioaddr + 3);
1023 dev->stats.tx_window_errors += inb(ioaddr + 4);
1024 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1025 dev->stats.tx_packets += inb(ioaddr + 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 /* Rx packets */ inb(ioaddr + 7);
1027 /* Tx deferrals */ inb(ioaddr + 8);
1028 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1029 inw(ioaddr + 12);
1030
1031 /* Back to window 1, and turn statistics back on. */
1032 EL3WINDOW(1);
1033 outw(StatsEnable, ioaddr + EL3_CMD);
1034 return;
1035}
1036
1037static int
1038el3_rx(struct net_device *dev)
1039{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 int ioaddr = dev->base_addr;
1041 short rx_status;
1042
1043 if (el3_debug > 5)
1044 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1045 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1046 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1047 if (rx_status & 0x4000) { /* Error, update stats. */
1048 short error = rx_status & 0x3800;
1049
1050 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001051 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 switch (error) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001053 case 0x0000: dev->stats.rx_over_errors++; break;
1054 case 0x0800: dev->stats.rx_length_errors++; break;
1055 case 0x1000: dev->stats.rx_frame_errors++; break;
1056 case 0x1800: dev->stats.rx_length_errors++; break;
1057 case 0x2000: dev->stats.rx_frame_errors++; break;
1058 case 0x2800: dev->stats.rx_crc_errors++; break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 }
1060 } else {
1061 short pkt_len = rx_status & 0x7ff;
1062 struct sk_buff *skb;
1063
1064 skb = dev_alloc_skb(pkt_len+5);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001065 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 if (el3_debug > 4)
1067 printk("Receiving packet size %d status %4.4x.\n",
1068 pkt_len, rx_status);
1069 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 skb_reserve(skb, 2); /* Align IP on 16 byte */
1071
1072 /* 'skb->data' points to the start of sk_buff data area. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1074 (pkt_len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075
1076 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1077 skb->protocol = eth_type_trans(skb,dev);
1078 netif_rx(skb);
1079 dev->last_rx = jiffies;
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001080 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 continue;
1082 }
1083 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001084 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 if (el3_debug)
1086 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1087 dev->name, pkt_len);
1088 }
1089 inw(ioaddr + EL3_STATUS); /* Delay. */
1090 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1091 printk(KERN_DEBUG " Waiting for 3c509 to discard packet, status %x.\n",
1092 inw(ioaddr + EL3_STATUS) );
1093 }
1094
1095 return 0;
1096}
1097
1098/*
1099 * Set or clear the multicast filter for this adaptor.
1100 */
1101static void
1102set_multicast_list(struct net_device *dev)
1103{
1104 unsigned long flags;
1105 struct el3_private *lp = netdev_priv(dev);
1106 int ioaddr = dev->base_addr;
1107
1108 if (el3_debug > 1) {
1109 static int old;
1110 if (old != dev->mc_count) {
1111 old = dev->mc_count;
1112 printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1113 }
1114 }
1115 spin_lock_irqsave(&lp->lock, flags);
1116 if (dev->flags&IFF_PROMISC) {
1117 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1118 ioaddr + EL3_CMD);
1119 }
1120 else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1121 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1122 }
1123 else
1124 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1125 spin_unlock_irqrestore(&lp->lock, flags);
1126}
1127
1128static int
1129el3_close(struct net_device *dev)
1130{
1131 int ioaddr = dev->base_addr;
1132 struct el3_private *lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001133
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 if (el3_debug > 2)
1135 printk("%s: Shutting down ethercard.\n", dev->name);
1136
1137 el3_down(dev);
1138
1139 free_irq(dev->irq, dev);
1140 /* Switching back to window 0 disables the IRQ. */
1141 EL3WINDOW(0);
1142 if (lp->type != EL3_EISA) {
1143 /* But we explicitly zero the IRQ line select anyway. Don't do
1144 * it on EISA cards, it prevents the module from getting an
1145 * IRQ after unload+reload... */
1146 outw(0x0f00, ioaddr + WN0_IRQ);
1147 }
1148
1149 return 0;
1150}
1151
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001152static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153el3_link_ok(struct net_device *dev)
1154{
1155 int ioaddr = dev->base_addr;
1156 u16 tmp;
1157
1158 EL3WINDOW(4);
1159 tmp = inw(ioaddr + WN4_MEDIA);
1160 EL3WINDOW(1);
1161 return tmp & (1<<11);
1162}
1163
1164static int
1165el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1166{
1167 u16 tmp;
1168 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001169
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 EL3WINDOW(0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001171 /* obtain current transceiver via WN4_MEDIA? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 tmp = inw(ioaddr + WN0_ADDR_CONF);
1173 ecmd->transceiver = XCVR_INTERNAL;
1174 switch (tmp >> 14) {
1175 case 0:
1176 ecmd->port = PORT_TP;
1177 break;
1178 case 1:
1179 ecmd->port = PORT_AUI;
1180 ecmd->transceiver = XCVR_EXTERNAL;
1181 break;
1182 case 3:
1183 ecmd->port = PORT_BNC;
1184 default:
1185 break;
1186 }
1187
1188 ecmd->duplex = DUPLEX_HALF;
1189 ecmd->supported = 0;
1190 tmp = inw(ioaddr + WN0_CONF_CTRL);
1191 if (tmp & (1<<13))
1192 ecmd->supported |= SUPPORTED_AUI;
1193 if (tmp & (1<<12))
1194 ecmd->supported |= SUPPORTED_BNC;
1195 if (tmp & (1<<9)) {
1196 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1197 SUPPORTED_10baseT_Full; /* hmm... */
1198 EL3WINDOW(4);
1199 tmp = inw(ioaddr + WN4_NETDIAG);
1200 if (tmp & FD_ENABLE)
1201 ecmd->duplex = DUPLEX_FULL;
1202 }
1203
1204 ecmd->speed = SPEED_10;
1205 EL3WINDOW(1);
1206 return 0;
1207}
1208
1209static int
1210el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1211{
1212 u16 tmp;
1213 int ioaddr = dev->base_addr;
1214
1215 if (ecmd->speed != SPEED_10)
1216 return -EINVAL;
1217 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1218 return -EINVAL;
1219 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1220 return -EINVAL;
1221
1222 /* change XCVR type */
1223 EL3WINDOW(0);
1224 tmp = inw(ioaddr + WN0_ADDR_CONF);
1225 switch (ecmd->port) {
1226 case PORT_TP:
1227 tmp &= ~(3<<14);
1228 dev->if_port = 0;
1229 break;
1230 case PORT_AUI:
1231 tmp |= (1<<14);
1232 dev->if_port = 1;
1233 break;
1234 case PORT_BNC:
1235 tmp |= (3<<14);
1236 dev->if_port = 3;
1237 break;
1238 default:
1239 return -EINVAL;
1240 }
1241
1242 outw(tmp, ioaddr + WN0_ADDR_CONF);
1243 if (dev->if_port == 3) {
1244 /* fire up the DC-DC convertor if BNC gets enabled */
1245 tmp = inw(ioaddr + WN0_ADDR_CONF);
1246 if (tmp & (3 << 14)) {
1247 outw(StartCoax, ioaddr + EL3_CMD);
1248 udelay(800);
1249 } else
1250 return -EIO;
1251 }
1252
1253 EL3WINDOW(4);
1254 tmp = inw(ioaddr + WN4_NETDIAG);
1255 if (ecmd->duplex == DUPLEX_FULL)
1256 tmp |= FD_ENABLE;
1257 else
1258 tmp &= ~FD_ENABLE;
1259 outw(tmp, ioaddr + WN4_NETDIAG);
1260 EL3WINDOW(1);
1261
1262 return 0;
1263}
1264
1265static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1266{
1267 strcpy(info->driver, DRV_NAME);
1268 strcpy(info->version, DRV_VERSION);
1269}
1270
1271static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1272{
1273 struct el3_private *lp = netdev_priv(dev);
1274 int ret;
1275
1276 spin_lock_irq(&lp->lock);
1277 ret = el3_netdev_get_ecmd(dev, ecmd);
1278 spin_unlock_irq(&lp->lock);
1279 return ret;
1280}
1281
1282static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1283{
1284 struct el3_private *lp = netdev_priv(dev);
1285 int ret;
1286
1287 spin_lock_irq(&lp->lock);
1288 ret = el3_netdev_set_ecmd(dev, ecmd);
1289 spin_unlock_irq(&lp->lock);
1290 return ret;
1291}
1292
1293static u32 el3_get_link(struct net_device *dev)
1294{
1295 struct el3_private *lp = netdev_priv(dev);
1296 u32 ret;
1297
1298 spin_lock_irq(&lp->lock);
1299 ret = el3_link_ok(dev);
1300 spin_unlock_irq(&lp->lock);
1301 return ret;
1302}
1303
1304static u32 el3_get_msglevel(struct net_device *dev)
1305{
1306 return el3_debug;
1307}
1308
1309static void el3_set_msglevel(struct net_device *dev, u32 v)
1310{
1311 el3_debug = v;
1312}
1313
Jeff Garzik7282d492006-09-13 14:30:00 -04001314static const struct ethtool_ops ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 .get_drvinfo = el3_get_drvinfo,
1316 .get_settings = el3_get_settings,
1317 .set_settings = el3_set_settings,
1318 .get_link = el3_get_link,
1319 .get_msglevel = el3_get_msglevel,
1320 .set_msglevel = el3_set_msglevel,
1321};
1322
1323static void
1324el3_down(struct net_device *dev)
1325{
1326 int ioaddr = dev->base_addr;
1327
1328 netif_stop_queue(dev);
1329
1330 /* Turn off statistics ASAP. We update lp->stats below. */
1331 outw(StatsDisable, ioaddr + EL3_CMD);
1332
1333 /* Disable the receiver and transmitter. */
1334 outw(RxDisable, ioaddr + EL3_CMD);
1335 outw(TxDisable, ioaddr + EL3_CMD);
1336
1337 if (dev->if_port == 3)
1338 /* Turn off thinnet power. Green! */
1339 outw(StopCoax, ioaddr + EL3_CMD);
1340 else if (dev->if_port == 0) {
1341 /* Disable link beat and jabber, if_port may change here next open(). */
1342 EL3WINDOW(4);
1343 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1344 }
1345
1346 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1347
1348 update_stats(dev);
1349}
1350
1351static void
1352el3_up(struct net_device *dev)
1353{
1354 int i, sw_info, net_diag;
1355 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001356
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 /* Activating the board required and does no harm otherwise */
1358 outw(0x0001, ioaddr + 4);
1359
1360 /* Set the IRQ line. */
1361 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1362
1363 /* Set the station address in window 2 each time opened. */
1364 EL3WINDOW(2);
1365
1366 for (i = 0; i < 6; i++)
1367 outb(dev->dev_addr[i], ioaddr + i);
1368
1369 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1370 /* Start the thinnet transceiver. We should really wait 50ms...*/
1371 outw(StartCoax, ioaddr + EL3_CMD);
1372 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1373 /* Combine secondary sw_info word (the adapter level) and primary
1374 sw_info word (duplex setting plus other useless bits) */
1375 EL3WINDOW(0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001376 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1378
1379 EL3WINDOW(4);
1380 net_diag = inw(ioaddr + WN4_NETDIAG);
1381 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1382 printk("%s: ", dev->name);
1383 switch (dev->if_port & 0x0c) {
1384 case 12:
1385 /* force full-duplex mode if 3c5x9b */
1386 if (sw_info & 0x000f) {
1387 printk("Forcing 3c5x9b full-duplex mode");
1388 break;
1389 }
1390 case 8:
1391 /* set full-duplex mode based on eeprom config setting */
1392 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1393 printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1394 break;
1395 }
1396 default:
1397 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1398 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1399 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1400 }
1401
1402 outw(net_diag, ioaddr + WN4_NETDIAG);
1403 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1404 if (el3_debug > 3)
1405 printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1406 /* Enable link beat and jabber check. */
1407 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1408 }
1409
1410 /* Switch to the stats window, and clear all stats by reading. */
1411 outw(StatsDisable, ioaddr + EL3_CMD);
1412 EL3WINDOW(6);
1413 for (i = 0; i < 9; i++)
1414 inb(ioaddr + i);
1415 inw(ioaddr + 10);
1416 inw(ioaddr + 12);
1417
1418 /* Switch to register set 1 for normal use. */
1419 EL3WINDOW(1);
1420
1421 /* Accept b-case and phys addr only. */
1422 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1423 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1424
1425 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1426 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1427 /* Allow status bits to be seen. */
1428 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1429 /* Ack all pending events, and set active indicator mask. */
1430 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1431 ioaddr + EL3_CMD);
1432 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1433 ioaddr + EL3_CMD);
1434
1435 netif_start_queue(dev);
1436}
1437
1438/* Power Management support functions */
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001439#ifdef CONFIG_PM
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440
1441static int
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001442el3_suspend(struct device *pdev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443{
1444 unsigned long flags;
1445 struct net_device *dev;
1446 struct el3_private *lp;
1447 int ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001448
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001449 dev = pdev->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 lp = netdev_priv(dev);
1451 ioaddr = dev->base_addr;
1452
1453 spin_lock_irqsave(&lp->lock, flags);
1454
1455 if (netif_running(dev))
1456 netif_device_detach(dev);
1457
1458 el3_down(dev);
1459 outw(PowerDown, ioaddr + EL3_CMD);
1460
1461 spin_unlock_irqrestore(&lp->lock, flags);
1462 return 0;
1463}
1464
1465static int
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001466el3_resume(struct device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467{
1468 unsigned long flags;
1469 struct net_device *dev;
1470 struct el3_private *lp;
1471 int ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001472
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001473 dev = pdev->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 lp = netdev_priv(dev);
1475 ioaddr = dev->base_addr;
1476
1477 spin_lock_irqsave(&lp->lock, flags);
1478
1479 outw(PowerUp, ioaddr + EL3_CMD);
1480 el3_up(dev);
1481
1482 if (netif_running(dev))
1483 netif_device_attach(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001484
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 spin_unlock_irqrestore(&lp->lock, flags);
1486 return 0;
1487}
1488
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001489#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490
1491module_param(debug,int, 0);
1492module_param_array(irq, int, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493module_param(max_interrupt_work, int, 0);
1494MODULE_PARM_DESC(debug, "debug level (0-6)");
1495MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001497#ifdef CONFIG_PNP
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498module_param(nopnp, int, 0);
1499MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001500#endif /* CONFIG_PNP */
1501MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502MODULE_LICENSE("GPL");
1503
1504static int __init el3_init_module(void)
1505{
Andrew Morton0992a5d2006-03-08 00:06:27 -08001506 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507
1508 if (debug >= 0)
1509 el3_debug = debug;
1510
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001511#ifdef CONFIG_PNP
1512 if (!nopnp) {
1513 ret = pnp_register_driver(&el3_pnp_driver);
1514 if (!ret)
1515 pnp_registered = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 }
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001517#endif
1518 /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1519 /* Start with 0x110 to avoid some sound cards.*/
1520 for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1521 if (!request_region(id_port, 1, "3c509-control"))
1522 continue;
1523 outb(0x00, id_port);
1524 outb(0xff, id_port);
1525 if (inb(id_port) & 0x01)
1526 break;
1527 else
1528 release_region(id_port, 1);
1529 }
1530 if (id_port >= 0x200) {
1531 id_port = 0;
1532 printk(KERN_ERR "No I/O port available for 3c509 activation.\n");
1533 } else {
1534 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1535 if (!ret)
1536 isa_registered = 1;
1537 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538#ifdef CONFIG_EISA
Andrew Morton0992a5d2006-03-08 00:06:27 -08001539 ret = eisa_driver_register(&el3_eisa_driver);
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001540 if (!ret)
1541 eisa_registered = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542#endif
1543#ifdef CONFIG_MCA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001544 ret = mca_register_driver(&el3_mca_driver);
1545 if (!ret)
1546 mca_registered = 1;
1547#endif
1548
1549#ifdef CONFIG_PNP
1550 if (pnp_registered)
1551 ret = 0;
1552#endif
1553 if (isa_registered)
1554 ret = 0;
1555#ifdef CONFIG_EISA
1556 if (eisa_registered)
1557 ret = 0;
1558#endif
1559#ifdef CONFIG_MCA
1560 if (mca_registered)
1561 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562#endif
Andrew Morton0992a5d2006-03-08 00:06:27 -08001563 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564}
1565
1566static void __exit el3_cleanup_module(void)
1567{
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001568#ifdef CONFIG_PNP
1569 if (pnp_registered)
1570 pnp_unregister_driver(&el3_pnp_driver);
1571#endif
1572 if (isa_registered)
1573 isa_unregister_driver(&el3_isa_driver);
1574 if (id_port)
1575 release_region(id_port, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576#ifdef CONFIG_EISA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001577 if (eisa_registered)
1578 eisa_driver_unregister(&el3_eisa_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579#endif
1580#ifdef CONFIG_MCA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001581 if (mca_registered)
1582 mca_unregister_driver(&el3_mca_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583#endif
1584}
1585
1586module_init (el3_init_module);
1587module_exit (el3_cleanup_module);