1 /* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
3 Written 1993-2000 by Donald Becker.
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.
11 This driver is for the 3Com EtherLinkIII series.
13 The author may be reached as becker@scyld.com, or C/O
14 Scyld Computing Corporation
15 410 Severn Ave., Suite 210
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.
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.
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)
35 v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
37 Andrea Arcangeli: Upgraded to Donald Becker's version 1.12.
38 Rick Payne: Fixed SMP race condition
39 v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
40 v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
41 v1.15 1/31/98 Faster recovery for Tx errors. -djb
42 v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
43 v1.18 12Mar2001 Andrew Morton <andrewm@uow.edu.au>
44 - Avoid bogus detect of 3c590's (Andrzej Krzysztofowicz)
45 - Reviewed against 1.18 from scyld.com
46 v1.18a 17Nov2001 Jeff Garzik <jgarzik@pobox.com>
48 v1.18b 1Mar2002 Zwane Mwaikambo <zwane@commfireservices.com>
49 - Power Management support
50 v1.18c 1Mar2002 David Ruggiero <jdr@farfalle.com>
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.
60 #define DRV_NAME "3c509"
61 #define DRV_VERSION "1.19b"
62 #define DRV_RELDATE "08Nov2002"
64 /* A few values that may be tweaked. */
66 /* Time in jiffies before concluding the transmitter is hung. */
67 #define TX_TIMEOUT (400*HZ/1000)
68 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
69 static int max_interrupt_work
= 10;
71 #include <linux/module.h>
73 #include <linux/mca.h>
75 #include <linux/isapnp.h>
76 #include <linux/string.h>
77 #include <linux/interrupt.h>
78 #include <linux/errno.h>
80 #include <linux/slab.h>
81 #include <linux/ioport.h>
82 #include <linux/init.h>
83 #include <linux/netdevice.h>
84 #include <linux/etherdevice.h>
86 #include <linux/skbuff.h>
87 #include <linux/delay.h> /* for udelay() */
88 #include <linux/spinlock.h>
89 #include <linux/ethtool.h>
90 #include <linux/device.h>
91 #include <linux/eisa.h>
92 #include <linux/bitops.h>
94 #include <asm/uaccess.h>
98 static char versionA
[] __initdata
= DRV_NAME
".c:" DRV_VERSION
" " DRV_RELDATE
" becker@scyld.com\n";
99 static char versionB
[] __initdata
= "http://www.scyld.com/network/3c509.html\n";
101 #if defined(CONFIG_PM) && (defined(CONFIG_MCA) || defined(CONFIG_EISA))
106 static int el3_debug
= EL3_DEBUG
;
108 static int el3_debug
= 2;
111 /* Used to do a global count of all the cards in the system. Must be
112 * a global variable so that the mca/eisa probe routines can increment
114 static int el3_cards
= 0;
116 /* To minimize the size of the driver source I only define operating
117 constants if they are used several times. You'll need the manual
118 anyway if you want to understand driver details. */
119 /* Offsets from base I/O address. */
120 #define EL3_DATA 0x00
122 #define EL3_STATUS 0x0e
123 #define EEPROM_READ 0x80
125 #define EL3_IO_EXTENT 16
127 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
130 /* The top five bits written to EL3_CMD are a command, the lower
131 11 bits are the parameter, if applicable. */
133 TotalReset
= 0<<11, SelectWindow
= 1<<11, StartCoax
= 2<<11,
134 RxDisable
= 3<<11, RxEnable
= 4<<11, RxReset
= 5<<11, RxDiscard
= 8<<11,
135 TxEnable
= 9<<11, TxDisable
= 10<<11, TxReset
= 11<<11,
136 FakeIntr
= 12<<11, AckIntr
= 13<<11, SetIntrEnb
= 14<<11,
137 SetStatusEnb
= 15<<11, SetRxFilter
= 16<<11, SetRxThreshold
= 17<<11,
138 SetTxThreshold
= 18<<11, SetTxStart
= 19<<11, StatsEnable
= 21<<11,
139 StatsDisable
= 22<<11, StopCoax
= 23<<11, PowerUp
= 27<<11,
140 PowerDown
= 28<<11, PowerAuto
= 29<<11};
143 IntLatch
= 0x0001, AdapterFailure
= 0x0002, TxComplete
= 0x0004,
144 TxAvailable
= 0x0008, RxComplete
= 0x0010, RxEarly
= 0x0020,
145 IntReq
= 0x0040, StatsFull
= 0x0080, CmdBusy
= 0x1000, };
147 /* The SetRxFilter command accepts the following classes: */
149 RxStation
= 1, RxMulticast
= 2, RxBroadcast
= 4, RxProm
= 8 };
151 /* Register window 1 offsets, the window used in normal operation. */
154 #define RX_STATUS 0x08
155 #define TX_STATUS 0x0B
156 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
158 #define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
159 #define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
160 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
161 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
162 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
163 #define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
164 #define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
167 * Must be a power of two (we use a binary and in the
170 #define SKB_QUEUE_SIZE 64
173 struct net_device_stats stats
;
174 struct net_device
*next_dev
;
178 struct sk_buff
*queue
[SKB_QUEUE_SIZE
];
183 } type
; /* type of device */
186 static int id_port __initdata
= 0x110; /* Start with 0x110 to avoid new sound cards.*/
187 static struct net_device
*el3_root_dev
;
189 static ushort
id_read_eeprom(int index
);
190 static ushort
read_eeprom(int ioaddr
, int index
);
191 static int el3_open(struct net_device
*dev
);
192 static int el3_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
);
193 static irqreturn_t
el3_interrupt(int irq
, void *dev_id
);
194 static void update_stats(struct net_device
*dev
);
195 static struct net_device_stats
*el3_get_stats(struct net_device
*dev
);
196 static int el3_rx(struct net_device
*dev
);
197 static int el3_close(struct net_device
*dev
);
198 static void set_multicast_list(struct net_device
*dev
);
199 static void el3_tx_timeout (struct net_device
*dev
);
200 static void el3_down(struct net_device
*dev
);
201 static void el3_up(struct net_device
*dev
);
202 static const struct ethtool_ops ethtool_ops
;
204 static int el3_suspend(struct device
*, pm_message_t
);
205 static int el3_resume(struct device
*);
207 #define el3_suspend NULL
208 #define el3_resume NULL
212 /* generic device remove for all device types */
213 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
214 static int el3_device_remove (struct device
*device
);
216 #ifdef CONFIG_NET_POLL_CONTROLLER
217 static void el3_poll_controller(struct net_device
*dev
);
221 static struct eisa_device_id el3_eisa_ids
[] = {
227 MODULE_DEVICE_TABLE(eisa
, el3_eisa_ids
);
229 static int el3_eisa_probe (struct device
*device
);
231 static struct eisa_driver el3_eisa_driver
= {
232 .id_table
= el3_eisa_ids
,
235 .probe
= el3_eisa_probe
,
236 .remove
= __devexit_p (el3_device_remove
),
237 .suspend
= el3_suspend
,
238 .resume
= el3_resume
,
244 static int el3_mca_probe(struct device
*dev
);
246 static short el3_mca_adapter_ids
[] __initdata
= {
255 static char *el3_mca_adapter_names
[] __initdata
= {
256 "3Com 3c529 EtherLink III (10base2)",
257 "3Com 3c529 EtherLink III (10baseT)",
258 "3Com 3c529 EtherLink III (test mode)",
259 "3Com 3c529 EtherLink III (TP or coax)",
260 "3Com 3c529 EtherLink III (TP)",
264 static struct mca_driver el3_mca_driver
= {
265 .id_table
= el3_mca_adapter_ids
,
268 .bus
= &mca_bus_type
,
269 .probe
= el3_mca_probe
,
270 .remove
= __devexit_p(el3_device_remove
),
271 .suspend
= el3_suspend
,
272 .resume
= el3_resume
,
275 #endif /* CONFIG_MCA */
277 #if defined(__ISAPNP__)
278 static struct isapnp_device_id el3_isapnp_adapters
[] __initdata
= {
279 { ISAPNP_ANY_ID
, ISAPNP_ANY_ID
,
280 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5090),
281 (long) "3Com Etherlink III (TP)" },
282 { ISAPNP_ANY_ID
, ISAPNP_ANY_ID
,
283 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5091),
284 (long) "3Com Etherlink III" },
285 { ISAPNP_ANY_ID
, ISAPNP_ANY_ID
,
286 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5094),
287 (long) "3Com Etherlink III (combo)" },
288 { ISAPNP_ANY_ID
, ISAPNP_ANY_ID
,
289 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5095),
290 (long) "3Com Etherlink III (TPO)" },
291 { ISAPNP_ANY_ID
, ISAPNP_ANY_ID
,
292 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5098),
293 (long) "3Com Etherlink III (TPC)" },
294 { ISAPNP_ANY_ID
, ISAPNP_ANY_ID
,
295 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f7),
296 (long) "3Com Etherlink III compatible" },
297 { ISAPNP_ANY_ID
, ISAPNP_ANY_ID
,
298 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f8),
299 (long) "3Com Etherlink III compatible" },
300 { } /* terminate list */
303 static u16 el3_isapnp_phys_addr
[8][3];
305 #endif /* __ISAPNP__ */
307 /* With the driver model introduction for EISA devices, both init
308 * and cleanup have been split :
309 * - EISA devices probe/remove starts in el3_eisa_probe/el3_device_remove
310 * - MCA/ISA still use el3_probe
312 * Both call el3_common_init/el3_common_remove. */
314 static int __init
el3_common_init(struct net_device
*dev
)
316 struct el3_private
*lp
= netdev_priv(dev
);
320 spin_lock_init(&lp
->lock
);
322 if (dev
->mem_start
& 0x05) { /* xcvr codes 1/3/4/12 */
323 dev
->if_port
= (dev
->mem_start
& 0x0f);
324 } else { /* xcvr codes 0/8 */
325 /* use eeprom value, but save user's full-duplex selection */
326 dev
->if_port
|= (dev
->mem_start
& 0x08);
329 /* The EL3-specific entries in the device structure. */
330 dev
->open
= &el3_open
;
331 dev
->hard_start_xmit
= &el3_start_xmit
;
332 dev
->stop
= &el3_close
;
333 dev
->get_stats
= &el3_get_stats
;
334 dev
->set_multicast_list
= &set_multicast_list
;
335 dev
->tx_timeout
= el3_tx_timeout
;
336 dev
->watchdog_timeo
= TX_TIMEOUT
;
337 #ifdef CONFIG_NET_POLL_CONTROLLER
338 dev
->poll_controller
= el3_poll_controller
;
340 SET_ETHTOOL_OPS(dev
, ðtool_ops
);
342 err
= register_netdev(dev
);
344 printk(KERN_ERR
"Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
345 dev
->base_addr
, dev
->irq
);
346 release_region(dev
->base_addr
, EL3_IO_EXTENT
);
351 const char *if_names
[] = {"10baseT", "AUI", "undefined", "BNC"};
352 printk("%s: 3c5x9 found at %#3.3lx, %s port, address ",
353 dev
->name
, dev
->base_addr
,
354 if_names
[(dev
->if_port
& 0x03)]);
357 /* Read in the station address. */
358 for (i
= 0; i
< 6; i
++)
359 printk(" %2.2x", dev
->dev_addr
[i
]);
360 printk(", IRQ %d.\n", dev
->irq
);
363 printk(KERN_INFO
"%s" KERN_INFO
"%s", versionA
, versionB
);
368 static void el3_common_remove (struct net_device
*dev
)
370 struct el3_private
*lp
= netdev_priv(dev
);
372 (void) lp
; /* Keep gcc quiet... */
373 #if defined(__ISAPNP__)
374 if (lp
->type
== EL3_PNP
)
375 pnp_device_detach(to_pnp_dev(lp
->dev
));
378 unregister_netdev (dev
);
379 release_region(dev
->base_addr
, EL3_IO_EXTENT
);
383 static int __init
el3_probe(int card_idx
)
385 struct net_device
*dev
;
386 struct el3_private
*lp
;
387 short lrs_state
= 0xff, i
;
388 int ioaddr
, irq
, if_port
;
390 static int current_tag
;
392 #if defined(__ISAPNP__)
393 static int pnp_cards
;
394 struct pnp_dev
*idev
= NULL
;
399 for (i
=0; el3_isapnp_adapters
[i
].vendor
!= 0; i
++) {
401 while ((idev
= pnp_find_dev(NULL
,
402 el3_isapnp_adapters
[i
].vendor
,
403 el3_isapnp_adapters
[i
].function
,
405 if (pnp_device_attach(idev
) < 0)
407 if (pnp_activate_dev(idev
) < 0) {
409 pnp_device_detach(idev
);
412 if (!pnp_port_valid(idev
, 0) || !pnp_irq_valid(idev
, 0))
414 ioaddr
= pnp_port_start(idev
, 0);
415 if (!request_region(ioaddr
, EL3_IO_EXTENT
, "3c509 PnP")) {
416 pnp_device_detach(idev
);
419 irq
= pnp_irq(idev
, 0);
421 printk ("ISAPnP reports %s at i/o 0x%x, irq %d\n",
422 (char*) el3_isapnp_adapters
[i
].driver_data
, ioaddr
, irq
);
424 for (j
= 0; j
< 3; j
++)
425 el3_isapnp_phys_addr
[pnp_cards
][j
] =
427 htons(read_eeprom(ioaddr
, j
));
428 if_port
= read_eeprom(ioaddr
, 8) >> 14;
429 dev
= alloc_etherdev(sizeof (struct el3_private
));
431 release_region(ioaddr
, EL3_IO_EXTENT
);
432 pnp_device_detach(idev
);
436 SET_MODULE_OWNER(dev
);
437 SET_NETDEV_DEV(dev
, &idev
->dev
);
440 netdev_boot_setup_check(dev
);
445 #endif /* __ISAPNP__ */
447 /* Select an open I/O location at 0x1*0 to do contention select. */
448 for ( ; id_port
< 0x200; id_port
+= 0x10) {
449 if (!request_region(id_port
, 1, "3c509"))
453 if (inb(id_port
) & 0x01){
454 release_region(id_port
, 1);
457 release_region(id_port
, 1);
459 if (id_port
>= 0x200) {
460 /* Rare -- do we really need a warning? */
461 printk(" WARNING: No I/O port available for 3c509 activation.\n");
465 /* Next check for all ISA bus boards by sending the ID sequence to the
466 ID_PORT. We find cards past the first by setting the 'current_tag'
467 on cards as they are found. Cards with their tag set will not
468 respond to subsequent ID sequences. */
472 for(i
= 0; i
< 255; i
++) {
473 outb(lrs_state
, id_port
);
475 lrs_state
= lrs_state
& 0x100 ? lrs_state
^ 0xcf : lrs_state
;
478 /* For the first probe, clear all board's tag registers. */
479 if (current_tag
== 0)
481 else /* Otherwise kill off already-found boards. */
484 if (id_read_eeprom(7) != 0x6d50) {
488 /* Read in EEPROM data, which does contention-select.
489 Only the lowest address board will stay "on-line".
490 3Com got the byte order backwards. */
491 for (i
= 0; i
< 3; i
++) {
492 phys_addr
[i
] = htons(id_read_eeprom(i
));
495 #if defined(__ISAPNP__)
497 /* The ISA PnP 3c509 cards respond to the ID sequence.
498 This check is needed in order not to register them twice. */
499 for (i
= 0; i
< pnp_cards
; i
++) {
500 if (phys_addr
[0] == el3_isapnp_phys_addr
[i
][0] &&
501 phys_addr
[1] == el3_isapnp_phys_addr
[i
][1] &&
502 phys_addr
[2] == el3_isapnp_phys_addr
[i
][2])
505 printk("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
506 phys_addr
[0] & 0xff, phys_addr
[0] >> 8,
507 phys_addr
[1] & 0xff, phys_addr
[1] >> 8,
508 phys_addr
[2] & 0xff, phys_addr
[2] >> 8);
509 /* Set the adaptor tag so that the next card can be found. */
510 outb(0xd0 + ++current_tag
, id_port
);
515 #endif /* __ISAPNP__ */
518 unsigned int iobase
= id_read_eeprom(8);
519 if_port
= iobase
>> 14;
520 ioaddr
= 0x200 + ((iobase
& 0x1f) << 4);
522 irq
= id_read_eeprom(9) >> 12;
524 dev
= alloc_etherdev(sizeof (struct el3_private
));
528 SET_MODULE_OWNER(dev
);
530 netdev_boot_setup_check(dev
);
532 /* Set passed-in IRQ or I/O Addr. */
533 if (dev
->irq
> 1 && dev
->irq
< 16)
536 if (dev
->base_addr
) {
537 if (dev
->mem_end
== 0x3c509 /* Magic key */
538 && dev
->base_addr
>= 0x200 && dev
->base_addr
<= 0x3e0)
539 ioaddr
= dev
->base_addr
& 0x3f0;
540 else if (dev
->base_addr
!= ioaddr
)
544 if (!request_region(ioaddr
, EL3_IO_EXTENT
, "3c509")) {
549 /* Set the adaptor tag so that the next card can be found. */
550 outb(0xd0 + ++current_tag
, id_port
);
552 /* Activate the adaptor at the EEPROM location. */
553 outb((ioaddr
>> 4) | 0xe0, id_port
);
556 if (inw(ioaddr
) != 0x6d50)
559 /* Free the interrupt so that some other card can use it. */
560 outw(0x0f00, ioaddr
+ WN0_IRQ
);
562 #if defined(__ISAPNP__)
563 found
: /* PNP jumps here... */
564 #endif /* __ISAPNP__ */
566 memcpy(dev
->dev_addr
, phys_addr
, sizeof(phys_addr
));
567 dev
->base_addr
= ioaddr
;
569 dev
->if_port
= if_port
;
570 lp
= netdev_priv(dev
);
571 #if defined(__ISAPNP__)
572 lp
->dev
= &idev
->dev
;
574 err
= el3_common_init(dev
);
580 lp
->next_dev
= el3_root_dev
;
585 #if defined(__ISAPNP__)
587 pnp_device_detach(idev
);
595 static int __init
el3_mca_probe(struct device
*device
)
597 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
598 * heavily modified by Chris Beauregard
599 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
602 * redone for multi-card detection by ZP Gu (zpg@castle.net)
603 * now works as a module */
605 struct el3_private
*lp
;
607 int ioaddr
, irq
, if_port
;
609 struct net_device
*dev
= NULL
;
611 struct mca_device
*mdev
= to_mca_device(device
);
612 int slot
= mdev
->slot
;
615 pos4
= mca_device_read_stored_pos(mdev
, 4);
616 pos5
= mca_device_read_stored_pos(mdev
, 5);
618 ioaddr
= ((short)((pos4
&0xfc)|0x02)) << 8;
622 printk("3c529: found %s at slot %d\n",
623 el3_mca_adapter_names
[mdev
->index
], slot
+ 1);
626 strncpy(mdev
->name
, el3_mca_adapter_names
[mdev
->index
],
628 mca_device_set_claim(mdev
, 1);
630 if_port
= pos4
& 0x03;
632 irq
= mca_device_transform_irq(mdev
, irq
);
633 ioaddr
= mca_device_transform_ioport(mdev
, ioaddr
);
635 printk("3c529: irq %d ioaddr 0x%x ifport %d\n", irq
, ioaddr
, if_port
);
638 for (i
= 0; i
< 3; i
++) {
639 phys_addr
[i
] = htons(read_eeprom(ioaddr
, i
));
642 dev
= alloc_etherdev(sizeof (struct el3_private
));
644 release_region(ioaddr
, EL3_IO_EXTENT
);
648 SET_MODULE_OWNER(dev
);
649 netdev_boot_setup_check(dev
);
651 memcpy(dev
->dev_addr
, phys_addr
, sizeof(phys_addr
));
652 dev
->base_addr
= ioaddr
;
654 dev
->if_port
= if_port
;
655 lp
= netdev_priv(dev
);
658 device
->driver_data
= dev
;
659 err
= el3_common_init(dev
);
662 device
->driver_data
= NULL
;
671 #endif /* CONFIG_MCA */
674 static int __init
el3_eisa_probe (struct device
*device
)
676 struct el3_private
*lp
;
678 int ioaddr
, irq
, if_port
;
680 struct net_device
*dev
= NULL
;
681 struct eisa_device
*edev
;
684 /* Yeepee, The driver framework is calling us ! */
685 edev
= to_eisa_device (device
);
686 ioaddr
= edev
->base_addr
;
688 if (!request_region(ioaddr
, EL3_IO_EXTENT
, "3c509"))
691 /* Change the register set to the configuration window 0. */
692 outw(SelectWindow
| 0, ioaddr
+ 0xC80 + EL3_CMD
);
694 irq
= inw(ioaddr
+ WN0_IRQ
) >> 12;
695 if_port
= inw(ioaddr
+ 6)>>14;
696 for (i
= 0; i
< 3; i
++)
697 phys_addr
[i
] = htons(read_eeprom(ioaddr
, i
));
699 /* Restore the "Product ID" to the EEPROM read register. */
700 read_eeprom(ioaddr
, 3);
702 dev
= alloc_etherdev(sizeof (struct el3_private
));
704 release_region(ioaddr
, EL3_IO_EXTENT
);
708 SET_MODULE_OWNER(dev
);
710 netdev_boot_setup_check(dev
);
712 memcpy(dev
->dev_addr
, phys_addr
, sizeof(phys_addr
));
713 dev
->base_addr
= ioaddr
;
715 dev
->if_port
= if_port
;
716 lp
= netdev_priv(dev
);
719 eisa_set_drvdata (edev
, dev
);
720 err
= el3_common_init(dev
);
723 eisa_set_drvdata (edev
, NULL
);
733 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
734 /* This remove works for all device types.
736 * The net dev must be stored in the driver_data field */
737 static int __devexit
el3_device_remove (struct device
*device
)
739 struct net_device
*dev
;
741 dev
= device
->driver_data
;
743 el3_common_remove (dev
);
748 /* Read a word from the EEPROM using the regular EEPROM access register.
749 Assume that we are in register window zero.
751 static ushort
read_eeprom(int ioaddr
, int index
)
753 outw(EEPROM_READ
+ index
, ioaddr
+ 10);
754 /* Pause for at least 162 us. for the read to take place.
755 Some chips seem to require much longer */
757 return inw(ioaddr
+ 12);
760 /* Read a word from the EEPROM when in the ISA ID probe state. */
761 static ushort __init
id_read_eeprom(int index
)
765 /* Issue read command, and pause for at least 162 us. for it to complete.
766 Assume extra-fast 16Mhz bus. */
767 outb(EEPROM_READ
+ index
, id_port
);
769 /* Pause for at least 162 us. for the read to take place. */
770 /* Some chips seem to require much longer */
773 for (bit
= 15; bit
>= 0; bit
--)
774 word
= (word
<< 1) + (inb(id_port
) & 0x01);
777 printk(" 3c509 EEPROM word %d %#4.4x.\n", index
, word
);
784 el3_open(struct net_device
*dev
)
786 int ioaddr
= dev
->base_addr
;
789 outw(TxReset
, ioaddr
+ EL3_CMD
);
790 outw(RxReset
, ioaddr
+ EL3_CMD
);
791 outw(SetStatusEnb
| 0x00, ioaddr
+ EL3_CMD
);
793 i
= request_irq(dev
->irq
, &el3_interrupt
, 0, dev
->name
, dev
);
799 printk("%s: Opening, IRQ %d status@%x %4.4x.\n", dev
->name
,
800 dev
->irq
, ioaddr
+ EL3_STATUS
, inw(ioaddr
+ EL3_STATUS
));
805 printk("%s: Opened 3c509 IRQ %d status %4.4x.\n",
806 dev
->name
, dev
->irq
, inw(ioaddr
+ EL3_STATUS
));
812 el3_tx_timeout (struct net_device
*dev
)
814 struct el3_private
*lp
= netdev_priv(dev
);
815 int ioaddr
= dev
->base_addr
;
817 /* Transmitter timeout, serious problems. */
818 printk("%s: transmit timed out, Tx_status %2.2x status %4.4x "
819 "Tx FIFO room %d.\n",
820 dev
->name
, inb(ioaddr
+ TX_STATUS
), inw(ioaddr
+ EL3_STATUS
),
821 inw(ioaddr
+ TX_FREE
));
822 lp
->stats
.tx_errors
++;
823 dev
->trans_start
= jiffies
;
824 /* Issue TX_RESET and TX_START commands. */
825 outw(TxReset
, ioaddr
+ EL3_CMD
);
826 outw(TxEnable
, ioaddr
+ EL3_CMD
);
827 netif_wake_queue(dev
);
832 el3_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
834 struct el3_private
*lp
= netdev_priv(dev
);
835 int ioaddr
= dev
->base_addr
;
838 netif_stop_queue (dev
);
840 lp
->stats
.tx_bytes
+= skb
->len
;
843 printk("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
844 dev
->name
, skb
->len
, inw(ioaddr
+ EL3_STATUS
));
847 #ifndef final_version
848 { /* Error-checking code, delete someday. */
849 ushort status
= inw(ioaddr
+ EL3_STATUS
);
850 if (status
& 0x0001 /* IRQ line active, missed one. */
851 && inw(ioaddr
+ EL3_STATUS
) & 1) { /* Make sure. */
852 printk("%s: Missed interrupt, status then %04x now %04x"
853 " Tx %2.2x Rx %4.4x.\n", dev
->name
, status
,
854 inw(ioaddr
+ EL3_STATUS
), inb(ioaddr
+ TX_STATUS
),
855 inw(ioaddr
+ RX_STATUS
));
856 /* Fake interrupt trigger by masking, acknowledge interrupts. */
857 outw(SetStatusEnb
| 0x00, ioaddr
+ EL3_CMD
);
858 outw(AckIntr
| IntLatch
| TxAvailable
| RxEarly
| IntReq
,
860 outw(SetStatusEnb
| 0xff, ioaddr
+ EL3_CMD
);
866 * We lock the driver against other processors. Note
867 * we don't need to lock versus the IRQ as we suspended
868 * that. This means that we lose the ability to take
869 * an RX during a TX upload. That sucks a bit with SMP
870 * on an original 3c509 (2K buffer)
872 * Using disable_irq stops us crapping on other
873 * time sensitive devices.
876 spin_lock_irqsave(&lp
->lock
, flags
);
878 /* Put out the doubleword header... */
879 outw(skb
->len
, ioaddr
+ TX_FIFO
);
880 outw(0x00, ioaddr
+ TX_FIFO
);
881 /* ... and the packet rounded to a doubleword. */
882 outsl(ioaddr
+ TX_FIFO
, skb
->data
, (skb
->len
+ 3) >> 2);
884 dev
->trans_start
= jiffies
;
885 if (inw(ioaddr
+ TX_FREE
) > 1536)
886 netif_start_queue(dev
);
888 /* Interrupt us when the FIFO has room for max-sized packet. */
889 outw(SetTxThreshold
+ 1536, ioaddr
+ EL3_CMD
);
891 spin_unlock_irqrestore(&lp
->lock
, flags
);
895 /* Clear the Tx status stack. */
900 while (--i
> 0 && (tx_status
= inb(ioaddr
+ TX_STATUS
)) > 0) {
901 if (tx_status
& 0x38) lp
->stats
.tx_aborted_errors
++;
902 if (tx_status
& 0x30) outw(TxReset
, ioaddr
+ EL3_CMD
);
903 if (tx_status
& 0x3C) outw(TxEnable
, ioaddr
+ EL3_CMD
);
904 outb(0x00, ioaddr
+ TX_STATUS
); /* Pop the status stack. */
910 /* The EL3 interrupt handler. */
912 el3_interrupt(int irq
, void *dev_id
)
914 struct net_device
*dev
= dev_id
;
915 struct el3_private
*lp
;
917 int i
= max_interrupt_work
;
919 lp
= netdev_priv(dev
);
920 spin_lock(&lp
->lock
);
922 ioaddr
= dev
->base_addr
;
925 status
= inw(ioaddr
+ EL3_STATUS
);
926 printk("%s: interrupt, status %4.4x.\n", dev
->name
, status
);
929 while ((status
= inw(ioaddr
+ EL3_STATUS
)) &
930 (IntLatch
| RxComplete
| StatsFull
)) {
932 if (status
& RxComplete
)
935 if (status
& TxAvailable
) {
937 printk(" TX room bit was handled.\n");
938 /* There's room in the FIFO for a full-sized packet. */
939 outw(AckIntr
| TxAvailable
, ioaddr
+ EL3_CMD
);
940 netif_wake_queue (dev
);
942 if (status
& (AdapterFailure
| RxEarly
| StatsFull
| TxComplete
)) {
943 /* Handle all uncommon interrupts. */
944 if (status
& StatsFull
) /* Empty statistics. */
946 if (status
& RxEarly
) { /* Rx early is unused. */
948 outw(AckIntr
| RxEarly
, ioaddr
+ EL3_CMD
);
950 if (status
& TxComplete
) { /* Really Tx error. */
951 struct el3_private
*lp
= netdev_priv(dev
);
955 while (--i
>0 && (tx_status
= inb(ioaddr
+ TX_STATUS
)) > 0) {
956 if (tx_status
& 0x38) lp
->stats
.tx_aborted_errors
++;
957 if (tx_status
& 0x30) outw(TxReset
, ioaddr
+ EL3_CMD
);
958 if (tx_status
& 0x3C) outw(TxEnable
, ioaddr
+ EL3_CMD
);
959 outb(0x00, ioaddr
+ TX_STATUS
); /* Pop the status stack. */
962 if (status
& AdapterFailure
) {
963 /* Adapter failure requires Rx reset and reinit. */
964 outw(RxReset
, ioaddr
+ EL3_CMD
);
965 /* Set the Rx filter to the current state. */
966 outw(SetRxFilter
| RxStation
| RxBroadcast
967 | (dev
->flags
& IFF_ALLMULTI
? RxMulticast
: 0)
968 | (dev
->flags
& IFF_PROMISC
? RxProm
: 0),
970 outw(RxEnable
, ioaddr
+ EL3_CMD
); /* Re-enable the receiver. */
971 outw(AckIntr
| AdapterFailure
, ioaddr
+ EL3_CMD
);
976 printk("%s: Infinite loop in interrupt, status %4.4x.\n",
978 /* Clear all interrupts. */
979 outw(AckIntr
| 0xFF, ioaddr
+ EL3_CMD
);
982 /* Acknowledge the IRQ. */
983 outw(AckIntr
| IntReq
| IntLatch
, ioaddr
+ EL3_CMD
); /* Ack IRQ */
987 printk("%s: exiting interrupt, status %4.4x.\n", dev
->name
,
988 inw(ioaddr
+ EL3_STATUS
));
990 spin_unlock(&lp
->lock
);
995 #ifdef CONFIG_NET_POLL_CONTROLLER
997 * Polling receive - used by netconsole and other diagnostic tools
998 * to allow network i/o with interrupts disabled.
1000 static void el3_poll_controller(struct net_device
*dev
)
1002 disable_irq(dev
->irq
);
1003 el3_interrupt(dev
->irq
, dev
);
1004 enable_irq(dev
->irq
);
1008 static struct net_device_stats
*
1009 el3_get_stats(struct net_device
*dev
)
1011 struct el3_private
*lp
= netdev_priv(dev
);
1012 unsigned long flags
;
1015 * This is fast enough not to bother with disable IRQ
1019 spin_lock_irqsave(&lp
->lock
, flags
);
1021 spin_unlock_irqrestore(&lp
->lock
, flags
);
1025 /* Update statistics. We change to register window 6, so this should be run
1026 single-threaded if the device is active. This is expected to be a rare
1027 operation, and it's simpler for the rest of the driver to assume that
1028 window 1 is always valid rather than use a special window-state variable.
1030 static void update_stats(struct net_device
*dev
)
1032 struct el3_private
*lp
= netdev_priv(dev
);
1033 int ioaddr
= dev
->base_addr
;
1036 printk(" Updating the statistics.\n");
1037 /* Turn off statistics updates while reading. */
1038 outw(StatsDisable
, ioaddr
+ EL3_CMD
);
1039 /* Switch to the stats window, and read everything. */
1041 lp
->stats
.tx_carrier_errors
+= inb(ioaddr
+ 0);
1042 lp
->stats
.tx_heartbeat_errors
+= inb(ioaddr
+ 1);
1043 /* Multiple collisions. */ inb(ioaddr
+ 2);
1044 lp
->stats
.collisions
+= inb(ioaddr
+ 3);
1045 lp
->stats
.tx_window_errors
+= inb(ioaddr
+ 4);
1046 lp
->stats
.rx_fifo_errors
+= inb(ioaddr
+ 5);
1047 lp
->stats
.tx_packets
+= inb(ioaddr
+ 6);
1048 /* Rx packets */ inb(ioaddr
+ 7);
1049 /* Tx deferrals */ inb(ioaddr
+ 8);
1050 inw(ioaddr
+ 10); /* Total Rx and Tx octets. */
1053 /* Back to window 1, and turn statistics back on. */
1055 outw(StatsEnable
, ioaddr
+ EL3_CMD
);
1060 el3_rx(struct net_device
*dev
)
1062 struct el3_private
*lp
= netdev_priv(dev
);
1063 int ioaddr
= dev
->base_addr
;
1067 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1068 inw(ioaddr
+EL3_STATUS
), inw(ioaddr
+RX_STATUS
));
1069 while ((rx_status
= inw(ioaddr
+ RX_STATUS
)) > 0) {
1070 if (rx_status
& 0x4000) { /* Error, update stats. */
1071 short error
= rx_status
& 0x3800;
1073 outw(RxDiscard
, ioaddr
+ EL3_CMD
);
1074 lp
->stats
.rx_errors
++;
1076 case 0x0000: lp
->stats
.rx_over_errors
++; break;
1077 case 0x0800: lp
->stats
.rx_length_errors
++; break;
1078 case 0x1000: lp
->stats
.rx_frame_errors
++; break;
1079 case 0x1800: lp
->stats
.rx_length_errors
++; break;
1080 case 0x2000: lp
->stats
.rx_frame_errors
++; break;
1081 case 0x2800: lp
->stats
.rx_crc_errors
++; break;
1084 short pkt_len
= rx_status
& 0x7ff;
1085 struct sk_buff
*skb
;
1087 skb
= dev_alloc_skb(pkt_len
+5);
1088 lp
->stats
.rx_bytes
+= pkt_len
;
1090 printk("Receiving packet size %d status %4.4x.\n",
1091 pkt_len
, rx_status
);
1093 skb_reserve(skb
, 2); /* Align IP on 16 byte */
1095 /* 'skb->data' points to the start of sk_buff data area. */
1096 insl(ioaddr
+ RX_FIFO
, skb_put(skb
,pkt_len
),
1097 (pkt_len
+ 3) >> 2);
1099 outw(RxDiscard
, ioaddr
+ EL3_CMD
); /* Pop top Rx packet. */
1100 skb
->protocol
= eth_type_trans(skb
,dev
);
1102 dev
->last_rx
= jiffies
;
1103 lp
->stats
.rx_packets
++;
1106 outw(RxDiscard
, ioaddr
+ EL3_CMD
);
1107 lp
->stats
.rx_dropped
++;
1109 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1110 dev
->name
, pkt_len
);
1112 inw(ioaddr
+ EL3_STATUS
); /* Delay. */
1113 while (inw(ioaddr
+ EL3_STATUS
) & 0x1000)
1114 printk(KERN_DEBUG
" Waiting for 3c509 to discard packet, status %x.\n",
1115 inw(ioaddr
+ EL3_STATUS
) );
1122 * Set or clear the multicast filter for this adaptor.
1125 set_multicast_list(struct net_device
*dev
)
1127 unsigned long flags
;
1128 struct el3_private
*lp
= netdev_priv(dev
);
1129 int ioaddr
= dev
->base_addr
;
1131 if (el3_debug
> 1) {
1133 if (old
!= dev
->mc_count
) {
1134 old
= dev
->mc_count
;
1135 printk("%s: Setting Rx mode to %d addresses.\n", dev
->name
, dev
->mc_count
);
1138 spin_lock_irqsave(&lp
->lock
, flags
);
1139 if (dev
->flags
&IFF_PROMISC
) {
1140 outw(SetRxFilter
| RxStation
| RxMulticast
| RxBroadcast
| RxProm
,
1143 else if (dev
->mc_count
|| (dev
->flags
&IFF_ALLMULTI
)) {
1144 outw(SetRxFilter
| RxStation
| RxMulticast
| RxBroadcast
, ioaddr
+ EL3_CMD
);
1147 outw(SetRxFilter
| RxStation
| RxBroadcast
, ioaddr
+ EL3_CMD
);
1148 spin_unlock_irqrestore(&lp
->lock
, flags
);
1152 el3_close(struct net_device
*dev
)
1154 int ioaddr
= dev
->base_addr
;
1155 struct el3_private
*lp
= netdev_priv(dev
);
1158 printk("%s: Shutting down ethercard.\n", dev
->name
);
1162 free_irq(dev
->irq
, dev
);
1163 /* Switching back to window 0 disables the IRQ. */
1165 if (lp
->type
!= EL3_EISA
) {
1166 /* But we explicitly zero the IRQ line select anyway. Don't do
1167 * it on EISA cards, it prevents the module from getting an
1168 * IRQ after unload+reload... */
1169 outw(0x0f00, ioaddr
+ WN0_IRQ
);
1176 el3_link_ok(struct net_device
*dev
)
1178 int ioaddr
= dev
->base_addr
;
1182 tmp
= inw(ioaddr
+ WN4_MEDIA
);
1184 return tmp
& (1<<11);
1188 el3_netdev_get_ecmd(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1191 int ioaddr
= dev
->base_addr
;
1194 /* obtain current transceiver via WN4_MEDIA? */
1195 tmp
= inw(ioaddr
+ WN0_ADDR_CONF
);
1196 ecmd
->transceiver
= XCVR_INTERNAL
;
1197 switch (tmp
>> 14) {
1199 ecmd
->port
= PORT_TP
;
1202 ecmd
->port
= PORT_AUI
;
1203 ecmd
->transceiver
= XCVR_EXTERNAL
;
1206 ecmd
->port
= PORT_BNC
;
1211 ecmd
->duplex
= DUPLEX_HALF
;
1212 ecmd
->supported
= 0;
1213 tmp
= inw(ioaddr
+ WN0_CONF_CTRL
);
1215 ecmd
->supported
|= SUPPORTED_AUI
;
1217 ecmd
->supported
|= SUPPORTED_BNC
;
1219 ecmd
->supported
|= SUPPORTED_TP
| SUPPORTED_10baseT_Half
|
1220 SUPPORTED_10baseT_Full
; /* hmm... */
1222 tmp
= inw(ioaddr
+ WN4_NETDIAG
);
1223 if (tmp
& FD_ENABLE
)
1224 ecmd
->duplex
= DUPLEX_FULL
;
1227 ecmd
->speed
= SPEED_10
;
1233 el3_netdev_set_ecmd(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1236 int ioaddr
= dev
->base_addr
;
1238 if (ecmd
->speed
!= SPEED_10
)
1240 if ((ecmd
->duplex
!= DUPLEX_HALF
) && (ecmd
->duplex
!= DUPLEX_FULL
))
1242 if ((ecmd
->transceiver
!= XCVR_INTERNAL
) && (ecmd
->transceiver
!= XCVR_EXTERNAL
))
1245 /* change XCVR type */
1247 tmp
= inw(ioaddr
+ WN0_ADDR_CONF
);
1248 switch (ecmd
->port
) {
1265 outw(tmp
, ioaddr
+ WN0_ADDR_CONF
);
1266 if (dev
->if_port
== 3) {
1267 /* fire up the DC-DC convertor if BNC gets enabled */
1268 tmp
= inw(ioaddr
+ WN0_ADDR_CONF
);
1269 if (tmp
& (3 << 14)) {
1270 outw(StartCoax
, ioaddr
+ EL3_CMD
);
1277 tmp
= inw(ioaddr
+ WN4_NETDIAG
);
1278 if (ecmd
->duplex
== DUPLEX_FULL
)
1282 outw(tmp
, ioaddr
+ WN4_NETDIAG
);
1288 static void el3_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
1290 strcpy(info
->driver
, DRV_NAME
);
1291 strcpy(info
->version
, DRV_VERSION
);
1294 static int el3_get_settings(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1296 struct el3_private
*lp
= netdev_priv(dev
);
1299 spin_lock_irq(&lp
->lock
);
1300 ret
= el3_netdev_get_ecmd(dev
, ecmd
);
1301 spin_unlock_irq(&lp
->lock
);
1305 static int el3_set_settings(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1307 struct el3_private
*lp
= netdev_priv(dev
);
1310 spin_lock_irq(&lp
->lock
);
1311 ret
= el3_netdev_set_ecmd(dev
, ecmd
);
1312 spin_unlock_irq(&lp
->lock
);
1316 static u32
el3_get_link(struct net_device
*dev
)
1318 struct el3_private
*lp
= netdev_priv(dev
);
1321 spin_lock_irq(&lp
->lock
);
1322 ret
= el3_link_ok(dev
);
1323 spin_unlock_irq(&lp
->lock
);
1327 static u32
el3_get_msglevel(struct net_device
*dev
)
1332 static void el3_set_msglevel(struct net_device
*dev
, u32 v
)
1337 static const struct ethtool_ops ethtool_ops
= {
1338 .get_drvinfo
= el3_get_drvinfo
,
1339 .get_settings
= el3_get_settings
,
1340 .set_settings
= el3_set_settings
,
1341 .get_link
= el3_get_link
,
1342 .get_msglevel
= el3_get_msglevel
,
1343 .set_msglevel
= el3_set_msglevel
,
1347 el3_down(struct net_device
*dev
)
1349 int ioaddr
= dev
->base_addr
;
1351 netif_stop_queue(dev
);
1353 /* Turn off statistics ASAP. We update lp->stats below. */
1354 outw(StatsDisable
, ioaddr
+ EL3_CMD
);
1356 /* Disable the receiver and transmitter. */
1357 outw(RxDisable
, ioaddr
+ EL3_CMD
);
1358 outw(TxDisable
, ioaddr
+ EL3_CMD
);
1360 if (dev
->if_port
== 3)
1361 /* Turn off thinnet power. Green! */
1362 outw(StopCoax
, ioaddr
+ EL3_CMD
);
1363 else if (dev
->if_port
== 0) {
1364 /* Disable link beat and jabber, if_port may change here next open(). */
1366 outw(inw(ioaddr
+ WN4_MEDIA
) & ~MEDIA_TP
, ioaddr
+ WN4_MEDIA
);
1369 outw(SetIntrEnb
| 0x0000, ioaddr
+ EL3_CMD
);
1375 el3_up(struct net_device
*dev
)
1377 int i
, sw_info
, net_diag
;
1378 int ioaddr
= dev
->base_addr
;
1380 /* Activating the board required and does no harm otherwise */
1381 outw(0x0001, ioaddr
+ 4);
1383 /* Set the IRQ line. */
1384 outw((dev
->irq
<< 12) | 0x0f00, ioaddr
+ WN0_IRQ
);
1386 /* Set the station address in window 2 each time opened. */
1389 for (i
= 0; i
< 6; i
++)
1390 outb(dev
->dev_addr
[i
], ioaddr
+ i
);
1392 if ((dev
->if_port
& 0x03) == 3) /* BNC interface */
1393 /* Start the thinnet transceiver. We should really wait 50ms...*/
1394 outw(StartCoax
, ioaddr
+ EL3_CMD
);
1395 else if ((dev
->if_port
& 0x03) == 0) { /* 10baseT interface */
1396 /* Combine secondary sw_info word (the adapter level) and primary
1397 sw_info word (duplex setting plus other useless bits) */
1399 sw_info
= (read_eeprom(ioaddr
, 0x14) & 0x400f) |
1400 (read_eeprom(ioaddr
, 0x0d) & 0xBff0);
1403 net_diag
= inw(ioaddr
+ WN4_NETDIAG
);
1404 net_diag
= (net_diag
| FD_ENABLE
); /* temporarily assume full-duplex will be set */
1405 printk("%s: ", dev
->name
);
1406 switch (dev
->if_port
& 0x0c) {
1408 /* force full-duplex mode if 3c5x9b */
1409 if (sw_info
& 0x000f) {
1410 printk("Forcing 3c5x9b full-duplex mode");
1414 /* set full-duplex mode based on eeprom config setting */
1415 if ((sw_info
& 0x000f) && (sw_info
& 0x8000)) {
1416 printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1420 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1421 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1422 net_diag
= (net_diag
& ~FD_ENABLE
); /* disable full duplex */
1425 outw(net_diag
, ioaddr
+ WN4_NETDIAG
);
1426 printk(" if_port: %d, sw_info: %4.4x\n", dev
->if_port
, sw_info
);
1428 printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev
->name
, net_diag
);
1429 /* Enable link beat and jabber check. */
1430 outw(inw(ioaddr
+ WN4_MEDIA
) | MEDIA_TP
, ioaddr
+ WN4_MEDIA
);
1433 /* Switch to the stats window, and clear all stats by reading. */
1434 outw(StatsDisable
, ioaddr
+ EL3_CMD
);
1436 for (i
= 0; i
< 9; i
++)
1441 /* Switch to register set 1 for normal use. */
1444 /* Accept b-case and phys addr only. */
1445 outw(SetRxFilter
| RxStation
| RxBroadcast
, ioaddr
+ EL3_CMD
);
1446 outw(StatsEnable
, ioaddr
+ EL3_CMD
); /* Turn on statistics. */
1448 outw(RxEnable
, ioaddr
+ EL3_CMD
); /* Enable the receiver. */
1449 outw(TxEnable
, ioaddr
+ EL3_CMD
); /* Enable transmitter. */
1450 /* Allow status bits to be seen. */
1451 outw(SetStatusEnb
| 0xff, ioaddr
+ EL3_CMD
);
1452 /* Ack all pending events, and set active indicator mask. */
1453 outw(AckIntr
| IntLatch
| TxAvailable
| RxEarly
| IntReq
,
1455 outw(SetIntrEnb
| IntLatch
|TxAvailable
|TxComplete
|RxComplete
|StatsFull
,
1458 netif_start_queue(dev
);
1461 /* Power Management support functions */
1465 el3_suspend(struct device
*pdev
, pm_message_t state
)
1467 unsigned long flags
;
1468 struct net_device
*dev
;
1469 struct el3_private
*lp
;
1472 dev
= pdev
->driver_data
;
1473 lp
= netdev_priv(dev
);
1474 ioaddr
= dev
->base_addr
;
1476 spin_lock_irqsave(&lp
->lock
, flags
);
1478 if (netif_running(dev
))
1479 netif_device_detach(dev
);
1482 outw(PowerDown
, ioaddr
+ EL3_CMD
);
1484 spin_unlock_irqrestore(&lp
->lock
, flags
);
1489 el3_resume(struct device
*pdev
)
1491 unsigned long flags
;
1492 struct net_device
*dev
;
1493 struct el3_private
*lp
;
1496 dev
= pdev
->driver_data
;
1497 lp
= netdev_priv(dev
);
1498 ioaddr
= dev
->base_addr
;
1500 spin_lock_irqsave(&lp
->lock
, flags
);
1502 outw(PowerUp
, ioaddr
+ EL3_CMD
);
1505 if (netif_running(dev
))
1506 netif_device_attach(dev
);
1508 spin_unlock_irqrestore(&lp
->lock
, flags
);
1512 #endif /* EL3_SUSPEND */
1514 /* Parameters that may be passed into the module. */
1515 static int debug
= -1;
1516 static int irq
[] = {-1, -1, -1, -1, -1, -1, -1, -1};
1517 static int xcvr
[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1519 module_param(debug
,int, 0);
1520 module_param_array(irq
, int, NULL
, 0);
1521 module_param_array(xcvr
, int, NULL
, 0);
1522 module_param(max_interrupt_work
, int, 0);
1523 MODULE_PARM_DESC(debug
, "debug level (0-6)");
1524 MODULE_PARM_DESC(irq
, "IRQ number(s) (assigned)");
1525 MODULE_PARM_DESC(xcvr
,"transceiver(s) (0=internal, 1=external)");
1526 MODULE_PARM_DESC(max_interrupt_work
, "maximum events handled per interrupt");
1527 #if defined(__ISAPNP__)
1528 module_param(nopnp
, int, 0);
1529 MODULE_PARM_DESC(nopnp
, "disable ISA PnP support (0-1)");
1530 MODULE_DEVICE_TABLE(isapnp
, el3_isapnp_adapters
);
1531 #endif /* __ISAPNP__ */
1532 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B) ISA/PnP ethernet driver");
1533 MODULE_LICENSE("GPL");
1535 static int __init
el3_init_module(void)
1543 el3_root_dev
= NULL
;
1544 while (el3_probe(el3_cards
) == 0) {
1545 if (irq
[el3_cards
] > 1)
1546 el3_root_dev
->irq
= irq
[el3_cards
];
1547 if (xcvr
[el3_cards
] >= 0)
1548 el3_root_dev
->if_port
= xcvr
[el3_cards
];
1553 ret
= eisa_driver_register(&el3_eisa_driver
);
1557 int err
= mca_register_driver(&el3_mca_driver
);
1565 static void __exit
el3_cleanup_module(void)
1567 struct net_device
*next_dev
;
1569 while (el3_root_dev
) {
1570 struct el3_private
*lp
= netdev_priv(el3_root_dev
);
1572 next_dev
= lp
->next_dev
;
1573 el3_common_remove (el3_root_dev
);
1574 el3_root_dev
= next_dev
;
1578 eisa_driver_unregister (&el3_eisa_driver
);
1581 mca_unregister_driver(&el3_mca_driver
);
1585 module_init (el3_init_module
);
1586 module_exit (el3_cleanup_module
);