blob: d2137efbd455601295cf01cf0eeaf395c3ee0d13 [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)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000260 pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700261 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[] = {
Maciej W. Rozyckicf9f6e22009-06-01 03:12:04 -0700483 { "TCM5090" },
484 { "TCM5091" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 { "TCM5092" },
486 { "TCM5093" },
Maciej W. Rozyckicf9f6e22009-06-01 03:12:04 -0700487 { "TCM5094" },
Adrian Bunkf04e3f02005-05-16 21:13:03 +0200488 { "TCM5095" },
Maciej W. Rozyckicf9f6e22009-06-01 03:12:04 -0700489 { "TCM5098" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 { "" }
491};
Michael Tokarev07563c72006-09-27 01:50:56 -0700492MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
494static int el3_eisa_probe (struct device *device);
495
496static struct eisa_driver el3_eisa_driver = {
497 .id_table = el3_eisa_ids,
498 .driver = {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700499 .name = "3c579",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 .probe = el3_eisa_probe,
Pekka Enberg60a89ff2006-03-08 00:06:28 -0800501 .remove = __devexit_p (el3_device_remove),
502 .suspend = el3_suspend,
503 .resume = el3_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 }
505};
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700506static int eisa_registered;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507#endif
508
509#ifdef CONFIG_MCA
510static int el3_mca_probe(struct device *dev);
511
512static short el3_mca_adapter_ids[] __initdata = {
513 0x627c,
514 0x627d,
515 0x62db,
516 0x62f6,
517 0x62f7,
518 0x0000
519};
520
521static char *el3_mca_adapter_names[] __initdata = {
522 "3Com 3c529 EtherLink III (10base2)",
523 "3Com 3c529 EtherLink III (10baseT)",
524 "3Com 3c529 EtherLink III (test mode)",
525 "3Com 3c529 EtherLink III (TP or coax)",
526 "3Com 3c529 EtherLink III (TP)",
527 NULL
528};
529
530static struct mca_driver el3_mca_driver = {
531 .id_table = el3_mca_adapter_ids,
532 .driver = {
533 .name = "3c529",
534 .bus = &mca_bus_type,
535 .probe = el3_mca_probe,
536 .remove = __devexit_p(el3_device_remove),
Pekka Enberg60a89ff2006-03-08 00:06:28 -0800537 .suspend = el3_suspend,
538 .resume = el3_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 },
540};
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700541static int mca_registered;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542#endif /* CONFIG_MCA */
543
Stephen Hemminger3186ae82009-01-09 13:01:14 +0000544static const struct net_device_ops netdev_ops = {
545 .ndo_open = el3_open,
546 .ndo_stop = el3_close,
547 .ndo_start_xmit = el3_start_xmit,
548 .ndo_get_stats = el3_get_stats,
549 .ndo_set_multicast_list = set_multicast_list,
550 .ndo_tx_timeout = el3_tx_timeout,
551 .ndo_change_mtu = eth_change_mtu,
552 .ndo_set_mac_address = eth_mac_addr,
553 .ndo_validate_addr = eth_validate_addr,
554#ifdef CONFIG_NET_POLL_CONTROLLER
555 .ndo_poll_controller = el3_poll_controller,
556#endif
557};
558
Al Viro37b2a172008-11-01 18:20:19 +0000559static int __devinit el3_common_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
561 struct el3_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 int err;
Joe Perches0795af52007-10-03 17:59:30 -0700563 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
565 spin_lock_init(&lp->lock);
566
567 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
568 dev->if_port = (dev->mem_start & 0x0f);
569 } else { /* xcvr codes 0/8 */
570 /* use eeprom value, but save user's full-duplex selection */
571 dev->if_port |= (dev->mem_start & 0x08);
572 }
573
574 /* The EL3-specific entries in the device structure. */
Stephen Hemminger3186ae82009-01-09 13:01:14 +0000575 dev->netdev_ops = &netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 dev->watchdog_timeo = TX_TIMEOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 SET_ETHTOOL_OPS(dev, &ethtool_ops);
578
579 err = register_netdev(dev);
580 if (err) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000581 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 dev->base_addr, dev->irq);
583 release_region(dev->base_addr, EL3_IO_EXTENT);
584 return err;
585 }
586
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000587 pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
Joe Perches0795af52007-10-03 17:59:30 -0700588 dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
Johannes Berge1749612008-10-27 15:59:26 -0700589 dev->dev_addr, dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
591 if (el3_debug > 0)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000592 pr_info("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 return 0;
594
595}
596
597static void el3_common_remove (struct net_device *dev)
598{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 unregister_netdev (dev);
600 release_region(dev->base_addr, EL3_IO_EXTENT);
601 free_netdev (dev);
602}
603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604#ifdef CONFIG_MCA
605static int __init el3_mca_probe(struct device *device)
606{
607 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
608 * heavily modified by Chris Beauregard
609 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
610 * probing.
611 *
612 * redone for multi-card detection by ZP Gu (zpg@castle.net)
613 * now works as a module */
614
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 short i;
616 int ioaddr, irq, if_port;
Al Viro4ec7ffa2008-05-21 06:32:11 +0100617 __be16 phys_addr[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 struct net_device *dev = NULL;
619 u_char pos4, pos5;
620 struct mca_device *mdev = to_mca_device(device);
621 int slot = mdev->slot;
622 int err;
623
624 pos4 = mca_device_read_stored_pos(mdev, 4);
625 pos5 = mca_device_read_stored_pos(mdev, 5);
626
627 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
628 irq = pos5 & 0x0f;
629
630
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000631 pr_info("3c529: found %s at slot %d\n",
632 el3_mca_adapter_names[mdev->index], slot + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
634 /* claim the slot */
635 strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
636 sizeof(mdev->name));
637 mca_device_set_claim(mdev, 1);
638
639 if_port = pos4 & 0x03;
640
641 irq = mca_device_transform_irq(mdev, irq);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400642 ioaddr = mca_device_transform_ioport(mdev, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 if (el3_debug > 2) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000644 pr_debug("3c529: irq %d ioaddr 0x%x ifport %d\n", irq, ioaddr, if_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 }
646 EL3WINDOW(0);
Al Viro4ec7ffa2008-05-21 06:32:11 +0100647 for (i = 0; i < 3; i++)
648 phys_addr[i] = htons(read_eeprom(ioaddr, i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
650 dev = alloc_etherdev(sizeof (struct el3_private));
651 if (dev == NULL) {
Al Viro4ec7ffa2008-05-21 06:32:11 +0100652 release_region(ioaddr, EL3_IO_EXTENT);
653 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 }
655
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 netdev_boot_setup_check(dev);
657
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700658 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_MCA);
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +0000659 dev_set_drvdata(device, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 err = el3_common_init(dev);
661
662 if (err) {
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +0000663 dev_set_drvdata(device, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 free_netdev(dev);
665 return -ENOMEM;
666 }
667
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700668 el3_devs[el3_cards++] = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 return 0;
670}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400671
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672#endif /* CONFIG_MCA */
673
674#ifdef CONFIG_EISA
675static int __init el3_eisa_probe (struct device *device)
676{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 short i;
678 int ioaddr, irq, if_port;
Al Viro4ec7ffa2008-05-21 06:32:11 +0100679 __be16 phys_addr[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 struct net_device *dev = NULL;
681 struct eisa_device *edev;
682 int err;
683
684 /* Yeepee, The driver framework is calling us ! */
685 edev = to_eisa_device (device);
686 ioaddr = edev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400687
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700688 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 return -EBUSY;
690
691 /* Change the register set to the configuration window 0. */
692 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
693
694 irq = inw(ioaddr + WN0_IRQ) >> 12;
695 if_port = inw(ioaddr + 6)>>14;
696 for (i = 0; i < 3; i++)
697 phys_addr[i] = htons(read_eeprom(ioaddr, i));
698
699 /* Restore the "Product ID" to the EEPROM read register. */
700 read_eeprom(ioaddr, 3);
701
702 dev = alloc_etherdev(sizeof (struct el3_private));
703 if (dev == NULL) {
704 release_region(ioaddr, EL3_IO_EXTENT);
705 return -ENOMEM;
706 }
707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 netdev_boot_setup_check(dev);
709
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700710 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 eisa_set_drvdata (edev, dev);
712 err = el3_common_init(dev);
713
714 if (err) {
715 eisa_set_drvdata (edev, NULL);
716 free_netdev(dev);
717 return err;
718 }
719
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700720 el3_devs[el3_cards++] = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 return 0;
722}
723#endif
724
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725/* This remove works for all device types.
726 *
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +0000727 * The net dev must be stored in the driver data field */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728static int __devexit el3_device_remove (struct device *device)
729{
730 struct net_device *dev;
731
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +0000732 dev = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
734 el3_common_remove (dev);
735 return 0;
736}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
738/* Read a word from the EEPROM using the regular EEPROM access register.
739 Assume that we are in register window zero.
740 */
741static ushort read_eeprom(int ioaddr, int index)
742{
743 outw(EEPROM_READ + index, ioaddr + 10);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400744 /* Pause for at least 162 us. for the read to take place.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 Some chips seem to require much longer */
746 mdelay(2);
747 return inw(ioaddr + 12);
748}
749
750/* Read a word from the EEPROM when in the ISA ID probe state. */
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700751static ushort id_read_eeprom(int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752{
753 int bit, word = 0;
754
755 /* Issue read command, and pause for at least 162 us. for it to complete.
756 Assume extra-fast 16Mhz bus. */
757 outb(EEPROM_READ + index, id_port);
758
759 /* Pause for at least 162 us. for the read to take place. */
760 /* Some chips seem to require much longer */
761 mdelay(4);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 for (bit = 15; bit >= 0; bit--)
764 word = (word << 1) + (inb(id_port) & 0x01);
765
766 if (el3_debug > 3)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000767 pr_debug(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
769 return word;
770}
771
772
773static int
774el3_open(struct net_device *dev)
775{
776 int ioaddr = dev->base_addr;
777 int i;
778
779 outw(TxReset, ioaddr + EL3_CMD);
780 outw(RxReset, ioaddr + EL3_CMD);
781 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
782
783 i = request_irq(dev->irq, &el3_interrupt, 0, dev->name, dev);
784 if (i)
785 return i;
786
787 EL3WINDOW(0);
788 if (el3_debug > 3)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000789 pr_debug("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
791
792 el3_up(dev);
793
794 if (el3_debug > 3)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000795 pr_debug("%s: Opened 3c509 IRQ %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
797
798 return 0;
799}
800
801static void
802el3_tx_timeout (struct net_device *dev)
803{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 int ioaddr = dev->base_addr;
805
806 /* Transmitter timeout, serious problems. */
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000807 pr_warning("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
809 inw(ioaddr + TX_FREE));
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300810 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 dev->trans_start = jiffies;
812 /* Issue TX_RESET and TX_START commands. */
813 outw(TxReset, ioaddr + EL3_CMD);
814 outw(TxEnable, ioaddr + EL3_CMD);
815 netif_wake_queue(dev);
816}
817
818
819static int
820el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
821{
822 struct el3_private *lp = netdev_priv(dev);
823 int ioaddr = dev->base_addr;
824 unsigned long flags;
825
826 netif_stop_queue (dev);
827
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300828 dev->stats.tx_bytes += skb->len;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400829
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 if (el3_debug > 4) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000831 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
833 }
834#if 0
835#ifndef final_version
836 { /* Error-checking code, delete someday. */
837 ushort status = inw(ioaddr + EL3_STATUS);
838 if (status & 0x0001 /* IRQ line active, missed one. */
839 && inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000840 pr_debug("%s: Missed interrupt, status then %04x now %04x"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
842 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
843 inw(ioaddr + RX_STATUS));
844 /* Fake interrupt trigger by masking, acknowledge interrupts. */
845 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
846 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
847 ioaddr + EL3_CMD);
848 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
849 }
850 }
851#endif
852#endif
853 /*
854 * We lock the driver against other processors. Note
855 * we don't need to lock versus the IRQ as we suspended
856 * that. This means that we lose the ability to take
857 * an RX during a TX upload. That sucks a bit with SMP
858 * on an original 3c509 (2K buffer)
859 *
860 * Using disable_irq stops us crapping on other
861 * time sensitive devices.
862 */
863
864 spin_lock_irqsave(&lp->lock, flags);
865
866 /* Put out the doubleword header... */
867 outw(skb->len, ioaddr + TX_FIFO);
868 outw(0x00, ioaddr + TX_FIFO);
869 /* ... and the packet rounded to a doubleword. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
872 dev->trans_start = jiffies;
873 if (inw(ioaddr + TX_FREE) > 1536)
874 netif_start_queue(dev);
875 else
876 /* Interrupt us when the FIFO has room for max-sized packet. */
877 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
878
879 spin_unlock_irqrestore(&lp->lock, flags);
880
881 dev_kfree_skb (skb);
882
883 /* Clear the Tx status stack. */
884 {
885 short tx_status;
886 int i = 4;
887
888 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300889 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
891 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
892 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
893 }
894 }
895 return 0;
896}
897
898/* The EL3 interrupt handler. */
899static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +0100900el3_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901{
Jeff Garzikc31f28e2006-10-06 14:56:04 -0400902 struct net_device *dev = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 struct el3_private *lp;
904 int ioaddr, status;
905 int i = max_interrupt_work;
906
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 lp = netdev_priv(dev);
908 spin_lock(&lp->lock);
909
910 ioaddr = dev->base_addr;
911
912 if (el3_debug > 4) {
913 status = inw(ioaddr + EL3_STATUS);
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000914 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 }
916
917 while ((status = inw(ioaddr + EL3_STATUS)) &
918 (IntLatch | RxComplete | StatsFull)) {
919
920 if (status & RxComplete)
921 el3_rx(dev);
922
923 if (status & TxAvailable) {
924 if (el3_debug > 5)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000925 pr_debug(" TX room bit was handled.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 /* There's room in the FIFO for a full-sized packet. */
927 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
928 netif_wake_queue (dev);
929 }
930 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
931 /* Handle all uncommon interrupts. */
932 if (status & StatsFull) /* Empty statistics. */
933 update_stats(dev);
934 if (status & RxEarly) { /* Rx early is unused. */
935 el3_rx(dev);
936 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
937 }
938 if (status & TxComplete) { /* Really Tx error. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 short tx_status;
940 int i = 4;
941
942 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300943 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
945 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
946 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
947 }
948 }
949 if (status & AdapterFailure) {
950 /* Adapter failure requires Rx reset and reinit. */
951 outw(RxReset, ioaddr + EL3_CMD);
952 /* Set the Rx filter to the current state. */
953 outw(SetRxFilter | RxStation | RxBroadcast
954 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
955 | (dev->flags & IFF_PROMISC ? RxProm : 0),
956 ioaddr + EL3_CMD);
957 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
958 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
959 }
960 }
961
962 if (--i < 0) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000963 pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 dev->name, status);
965 /* Clear all interrupts. */
966 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
967 break;
968 }
969 /* Acknowledge the IRQ. */
970 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
971 }
972
973 if (el3_debug > 4) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000974 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 inw(ioaddr + EL3_STATUS));
976 }
977 spin_unlock(&lp->lock);
978 return IRQ_HANDLED;
979}
980
981
982#ifdef CONFIG_NET_POLL_CONTROLLER
983/*
984 * Polling receive - used by netconsole and other diagnostic tools
985 * to allow network i/o with interrupts disabled.
986 */
987static void el3_poll_controller(struct net_device *dev)
988{
989 disable_irq(dev->irq);
David Howells7d12e782006-10-05 14:55:46 +0100990 el3_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 enable_irq(dev->irq);
992}
993#endif
994
995static struct net_device_stats *
996el3_get_stats(struct net_device *dev)
997{
998 struct el3_private *lp = netdev_priv(dev);
999 unsigned long flags;
1000
1001 /*
1002 * This is fast enough not to bother with disable IRQ
1003 * stuff.
1004 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001005
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 spin_lock_irqsave(&lp->lock, flags);
1007 update_stats(dev);
1008 spin_unlock_irqrestore(&lp->lock, flags);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001009 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010}
1011
1012/* Update statistics. We change to register window 6, so this should be run
1013 single-threaded if the device is active. This is expected to be a rare
1014 operation, and it's simpler for the rest of the driver to assume that
1015 window 1 is always valid rather than use a special window-state variable.
1016 */
1017static void update_stats(struct net_device *dev)
1018{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 int ioaddr = dev->base_addr;
1020
1021 if (el3_debug > 5)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001022 pr_debug(" Updating the statistics.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 /* Turn off statistics updates while reading. */
1024 outw(StatsDisable, ioaddr + EL3_CMD);
1025 /* Switch to the stats window, and read everything. */
1026 EL3WINDOW(6);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001027 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1028 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 /* Multiple collisions. */ inb(ioaddr + 2);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001030 dev->stats.collisions += inb(ioaddr + 3);
1031 dev->stats.tx_window_errors += inb(ioaddr + 4);
1032 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1033 dev->stats.tx_packets += inb(ioaddr + 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 /* Rx packets */ inb(ioaddr + 7);
1035 /* Tx deferrals */ inb(ioaddr + 8);
1036 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1037 inw(ioaddr + 12);
1038
1039 /* Back to window 1, and turn statistics back on. */
1040 EL3WINDOW(1);
1041 outw(StatsEnable, ioaddr + EL3_CMD);
1042 return;
1043}
1044
1045static int
1046el3_rx(struct net_device *dev)
1047{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 int ioaddr = dev->base_addr;
1049 short rx_status;
1050
1051 if (el3_debug > 5)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001052 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1054 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1055 if (rx_status & 0x4000) { /* Error, update stats. */
1056 short error = rx_status & 0x3800;
1057
1058 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001059 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 switch (error) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001061 case 0x0000: dev->stats.rx_over_errors++; break;
1062 case 0x0800: dev->stats.rx_length_errors++; break;
1063 case 0x1000: dev->stats.rx_frame_errors++; break;
1064 case 0x1800: dev->stats.rx_length_errors++; break;
1065 case 0x2000: dev->stats.rx_frame_errors++; break;
1066 case 0x2800: dev->stats.rx_crc_errors++; break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 }
1068 } else {
1069 short pkt_len = rx_status & 0x7ff;
1070 struct sk_buff *skb;
1071
1072 skb = dev_alloc_skb(pkt_len+5);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 if (el3_debug > 4)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001074 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 pkt_len, rx_status);
1076 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 skb_reserve(skb, 2); /* Align IP on 16 byte */
1078
1079 /* 'skb->data' points to the start of sk_buff data area. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1081 (pkt_len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082
1083 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1084 skb->protocol = eth_type_trans(skb,dev);
1085 netif_rx(skb);
Wang Chenf7f312a2008-05-20 17:13:52 +08001086 dev->stats.rx_bytes += pkt_len;
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001087 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 continue;
1089 }
1090 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001091 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 if (el3_debug)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001093 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 dev->name, pkt_len);
1095 }
1096 inw(ioaddr + EL3_STATUS); /* Delay. */
1097 while (inw(ioaddr + EL3_STATUS) & 0x1000)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001098 pr_debug(" Waiting for 3c509 to discard packet, status %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 inw(ioaddr + EL3_STATUS) );
1100 }
1101
1102 return 0;
1103}
1104
1105/*
1106 * Set or clear the multicast filter for this adaptor.
1107 */
1108static void
1109set_multicast_list(struct net_device *dev)
1110{
1111 unsigned long flags;
1112 struct el3_private *lp = netdev_priv(dev);
1113 int ioaddr = dev->base_addr;
1114
1115 if (el3_debug > 1) {
1116 static int old;
1117 if (old != dev->mc_count) {
1118 old = dev->mc_count;
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001119 pr_debug("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 }
1121 }
1122 spin_lock_irqsave(&lp->lock, flags);
1123 if (dev->flags&IFF_PROMISC) {
1124 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1125 ioaddr + EL3_CMD);
1126 }
1127 else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1128 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1129 }
1130 else
1131 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1132 spin_unlock_irqrestore(&lp->lock, flags);
1133}
1134
1135static int
1136el3_close(struct net_device *dev)
1137{
1138 int ioaddr = dev->base_addr;
1139 struct el3_private *lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001140
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 if (el3_debug > 2)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001142 pr_debug("%s: Shutting down ethercard.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
1144 el3_down(dev);
1145
1146 free_irq(dev->irq, dev);
1147 /* Switching back to window 0 disables the IRQ. */
1148 EL3WINDOW(0);
1149 if (lp->type != EL3_EISA) {
1150 /* But we explicitly zero the IRQ line select anyway. Don't do
1151 * it on EISA cards, it prevents the module from getting an
1152 * IRQ after unload+reload... */
1153 outw(0x0f00, ioaddr + WN0_IRQ);
1154 }
1155
1156 return 0;
1157}
1158
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001159static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160el3_link_ok(struct net_device *dev)
1161{
1162 int ioaddr = dev->base_addr;
1163 u16 tmp;
1164
1165 EL3WINDOW(4);
1166 tmp = inw(ioaddr + WN4_MEDIA);
1167 EL3WINDOW(1);
1168 return tmp & (1<<11);
1169}
1170
1171static int
1172el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1173{
1174 u16 tmp;
1175 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001176
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 EL3WINDOW(0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001178 /* obtain current transceiver via WN4_MEDIA? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 tmp = inw(ioaddr + WN0_ADDR_CONF);
1180 ecmd->transceiver = XCVR_INTERNAL;
1181 switch (tmp >> 14) {
1182 case 0:
1183 ecmd->port = PORT_TP;
1184 break;
1185 case 1:
1186 ecmd->port = PORT_AUI;
1187 ecmd->transceiver = XCVR_EXTERNAL;
1188 break;
1189 case 3:
1190 ecmd->port = PORT_BNC;
1191 default:
1192 break;
1193 }
1194
1195 ecmd->duplex = DUPLEX_HALF;
1196 ecmd->supported = 0;
1197 tmp = inw(ioaddr + WN0_CONF_CTRL);
1198 if (tmp & (1<<13))
1199 ecmd->supported |= SUPPORTED_AUI;
1200 if (tmp & (1<<12))
1201 ecmd->supported |= SUPPORTED_BNC;
1202 if (tmp & (1<<9)) {
1203 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1204 SUPPORTED_10baseT_Full; /* hmm... */
1205 EL3WINDOW(4);
1206 tmp = inw(ioaddr + WN4_NETDIAG);
1207 if (tmp & FD_ENABLE)
1208 ecmd->duplex = DUPLEX_FULL;
1209 }
1210
1211 ecmd->speed = SPEED_10;
1212 EL3WINDOW(1);
1213 return 0;
1214}
1215
1216static int
1217el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1218{
1219 u16 tmp;
1220 int ioaddr = dev->base_addr;
1221
1222 if (ecmd->speed != SPEED_10)
1223 return -EINVAL;
1224 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1225 return -EINVAL;
1226 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1227 return -EINVAL;
1228
1229 /* change XCVR type */
1230 EL3WINDOW(0);
1231 tmp = inw(ioaddr + WN0_ADDR_CONF);
1232 switch (ecmd->port) {
1233 case PORT_TP:
1234 tmp &= ~(3<<14);
1235 dev->if_port = 0;
1236 break;
1237 case PORT_AUI:
1238 tmp |= (1<<14);
1239 dev->if_port = 1;
1240 break;
1241 case PORT_BNC:
1242 tmp |= (3<<14);
1243 dev->if_port = 3;
1244 break;
1245 default:
1246 return -EINVAL;
1247 }
1248
1249 outw(tmp, ioaddr + WN0_ADDR_CONF);
1250 if (dev->if_port == 3) {
1251 /* fire up the DC-DC convertor if BNC gets enabled */
1252 tmp = inw(ioaddr + WN0_ADDR_CONF);
1253 if (tmp & (3 << 14)) {
1254 outw(StartCoax, ioaddr + EL3_CMD);
1255 udelay(800);
1256 } else
1257 return -EIO;
1258 }
1259
1260 EL3WINDOW(4);
1261 tmp = inw(ioaddr + WN4_NETDIAG);
1262 if (ecmd->duplex == DUPLEX_FULL)
1263 tmp |= FD_ENABLE;
1264 else
1265 tmp &= ~FD_ENABLE;
1266 outw(tmp, ioaddr + WN4_NETDIAG);
1267 EL3WINDOW(1);
1268
1269 return 0;
1270}
1271
1272static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1273{
1274 strcpy(info->driver, DRV_NAME);
1275 strcpy(info->version, DRV_VERSION);
1276}
1277
1278static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1279{
1280 struct el3_private *lp = netdev_priv(dev);
1281 int ret;
1282
1283 spin_lock_irq(&lp->lock);
1284 ret = el3_netdev_get_ecmd(dev, ecmd);
1285 spin_unlock_irq(&lp->lock);
1286 return ret;
1287}
1288
1289static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1290{
1291 struct el3_private *lp = netdev_priv(dev);
1292 int ret;
1293
1294 spin_lock_irq(&lp->lock);
1295 ret = el3_netdev_set_ecmd(dev, ecmd);
1296 spin_unlock_irq(&lp->lock);
1297 return ret;
1298}
1299
1300static u32 el3_get_link(struct net_device *dev)
1301{
1302 struct el3_private *lp = netdev_priv(dev);
1303 u32 ret;
1304
1305 spin_lock_irq(&lp->lock);
1306 ret = el3_link_ok(dev);
1307 spin_unlock_irq(&lp->lock);
1308 return ret;
1309}
1310
1311static u32 el3_get_msglevel(struct net_device *dev)
1312{
1313 return el3_debug;
1314}
1315
1316static void el3_set_msglevel(struct net_device *dev, u32 v)
1317{
1318 el3_debug = v;
1319}
1320
Jeff Garzik7282d492006-09-13 14:30:00 -04001321static const struct ethtool_ops ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 .get_drvinfo = el3_get_drvinfo,
1323 .get_settings = el3_get_settings,
1324 .set_settings = el3_set_settings,
1325 .get_link = el3_get_link,
1326 .get_msglevel = el3_get_msglevel,
1327 .set_msglevel = el3_set_msglevel,
1328};
1329
1330static void
1331el3_down(struct net_device *dev)
1332{
1333 int ioaddr = dev->base_addr;
1334
1335 netif_stop_queue(dev);
1336
1337 /* Turn off statistics ASAP. We update lp->stats below. */
1338 outw(StatsDisable, ioaddr + EL3_CMD);
1339
1340 /* Disable the receiver and transmitter. */
1341 outw(RxDisable, ioaddr + EL3_CMD);
1342 outw(TxDisable, ioaddr + EL3_CMD);
1343
1344 if (dev->if_port == 3)
1345 /* Turn off thinnet power. Green! */
1346 outw(StopCoax, ioaddr + EL3_CMD);
1347 else if (dev->if_port == 0) {
1348 /* Disable link beat and jabber, if_port may change here next open(). */
1349 EL3WINDOW(4);
1350 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1351 }
1352
1353 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1354
1355 update_stats(dev);
1356}
1357
1358static void
1359el3_up(struct net_device *dev)
1360{
1361 int i, sw_info, net_diag;
1362 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001363
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 /* Activating the board required and does no harm otherwise */
1365 outw(0x0001, ioaddr + 4);
1366
1367 /* Set the IRQ line. */
1368 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1369
1370 /* Set the station address in window 2 each time opened. */
1371 EL3WINDOW(2);
1372
1373 for (i = 0; i < 6; i++)
1374 outb(dev->dev_addr[i], ioaddr + i);
1375
1376 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1377 /* Start the thinnet transceiver. We should really wait 50ms...*/
1378 outw(StartCoax, ioaddr + EL3_CMD);
1379 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1380 /* Combine secondary sw_info word (the adapter level) and primary
1381 sw_info word (duplex setting plus other useless bits) */
1382 EL3WINDOW(0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001383 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1385
1386 EL3WINDOW(4);
1387 net_diag = inw(ioaddr + WN4_NETDIAG);
1388 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001389 pr_info("%s: ", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 switch (dev->if_port & 0x0c) {
1391 case 12:
1392 /* force full-duplex mode if 3c5x9b */
1393 if (sw_info & 0x000f) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001394 pr_cont("Forcing 3c5x9b full-duplex mode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 break;
1396 }
1397 case 8:
1398 /* set full-duplex mode based on eeprom config setting */
1399 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001400 pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 break;
1402 }
1403 default:
1404 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001405 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1407 }
1408
1409 outw(net_diag, ioaddr + WN4_NETDIAG);
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001410 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 if (el3_debug > 3)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001412 pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 /* Enable link beat and jabber check. */
1414 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1415 }
1416
1417 /* Switch to the stats window, and clear all stats by reading. */
1418 outw(StatsDisable, ioaddr + EL3_CMD);
1419 EL3WINDOW(6);
1420 for (i = 0; i < 9; i++)
1421 inb(ioaddr + i);
1422 inw(ioaddr + 10);
1423 inw(ioaddr + 12);
1424
1425 /* Switch to register set 1 for normal use. */
1426 EL3WINDOW(1);
1427
1428 /* Accept b-case and phys addr only. */
1429 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1430 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1431
1432 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1433 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1434 /* Allow status bits to be seen. */
1435 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1436 /* Ack all pending events, and set active indicator mask. */
1437 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1438 ioaddr + EL3_CMD);
1439 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1440 ioaddr + EL3_CMD);
1441
1442 netif_start_queue(dev);
1443}
1444
1445/* Power Management support functions */
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001446#ifdef CONFIG_PM
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
1448static int
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001449el3_suspend(struct device *pdev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450{
1451 unsigned long flags;
1452 struct net_device *dev;
1453 struct el3_private *lp;
1454 int ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001455
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +00001456 dev = dev_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 lp = netdev_priv(dev);
1458 ioaddr = dev->base_addr;
1459
1460 spin_lock_irqsave(&lp->lock, flags);
1461
1462 if (netif_running(dev))
1463 netif_device_detach(dev);
1464
1465 el3_down(dev);
1466 outw(PowerDown, ioaddr + EL3_CMD);
1467
1468 spin_unlock_irqrestore(&lp->lock, flags);
1469 return 0;
1470}
1471
1472static int
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001473el3_resume(struct device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474{
1475 unsigned long flags;
1476 struct net_device *dev;
1477 struct el3_private *lp;
1478 int ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001479
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +00001480 dev = dev_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 lp = netdev_priv(dev);
1482 ioaddr = dev->base_addr;
1483
1484 spin_lock_irqsave(&lp->lock, flags);
1485
1486 outw(PowerUp, ioaddr + EL3_CMD);
Ondrej Zary152abd12009-02-06 22:04:08 -08001487 EL3WINDOW(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 el3_up(dev);
1489
1490 if (netif_running(dev))
1491 netif_device_attach(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001492
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 spin_unlock_irqrestore(&lp->lock, flags);
1494 return 0;
1495}
1496
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001497#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
1499module_param(debug,int, 0);
1500module_param_array(irq, int, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501module_param(max_interrupt_work, int, 0);
1502MODULE_PARM_DESC(debug, "debug level (0-6)");
1503MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001505#ifdef CONFIG_PNP
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506module_param(nopnp, int, 0);
1507MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001508#endif /* CONFIG_PNP */
1509MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510MODULE_LICENSE("GPL");
1511
1512static int __init el3_init_module(void)
1513{
Andrew Morton0992a5d2006-03-08 00:06:27 -08001514 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515
1516 if (debug >= 0)
1517 el3_debug = debug;
1518
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001519#ifdef CONFIG_PNP
1520 if (!nopnp) {
1521 ret = pnp_register_driver(&el3_pnp_driver);
1522 if (!ret)
1523 pnp_registered = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 }
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001525#endif
1526 /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1527 /* Start with 0x110 to avoid some sound cards.*/
1528 for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1529 if (!request_region(id_port, 1, "3c509-control"))
1530 continue;
1531 outb(0x00, id_port);
1532 outb(0xff, id_port);
1533 if (inb(id_port) & 0x01)
1534 break;
1535 else
1536 release_region(id_port, 1);
1537 }
1538 if (id_port >= 0x200) {
1539 id_port = 0;
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001540 pr_err("No I/O port available for 3c509 activation.\n");
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001541 } else {
1542 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1543 if (!ret)
1544 isa_registered = 1;
1545 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546#ifdef CONFIG_EISA
Andrew Morton0992a5d2006-03-08 00:06:27 -08001547 ret = eisa_driver_register(&el3_eisa_driver);
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001548 if (!ret)
1549 eisa_registered = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550#endif
1551#ifdef CONFIG_MCA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001552 ret = mca_register_driver(&el3_mca_driver);
1553 if (!ret)
1554 mca_registered = 1;
1555#endif
1556
1557#ifdef CONFIG_PNP
1558 if (pnp_registered)
1559 ret = 0;
1560#endif
1561 if (isa_registered)
1562 ret = 0;
1563#ifdef CONFIG_EISA
1564 if (eisa_registered)
1565 ret = 0;
1566#endif
1567#ifdef CONFIG_MCA
1568 if (mca_registered)
1569 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570#endif
Andrew Morton0992a5d2006-03-08 00:06:27 -08001571 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572}
1573
1574static void __exit el3_cleanup_module(void)
1575{
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001576#ifdef CONFIG_PNP
1577 if (pnp_registered)
1578 pnp_unregister_driver(&el3_pnp_driver);
1579#endif
1580 if (isa_registered)
1581 isa_unregister_driver(&el3_isa_driver);
1582 if (id_port)
1583 release_region(id_port, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584#ifdef CONFIG_EISA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001585 if (eisa_registered)
1586 eisa_driver_unregister(&el3_eisa_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587#endif
1588#ifdef CONFIG_MCA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001589 if (mca_registered)
1590 mca_unregister_driver(&el3_mca_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591#endif
1592}
1593
1594module_init (el3_init_module);
1595module_exit (el3_cleanup_module);