Loading...
Note: File does not exist in v3.1.
1/* 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.
31 Alan Cox: Increased the eeprom delay. Regardless of
32 what the docs say some people definitely
33 get problems with lower (but in card spec)
34 delays
35 v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
36 other cleanups. -djb
37 Andrea Arcangeli: Upgraded to Donald Becker's version 1.12.
38 Rick Payne: Fixed SMP race condition
39 v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
40 v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
41 v1.15 1/31/98 Faster recovery for Tx errors. -djb
42 v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
43 v1.18 12Mar2001 Andrew Morton
44 - Avoid bogus detect of 3c590's (Andrzej Krzysztofowicz)
45 - Reviewed against 1.18 from scyld.com
46 v1.18a 17Nov2001 Jeff Garzik <jgarzik@pobox.com>
47 - ethtool support
48 v1.18b 1Mar2002 Zwane Mwaikambo <zwane@commfireservices.com>
49 - Power Management support
50 v1.18c 1Mar2002 David Ruggiero <jdr@farfalle.com>
51 - Full duplex support
52 v1.19 16Oct2002 Zwane Mwaikambo <zwane@linuxpower.ca>
53 - Additional ethtool features
54 v1.19a 28Oct2002 Davud Ruggiero <jdr@farfalle.com>
55 - Increase *read_eeprom udelay to workaround oops with 2 cards.
56 v1.19b 08Nov2002 Marc Zyngier <maz@wild-wind.fr.eu.org>
57 - Introduce driver model for EISA cards.
58 v1.20 04Feb2008 Ondrej Zary <linux@rainbow-software.org>
59 - convert to isa_driver and pnp_driver and some cleanups
60*/
61
62#define DRV_NAME "3c509"
63
64/* A few values that may be tweaked. */
65
66/* Time in jiffies before concluding the transmitter is hung. */
67#define TX_TIMEOUT (400*HZ/1000)
68
69#include <linux/module.h>
70#include <linux/isa.h>
71#include <linux/pnp.h>
72#include <linux/string.h>
73#include <linux/interrupt.h>
74#include <linux/errno.h>
75#include <linux/in.h>
76#include <linux/ioport.h>
77#include <linux/init.h>
78#include <linux/netdevice.h>
79#include <linux/etherdevice.h>
80#include <linux/pm.h>
81#include <linux/skbuff.h>
82#include <linux/delay.h> /* for udelay() */
83#include <linux/spinlock.h>
84#include <linux/ethtool.h>
85#include <linux/device.h>
86#include <linux/eisa.h>
87#include <linux/bitops.h>
88
89#include <linux/uaccess.h>
90#include <asm/io.h>
91#include <asm/irq.h>
92
93#ifdef EL3_DEBUG
94static int el3_debug = EL3_DEBUG;
95#else
96static int el3_debug = 2;
97#endif
98
99/* Used to do a global count of all the cards in the system. Must be
100 * a global variable so that the eisa probe routines can increment
101 * it */
102static int el3_cards = 0;
103#define EL3_MAX_CARDS 8
104
105/* To minimize the size of the driver source I only define operating
106 constants if they are used several times. You'll need the manual
107 anyway if you want to understand driver details. */
108/* Offsets from base I/O address. */
109#define EL3_DATA 0x00
110#define EL3_CMD 0x0e
111#define EL3_STATUS 0x0e
112#define EEPROM_READ 0x80
113
114#define EL3_IO_EXTENT 16
115
116#define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
117
118
119/* The top five bits written to EL3_CMD are a command, the lower
120 11 bits are the parameter, if applicable. */
121enum c509cmd {
122 TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
123 RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
124 TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
125 FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
126 SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
127 SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
128 StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
129 PowerDown = 28<<11, PowerAuto = 29<<11};
130
131enum c509status {
132 IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
133 TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
134 IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
135
136/* The SetRxFilter command accepts the following classes: */
137enum RxFilter {
138 RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
139
140/* Register window 1 offsets, the window used in normal operation. */
141#define TX_FIFO 0x00
142#define RX_FIFO 0x00
143#define RX_STATUS 0x08
144#define TX_STATUS 0x0B
145#define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
146
147#define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
148#define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
149#define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
150#define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
151#define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
152#define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
153#define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
154
155/*
156 * Must be a power of two (we use a binary and in the
157 * circular queue)
158 */
159#define SKB_QUEUE_SIZE 64
160
161enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_EISA };
162
163struct el3_private {
164 spinlock_t lock;
165 /* skb send-queue */
166 int head, size;
167 struct sk_buff *queue[SKB_QUEUE_SIZE];
168 enum el3_cardtype type;
169};
170static int id_port;
171static int current_tag;
172static struct net_device *el3_devs[EL3_MAX_CARDS];
173
174/* Parameters that may be passed into the module. */
175static int debug = -1;
176static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
177/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
178static int max_interrupt_work = 10;
179#ifdef CONFIG_PNP
180static int nopnp;
181#endif
182
183static int el3_common_init(struct net_device *dev);
184static void el3_common_remove(struct net_device *dev);
185static ushort id_read_eeprom(int index);
186static ushort read_eeprom(int ioaddr, int index);
187static int el3_open(struct net_device *dev);
188static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
189static irqreturn_t el3_interrupt(int irq, void *dev_id);
190static void update_stats(struct net_device *dev);
191static struct net_device_stats *el3_get_stats(struct net_device *dev);
192static int el3_rx(struct net_device *dev);
193static int el3_close(struct net_device *dev);
194static void set_multicast_list(struct net_device *dev);
195static void el3_tx_timeout (struct net_device *dev, unsigned int txqueue);
196static void el3_down(struct net_device *dev);
197static void el3_up(struct net_device *dev);
198static const struct ethtool_ops ethtool_ops;
199#ifdef CONFIG_PM
200static int el3_suspend(struct device *, pm_message_t);
201static int el3_resume(struct device *);
202#else
203#define el3_suspend NULL
204#define el3_resume NULL
205#endif
206
207
208/* generic device remove for all device types */
209static int el3_device_remove (struct device *device);
210#ifdef CONFIG_NET_POLL_CONTROLLER
211static void el3_poll_controller(struct net_device *dev);
212#endif
213
214/* Return 0 on success, 1 on error, 2 when found already detected PnP card */
215static int el3_isa_id_sequence(__be16 *phys_addr)
216{
217 short lrs_state = 0xff;
218 int i;
219
220 /* ISA boards are detected by sending the ID sequence to the
221 ID_PORT. We find cards past the first by setting the 'current_tag'
222 on cards as they are found. Cards with their tag set will not
223 respond to subsequent ID sequences. */
224
225 outb(0x00, id_port);
226 outb(0x00, id_port);
227 for (i = 0; i < 255; i++) {
228 outb(lrs_state, id_port);
229 lrs_state <<= 1;
230 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
231 }
232 /* For the first probe, clear all board's tag registers. */
233 if (current_tag == 0)
234 outb(0xd0, id_port);
235 else /* Otherwise kill off already-found boards. */
236 outb(0xd8, id_port);
237 if (id_read_eeprom(7) != 0x6d50)
238 return 1;
239 /* Read in EEPROM data, which does contention-select.
240 Only the lowest address board will stay "on-line".
241 3Com got the byte order backwards. */
242 for (i = 0; i < 3; i++)
243 phys_addr[i] = htons(id_read_eeprom(i));
244#ifdef CONFIG_PNP
245 if (!nopnp) {
246 /* The ISA PnP 3c509 cards respond to the ID sequence too.
247 This check is needed in order not to register them twice. */
248 for (i = 0; i < el3_cards; i++) {
249 struct el3_private *lp = netdev_priv(el3_devs[i]);
250 if (lp->type == EL3_PNP &&
251 ether_addr_equal((u8 *)phys_addr, el3_devs[i]->dev_addr)) {
252 if (el3_debug > 3)
253 pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
254 phys_addr[0] & 0xff, phys_addr[0] >> 8,
255 phys_addr[1] & 0xff, phys_addr[1] >> 8,
256 phys_addr[2] & 0xff, phys_addr[2] >> 8);
257 /* Set the adaptor tag so that the next card can be found. */
258 outb(0xd0 + ++current_tag, id_port);
259 return 2;
260 }
261 }
262 }
263#endif /* CONFIG_PNP */
264 return 0;
265
266}
267
268static void el3_dev_fill(struct net_device *dev, __be16 *phys_addr, int ioaddr,
269 int irq, int if_port, enum el3_cardtype type)
270{
271 struct el3_private *lp = netdev_priv(dev);
272
273 memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
274 dev->base_addr = ioaddr;
275 dev->irq = irq;
276 dev->if_port = if_port;
277 lp->type = type;
278}
279
280static int el3_isa_match(struct device *pdev, unsigned int ndev)
281{
282 struct net_device *dev;
283 int ioaddr, isa_irq, if_port, err;
284 unsigned int iobase;
285 __be16 phys_addr[3];
286
287 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
288 ; /* Skip to next card when PnP card found */
289 if (err == 1)
290 return 0;
291
292 iobase = id_read_eeprom(8);
293 if_port = iobase >> 14;
294 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
295 if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
296 isa_irq = irq[el3_cards];
297 else
298 isa_irq = id_read_eeprom(9) >> 12;
299
300 dev = alloc_etherdev(sizeof(struct el3_private));
301 if (!dev)
302 return -ENOMEM;
303
304 SET_NETDEV_DEV(dev, pdev);
305 netdev_boot_setup_check(dev);
306
307 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
308 free_netdev(dev);
309 return 0;
310 }
311
312 /* Set the adaptor tag so that the next card can be found. */
313 outb(0xd0 + ++current_tag, id_port);
314
315 /* Activate the adaptor at the EEPROM location. */
316 outb((ioaddr >> 4) | 0xe0, id_port);
317
318 EL3WINDOW(0);
319 if (inw(ioaddr) != 0x6d50) {
320 free_netdev(dev);
321 return 0;
322 }
323
324 /* Free the interrupt so that some other card can use it. */
325 outw(0x0f00, ioaddr + WN0_IRQ);
326
327 el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
328 dev_set_drvdata(pdev, dev);
329 if (el3_common_init(dev)) {
330 free_netdev(dev);
331 return 0;
332 }
333
334 el3_devs[el3_cards++] = dev;
335 return 1;
336}
337
338static int el3_isa_remove(struct device *pdev,
339 unsigned int ndev)
340{
341 el3_device_remove(pdev);
342 dev_set_drvdata(pdev, NULL);
343 return 0;
344}
345
346#ifdef CONFIG_PM
347static int el3_isa_suspend(struct device *dev, unsigned int n,
348 pm_message_t state)
349{
350 current_tag = 0;
351 return el3_suspend(dev, state);
352}
353
354static int el3_isa_resume(struct device *dev, unsigned int n)
355{
356 struct net_device *ndev = dev_get_drvdata(dev);
357 int ioaddr = ndev->base_addr, err;
358 __be16 phys_addr[3];
359
360 while ((err = el3_isa_id_sequence(phys_addr)) == 2)
361 ; /* Skip to next card when PnP card found */
362 if (err == 1)
363 return 0;
364 /* Set the adaptor tag so that the next card can be found. */
365 outb(0xd0 + ++current_tag, id_port);
366 /* Enable the card */
367 outb((ioaddr >> 4) | 0xe0, id_port);
368 EL3WINDOW(0);
369 if (inw(ioaddr) != 0x6d50)
370 return 1;
371 /* Free the interrupt so that some other card can use it. */
372 outw(0x0f00, ioaddr + WN0_IRQ);
373 return el3_resume(dev);
374}
375#endif
376
377static struct isa_driver el3_isa_driver = {
378 .match = el3_isa_match,
379 .remove = el3_isa_remove,
380#ifdef CONFIG_PM
381 .suspend = el3_isa_suspend,
382 .resume = el3_isa_resume,
383#endif
384 .driver = {
385 .name = "3c509"
386 },
387};
388static int isa_registered;
389
390#ifdef CONFIG_PNP
391static const struct pnp_device_id el3_pnp_ids[] = {
392 { .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
393 { .id = "TCM5091" }, /* 3Com Etherlink III */
394 { .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
395 { .id = "TCM5095" }, /* 3Com Etherlink III (TPO) */
396 { .id = "TCM5098" }, /* 3Com Etherlink III (TPC) */
397 { .id = "PNP80f7" }, /* 3Com Etherlink III compatible */
398 { .id = "PNP80f8" }, /* 3Com Etherlink III compatible */
399 { .id = "" }
400};
401MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
402
403static int el3_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
404{
405 short i;
406 int ioaddr, irq, if_port;
407 __be16 phys_addr[3];
408 struct net_device *dev = NULL;
409 int err;
410
411 ioaddr = pnp_port_start(pdev, 0);
412 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
413 return -EBUSY;
414 irq = pnp_irq(pdev, 0);
415 EL3WINDOW(0);
416 for (i = 0; i < 3; i++)
417 phys_addr[i] = htons(read_eeprom(ioaddr, i));
418 if_port = read_eeprom(ioaddr, 8) >> 14;
419 dev = alloc_etherdev(sizeof(struct el3_private));
420 if (!dev) {
421 release_region(ioaddr, EL3_IO_EXTENT);
422 return -ENOMEM;
423 }
424 SET_NETDEV_DEV(dev, &pdev->dev);
425 netdev_boot_setup_check(dev);
426
427 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
428 pnp_set_drvdata(pdev, dev);
429 err = el3_common_init(dev);
430
431 if (err) {
432 pnp_set_drvdata(pdev, NULL);
433 free_netdev(dev);
434 return err;
435 }
436
437 el3_devs[el3_cards++] = dev;
438 return 0;
439}
440
441static void el3_pnp_remove(struct pnp_dev *pdev)
442{
443 el3_common_remove(pnp_get_drvdata(pdev));
444 pnp_set_drvdata(pdev, NULL);
445}
446
447#ifdef CONFIG_PM
448static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
449{
450 return el3_suspend(&pdev->dev, state);
451}
452
453static int el3_pnp_resume(struct pnp_dev *pdev)
454{
455 return el3_resume(&pdev->dev);
456}
457#endif
458
459static struct pnp_driver el3_pnp_driver = {
460 .name = "3c509",
461 .id_table = el3_pnp_ids,
462 .probe = el3_pnp_probe,
463 .remove = el3_pnp_remove,
464#ifdef CONFIG_PM
465 .suspend = el3_pnp_suspend,
466 .resume = el3_pnp_resume,
467#endif
468};
469static int pnp_registered;
470#endif /* CONFIG_PNP */
471
472#ifdef CONFIG_EISA
473static const struct eisa_device_id el3_eisa_ids[] = {
474 { "TCM5090" },
475 { "TCM5091" },
476 { "TCM5092" },
477 { "TCM5093" },
478 { "TCM5094" },
479 { "TCM5095" },
480 { "TCM5098" },
481 { "" }
482};
483MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
484
485static int el3_eisa_probe (struct device *device);
486
487static struct eisa_driver el3_eisa_driver = {
488 .id_table = el3_eisa_ids,
489 .driver = {
490 .name = "3c579",
491 .probe = el3_eisa_probe,
492 .remove = el3_device_remove,
493 .suspend = el3_suspend,
494 .resume = el3_resume,
495 }
496};
497static int eisa_registered;
498#endif
499
500static const struct net_device_ops netdev_ops = {
501 .ndo_open = el3_open,
502 .ndo_stop = el3_close,
503 .ndo_start_xmit = el3_start_xmit,
504 .ndo_get_stats = el3_get_stats,
505 .ndo_set_rx_mode = set_multicast_list,
506 .ndo_tx_timeout = el3_tx_timeout,
507 .ndo_set_mac_address = eth_mac_addr,
508 .ndo_validate_addr = eth_validate_addr,
509#ifdef CONFIG_NET_POLL_CONTROLLER
510 .ndo_poll_controller = el3_poll_controller,
511#endif
512};
513
514static int el3_common_init(struct net_device *dev)
515{
516 struct el3_private *lp = netdev_priv(dev);
517 int err;
518 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
519
520 spin_lock_init(&lp->lock);
521
522 if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
523 dev->if_port = (dev->mem_start & 0x0f);
524 } else { /* xcvr codes 0/8 */
525 /* use eeprom value, but save user's full-duplex selection */
526 dev->if_port |= (dev->mem_start & 0x08);
527 }
528
529 /* The EL3-specific entries in the device structure. */
530 dev->netdev_ops = &netdev_ops;
531 dev->watchdog_timeo = TX_TIMEOUT;
532 dev->ethtool_ops = ðtool_ops;
533
534 err = register_netdev(dev);
535 if (err) {
536 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
537 dev->base_addr, dev->irq);
538 release_region(dev->base_addr, EL3_IO_EXTENT);
539 return err;
540 }
541
542 pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
543 dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
544 dev->dev_addr, dev->irq);
545
546 return 0;
547
548}
549
550static void el3_common_remove (struct net_device *dev)
551{
552 unregister_netdev (dev);
553 release_region(dev->base_addr, EL3_IO_EXTENT);
554 free_netdev (dev);
555}
556
557#ifdef CONFIG_EISA
558static int el3_eisa_probe(struct device *device)
559{
560 short i;
561 int ioaddr, irq, if_port;
562 __be16 phys_addr[3];
563 struct net_device *dev = NULL;
564 struct eisa_device *edev;
565 int err;
566
567 /* Yeepee, The driver framework is calling us ! */
568 edev = to_eisa_device (device);
569 ioaddr = edev->base_addr;
570
571 if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
572 return -EBUSY;
573
574 /* Change the register set to the configuration window 0. */
575 outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
576
577 irq = inw(ioaddr + WN0_IRQ) >> 12;
578 if_port = inw(ioaddr + 6)>>14;
579 for (i = 0; i < 3; i++)
580 phys_addr[i] = htons(read_eeprom(ioaddr, i));
581
582 /* Restore the "Product ID" to the EEPROM read register. */
583 read_eeprom(ioaddr, 3);
584
585 dev = alloc_etherdev(sizeof (struct el3_private));
586 if (dev == NULL) {
587 release_region(ioaddr, EL3_IO_EXTENT);
588 return -ENOMEM;
589 }
590
591 SET_NETDEV_DEV(dev, device);
592 netdev_boot_setup_check(dev);
593
594 el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
595 eisa_set_drvdata (edev, dev);
596 err = el3_common_init(dev);
597
598 if (err) {
599 eisa_set_drvdata (edev, NULL);
600 free_netdev(dev);
601 return err;
602 }
603
604 el3_devs[el3_cards++] = dev;
605 return 0;
606}
607#endif
608
609/* This remove works for all device types.
610 *
611 * The net dev must be stored in the driver data field */
612static int el3_device_remove(struct device *device)
613{
614 struct net_device *dev;
615
616 dev = dev_get_drvdata(device);
617
618 el3_common_remove (dev);
619 return 0;
620}
621
622/* Read a word from the EEPROM using the regular EEPROM access register.
623 Assume that we are in register window zero.
624 */
625static ushort read_eeprom(int ioaddr, int index)
626{
627 outw(EEPROM_READ + index, ioaddr + 10);
628 /* Pause for at least 162 us. for the read to take place.
629 Some chips seem to require much longer */
630 mdelay(2);
631 return inw(ioaddr + 12);
632}
633
634/* Read a word from the EEPROM when in the ISA ID probe state. */
635static ushort id_read_eeprom(int index)
636{
637 int bit, word = 0;
638
639 /* Issue read command, and pause for at least 162 us. for it to complete.
640 Assume extra-fast 16Mhz bus. */
641 outb(EEPROM_READ + index, id_port);
642
643 /* Pause for at least 162 us. for the read to take place. */
644 /* Some chips seem to require much longer */
645 mdelay(4);
646
647 for (bit = 15; bit >= 0; bit--)
648 word = (word << 1) + (inb(id_port) & 0x01);
649
650 if (el3_debug > 3)
651 pr_debug(" 3c509 EEPROM word %d %#4.4x.\n", index, word);
652
653 return word;
654}
655
656
657static int
658el3_open(struct net_device *dev)
659{
660 int ioaddr = dev->base_addr;
661 int i;
662
663 outw(TxReset, ioaddr + EL3_CMD);
664 outw(RxReset, ioaddr + EL3_CMD);
665 outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
666
667 i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
668 if (i)
669 return i;
670
671 EL3WINDOW(0);
672 if (el3_debug > 3)
673 pr_debug("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name,
674 dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
675
676 el3_up(dev);
677
678 if (el3_debug > 3)
679 pr_debug("%s: Opened 3c509 IRQ %d status %4.4x.\n",
680 dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
681
682 return 0;
683}
684
685static void
686el3_tx_timeout (struct net_device *dev, unsigned int txqueue)
687{
688 int ioaddr = dev->base_addr;
689
690 /* Transmitter timeout, serious problems. */
691 pr_warn("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d\n",
692 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
693 inw(ioaddr + TX_FREE));
694 dev->stats.tx_errors++;
695 netif_trans_update(dev); /* prevent tx timeout */
696 /* Issue TX_RESET and TX_START commands. */
697 outw(TxReset, ioaddr + EL3_CMD);
698 outw(TxEnable, ioaddr + EL3_CMD);
699 netif_wake_queue(dev);
700}
701
702
703static netdev_tx_t
704el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
705{
706 struct el3_private *lp = netdev_priv(dev);
707 int ioaddr = dev->base_addr;
708 unsigned long flags;
709
710 netif_stop_queue (dev);
711
712 dev->stats.tx_bytes += skb->len;
713
714 if (el3_debug > 4) {
715 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
716 dev->name, skb->len, inw(ioaddr + EL3_STATUS));
717 }
718 /*
719 * We lock the driver against other processors. Note
720 * we don't need to lock versus the IRQ as we suspended
721 * that. This means that we lose the ability to take
722 * an RX during a TX upload. That sucks a bit with SMP
723 * on an original 3c509 (2K buffer)
724 *
725 * Using disable_irq stops us crapping on other
726 * time sensitive devices.
727 */
728
729 spin_lock_irqsave(&lp->lock, flags);
730
731 /* Put out the doubleword header... */
732 outw(skb->len, ioaddr + TX_FIFO);
733 outw(0x00, ioaddr + TX_FIFO);
734 /* ... and the packet rounded to a doubleword. */
735 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
736
737 if (inw(ioaddr + TX_FREE) > 1536)
738 netif_start_queue(dev);
739 else
740 /* Interrupt us when the FIFO has room for max-sized packet. */
741 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
742
743 spin_unlock_irqrestore(&lp->lock, flags);
744
745 dev_consume_skb_any (skb);
746
747 /* Clear the Tx status stack. */
748 {
749 short tx_status;
750 int i = 4;
751
752 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
753 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
754 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
755 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
756 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
757 }
758 }
759 return NETDEV_TX_OK;
760}
761
762/* The EL3 interrupt handler. */
763static irqreturn_t
764el3_interrupt(int irq, void *dev_id)
765{
766 struct net_device *dev = dev_id;
767 struct el3_private *lp;
768 int ioaddr, status;
769 int i = max_interrupt_work;
770
771 lp = netdev_priv(dev);
772 spin_lock(&lp->lock);
773
774 ioaddr = dev->base_addr;
775
776 if (el3_debug > 4) {
777 status = inw(ioaddr + EL3_STATUS);
778 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
779 }
780
781 while ((status = inw(ioaddr + EL3_STATUS)) &
782 (IntLatch | RxComplete | StatsFull)) {
783
784 if (status & RxComplete)
785 el3_rx(dev);
786
787 if (status & TxAvailable) {
788 if (el3_debug > 5)
789 pr_debug(" TX room bit was handled.\n");
790 /* There's room in the FIFO for a full-sized packet. */
791 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
792 netif_wake_queue (dev);
793 }
794 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
795 /* Handle all uncommon interrupts. */
796 if (status & StatsFull) /* Empty statistics. */
797 update_stats(dev);
798 if (status & RxEarly) { /* Rx early is unused. */
799 el3_rx(dev);
800 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
801 }
802 if (status & TxComplete) { /* Really Tx error. */
803 short tx_status;
804 int i = 4;
805
806 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
807 if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
808 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
809 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
810 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
811 }
812 }
813 if (status & AdapterFailure) {
814 /* Adapter failure requires Rx reset and reinit. */
815 outw(RxReset, ioaddr + EL3_CMD);
816 /* Set the Rx filter to the current state. */
817 outw(SetRxFilter | RxStation | RxBroadcast
818 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
819 | (dev->flags & IFF_PROMISC ? RxProm : 0),
820 ioaddr + EL3_CMD);
821 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
822 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
823 }
824 }
825
826 if (--i < 0) {
827 pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
828 dev->name, status);
829 /* Clear all interrupts. */
830 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
831 break;
832 }
833 /* Acknowledge the IRQ. */
834 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
835 }
836
837 if (el3_debug > 4) {
838 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
839 inw(ioaddr + EL3_STATUS));
840 }
841 spin_unlock(&lp->lock);
842 return IRQ_HANDLED;
843}
844
845
846#ifdef CONFIG_NET_POLL_CONTROLLER
847/*
848 * Polling receive - used by netconsole and other diagnostic tools
849 * to allow network i/o with interrupts disabled.
850 */
851static void el3_poll_controller(struct net_device *dev)
852{
853 disable_irq(dev->irq);
854 el3_interrupt(dev->irq, dev);
855 enable_irq(dev->irq);
856}
857#endif
858
859static struct net_device_stats *
860el3_get_stats(struct net_device *dev)
861{
862 struct el3_private *lp = netdev_priv(dev);
863 unsigned long flags;
864
865 /*
866 * This is fast enough not to bother with disable IRQ
867 * stuff.
868 */
869
870 spin_lock_irqsave(&lp->lock, flags);
871 update_stats(dev);
872 spin_unlock_irqrestore(&lp->lock, flags);
873 return &dev->stats;
874}
875
876/* Update statistics. We change to register window 6, so this should be run
877 single-threaded if the device is active. This is expected to be a rare
878 operation, and it's simpler for the rest of the driver to assume that
879 window 1 is always valid rather than use a special window-state variable.
880 */
881static void update_stats(struct net_device *dev)
882{
883 int ioaddr = dev->base_addr;
884
885 if (el3_debug > 5)
886 pr_debug(" Updating the statistics.\n");
887 /* Turn off statistics updates while reading. */
888 outw(StatsDisable, ioaddr + EL3_CMD);
889 /* Switch to the stats window, and read everything. */
890 EL3WINDOW(6);
891 dev->stats.tx_carrier_errors += inb(ioaddr + 0);
892 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1);
893 /* Multiple collisions. */ inb(ioaddr + 2);
894 dev->stats.collisions += inb(ioaddr + 3);
895 dev->stats.tx_window_errors += inb(ioaddr + 4);
896 dev->stats.rx_fifo_errors += inb(ioaddr + 5);
897 dev->stats.tx_packets += inb(ioaddr + 6);
898 /* Rx packets */ inb(ioaddr + 7);
899 /* Tx deferrals */ inb(ioaddr + 8);
900 inw(ioaddr + 10); /* Total Rx and Tx octets. */
901 inw(ioaddr + 12);
902
903 /* Back to window 1, and turn statistics back on. */
904 EL3WINDOW(1);
905 outw(StatsEnable, ioaddr + EL3_CMD);
906}
907
908static int
909el3_rx(struct net_device *dev)
910{
911 int ioaddr = dev->base_addr;
912 short rx_status;
913
914 if (el3_debug > 5)
915 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
916 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
917 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
918 if (rx_status & 0x4000) { /* Error, update stats. */
919 short error = rx_status & 0x3800;
920
921 outw(RxDiscard, ioaddr + EL3_CMD);
922 dev->stats.rx_errors++;
923 switch (error) {
924 case 0x0000: dev->stats.rx_over_errors++; break;
925 case 0x0800: dev->stats.rx_length_errors++; break;
926 case 0x1000: dev->stats.rx_frame_errors++; break;
927 case 0x1800: dev->stats.rx_length_errors++; break;
928 case 0x2000: dev->stats.rx_frame_errors++; break;
929 case 0x2800: dev->stats.rx_crc_errors++; break;
930 }
931 } else {
932 short pkt_len = rx_status & 0x7ff;
933 struct sk_buff *skb;
934
935 skb = netdev_alloc_skb(dev, pkt_len + 5);
936 if (el3_debug > 4)
937 pr_debug("Receiving packet size %d status %4.4x.\n",
938 pkt_len, rx_status);
939 if (skb != NULL) {
940 skb_reserve(skb, 2); /* Align IP on 16 byte */
941
942 /* 'skb->data' points to the start of sk_buff data area. */
943 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
944 (pkt_len + 3) >> 2);
945
946 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
947 skb->protocol = eth_type_trans(skb,dev);
948 netif_rx(skb);
949 dev->stats.rx_bytes += pkt_len;
950 dev->stats.rx_packets++;
951 continue;
952 }
953 outw(RxDiscard, ioaddr + EL3_CMD);
954 dev->stats.rx_dropped++;
955 if (el3_debug)
956 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
957 dev->name, pkt_len);
958 }
959 inw(ioaddr + EL3_STATUS); /* Delay. */
960 while (inw(ioaddr + EL3_STATUS) & 0x1000)
961 pr_debug(" Waiting for 3c509 to discard packet, status %x.\n",
962 inw(ioaddr + EL3_STATUS) );
963 }
964
965 return 0;
966}
967
968/*
969 * Set or clear the multicast filter for this adaptor.
970 */
971static void
972set_multicast_list(struct net_device *dev)
973{
974 unsigned long flags;
975 struct el3_private *lp = netdev_priv(dev);
976 int ioaddr = dev->base_addr;
977 int mc_count = netdev_mc_count(dev);
978
979 if (el3_debug > 1) {
980 static int old;
981 if (old != mc_count) {
982 old = mc_count;
983 pr_debug("%s: Setting Rx mode to %d addresses.\n",
984 dev->name, mc_count);
985 }
986 }
987 spin_lock_irqsave(&lp->lock, flags);
988 if (dev->flags&IFF_PROMISC) {
989 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
990 ioaddr + EL3_CMD);
991 }
992 else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
993 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
994 }
995 else
996 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
997 spin_unlock_irqrestore(&lp->lock, flags);
998}
999
1000static int
1001el3_close(struct net_device *dev)
1002{
1003 int ioaddr = dev->base_addr;
1004 struct el3_private *lp = netdev_priv(dev);
1005
1006 if (el3_debug > 2)
1007 pr_debug("%s: Shutting down ethercard.\n", dev->name);
1008
1009 el3_down(dev);
1010
1011 free_irq(dev->irq, dev);
1012 /* Switching back to window 0 disables the IRQ. */
1013 EL3WINDOW(0);
1014 if (lp->type != EL3_EISA) {
1015 /* But we explicitly zero the IRQ line select anyway. Don't do
1016 * it on EISA cards, it prevents the module from getting an
1017 * IRQ after unload+reload... */
1018 outw(0x0f00, ioaddr + WN0_IRQ);
1019 }
1020
1021 return 0;
1022}
1023
1024static int
1025el3_link_ok(struct net_device *dev)
1026{
1027 int ioaddr = dev->base_addr;
1028 u16 tmp;
1029
1030 EL3WINDOW(4);
1031 tmp = inw(ioaddr + WN4_MEDIA);
1032 EL3WINDOW(1);
1033 return tmp & (1<<11);
1034}
1035
1036static void
1037el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_link_ksettings *cmd)
1038{
1039 u16 tmp;
1040 int ioaddr = dev->base_addr;
1041 u32 supported;
1042
1043 EL3WINDOW(0);
1044 /* obtain current transceiver via WN4_MEDIA? */
1045 tmp = inw(ioaddr + WN0_ADDR_CONF);
1046 switch (tmp >> 14) {
1047 case 0:
1048 cmd->base.port = PORT_TP;
1049 break;
1050 case 1:
1051 cmd->base.port = PORT_AUI;
1052 break;
1053 case 3:
1054 cmd->base.port = PORT_BNC;
1055 default:
1056 break;
1057 }
1058
1059 cmd->base.duplex = DUPLEX_HALF;
1060 supported = 0;
1061 tmp = inw(ioaddr + WN0_CONF_CTRL);
1062 if (tmp & (1<<13))
1063 supported |= SUPPORTED_AUI;
1064 if (tmp & (1<<12))
1065 supported |= SUPPORTED_BNC;
1066 if (tmp & (1<<9)) {
1067 supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1068 SUPPORTED_10baseT_Full; /* hmm... */
1069 EL3WINDOW(4);
1070 tmp = inw(ioaddr + WN4_NETDIAG);
1071 if (tmp & FD_ENABLE)
1072 cmd->base.duplex = DUPLEX_FULL;
1073 }
1074
1075 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
1076 supported);
1077 cmd->base.speed = SPEED_10;
1078 EL3WINDOW(1);
1079}
1080
1081static int
1082el3_netdev_set_ecmd(struct net_device *dev,
1083 const struct ethtool_link_ksettings *cmd)
1084{
1085 u16 tmp;
1086 int ioaddr = dev->base_addr;
1087
1088 if (cmd->base.speed != SPEED_10)
1089 return -EINVAL;
1090 if ((cmd->base.duplex != DUPLEX_HALF) &&
1091 (cmd->base.duplex != DUPLEX_FULL))
1092 return -EINVAL;
1093
1094 /* change XCVR type */
1095 EL3WINDOW(0);
1096 tmp = inw(ioaddr + WN0_ADDR_CONF);
1097 switch (cmd->base.port) {
1098 case PORT_TP:
1099 tmp &= ~(3<<14);
1100 dev->if_port = 0;
1101 break;
1102 case PORT_AUI:
1103 tmp |= (1<<14);
1104 dev->if_port = 1;
1105 break;
1106 case PORT_BNC:
1107 tmp |= (3<<14);
1108 dev->if_port = 3;
1109 break;
1110 default:
1111 return -EINVAL;
1112 }
1113
1114 outw(tmp, ioaddr + WN0_ADDR_CONF);
1115 if (dev->if_port == 3) {
1116 /* fire up the DC-DC convertor if BNC gets enabled */
1117 tmp = inw(ioaddr + WN0_ADDR_CONF);
1118 if (tmp & (3 << 14)) {
1119 outw(StartCoax, ioaddr + EL3_CMD);
1120 udelay(800);
1121 } else
1122 return -EIO;
1123 }
1124
1125 EL3WINDOW(4);
1126 tmp = inw(ioaddr + WN4_NETDIAG);
1127 if (cmd->base.duplex == DUPLEX_FULL)
1128 tmp |= FD_ENABLE;
1129 else
1130 tmp &= ~FD_ENABLE;
1131 outw(tmp, ioaddr + WN4_NETDIAG);
1132 EL3WINDOW(1);
1133
1134 return 0;
1135}
1136
1137static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1138{
1139 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1140}
1141
1142static int el3_get_link_ksettings(struct net_device *dev,
1143 struct ethtool_link_ksettings *cmd)
1144{
1145 struct el3_private *lp = netdev_priv(dev);
1146
1147 spin_lock_irq(&lp->lock);
1148 el3_netdev_get_ecmd(dev, cmd);
1149 spin_unlock_irq(&lp->lock);
1150 return 0;
1151}
1152
1153static int el3_set_link_ksettings(struct net_device *dev,
1154 const struct ethtool_link_ksettings *cmd)
1155{
1156 struct el3_private *lp = netdev_priv(dev);
1157 int ret;
1158
1159 spin_lock_irq(&lp->lock);
1160 ret = el3_netdev_set_ecmd(dev, cmd);
1161 spin_unlock_irq(&lp->lock);
1162 return ret;
1163}
1164
1165static u32 el3_get_link(struct net_device *dev)
1166{
1167 struct el3_private *lp = netdev_priv(dev);
1168 u32 ret;
1169
1170 spin_lock_irq(&lp->lock);
1171 ret = el3_link_ok(dev);
1172 spin_unlock_irq(&lp->lock);
1173 return ret;
1174}
1175
1176static u32 el3_get_msglevel(struct net_device *dev)
1177{
1178 return el3_debug;
1179}
1180
1181static void el3_set_msglevel(struct net_device *dev, u32 v)
1182{
1183 el3_debug = v;
1184}
1185
1186static const struct ethtool_ops ethtool_ops = {
1187 .get_drvinfo = el3_get_drvinfo,
1188 .get_link = el3_get_link,
1189 .get_msglevel = el3_get_msglevel,
1190 .set_msglevel = el3_set_msglevel,
1191 .get_link_ksettings = el3_get_link_ksettings,
1192 .set_link_ksettings = el3_set_link_ksettings,
1193};
1194
1195static void
1196el3_down(struct net_device *dev)
1197{
1198 int ioaddr = dev->base_addr;
1199
1200 netif_stop_queue(dev);
1201
1202 /* Turn off statistics ASAP. We update lp->stats below. */
1203 outw(StatsDisable, ioaddr + EL3_CMD);
1204
1205 /* Disable the receiver and transmitter. */
1206 outw(RxDisable, ioaddr + EL3_CMD);
1207 outw(TxDisable, ioaddr + EL3_CMD);
1208
1209 if (dev->if_port == 3)
1210 /* Turn off thinnet power. Green! */
1211 outw(StopCoax, ioaddr + EL3_CMD);
1212 else if (dev->if_port == 0) {
1213 /* Disable link beat and jabber, if_port may change here next open(). */
1214 EL3WINDOW(4);
1215 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1216 }
1217
1218 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1219
1220 update_stats(dev);
1221}
1222
1223static void
1224el3_up(struct net_device *dev)
1225{
1226 int i, sw_info, net_diag;
1227 int ioaddr = dev->base_addr;
1228
1229 /* Activating the board required and does no harm otherwise */
1230 outw(0x0001, ioaddr + 4);
1231
1232 /* Set the IRQ line. */
1233 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1234
1235 /* Set the station address in window 2 each time opened. */
1236 EL3WINDOW(2);
1237
1238 for (i = 0; i < 6; i++)
1239 outb(dev->dev_addr[i], ioaddr + i);
1240
1241 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1242 /* Start the thinnet transceiver. We should really wait 50ms...*/
1243 outw(StartCoax, ioaddr + EL3_CMD);
1244 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1245 /* Combine secondary sw_info word (the adapter level) and primary
1246 sw_info word (duplex setting plus other useless bits) */
1247 EL3WINDOW(0);
1248 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1249 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1250
1251 EL3WINDOW(4);
1252 net_diag = inw(ioaddr + WN4_NETDIAG);
1253 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1254 pr_info("%s: ", dev->name);
1255 switch (dev->if_port & 0x0c) {
1256 case 12:
1257 /* force full-duplex mode if 3c5x9b */
1258 if (sw_info & 0x000f) {
1259 pr_cont("Forcing 3c5x9b full-duplex mode");
1260 break;
1261 }
1262 fallthrough;
1263 case 8:
1264 /* set full-duplex mode based on eeprom config setting */
1265 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1266 pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1267 break;
1268 }
1269 fallthrough;
1270 default:
1271 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1272 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1273 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1274 }
1275
1276 outw(net_diag, ioaddr + WN4_NETDIAG);
1277 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1278 if (el3_debug > 3)
1279 pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1280 /* Enable link beat and jabber check. */
1281 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1282 }
1283
1284 /* Switch to the stats window, and clear all stats by reading. */
1285 outw(StatsDisable, ioaddr + EL3_CMD);
1286 EL3WINDOW(6);
1287 for (i = 0; i < 9; i++)
1288 inb(ioaddr + i);
1289 inw(ioaddr + 10);
1290 inw(ioaddr + 12);
1291
1292 /* Switch to register set 1 for normal use. */
1293 EL3WINDOW(1);
1294
1295 /* Accept b-case and phys addr only. */
1296 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1297 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1298
1299 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1300 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1301 /* Allow status bits to be seen. */
1302 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1303 /* Ack all pending events, and set active indicator mask. */
1304 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1305 ioaddr + EL3_CMD);
1306 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1307 ioaddr + EL3_CMD);
1308
1309 netif_start_queue(dev);
1310}
1311
1312/* Power Management support functions */
1313#ifdef CONFIG_PM
1314
1315static int
1316el3_suspend(struct device *pdev, pm_message_t state)
1317{
1318 unsigned long flags;
1319 struct net_device *dev;
1320 struct el3_private *lp;
1321 int ioaddr;
1322
1323 dev = dev_get_drvdata(pdev);
1324 lp = netdev_priv(dev);
1325 ioaddr = dev->base_addr;
1326
1327 spin_lock_irqsave(&lp->lock, flags);
1328
1329 if (netif_running(dev))
1330 netif_device_detach(dev);
1331
1332 el3_down(dev);
1333 outw(PowerDown, ioaddr + EL3_CMD);
1334
1335 spin_unlock_irqrestore(&lp->lock, flags);
1336 return 0;
1337}
1338
1339static int
1340el3_resume(struct device *pdev)
1341{
1342 unsigned long flags;
1343 struct net_device *dev;
1344 struct el3_private *lp;
1345 int ioaddr;
1346
1347 dev = dev_get_drvdata(pdev);
1348 lp = netdev_priv(dev);
1349 ioaddr = dev->base_addr;
1350
1351 spin_lock_irqsave(&lp->lock, flags);
1352
1353 outw(PowerUp, ioaddr + EL3_CMD);
1354 EL3WINDOW(0);
1355 el3_up(dev);
1356
1357 if (netif_running(dev))
1358 netif_device_attach(dev);
1359
1360 spin_unlock_irqrestore(&lp->lock, flags);
1361 return 0;
1362}
1363
1364#endif /* CONFIG_PM */
1365
1366module_param(debug,int, 0);
1367module_param_hw_array(irq, int, irq, NULL, 0);
1368module_param(max_interrupt_work, int, 0);
1369MODULE_PARM_DESC(debug, "debug level (0-6)");
1370MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1371MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1372#ifdef CONFIG_PNP
1373module_param(nopnp, int, 0);
1374MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1375#endif /* CONFIG_PNP */
1376MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1377MODULE_LICENSE("GPL");
1378
1379static int __init el3_init_module(void)
1380{
1381 int ret = 0;
1382
1383 if (debug >= 0)
1384 el3_debug = debug;
1385
1386#ifdef CONFIG_PNP
1387 if (!nopnp) {
1388 ret = pnp_register_driver(&el3_pnp_driver);
1389 if (!ret)
1390 pnp_registered = 1;
1391 }
1392#endif
1393 /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1394 /* Start with 0x110 to avoid some sound cards.*/
1395 for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1396 if (!request_region(id_port, 1, "3c509-control"))
1397 continue;
1398 outb(0x00, id_port);
1399 outb(0xff, id_port);
1400 if (inb(id_port) & 0x01)
1401 break;
1402 else
1403 release_region(id_port, 1);
1404 }
1405 if (id_port >= 0x200) {
1406 id_port = 0;
1407 pr_err("No I/O port available for 3c509 activation.\n");
1408 } else {
1409 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1410 if (!ret)
1411 isa_registered = 1;
1412 }
1413#ifdef CONFIG_EISA
1414 ret = eisa_driver_register(&el3_eisa_driver);
1415 if (!ret)
1416 eisa_registered = 1;
1417#endif
1418
1419#ifdef CONFIG_PNP
1420 if (pnp_registered)
1421 ret = 0;
1422#endif
1423 if (isa_registered)
1424 ret = 0;
1425#ifdef CONFIG_EISA
1426 if (eisa_registered)
1427 ret = 0;
1428#endif
1429 return ret;
1430}
1431
1432static void __exit el3_cleanup_module(void)
1433{
1434#ifdef CONFIG_PNP
1435 if (pnp_registered)
1436 pnp_unregister_driver(&el3_pnp_driver);
1437#endif
1438 if (isa_registered)
1439 isa_unregister_driver(&el3_isa_driver);
1440 if (id_port)
1441 release_region(id_port, 1);
1442#ifdef CONFIG_EISA
1443 if (eisa_registered)
1444 eisa_driver_unregister(&el3_eisa_driver);
1445#endif
1446}
1447
1448module_init (el3_init_module);
1449module_exit (el3_cleanup_module);