blob: 91abb965fb44e04c0b0160e69e135ebd735a200b [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070079#include <linux/ioport.h>
80#include <linux/init.h>
81#include <linux/netdevice.h>
82#include <linux/etherdevice.h>
83#include <linux/pm.h>
84#include <linux/skbuff.h>
85#include <linux/delay.h> /* for udelay() */
86#include <linux/spinlock.h>
87#include <linux/ethtool.h>
88#include <linux/device.h>
89#include <linux/eisa.h>
90#include <linux/bitops.h>
91
92#include <asm/uaccess.h>
93#include <asm/io.h>
94#include <asm/irq.h>
95
Al Viro37b2a172008-11-01 18:20:19 +000096static char version[] __devinitdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98#ifdef EL3_DEBUG
99static int el3_debug = EL3_DEBUG;
100#else
101static int el3_debug = 2;
102#endif
103
104/* Used to do a global count of all the cards in the system. Must be
105 * a global variable so that the mca/eisa probe routines can increment
106 * it */
107static int el3_cards = 0;
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700108#define EL3_MAX_CARDS 8
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110/* To minimize the size of the driver source I only define operating
111 constants if they are used several times. You'll need the manual
112 anyway if you want to understand driver details. */
113/* Offsets from base I/O address. */
114#define EL3_DATA 0x00
115#define EL3_CMD 0x0e
116#define EL3_STATUS 0x0e
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700117#define EEPROM_READ 0x80
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
119#define EL3_IO_EXTENT 16
120
121#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
122
123
124/* The top five bits written to EL3_CMD are a command, the lower
125 11 bits are the parameter, if applicable. */
126enum c509cmd {
127 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
128 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
129 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
130 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
131 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
132 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
133 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
134 PowerDown = 28<<11, PowerAuto = 29<<11};
135
136enum c509status {
137 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
138 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
139 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
140
141/* The SetRxFilter command accepts the following classes: */
142enum RxFilter {
143 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
144
145/* Register window 1 offsets, the window used in normal operation. */
146#define TX_FIFO 0x00
147#define RX_FIFO 0x00
148#define RX_STATUS 0x08
149#define TX_STATUS 0x0B
150#define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
151
152#define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
153#define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
154#define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
155#define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
156#define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
157#define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400158#define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
160/*
161 * Must be a power of two (we use a binary and in the
162 * circular queue)
163 */
164#define SKB_QUEUE_SIZE 64
165
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700166enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_MCA, EL3_EISA };
167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168struct el3_private {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 spinlock_t lock;
170 /* skb send-queue */
171 int head, size;
172 struct sk_buff *queue[SKB_QUEUE_SIZE];
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700173 enum el3_cardtype type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174};
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700175static int id_port;
176static int current_tag;
177static struct net_device *el3_devs[EL3_MAX_CARDS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700179/* Parameters that may be passed into the module. */
180static int debug = -1;
181static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
182/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
183static int max_interrupt_work = 10;
184#ifdef CONFIG_PNP
185static int nopnp;
186#endif
187
Al Viro37b2a172008-11-01 18:20:19 +0000188static int __devinit el3_common_init(struct net_device *dev);
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700189static void el3_common_remove(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190static ushort id_read_eeprom(int index);
191static ushort read_eeprom(int ioaddr, int index);
192static int el3_open(struct net_device *dev);
Stephen Hemminger27a1de92009-08-31 19:50:54 +0000193static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100194static irqreturn_t el3_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195static void update_stats(struct net_device *dev);
196static struct net_device_stats *el3_get_stats(struct net_device *dev);
197static int el3_rx(struct net_device *dev);
198static int el3_close(struct net_device *dev);
199static void set_multicast_list(struct net_device *dev);
200static void el3_tx_timeout (struct net_device *dev);
201static void el3_down(struct net_device *dev);
202static void el3_up(struct net_device *dev);
Jeff Garzik7282d492006-09-13 14:30:00 -0400203static const struct ethtool_ops ethtool_ops;
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700204#ifdef CONFIG_PM
Pekka Enberg60a89ff2006-03-08 00:06:28 -0800205static int el3_suspend(struct device *, pm_message_t);
206static int el3_resume(struct device *);
207#else
208#define el3_suspend NULL
209#define el3_resume NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210#endif
Pekka Enberg60a89ff2006-03-08 00:06:28 -0800211
212
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213/* generic device remove for all device types */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214static int el3_device_remove (struct device *device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215#ifdef CONFIG_NET_POLL_CONTROLLER
216static void el3_poll_controller(struct net_device *dev);
217#endif
218
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700219/* Return 0 on success, 1 on error, 2 when found already detected PnP card */
220static int el3_isa_id_sequence(__be16 *phys_addr)
221{
222 short lrs_state = 0xff;
223 int i;
224
225 /* ISA boards are detected by sending the ID sequence to the
226 ID_PORT. We find cards past the first by setting the 'current_tag'
227 on cards as they are found. Cards with their tag set will not
228 respond to subsequent ID sequences. */
229
230 outb(0x00, id_port);
231 outb(0x00, id_port);
232 for (i = 0; i < 255; i++) {
233 outb(lrs_state, id_port);
234 lrs_state <<= 1;
235 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
236 }
237 /* For the first probe, clear all board's tag registers. */
238 if (current_tag == 0)
239 outb(0xd0, id_port);
240 else /* Otherwise kill off already-found boards. */
241 outb(0xd8, id_port);
242 if (id_read_eeprom(7) != 0x6d50)
243 return 1;
244 /* Read in EEPROM data, which does contention-select.
245 Only the lowest address board will stay "on-line".
246 3Com got the byte order backwards. */
247 for (i = 0; i < 3; i++)
248 phys_addr[i] = htons(id_read_eeprom(i));
249#ifdef CONFIG_PNP
250 if (!nopnp) {
251 /* The ISA PnP 3c509 cards respond to the ID sequence too.
252 This check is needed in order not to register them twice. */
253 for (i = 0; i < el3_cards; i++) {
254 struct el3_private *lp = netdev_priv(el3_devs[i]);
Joe Perches8e95a202009-12-03 07:58:21 +0000255 if (lp->type == EL3_PNP &&
256 !memcmp(phys_addr, el3_devs[i]->dev_addr,
257 ETH_ALEN)) {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700258 if (el3_debug > 3)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000259 pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700260 phys_addr[0] & 0xff, phys_addr[0] >> 8,
261 phys_addr[1] & 0xff, phys_addr[1] >> 8,
262 phys_addr[2] & 0xff, phys_addr[2] >> 8);
263 /* Set the adaptor tag so that the next card can be found. */
264 outb(0xd0 + ++current_tag, id_port);
265 return 2;
266 }
267 }
268 }
269#endif /* CONFIG_PNP */
270 return 0;
271
272}
273
274static void __devinit el3_dev_fill(struct net_device *dev, __be16 *phys_addr,
275 int ioaddr, int irq, int if_port,
276 enum el3_cardtype type)
277{
278 struct el3_private *lp = netdev_priv(dev);
279
280 memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
281 dev->base_addr = ioaddr;
282 dev->irq = irq;
283 dev->if_port = if_port;
284 lp->type = type;
285}
286
287static int __devinit el3_isa_match(struct device *pdev,
288 unsigned int ndev)
289{
290 struct net_device *dev;
291 int ioaddr, isa_irq, if_port, err;
292 unsigned int iobase;
293 __be16 phys_addr[3];
294
295 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
296 ; /* Skip to next card when PnP card found */
297 if (err == 1)
298 return 0;
299
300 iobase = id_read_eeprom(8);
301 if_port = iobase >> 14;
302 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
303 if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
304 isa_irq = irq[el3_cards];
305 else
306 isa_irq = id_read_eeprom(9) >> 12;
307
308 dev = alloc_etherdev(sizeof(struct el3_private));
309 if (!dev)
310 return -ENOMEM;
311
312 netdev_boot_setup_check(dev);
313
314 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
315 free_netdev(dev);
316 return 0;
317 }
318
319 /* Set the adaptor tag so that the next card can be found. */
320 outb(0xd0 + ++current_tag, id_port);
321
322 /* Activate the adaptor at the EEPROM location. */
323 outb((ioaddr >> 4) | 0xe0, id_port);
324
325 EL3WINDOW(0);
326 if (inw(ioaddr) != 0x6d50) {
327 free_netdev(dev);
328 return 0;
329 }
330
331 /* Free the interrupt so that some other card can use it. */
332 outw(0x0f00, ioaddr + WN0_IRQ);
333
334 el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
335 dev_set_drvdata(pdev, dev);
336 if (el3_common_init(dev)) {
337 free_netdev(dev);
338 return 0;
339 }
340
341 el3_devs[el3_cards++] = dev;
342 return 1;
343}
344
345static int __devexit el3_isa_remove(struct device *pdev,
346 unsigned int ndev)
347{
348 el3_device_remove(pdev);
349 dev_set_drvdata(pdev, NULL);
350 return 0;
351}
352
353#ifdef CONFIG_PM
354static int el3_isa_suspend(struct device *dev, unsigned int n,
355 pm_message_t state)
356{
357 current_tag = 0;
358 return el3_suspend(dev, state);
359}
360
361static int el3_isa_resume(struct device *dev, unsigned int n)
362{
363 struct net_device *ndev = dev_get_drvdata(dev);
364 int ioaddr = ndev->base_addr, err;
365 __be16 phys_addr[3];
366
367 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
368 ; /* Skip to next card when PnP card found */
369 if (err == 1)
370 return 0;
371 /* Set the adaptor tag so that the next card can be found. */
372 outb(0xd0 + ++current_tag, id_port);
373 /* Enable the card */
374 outb((ioaddr >> 4) | 0xe0, id_port);
375 EL3WINDOW(0);
376 if (inw(ioaddr) != 0x6d50)
377 return 1;
378 /* Free the interrupt so that some other card can use it. */
379 outw(0x0f00, ioaddr + WN0_IRQ);
380 return el3_resume(dev);
381}
382#endif
383
384static struct isa_driver el3_isa_driver = {
385 .match = el3_isa_match,
386 .remove = __devexit_p(el3_isa_remove),
387#ifdef CONFIG_PM
388 .suspend = el3_isa_suspend,
389 .resume = el3_isa_resume,
390#endif
391 .driver = {
392 .name = "3c509"
393 },
394};
395static int isa_registered;
396
397#ifdef CONFIG_PNP
398static struct pnp_device_id el3_pnp_ids[] = {
399 { .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
400 { .id = "TCM5091" }, /* 3Com Etherlink III */
401 { .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
402 { .id = "TCM5095" }, /* 3Com Etherlink III (TPO) */
403 { .id = "TCM5098" }, /* 3Com Etherlink III (TPC) */
404 { .id = "PNP80f7" }, /* 3Com Etherlink III compatible */
405 { .id = "PNP80f8" }, /* 3Com Etherlink III compatible */
406 { .id = "" }
407};
408MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
409
410static int __devinit el3_pnp_probe(struct pnp_dev *pdev,
411 const struct pnp_device_id *id)
412{
413 short i;
414 int ioaddr, irq, if_port;
Al Viro4ec7ffa2008-05-21 06:32:11 +0100415 __be16 phys_addr[3];
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700416 struct net_device *dev = NULL;
417 int err;
418
419 ioaddr = pnp_port_start(pdev, 0);
420 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
421 return -EBUSY;
422 irq = pnp_irq(pdev, 0);
423 EL3WINDOW(0);
424 for (i = 0; i < 3; i++)
425 phys_addr[i] = htons(read_eeprom(ioaddr, i));
426 if_port = read_eeprom(ioaddr, 8) >> 14;
427 dev = alloc_etherdev(sizeof(struct el3_private));
428 if (!dev) {
429 release_region(ioaddr, EL3_IO_EXTENT);
430 return -ENOMEM;
431 }
432 SET_NETDEV_DEV(dev, &pdev->dev);
433 netdev_boot_setup_check(dev);
434
435 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
436 pnp_set_drvdata(pdev, dev);
437 err = el3_common_init(dev);
438
439 if (err) {
440 pnp_set_drvdata(pdev, NULL);
441 free_netdev(dev);
442 return err;
443 }
444
445 el3_devs[el3_cards++] = dev;
446 return 0;
447}
448
449static void __devexit el3_pnp_remove(struct pnp_dev *pdev)
450{
451 el3_common_remove(pnp_get_drvdata(pdev));
452 pnp_set_drvdata(pdev, NULL);
453}
454
455#ifdef CONFIG_PM
456static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
457{
458 return el3_suspend(&pdev->dev, state);
459}
460
461static int el3_pnp_resume(struct pnp_dev *pdev)
462{
463 return el3_resume(&pdev->dev);
464}
465#endif
466
467static struct pnp_driver el3_pnp_driver = {
468 .name = "3c509",
469 .id_table = el3_pnp_ids,
470 .probe = el3_pnp_probe,
471 .remove = __devexit_p(el3_pnp_remove),
472#ifdef CONFIG_PM
473 .suspend = el3_pnp_suspend,
474 .resume = el3_pnp_resume,
475#endif
476};
477static int pnp_registered;
478#endif /* CONFIG_PNP */
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480#ifdef CONFIG_EISA
481static struct eisa_device_id el3_eisa_ids[] = {
Maciej W. Rozyckicf9f6e22009-06-01 03:12:04 -0700482 { "TCM5090" },
483 { "TCM5091" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 { "TCM5092" },
485 { "TCM5093" },
Maciej W. Rozyckicf9f6e22009-06-01 03:12:04 -0700486 { "TCM5094" },
Adrian Bunkf04e3f02005-05-16 21:13:03 +0200487 { "TCM5095" },
Maciej W. Rozyckicf9f6e22009-06-01 03:12:04 -0700488 { "TCM5098" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 { "" }
490};
Michael Tokarev07563c72006-09-27 01:50:56 -0700491MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
493static int el3_eisa_probe (struct device *device);
494
495static struct eisa_driver el3_eisa_driver = {
496 .id_table = el3_eisa_ids,
497 .driver = {
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700498 .name = "3c579",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 .probe = el3_eisa_probe,
Pekka Enberg60a89ff2006-03-08 00:06:28 -0800500 .remove = __devexit_p (el3_device_remove),
501 .suspend = el3_suspend,
502 .resume = el3_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 }
504};
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700505static int eisa_registered;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506#endif
507
508#ifdef CONFIG_MCA
509static int el3_mca_probe(struct device *dev);
510
511static short el3_mca_adapter_ids[] __initdata = {
512 0x627c,
513 0x627d,
514 0x62db,
515 0x62f6,
516 0x62f7,
517 0x0000
518};
519
520static char *el3_mca_adapter_names[] __initdata = {
521 "3Com 3c529 EtherLink III (10base2)",
522 "3Com 3c529 EtherLink III (10baseT)",
523 "3Com 3c529 EtherLink III (test mode)",
524 "3Com 3c529 EtherLink III (TP or coax)",
525 "3Com 3c529 EtherLink III (TP)",
526 NULL
527};
528
529static struct mca_driver el3_mca_driver = {
530 .id_table = el3_mca_adapter_ids,
531 .driver = {
532 .name = "3c529",
533 .bus = &mca_bus_type,
534 .probe = el3_mca_probe,
535 .remove = __devexit_p(el3_device_remove),
Pekka Enberg60a89ff2006-03-08 00:06:28 -0800536 .suspend = el3_suspend,
537 .resume = el3_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 },
539};
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700540static int mca_registered;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541#endif /* CONFIG_MCA */
542
Stephen Hemminger3186ae82009-01-09 13:01:14 +0000543static const struct net_device_ops netdev_ops = {
544 .ndo_open = el3_open,
545 .ndo_stop = el3_close,
546 .ndo_start_xmit = el3_start_xmit,
547 .ndo_get_stats = el3_get_stats,
548 .ndo_set_multicast_list = set_multicast_list,
549 .ndo_tx_timeout = el3_tx_timeout,
550 .ndo_change_mtu = eth_change_mtu,
551 .ndo_set_mac_address = eth_mac_addr,
552 .ndo_validate_addr = eth_validate_addr,
553#ifdef CONFIG_NET_POLL_CONTROLLER
554 .ndo_poll_controller = el3_poll_controller,
555#endif
556};
557
Al Viro37b2a172008-11-01 18:20:19 +0000558static int __devinit el3_common_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559{
560 struct el3_private *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 int err;
Joe Perches0795af52007-10-03 17:59:30 -0700562 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
564 spin_lock_init(&lp->lock);
565
566 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
567 dev->if_port = (dev->mem_start & 0x0f);
568 } else { /* xcvr codes 0/8 */
569 /* use eeprom value, but save user's full-duplex selection */
570 dev->if_port |= (dev->mem_start & 0x08);
571 }
572
573 /* The EL3-specific entries in the device structure. */
Stephen Hemminger3186ae82009-01-09 13:01:14 +0000574 dev->netdev_ops = &netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 dev->watchdog_timeo = TX_TIMEOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 SET_ETHTOOL_OPS(dev, &ethtool_ops);
577
578 err = register_netdev(dev);
579 if (err) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000580 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 dev->base_addr, dev->irq);
582 release_region(dev->base_addr, EL3_IO_EXTENT);
583 return err;
584 }
585
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000586 pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
Joe Perches0795af52007-10-03 17:59:30 -0700587 dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
Johannes Berge1749612008-10-27 15:59:26 -0700588 dev->dev_addr, dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
590 if (el3_debug > 0)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000591 pr_info("%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 return 0;
593
594}
595
596static void el3_common_remove (struct net_device *dev)
597{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 unregister_netdev (dev);
599 release_region(dev->base_addr, EL3_IO_EXTENT);
600 free_netdev (dev);
601}
602
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603#ifdef CONFIG_MCA
604static int __init el3_mca_probe(struct device *device)
605{
606 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
607 * heavily modified by Chris Beauregard
608 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
609 * probing.
610 *
611 * redone for multi-card detection by ZP Gu (zpg@castle.net)
612 * now works as a module */
613
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 short i;
615 int ioaddr, irq, if_port;
Al Viro4ec7ffa2008-05-21 06:32:11 +0100616 __be16 phys_addr[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 struct net_device *dev = NULL;
618 u_char pos4, pos5;
619 struct mca_device *mdev = to_mca_device(device);
620 int slot = mdev->slot;
621 int err;
622
623 pos4 = mca_device_read_stored_pos(mdev, 4);
624 pos5 = mca_device_read_stored_pos(mdev, 5);
625
626 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
627 irq = pos5 & 0x0f;
628
629
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000630 pr_info("3c529: found %s at slot %d\n",
631 el3_mca_adapter_names[mdev->index], slot + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
633 /* claim the slot */
634 strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
635 sizeof(mdev->name));
636 mca_device_set_claim(mdev, 1);
637
638 if_port = pos4 & 0x03;
639
640 irq = mca_device_transform_irq(mdev, irq);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400641 ioaddr = mca_device_transform_ioport(mdev, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 if (el3_debug > 2) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000643 pr_debug("3c529: irq %d ioaddr 0x%x ifport %d\n", irq, ioaddr, if_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 }
645 EL3WINDOW(0);
Al Viro4ec7ffa2008-05-21 06:32:11 +0100646 for (i = 0; i < 3; i++)
647 phys_addr[i] = htons(read_eeprom(ioaddr, i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
649 dev = alloc_etherdev(sizeof (struct el3_private));
650 if (dev == NULL) {
Al Viro4ec7ffa2008-05-21 06:32:11 +0100651 release_region(ioaddr, EL3_IO_EXTENT);
652 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 }
654
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 netdev_boot_setup_check(dev);
656
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700657 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_MCA);
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +0000658 dev_set_drvdata(device, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 err = el3_common_init(dev);
660
661 if (err) {
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +0000662 dev_set_drvdata(device, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 free_netdev(dev);
664 return -ENOMEM;
665 }
666
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700667 el3_devs[el3_cards++] = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 return 0;
669}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400670
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671#endif /* CONFIG_MCA */
672
673#ifdef CONFIG_EISA
674static int __init el3_eisa_probe (struct device *device)
675{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 short i;
677 int ioaddr, irq, if_port;
Al Viro4ec7ffa2008-05-21 06:32:11 +0100678 __be16 phys_addr[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 struct net_device *dev = NULL;
680 struct eisa_device *edev;
681 int err;
682
683 /* Yeepee, The driver framework is calling us ! */
684 edev = to_eisa_device (device);
685 ioaddr = edev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400686
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700687 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 return -EBUSY;
689
690 /* Change the register set to the configuration window 0. */
691 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
692
693 irq = inw(ioaddr + WN0_IRQ) >> 12;
694 if_port = inw(ioaddr + 6)>>14;
695 for (i = 0; i < 3; i++)
696 phys_addr[i] = htons(read_eeprom(ioaddr, i));
697
698 /* Restore the "Product ID" to the EEPROM read register. */
699 read_eeprom(ioaddr, 3);
700
701 dev = alloc_etherdev(sizeof (struct el3_private));
702 if (dev == NULL) {
703 release_region(ioaddr, EL3_IO_EXTENT);
704 return -ENOMEM;
705 }
706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 netdev_boot_setup_check(dev);
708
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700709 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 eisa_set_drvdata (edev, dev);
711 err = el3_common_init(dev);
712
713 if (err) {
714 eisa_set_drvdata (edev, NULL);
715 free_netdev(dev);
716 return err;
717 }
718
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700719 el3_devs[el3_cards++] = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 return 0;
721}
722#endif
723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724/* This remove works for all device types.
725 *
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +0000726 * The net dev must be stored in the driver data field */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727static int __devexit el3_device_remove (struct device *device)
728{
729 struct net_device *dev;
730
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +0000731 dev = dev_get_drvdata(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
733 el3_common_remove (dev);
734 return 0;
735}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
737/* Read a word from the EEPROM using the regular EEPROM access register.
738 Assume that we are in register window zero.
739 */
740static ushort read_eeprom(int ioaddr, int index)
741{
742 outw(EEPROM_READ + index, ioaddr + 10);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400743 /* Pause for at least 162 us. for the read to take place.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 Some chips seem to require much longer */
745 mdelay(2);
746 return inw(ioaddr + 12);
747}
748
749/* Read a word from the EEPROM when in the ISA ID probe state. */
Ondrej Zaryac4bed12008-03-28 14:41:23 -0700750static ushort id_read_eeprom(int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751{
752 int bit, word = 0;
753
754 /* Issue read command, and pause for at least 162 us. for it to complete.
755 Assume extra-fast 16Mhz bus. */
756 outb(EEPROM_READ + index, id_port);
757
758 /* Pause for at least 162 us. for the read to take place. */
759 /* Some chips seem to require much longer */
760 mdelay(4);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400761
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 for (bit = 15; bit >= 0; bit--)
763 word = (word << 1) + (inb(id_port) & 0x01);
764
765 if (el3_debug > 3)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000766 pr_debug(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
768 return word;
769}
770
771
772static int
773el3_open(struct net_device *dev)
774{
775 int ioaddr = dev->base_addr;
776 int i;
777
778 outw(TxReset, ioaddr + EL3_CMD);
779 outw(RxReset, ioaddr + EL3_CMD);
780 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
781
Joe Perchesa0607fd2009-11-18 23:29:17 -0800782 i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 if (i)
784 return i;
785
786 EL3WINDOW(0);
787 if (el3_debug > 3)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000788 pr_debug("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
790
791 el3_up(dev);
792
793 if (el3_debug > 3)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000794 pr_debug("%s: Opened 3c509 IRQ %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
796
797 return 0;
798}
799
800static void
801el3_tx_timeout (struct net_device *dev)
802{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 int ioaddr = dev->base_addr;
804
805 /* Transmitter timeout, serious problems. */
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000806 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 -0700807 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
808 inw(ioaddr + TX_FREE));
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300809 dev->stats.tx_errors++;
Eric Dumazet1ae5dc32010-05-10 05:01:31 -0700810 dev->trans_start = jiffies; /* prevent tx timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 /* Issue TX_RESET and TX_START commands. */
812 outw(TxReset, ioaddr + EL3_CMD);
813 outw(TxEnable, ioaddr + EL3_CMD);
814 netif_wake_queue(dev);
815}
816
817
Stephen Hemminger27a1de92009-08-31 19:50:54 +0000818static netdev_tx_t
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
820{
821 struct el3_private *lp = netdev_priv(dev);
822 int ioaddr = dev->base_addr;
823 unsigned long flags;
824
825 netif_stop_queue (dev);
826
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300827 dev->stats.tx_bytes += skb->len;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400828
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 if (el3_debug > 4) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000830 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
832 }
833#if 0
834#ifndef final_version
835 { /* Error-checking code, delete someday. */
836 ushort status = inw(ioaddr + EL3_STATUS);
Joe Perches8e95a202009-12-03 07:58:21 +0000837 if (status & 0x0001 && /* IRQ line active, missed one. */
838 inw(ioaddr + EL3_STATUS) & 1) { /* Make sure. */
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000839 pr_debug("%s: Missed interrupt, status then %04x now %04x"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 " Tx %2.2x Rx %4.4x.\n", dev->name, status,
841 inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
842 inw(ioaddr + RX_STATUS));
843 /* Fake interrupt trigger by masking, acknowledge interrupts. */
844 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
845 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
846 ioaddr + EL3_CMD);
847 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
848 }
849 }
850#endif
851#endif
852 /*
853 * We lock the driver against other processors. Note
854 * we don't need to lock versus the IRQ as we suspended
855 * that. This means that we lose the ability to take
856 * an RX during a TX upload. That sucks a bit with SMP
857 * on an original 3c509 (2K buffer)
858 *
859 * Using disable_irq stops us crapping on other
860 * time sensitive devices.
861 */
862
863 spin_lock_irqsave(&lp->lock, flags);
864
865 /* Put out the doubleword header... */
866 outw(skb->len, ioaddr + TX_FIFO);
867 outw(0x00, ioaddr + TX_FIFO);
868 /* ... and the packet rounded to a doubleword. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 if (inw(ioaddr + TX_FREE) > 1536)
872 netif_start_queue(dev);
873 else
874 /* Interrupt us when the FIFO has room for max-sized packet. */
875 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
876
877 spin_unlock_irqrestore(&lp->lock, flags);
878
879 dev_kfree_skb (skb);
880
881 /* Clear the Tx status stack. */
882 {
883 short tx_status;
884 int i = 4;
885
886 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300887 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
889 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
890 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
891 }
892 }
Patrick McHardy6ed10652009-06-23 06:03:08 +0000893 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894}
895
896/* The EL3 interrupt handler. */
897static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +0100898el3_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899{
Jeff Garzikc31f28e2006-10-06 14:56:04 -0400900 struct net_device *dev = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 struct el3_private *lp;
902 int ioaddr, status;
903 int i = max_interrupt_work;
904
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 lp = netdev_priv(dev);
906 spin_lock(&lp->lock);
907
908 ioaddr = dev->base_addr;
909
910 if (el3_debug > 4) {
911 status = inw(ioaddr + EL3_STATUS);
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000912 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 }
914
915 while ((status = inw(ioaddr + EL3_STATUS)) &
916 (IntLatch | RxComplete | StatsFull)) {
917
918 if (status & RxComplete)
919 el3_rx(dev);
920
921 if (status & TxAvailable) {
922 if (el3_debug > 5)
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000923 pr_debug(" TX room bit was handled.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 /* There's room in the FIFO for a full-sized packet. */
925 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
926 netif_wake_queue (dev);
927 }
928 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
929 /* Handle all uncommon interrupts. */
930 if (status & StatsFull) /* Empty statistics. */
931 update_stats(dev);
932 if (status & RxEarly) { /* Rx early is unused. */
933 el3_rx(dev);
934 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
935 }
936 if (status & TxComplete) { /* Really Tx error. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 short tx_status;
938 int i = 4;
939
940 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +0300941 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
943 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
944 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
945 }
946 }
947 if (status & AdapterFailure) {
948 /* Adapter failure requires Rx reset and reinit. */
949 outw(RxReset, ioaddr + EL3_CMD);
950 /* Set the Rx filter to the current state. */
951 outw(SetRxFilter | RxStation | RxBroadcast
952 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
953 | (dev->flags & IFF_PROMISC ? RxProm : 0),
954 ioaddr + EL3_CMD);
955 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
956 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
957 }
958 }
959
960 if (--i < 0) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000961 pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 dev->name, status);
963 /* Clear all interrupts. */
964 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
965 break;
966 }
967 /* Acknowledge the IRQ. */
968 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
969 }
970
971 if (el3_debug > 4) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +0000972 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 inw(ioaddr + EL3_STATUS));
974 }
975 spin_unlock(&lp->lock);
976 return IRQ_HANDLED;
977}
978
979
980#ifdef CONFIG_NET_POLL_CONTROLLER
981/*
982 * Polling receive - used by netconsole and other diagnostic tools
983 * to allow network i/o with interrupts disabled.
984 */
985static void el3_poll_controller(struct net_device *dev)
986{
987 disable_irq(dev->irq);
David Howells7d12e782006-10-05 14:55:46 +0100988 el3_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 enable_irq(dev->irq);
990}
991#endif
992
993static struct net_device_stats *
994el3_get_stats(struct net_device *dev)
995{
996 struct el3_private *lp = netdev_priv(dev);
997 unsigned long flags;
998
999 /*
1000 * This is fast enough not to bother with disable IRQ
1001 * stuff.
1002 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001003
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 spin_lock_irqsave(&lp->lock, flags);
1005 update_stats(dev);
1006 spin_unlock_irqrestore(&lp->lock, flags);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001007 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008}
1009
1010/* Update statistics. We change to register window 6, so this should be run
1011 single-threaded if the device is active. This is expected to be a rare
1012 operation, and it's simpler for the rest of the driver to assume that
1013 window 1 is always valid rather than use a special window-state variable.
1014 */
1015static void update_stats(struct net_device *dev)
1016{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 int ioaddr = dev->base_addr;
1018
1019 if (el3_debug > 5)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001020 pr_debug(" Updating the statistics.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 /* Turn off statistics updates while reading. */
1022 outw(StatsDisable, ioaddr + EL3_CMD);
1023 /* Switch to the stats window, and read everything. */
1024 EL3WINDOW(6);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001025 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
1026 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 /* Multiple collisions. */ inb(ioaddr + 2);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001028 dev->stats.collisions += inb(ioaddr + 3);
1029 dev->stats.tx_window_errors += inb(ioaddr + 4);
1030 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
1031 dev->stats.tx_packets += inb(ioaddr + 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 /* Rx packets */ inb(ioaddr + 7);
1033 /* Tx deferrals */ inb(ioaddr + 8);
1034 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1035 inw(ioaddr + 12);
1036
1037 /* Back to window 1, and turn statistics back on. */
1038 EL3WINDOW(1);
1039 outw(StatsEnable, ioaddr + EL3_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040}
1041
1042static int
1043el3_rx(struct net_device *dev)
1044{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 int ioaddr = dev->base_addr;
1046 short rx_status;
1047
1048 if (el3_debug > 5)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001049 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1051 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1052 if (rx_status & 0x4000) { /* Error, update stats. */
1053 short error = rx_status & 0x3800;
1054
1055 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001056 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 switch (error) {
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001058 case 0x0000: dev->stats.rx_over_errors++; break;
1059 case 0x0800: dev->stats.rx_length_errors++; break;
1060 case 0x1000: dev->stats.rx_frame_errors++; break;
1061 case 0x1800: dev->stats.rx_length_errors++; break;
1062 case 0x2000: dev->stats.rx_frame_errors++; break;
1063 case 0x2800: dev->stats.rx_crc_errors++; break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 }
1065 } else {
1066 short pkt_len = rx_status & 0x7ff;
1067 struct sk_buff *skb;
1068
1069 skb = dev_alloc_skb(pkt_len+5);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 if (el3_debug > 4)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001071 pr_debug("Receiving packet size %d status %4.4x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 pkt_len, rx_status);
1073 if (skb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 skb_reserve(skb, 2); /* Align IP on 16 byte */
1075
1076 /* 'skb->data' points to the start of sk_buff data area. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1078 (pkt_len + 3) >> 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
1080 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1081 skb->protocol = eth_type_trans(skb,dev);
1082 netif_rx(skb);
Wang Chenf7f312a2008-05-20 17:13:52 +08001083 dev->stats.rx_bytes += pkt_len;
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001084 dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 continue;
1086 }
1087 outw(RxDiscard, ioaddr + EL3_CMD);
Paulius Zaleckas815f8802008-04-29 02:45:43 +03001088 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 if (el3_debug)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001090 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 dev->name, pkt_len);
1092 }
1093 inw(ioaddr + EL3_STATUS); /* Delay. */
1094 while (inw(ioaddr + EL3_STATUS) & 0x1000)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001095 pr_debug(" Waiting for 3c509 to discard packet, status %x.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 inw(ioaddr + EL3_STATUS) );
1097 }
1098
1099 return 0;
1100}
1101
1102/*
1103 * Set or clear the multicast filter for this adaptor.
1104 */
1105static void
1106set_multicast_list(struct net_device *dev)
1107{
1108 unsigned long flags;
1109 struct el3_private *lp = netdev_priv(dev);
1110 int ioaddr = dev->base_addr;
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001111 int mc_count = netdev_mc_count(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
1113 if (el3_debug > 1) {
1114 static int old;
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001115 if (old != mc_count) {
1116 old = mc_count;
1117 pr_debug("%s: Setting Rx mode to %d addresses.\n",
1118 dev->name, mc_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 }
1120 }
1121 spin_lock_irqsave(&lp->lock, flags);
1122 if (dev->flags&IFF_PROMISC) {
1123 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1124 ioaddr + EL3_CMD);
1125 }
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001126 else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1128 }
1129 else
1130 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1131 spin_unlock_irqrestore(&lp->lock, flags);
1132}
1133
1134static int
1135el3_close(struct net_device *dev)
1136{
1137 int ioaddr = dev->base_addr;
1138 struct el3_private *lp = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001139
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 if (el3_debug > 2)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001141 pr_debug("%s: Shutting down ethercard.\n", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
1143 el3_down(dev);
1144
1145 free_irq(dev->irq, dev);
1146 /* Switching back to window 0 disables the IRQ. */
1147 EL3WINDOW(0);
1148 if (lp->type != EL3_EISA) {
1149 /* But we explicitly zero the IRQ line select anyway. Don't do
1150 * it on EISA cards, it prevents the module from getting an
1151 * IRQ after unload+reload... */
1152 outw(0x0f00, ioaddr + WN0_IRQ);
1153 }
1154
1155 return 0;
1156}
1157
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001158static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159el3_link_ok(struct net_device *dev)
1160{
1161 int ioaddr = dev->base_addr;
1162 u16 tmp;
1163
1164 EL3WINDOW(4);
1165 tmp = inw(ioaddr + WN4_MEDIA);
1166 EL3WINDOW(1);
1167 return tmp & (1<<11);
1168}
1169
1170static int
1171el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1172{
1173 u16 tmp;
1174 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001175
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 EL3WINDOW(0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001177 /* obtain current transceiver via WN4_MEDIA? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 tmp = inw(ioaddr + WN0_ADDR_CONF);
1179 ecmd->transceiver = XCVR_INTERNAL;
1180 switch (tmp >> 14) {
1181 case 0:
1182 ecmd->port = PORT_TP;
1183 break;
1184 case 1:
1185 ecmd->port = PORT_AUI;
1186 ecmd->transceiver = XCVR_EXTERNAL;
1187 break;
1188 case 3:
1189 ecmd->port = PORT_BNC;
1190 default:
1191 break;
1192 }
1193
1194 ecmd->duplex = DUPLEX_HALF;
1195 ecmd->supported = 0;
1196 tmp = inw(ioaddr + WN0_CONF_CTRL);
1197 if (tmp & (1<<13))
1198 ecmd->supported |= SUPPORTED_AUI;
1199 if (tmp & (1<<12))
1200 ecmd->supported |= SUPPORTED_BNC;
1201 if (tmp & (1<<9)) {
1202 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1203 SUPPORTED_10baseT_Full; /* hmm... */
1204 EL3WINDOW(4);
1205 tmp = inw(ioaddr + WN4_NETDIAG);
1206 if (tmp & FD_ENABLE)
1207 ecmd->duplex = DUPLEX_FULL;
1208 }
1209
1210 ecmd->speed = SPEED_10;
1211 EL3WINDOW(1);
1212 return 0;
1213}
1214
1215static int
1216el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1217{
1218 u16 tmp;
1219 int ioaddr = dev->base_addr;
1220
1221 if (ecmd->speed != SPEED_10)
1222 return -EINVAL;
1223 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1224 return -EINVAL;
1225 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1226 return -EINVAL;
1227
1228 /* change XCVR type */
1229 EL3WINDOW(0);
1230 tmp = inw(ioaddr + WN0_ADDR_CONF);
1231 switch (ecmd->port) {
1232 case PORT_TP:
1233 tmp &= ~(3<<14);
1234 dev->if_port = 0;
1235 break;
1236 case PORT_AUI:
1237 tmp |= (1<<14);
1238 dev->if_port = 1;
1239 break;
1240 case PORT_BNC:
1241 tmp |= (3<<14);
1242 dev->if_port = 3;
1243 break;
1244 default:
1245 return -EINVAL;
1246 }
1247
1248 outw(tmp, ioaddr + WN0_ADDR_CONF);
1249 if (dev->if_port == 3) {
1250 /* fire up the DC-DC convertor if BNC gets enabled */
1251 tmp = inw(ioaddr + WN0_ADDR_CONF);
1252 if (tmp & (3 << 14)) {
1253 outw(StartCoax, ioaddr + EL3_CMD);
1254 udelay(800);
1255 } else
1256 return -EIO;
1257 }
1258
1259 EL3WINDOW(4);
1260 tmp = inw(ioaddr + WN4_NETDIAG);
1261 if (ecmd->duplex == DUPLEX_FULL)
1262 tmp |= FD_ENABLE;
1263 else
1264 tmp &= ~FD_ENABLE;
1265 outw(tmp, ioaddr + WN4_NETDIAG);
1266 EL3WINDOW(1);
1267
1268 return 0;
1269}
1270
1271static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1272{
1273 strcpy(info->driver, DRV_NAME);
1274 strcpy(info->version, DRV_VERSION);
1275}
1276
1277static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1278{
1279 struct el3_private *lp = netdev_priv(dev);
1280 int ret;
1281
1282 spin_lock_irq(&lp->lock);
1283 ret = el3_netdev_get_ecmd(dev, ecmd);
1284 spin_unlock_irq(&lp->lock);
1285 return ret;
1286}
1287
1288static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1289{
1290 struct el3_private *lp = netdev_priv(dev);
1291 int ret;
1292
1293 spin_lock_irq(&lp->lock);
1294 ret = el3_netdev_set_ecmd(dev, ecmd);
1295 spin_unlock_irq(&lp->lock);
1296 return ret;
1297}
1298
1299static u32 el3_get_link(struct net_device *dev)
1300{
1301 struct el3_private *lp = netdev_priv(dev);
1302 u32 ret;
1303
1304 spin_lock_irq(&lp->lock);
1305 ret = el3_link_ok(dev);
1306 spin_unlock_irq(&lp->lock);
1307 return ret;
1308}
1309
1310static u32 el3_get_msglevel(struct net_device *dev)
1311{
1312 return el3_debug;
1313}
1314
1315static void el3_set_msglevel(struct net_device *dev, u32 v)
1316{
1317 el3_debug = v;
1318}
1319
Jeff Garzik7282d492006-09-13 14:30:00 -04001320static const struct ethtool_ops ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 .get_drvinfo = el3_get_drvinfo,
1322 .get_settings = el3_get_settings,
1323 .set_settings = el3_set_settings,
1324 .get_link = el3_get_link,
1325 .get_msglevel = el3_get_msglevel,
1326 .set_msglevel = el3_set_msglevel,
1327};
1328
1329static void
1330el3_down(struct net_device *dev)
1331{
1332 int ioaddr = dev->base_addr;
1333
1334 netif_stop_queue(dev);
1335
1336 /* Turn off statistics ASAP. We update lp->stats below. */
1337 outw(StatsDisable, ioaddr + EL3_CMD);
1338
1339 /* Disable the receiver and transmitter. */
1340 outw(RxDisable, ioaddr + EL3_CMD);
1341 outw(TxDisable, ioaddr + EL3_CMD);
1342
1343 if (dev->if_port == 3)
1344 /* Turn off thinnet power. Green! */
1345 outw(StopCoax, ioaddr + EL3_CMD);
1346 else if (dev->if_port == 0) {
1347 /* Disable link beat and jabber, if_port may change here next open(). */
1348 EL3WINDOW(4);
1349 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1350 }
1351
1352 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1353
1354 update_stats(dev);
1355}
1356
1357static void
1358el3_up(struct net_device *dev)
1359{
1360 int i, sw_info, net_diag;
1361 int ioaddr = dev->base_addr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001362
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 /* Activating the board required and does no harm otherwise */
1364 outw(0x0001, ioaddr + 4);
1365
1366 /* Set the IRQ line. */
1367 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1368
1369 /* Set the station address in window 2 each time opened. */
1370 EL3WINDOW(2);
1371
1372 for (i = 0; i < 6; i++)
1373 outb(dev->dev_addr[i], ioaddr + i);
1374
1375 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1376 /* Start the thinnet transceiver. We should really wait 50ms...*/
1377 outw(StartCoax, ioaddr + EL3_CMD);
1378 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1379 /* Combine secondary sw_info word (the adapter level) and primary
1380 sw_info word (duplex setting plus other useless bits) */
1381 EL3WINDOW(0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001382 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1384
1385 EL3WINDOW(4);
1386 net_diag = inw(ioaddr + WN4_NETDIAG);
1387 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001388 pr_info("%s: ", dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 switch (dev->if_port & 0x0c) {
1390 case 12:
1391 /* force full-duplex mode if 3c5x9b */
1392 if (sw_info & 0x000f) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001393 pr_cont("Forcing 3c5x9b full-duplex mode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 break;
1395 }
1396 case 8:
1397 /* set full-duplex mode based on eeprom config setting */
1398 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001399 pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 break;
1401 }
1402 default:
1403 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001404 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1406 }
1407
1408 outw(net_diag, ioaddr + WN4_NETDIAG);
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001409 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 if (el3_debug > 3)
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001411 pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 /* Enable link beat and jabber check. */
1413 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1414 }
1415
1416 /* Switch to the stats window, and clear all stats by reading. */
1417 outw(StatsDisable, ioaddr + EL3_CMD);
1418 EL3WINDOW(6);
1419 for (i = 0; i < 9; i++)
1420 inb(ioaddr + i);
1421 inw(ioaddr + 10);
1422 inw(ioaddr + 12);
1423
1424 /* Switch to register set 1 for normal use. */
1425 EL3WINDOW(1);
1426
1427 /* Accept b-case and phys addr only. */
1428 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1429 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1430
1431 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1432 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1433 /* Allow status bits to be seen. */
1434 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1435 /* Ack all pending events, and set active indicator mask. */
1436 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1437 ioaddr + EL3_CMD);
1438 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1439 ioaddr + EL3_CMD);
1440
1441 netif_start_queue(dev);
1442}
1443
1444/* Power Management support functions */
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001445#ifdef CONFIG_PM
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446
1447static int
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001448el3_suspend(struct device *pdev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449{
1450 unsigned long flags;
1451 struct net_device *dev;
1452 struct el3_private *lp;
1453 int ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001454
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +00001455 dev = dev_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 lp = netdev_priv(dev);
1457 ioaddr = dev->base_addr;
1458
1459 spin_lock_irqsave(&lp->lock, flags);
1460
1461 if (netif_running(dev))
1462 netif_device_detach(dev);
1463
1464 el3_down(dev);
1465 outw(PowerDown, ioaddr + EL3_CMD);
1466
1467 spin_unlock_irqrestore(&lp->lock, flags);
1468 return 0;
1469}
1470
1471static int
Pekka Enberg60a89ff2006-03-08 00:06:28 -08001472el3_resume(struct device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473{
1474 unsigned long flags;
1475 struct net_device *dev;
1476 struct el3_private *lp;
1477 int ioaddr;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001478
Greg Kroah-Hartman1aec5bd2009-04-30 12:19:31 +00001479 dev = dev_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 lp = netdev_priv(dev);
1481 ioaddr = dev->base_addr;
1482
1483 spin_lock_irqsave(&lp->lock, flags);
1484
1485 outw(PowerUp, ioaddr + EL3_CMD);
Ondrej Zary152abd12009-02-06 22:04:08 -08001486 EL3WINDOW(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 el3_up(dev);
1488
1489 if (netif_running(dev))
1490 netif_device_attach(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001491
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 spin_unlock_irqrestore(&lp->lock, flags);
1493 return 0;
1494}
1495
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001496#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
1498module_param(debug,int, 0);
1499module_param_array(irq, int, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500module_param(max_interrupt_work, int, 0);
1501MODULE_PARM_DESC(debug, "debug level (0-6)");
1502MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001504#ifdef CONFIG_PNP
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505module_param(nopnp, int, 0);
1506MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001507#endif /* CONFIG_PNP */
1508MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509MODULE_LICENSE("GPL");
1510
1511static int __init el3_init_module(void)
1512{
Andrew Morton0992a5d2006-03-08 00:06:27 -08001513 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514
1515 if (debug >= 0)
1516 el3_debug = debug;
1517
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001518#ifdef CONFIG_PNP
1519 if (!nopnp) {
1520 ret = pnp_register_driver(&el3_pnp_driver);
1521 if (!ret)
1522 pnp_registered = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 }
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001524#endif
1525 /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1526 /* Start with 0x110 to avoid some sound cards.*/
1527 for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1528 if (!request_region(id_port, 1, "3c509-control"))
1529 continue;
1530 outb(0x00, id_port);
1531 outb(0xff, id_port);
1532 if (inb(id_port) & 0x01)
1533 break;
1534 else
1535 release_region(id_port, 1);
1536 }
1537 if (id_port >= 0x200) {
1538 id_port = 0;
Alexander Beregalov646cdb32009-05-26 12:35:25 +00001539 pr_err("No I/O port available for 3c509 activation.\n");
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001540 } else {
1541 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1542 if (!ret)
1543 isa_registered = 1;
1544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545#ifdef CONFIG_EISA
Andrew Morton0992a5d2006-03-08 00:06:27 -08001546 ret = eisa_driver_register(&el3_eisa_driver);
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001547 if (!ret)
1548 eisa_registered = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549#endif
1550#ifdef CONFIG_MCA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001551 ret = mca_register_driver(&el3_mca_driver);
1552 if (!ret)
1553 mca_registered = 1;
1554#endif
1555
1556#ifdef CONFIG_PNP
1557 if (pnp_registered)
1558 ret = 0;
1559#endif
1560 if (isa_registered)
1561 ret = 0;
1562#ifdef CONFIG_EISA
1563 if (eisa_registered)
1564 ret = 0;
1565#endif
1566#ifdef CONFIG_MCA
1567 if (mca_registered)
1568 ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569#endif
Andrew Morton0992a5d2006-03-08 00:06:27 -08001570 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571}
1572
1573static void __exit el3_cleanup_module(void)
1574{
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001575#ifdef CONFIG_PNP
1576 if (pnp_registered)
1577 pnp_unregister_driver(&el3_pnp_driver);
1578#endif
1579 if (isa_registered)
1580 isa_unregister_driver(&el3_isa_driver);
1581 if (id_port)
1582 release_region(id_port, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583#ifdef CONFIG_EISA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001584 if (eisa_registered)
1585 eisa_driver_unregister(&el3_eisa_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586#endif
1587#ifdef CONFIG_MCA
Ondrej Zaryac4bed12008-03-28 14:41:23 -07001588 if (mca_registered)
1589 mca_unregister_driver(&el3_mca_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590#endif
1591}
1592
1593module_init (el3_init_module);
1594module_exit (el3_cleanup_module);