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
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.
58 v1.20 04Feb2008 Ondrej Zary <linux@rainbow-software.org>
59 - convert to isa_driver and pnp_driver and some cleanups
62 #define DRV_NAME "3c509"
63 #define DRV_VERSION "1.20"
64 #define DRV_RELDATE "04Feb2008"
66 /* A few values that may be tweaked. */
68 /* Time in jiffies before concluding the transmitter is hung. */
69 #define TX_TIMEOUT (400*HZ/1000)
71 #include <linux/module.h>
72 #include <linux/mca.h>
73 #include <linux/isa.h>
74 #include <linux/pnp.h>
75 #include <linux/string.h>
76 #include <linux/interrupt.h>
77 #include <linux/errno.h>
79 #include <linux/slab.h>
80 #include <linux/ioport.h>
81 #include <linux/init.h>
82 #include <linux/netdevice.h>
83 #include <linux/etherdevice.h>
85 #include <linux/skbuff.h>
86 #include <linux/delay.h> /* for udelay() */
87 #include <linux/spinlock.h>
88 #include <linux/ethtool.h>
89 #include <linux/device.h>
90 #include <linux/eisa.h>
91 #include <linux/bitops.h>
93 #include <asm/uaccess.h>
97 static char version
[] __devinitdata
= DRV_NAME
".c:" DRV_VERSION
" " DRV_RELDATE
" becker@scyld.com\n";
100 static int el3_debug
= EL3_DEBUG
;
102 static int el3_debug
= 2;
105 /* Used to do a global count of all the cards in the system. Must be
106 * a global variable so that the mca/eisa probe routines can increment
108 static int el3_cards
= 0;
109 #define EL3_MAX_CARDS 8
111 /* To minimize the size of the driver source I only define operating
112 constants if they are used several times. You'll need the manual
113 anyway if you want to understand driver details. */
114 /* Offsets from base I/O address. */
115 #define EL3_DATA 0x00
117 #define EL3_STATUS 0x0e
118 #define EEPROM_READ 0x80
120 #define EL3_IO_EXTENT 16
122 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
125 /* The top five bits written to EL3_CMD are a command, the lower
126 11 bits are the parameter, if applicable. */
128 TotalReset
= 0<<11, SelectWindow
= 1<<11, StartCoax
= 2<<11,
129 RxDisable
= 3<<11, RxEnable
= 4<<11, RxReset
= 5<<11, RxDiscard
= 8<<11,
130 TxEnable
= 9<<11, TxDisable
= 10<<11, TxReset
= 11<<11,
131 FakeIntr
= 12<<11, AckIntr
= 13<<11, SetIntrEnb
= 14<<11,
132 SetStatusEnb
= 15<<11, SetRxFilter
= 16<<11, SetRxThreshold
= 17<<11,
133 SetTxThreshold
= 18<<11, SetTxStart
= 19<<11, StatsEnable
= 21<<11,
134 StatsDisable
= 22<<11, StopCoax
= 23<<11, PowerUp
= 27<<11,
135 PowerDown
= 28<<11, PowerAuto
= 29<<11};
138 IntLatch
= 0x0001, AdapterFailure
= 0x0002, TxComplete
= 0x0004,
139 TxAvailable
= 0x0008, RxComplete
= 0x0010, RxEarly
= 0x0020,
140 IntReq
= 0x0040, StatsFull
= 0x0080, CmdBusy
= 0x1000, };
142 /* The SetRxFilter command accepts the following classes: */
144 RxStation
= 1, RxMulticast
= 2, RxBroadcast
= 4, RxProm
= 8 };
146 /* Register window 1 offsets, the window used in normal operation. */
149 #define RX_STATUS 0x08
150 #define TX_STATUS 0x0B
151 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */
153 #define WN0_CONF_CTRL 0x04 /* Window 0: Configuration control register */
154 #define WN0_ADDR_CONF 0x06 /* Window 0: Address configuration register */
155 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */
156 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */
157 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */
158 #define WN4_NETDIAG 0x06 /* Window 4: Net diagnostic */
159 #define FD_ENABLE 0x8000 /* Enable full-duplex ("external loopback") */
162 * Must be a power of two (we use a binary and in the
165 #define SKB_QUEUE_SIZE 64
167 enum el3_cardtype
{ EL3_ISA
, EL3_PNP
, EL3_MCA
, EL3_EISA
};
173 struct sk_buff
*queue
[SKB_QUEUE_SIZE
];
174 enum el3_cardtype type
;
177 static int current_tag
;
178 static struct net_device
*el3_devs
[EL3_MAX_CARDS
];
180 /* Parameters that may be passed into the module. */
181 static int debug
= -1;
182 static int irq
[] = {-1, -1, -1, -1, -1, -1, -1, -1};
183 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
184 static int max_interrupt_work
= 10;
189 static int __devinit
el3_common_init(struct net_device
*dev
);
190 static void el3_common_remove(struct net_device
*dev
);
191 static ushort
id_read_eeprom(int index
);
192 static ushort
read_eeprom(int ioaddr
, int index
);
193 static int el3_open(struct net_device
*dev
);
194 static int el3_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
);
195 static irqreturn_t
el3_interrupt(int irq
, void *dev_id
);
196 static void update_stats(struct net_device
*dev
);
197 static struct net_device_stats
*el3_get_stats(struct net_device
*dev
);
198 static int el3_rx(struct net_device
*dev
);
199 static int el3_close(struct net_device
*dev
);
200 static void set_multicast_list(struct net_device
*dev
);
201 static void el3_tx_timeout (struct net_device
*dev
);
202 static void el3_down(struct net_device
*dev
);
203 static void el3_up(struct net_device
*dev
);
204 static const struct ethtool_ops ethtool_ops
;
206 static int el3_suspend(struct device
*, pm_message_t
);
207 static int el3_resume(struct device
*);
209 #define el3_suspend NULL
210 #define el3_resume NULL
214 /* generic device remove for all device types */
215 static int el3_device_remove (struct device
*device
);
216 #ifdef CONFIG_NET_POLL_CONTROLLER
217 static void el3_poll_controller(struct net_device
*dev
);
220 /* Return 0 on success, 1 on error, 2 when found already detected PnP card */
221 static int el3_isa_id_sequence(__be16
*phys_addr
)
223 short lrs_state
= 0xff;
226 /* ISA boards are detected by sending the ID sequence to the
227 ID_PORT. We find cards past the first by setting the 'current_tag'
228 on cards as they are found. Cards with their tag set will not
229 respond to subsequent ID sequences. */
233 for (i
= 0; i
< 255; i
++) {
234 outb(lrs_state
, id_port
);
236 lrs_state
= lrs_state
& 0x100 ? lrs_state
^ 0xcf : lrs_state
;
238 /* For the first probe, clear all board's tag registers. */
239 if (current_tag
== 0)
241 else /* Otherwise kill off already-found boards. */
243 if (id_read_eeprom(7) != 0x6d50)
245 /* Read in EEPROM data, which does contention-select.
246 Only the lowest address board will stay "on-line".
247 3Com got the byte order backwards. */
248 for (i
= 0; i
< 3; i
++)
249 phys_addr
[i
] = htons(id_read_eeprom(i
));
252 /* The ISA PnP 3c509 cards respond to the ID sequence too.
253 This check is needed in order not to register them twice. */
254 for (i
= 0; i
< el3_cards
; i
++) {
255 struct el3_private
*lp
= netdev_priv(el3_devs
[i
]);
256 if (lp
->type
== EL3_PNP
257 && !memcmp(phys_addr
, el3_devs
[i
]->dev_addr
,
260 pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
261 phys_addr
[0] & 0xff, phys_addr
[0] >> 8,
262 phys_addr
[1] & 0xff, phys_addr
[1] >> 8,
263 phys_addr
[2] & 0xff, phys_addr
[2] >> 8);
264 /* Set the adaptor tag so that the next card can be found. */
265 outb(0xd0 + ++current_tag
, id_port
);
270 #endif /* CONFIG_PNP */
275 static void __devinit
el3_dev_fill(struct net_device
*dev
, __be16
*phys_addr
,
276 int ioaddr
, int irq
, int if_port
,
277 enum el3_cardtype type
)
279 struct el3_private
*lp
= netdev_priv(dev
);
281 memcpy(dev
->dev_addr
, phys_addr
, ETH_ALEN
);
282 dev
->base_addr
= ioaddr
;
284 dev
->if_port
= if_port
;
288 static int __devinit
el3_isa_match(struct device
*pdev
,
291 struct net_device
*dev
;
292 int ioaddr
, isa_irq
, if_port
, err
;
296 while ((err
= el3_isa_id_sequence(phys_addr
)) == 2)
297 ; /* Skip to next card when PnP card found */
301 iobase
= id_read_eeprom(8);
302 if_port
= iobase
>> 14;
303 ioaddr
= 0x200 + ((iobase
& 0x1f) << 4);
304 if (irq
[el3_cards
] > 1 && irq
[el3_cards
] < 16)
305 isa_irq
= irq
[el3_cards
];
307 isa_irq
= id_read_eeprom(9) >> 12;
309 dev
= alloc_etherdev(sizeof(struct el3_private
));
313 netdev_boot_setup_check(dev
);
315 if (!request_region(ioaddr
, EL3_IO_EXTENT
, "3c509-isa")) {
320 /* Set the adaptor tag so that the next card can be found. */
321 outb(0xd0 + ++current_tag
, id_port
);
323 /* Activate the adaptor at the EEPROM location. */
324 outb((ioaddr
>> 4) | 0xe0, id_port
);
327 if (inw(ioaddr
) != 0x6d50) {
332 /* Free the interrupt so that some other card can use it. */
333 outw(0x0f00, ioaddr
+ WN0_IRQ
);
335 el3_dev_fill(dev
, phys_addr
, ioaddr
, isa_irq
, if_port
, EL3_ISA
);
336 dev_set_drvdata(pdev
, dev
);
337 if (el3_common_init(dev
)) {
342 el3_devs
[el3_cards
++] = dev
;
346 static int __devexit
el3_isa_remove(struct device
*pdev
,
349 el3_device_remove(pdev
);
350 dev_set_drvdata(pdev
, NULL
);
355 static int el3_isa_suspend(struct device
*dev
, unsigned int n
,
359 return el3_suspend(dev
, state
);
362 static int el3_isa_resume(struct device
*dev
, unsigned int n
)
364 struct net_device
*ndev
= dev_get_drvdata(dev
);
365 int ioaddr
= ndev
->base_addr
, err
;
368 while ((err
= el3_isa_id_sequence(phys_addr
)) == 2)
369 ; /* Skip to next card when PnP card found */
372 /* Set the adaptor tag so that the next card can be found. */
373 outb(0xd0 + ++current_tag
, id_port
);
374 /* Enable the card */
375 outb((ioaddr
>> 4) | 0xe0, id_port
);
377 if (inw(ioaddr
) != 0x6d50)
379 /* Free the interrupt so that some other card can use it. */
380 outw(0x0f00, ioaddr
+ WN0_IRQ
);
381 return el3_resume(dev
);
385 static struct isa_driver el3_isa_driver
= {
386 .match
= el3_isa_match
,
387 .remove
= __devexit_p(el3_isa_remove
),
389 .suspend
= el3_isa_suspend
,
390 .resume
= el3_isa_resume
,
396 static int isa_registered
;
399 static struct pnp_device_id el3_pnp_ids
[] = {
400 { .id
= "TCM5090" }, /* 3Com Etherlink III (TP) */
401 { .id
= "TCM5091" }, /* 3Com Etherlink III */
402 { .id
= "TCM5094" }, /* 3Com Etherlink III (combo) */
403 { .id
= "TCM5095" }, /* 3Com Etherlink III (TPO) */
404 { .id
= "TCM5098" }, /* 3Com Etherlink III (TPC) */
405 { .id
= "PNP80f7" }, /* 3Com Etherlink III compatible */
406 { .id
= "PNP80f8" }, /* 3Com Etherlink III compatible */
409 MODULE_DEVICE_TABLE(pnp
, el3_pnp_ids
);
411 static int __devinit
el3_pnp_probe(struct pnp_dev
*pdev
,
412 const struct pnp_device_id
*id
)
415 int ioaddr
, irq
, if_port
;
417 struct net_device
*dev
= NULL
;
420 ioaddr
= pnp_port_start(pdev
, 0);
421 if (!request_region(ioaddr
, EL3_IO_EXTENT
, "3c509-pnp"))
423 irq
= pnp_irq(pdev
, 0);
425 for (i
= 0; i
< 3; i
++)
426 phys_addr
[i
] = htons(read_eeprom(ioaddr
, i
));
427 if_port
= read_eeprom(ioaddr
, 8) >> 14;
428 dev
= alloc_etherdev(sizeof(struct el3_private
));
430 release_region(ioaddr
, EL3_IO_EXTENT
);
433 SET_NETDEV_DEV(dev
, &pdev
->dev
);
434 netdev_boot_setup_check(dev
);
436 el3_dev_fill(dev
, phys_addr
, ioaddr
, irq
, if_port
, EL3_PNP
);
437 pnp_set_drvdata(pdev
, dev
);
438 err
= el3_common_init(dev
);
441 pnp_set_drvdata(pdev
, NULL
);
446 el3_devs
[el3_cards
++] = dev
;
450 static void __devexit
el3_pnp_remove(struct pnp_dev
*pdev
)
452 el3_common_remove(pnp_get_drvdata(pdev
));
453 pnp_set_drvdata(pdev
, NULL
);
457 static int el3_pnp_suspend(struct pnp_dev
*pdev
, pm_message_t state
)
459 return el3_suspend(&pdev
->dev
, state
);
462 static int el3_pnp_resume(struct pnp_dev
*pdev
)
464 return el3_resume(&pdev
->dev
);
468 static struct pnp_driver el3_pnp_driver
= {
470 .id_table
= el3_pnp_ids
,
471 .probe
= el3_pnp_probe
,
472 .remove
= __devexit_p(el3_pnp_remove
),
474 .suspend
= el3_pnp_suspend
,
475 .resume
= el3_pnp_resume
,
478 static int pnp_registered
;
479 #endif /* CONFIG_PNP */
482 static struct eisa_device_id el3_eisa_ids
[] = {
488 MODULE_DEVICE_TABLE(eisa
, el3_eisa_ids
);
490 static int el3_eisa_probe (struct device
*device
);
492 static struct eisa_driver el3_eisa_driver
= {
493 .id_table
= el3_eisa_ids
,
496 .probe
= el3_eisa_probe
,
497 .remove
= __devexit_p (el3_device_remove
),
498 .suspend
= el3_suspend
,
499 .resume
= el3_resume
,
502 static int eisa_registered
;
506 static int el3_mca_probe(struct device
*dev
);
508 static short el3_mca_adapter_ids
[] __initdata
= {
517 static char *el3_mca_adapter_names
[] __initdata
= {
518 "3Com 3c529 EtherLink III (10base2)",
519 "3Com 3c529 EtherLink III (10baseT)",
520 "3Com 3c529 EtherLink III (test mode)",
521 "3Com 3c529 EtherLink III (TP or coax)",
522 "3Com 3c529 EtherLink III (TP)",
526 static struct mca_driver el3_mca_driver
= {
527 .id_table
= el3_mca_adapter_ids
,
530 .bus
= &mca_bus_type
,
531 .probe
= el3_mca_probe
,
532 .remove
= __devexit_p(el3_device_remove
),
533 .suspend
= el3_suspend
,
534 .resume
= el3_resume
,
537 static int mca_registered
;
538 #endif /* CONFIG_MCA */
540 static const struct net_device_ops netdev_ops
= {
541 .ndo_open
= el3_open
,
542 .ndo_stop
= el3_close
,
543 .ndo_start_xmit
= el3_start_xmit
,
544 .ndo_get_stats
= el3_get_stats
,
545 .ndo_set_multicast_list
= set_multicast_list
,
546 .ndo_tx_timeout
= el3_tx_timeout
,
547 .ndo_change_mtu
= eth_change_mtu
,
548 .ndo_set_mac_address
= eth_mac_addr
,
549 .ndo_validate_addr
= eth_validate_addr
,
550 #ifdef CONFIG_NET_POLL_CONTROLLER
551 .ndo_poll_controller
= el3_poll_controller
,
555 static int __devinit
el3_common_init(struct net_device
*dev
)
557 struct el3_private
*lp
= netdev_priv(dev
);
559 const char *if_names
[] = {"10baseT", "AUI", "undefined", "BNC"};
561 spin_lock_init(&lp
->lock
);
563 if (dev
->mem_start
& 0x05) { /* xcvr codes 1/3/4/12 */
564 dev
->if_port
= (dev
->mem_start
& 0x0f);
565 } else { /* xcvr codes 0/8 */
566 /* use eeprom value, but save user's full-duplex selection */
567 dev
->if_port
|= (dev
->mem_start
& 0x08);
570 /* The EL3-specific entries in the device structure. */
571 dev
->netdev_ops
= &netdev_ops
;
572 dev
->watchdog_timeo
= TX_TIMEOUT
;
573 SET_ETHTOOL_OPS(dev
, ðtool_ops
);
575 err
= register_netdev(dev
);
577 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
578 dev
->base_addr
, dev
->irq
);
579 release_region(dev
->base_addr
, EL3_IO_EXTENT
);
583 pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
584 dev
->name
, dev
->base_addr
, if_names
[(dev
->if_port
& 0x03)],
585 dev
->dev_addr
, dev
->irq
);
588 pr_info("%s", version
);
593 static void el3_common_remove (struct net_device
*dev
)
595 unregister_netdev (dev
);
596 release_region(dev
->base_addr
, EL3_IO_EXTENT
);
601 static int __init
el3_mca_probe(struct device
*device
)
603 /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
604 * heavily modified by Chris Beauregard
605 * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
608 * redone for multi-card detection by ZP Gu (zpg@castle.net)
609 * now works as a module */
612 int ioaddr
, irq
, if_port
;
614 struct net_device
*dev
= NULL
;
616 struct mca_device
*mdev
= to_mca_device(device
);
617 int slot
= mdev
->slot
;
620 pos4
= mca_device_read_stored_pos(mdev
, 4);
621 pos5
= mca_device_read_stored_pos(mdev
, 5);
623 ioaddr
= ((short)((pos4
&0xfc)|0x02)) << 8;
627 pr_info("3c529: found %s at slot %d\n",
628 el3_mca_adapter_names
[mdev
->index
], slot
+ 1);
631 strncpy(mdev
->name
, el3_mca_adapter_names
[mdev
->index
],
633 mca_device_set_claim(mdev
, 1);
635 if_port
= pos4
& 0x03;
637 irq
= mca_device_transform_irq(mdev
, irq
);
638 ioaddr
= mca_device_transform_ioport(mdev
, ioaddr
);
640 pr_debug("3c529: irq %d ioaddr 0x%x ifport %d\n", irq
, ioaddr
, if_port
);
643 for (i
= 0; i
< 3; i
++)
644 phys_addr
[i
] = htons(read_eeprom(ioaddr
, i
));
646 dev
= alloc_etherdev(sizeof (struct el3_private
));
648 release_region(ioaddr
, EL3_IO_EXTENT
);
652 netdev_boot_setup_check(dev
);
654 el3_dev_fill(dev
, phys_addr
, ioaddr
, irq
, if_port
, EL3_MCA
);
655 dev_set_drvdata(device
, dev
);
656 err
= el3_common_init(dev
);
659 dev_set_drvdata(device
, NULL
);
664 el3_devs
[el3_cards
++] = dev
;
668 #endif /* CONFIG_MCA */
671 static int __init
el3_eisa_probe (struct device
*device
)
674 int ioaddr
, irq
, if_port
;
676 struct net_device
*dev
= NULL
;
677 struct eisa_device
*edev
;
680 /* Yeepee, The driver framework is calling us ! */
681 edev
= to_eisa_device (device
);
682 ioaddr
= edev
->base_addr
;
684 if (!request_region(ioaddr
, EL3_IO_EXTENT
, "3c579-eisa"))
687 /* Change the register set to the configuration window 0. */
688 outw(SelectWindow
| 0, ioaddr
+ 0xC80 + EL3_CMD
);
690 irq
= inw(ioaddr
+ WN0_IRQ
) >> 12;
691 if_port
= inw(ioaddr
+ 6)>>14;
692 for (i
= 0; i
< 3; i
++)
693 phys_addr
[i
] = htons(read_eeprom(ioaddr
, i
));
695 /* Restore the "Product ID" to the EEPROM read register. */
696 read_eeprom(ioaddr
, 3);
698 dev
= alloc_etherdev(sizeof (struct el3_private
));
700 release_region(ioaddr
, EL3_IO_EXTENT
);
704 netdev_boot_setup_check(dev
);
706 el3_dev_fill(dev
, phys_addr
, ioaddr
, irq
, if_port
, EL3_EISA
);
707 eisa_set_drvdata (edev
, dev
);
708 err
= el3_common_init(dev
);
711 eisa_set_drvdata (edev
, NULL
);
716 el3_devs
[el3_cards
++] = dev
;
721 /* This remove works for all device types.
723 * The net dev must be stored in the driver data field */
724 static int __devexit
el3_device_remove (struct device
*device
)
726 struct net_device
*dev
;
728 dev
= dev_get_drvdata(device
);
730 el3_common_remove (dev
);
734 /* Read a word from the EEPROM using the regular EEPROM access register.
735 Assume that we are in register window zero.
737 static ushort
read_eeprom(int ioaddr
, int index
)
739 outw(EEPROM_READ
+ index
, ioaddr
+ 10);
740 /* Pause for at least 162 us. for the read to take place.
741 Some chips seem to require much longer */
743 return inw(ioaddr
+ 12);
746 /* Read a word from the EEPROM when in the ISA ID probe state. */
747 static ushort
id_read_eeprom(int index
)
751 /* Issue read command, and pause for at least 162 us. for it to complete.
752 Assume extra-fast 16Mhz bus. */
753 outb(EEPROM_READ
+ index
, id_port
);
755 /* Pause for at least 162 us. for the read to take place. */
756 /* Some chips seem to require much longer */
759 for (bit
= 15; bit
>= 0; bit
--)
760 word
= (word
<< 1) + (inb(id_port
) & 0x01);
763 pr_debug(" 3c509 EEPROM word %d %#4.4x.\n", index
, word
);
770 el3_open(struct net_device
*dev
)
772 int ioaddr
= dev
->base_addr
;
775 outw(TxReset
, ioaddr
+ EL3_CMD
);
776 outw(RxReset
, ioaddr
+ EL3_CMD
);
777 outw(SetStatusEnb
| 0x00, ioaddr
+ EL3_CMD
);
779 i
= request_irq(dev
->irq
, &el3_interrupt
, 0, dev
->name
, dev
);
785 pr_debug("%s: Opening, IRQ %d status@%x %4.4x.\n", dev
->name
,
786 dev
->irq
, ioaddr
+ EL3_STATUS
, inw(ioaddr
+ EL3_STATUS
));
791 pr_debug("%s: Opened 3c509 IRQ %d status %4.4x.\n",
792 dev
->name
, dev
->irq
, inw(ioaddr
+ EL3_STATUS
));
798 el3_tx_timeout (struct net_device
*dev
)
800 int ioaddr
= dev
->base_addr
;
802 /* Transmitter timeout, serious problems. */
803 pr_warning("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d.\n",
804 dev
->name
, inb(ioaddr
+ TX_STATUS
), inw(ioaddr
+ EL3_STATUS
),
805 inw(ioaddr
+ TX_FREE
));
806 dev
->stats
.tx_errors
++;
807 dev
->trans_start
= jiffies
;
808 /* Issue TX_RESET and TX_START commands. */
809 outw(TxReset
, ioaddr
+ EL3_CMD
);
810 outw(TxEnable
, ioaddr
+ EL3_CMD
);
811 netif_wake_queue(dev
);
816 el3_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
818 struct el3_private
*lp
= netdev_priv(dev
);
819 int ioaddr
= dev
->base_addr
;
822 netif_stop_queue (dev
);
824 dev
->stats
.tx_bytes
+= skb
->len
;
827 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
828 dev
->name
, skb
->len
, inw(ioaddr
+ EL3_STATUS
));
831 #ifndef final_version
832 { /* Error-checking code, delete someday. */
833 ushort status
= inw(ioaddr
+ EL3_STATUS
);
834 if (status
& 0x0001 /* IRQ line active, missed one. */
835 && inw(ioaddr
+ EL3_STATUS
) & 1) { /* Make sure. */
836 pr_debug("%s: Missed interrupt, status then %04x now %04x"
837 " Tx %2.2x Rx %4.4x.\n", dev
->name
, status
,
838 inw(ioaddr
+ EL3_STATUS
), inb(ioaddr
+ TX_STATUS
),
839 inw(ioaddr
+ RX_STATUS
));
840 /* Fake interrupt trigger by masking, acknowledge interrupts. */
841 outw(SetStatusEnb
| 0x00, ioaddr
+ EL3_CMD
);
842 outw(AckIntr
| IntLatch
| TxAvailable
| RxEarly
| IntReq
,
844 outw(SetStatusEnb
| 0xff, ioaddr
+ EL3_CMD
);
850 * We lock the driver against other processors. Note
851 * we don't need to lock versus the IRQ as we suspended
852 * that. This means that we lose the ability to take
853 * an RX during a TX upload. That sucks a bit with SMP
854 * on an original 3c509 (2K buffer)
856 * Using disable_irq stops us crapping on other
857 * time sensitive devices.
860 spin_lock_irqsave(&lp
->lock
, flags
);
862 /* Put out the doubleword header... */
863 outw(skb
->len
, ioaddr
+ TX_FIFO
);
864 outw(0x00, ioaddr
+ TX_FIFO
);
865 /* ... and the packet rounded to a doubleword. */
866 outsl(ioaddr
+ TX_FIFO
, skb
->data
, (skb
->len
+ 3) >> 2);
868 dev
->trans_start
= jiffies
;
869 if (inw(ioaddr
+ TX_FREE
) > 1536)
870 netif_start_queue(dev
);
872 /* Interrupt us when the FIFO has room for max-sized packet. */
873 outw(SetTxThreshold
+ 1536, ioaddr
+ EL3_CMD
);
875 spin_unlock_irqrestore(&lp
->lock
, flags
);
879 /* Clear the Tx status stack. */
884 while (--i
> 0 && (tx_status
= inb(ioaddr
+ TX_STATUS
)) > 0) {
885 if (tx_status
& 0x38) dev
->stats
.tx_aborted_errors
++;
886 if (tx_status
& 0x30) outw(TxReset
, ioaddr
+ EL3_CMD
);
887 if (tx_status
& 0x3C) outw(TxEnable
, ioaddr
+ EL3_CMD
);
888 outb(0x00, ioaddr
+ TX_STATUS
); /* Pop the status stack. */
894 /* The EL3 interrupt handler. */
896 el3_interrupt(int irq
, void *dev_id
)
898 struct net_device
*dev
= dev_id
;
899 struct el3_private
*lp
;
901 int i
= max_interrupt_work
;
903 lp
= netdev_priv(dev
);
904 spin_lock(&lp
->lock
);
906 ioaddr
= dev
->base_addr
;
909 status
= inw(ioaddr
+ EL3_STATUS
);
910 pr_debug("%s: interrupt, status %4.4x.\n", dev
->name
, status
);
913 while ((status
= inw(ioaddr
+ EL3_STATUS
)) &
914 (IntLatch
| RxComplete
| StatsFull
)) {
916 if (status
& RxComplete
)
919 if (status
& TxAvailable
) {
921 pr_debug(" TX room bit was handled.\n");
922 /* There's room in the FIFO for a full-sized packet. */
923 outw(AckIntr
| TxAvailable
, ioaddr
+ EL3_CMD
);
924 netif_wake_queue (dev
);
926 if (status
& (AdapterFailure
| RxEarly
| StatsFull
| TxComplete
)) {
927 /* Handle all uncommon interrupts. */
928 if (status
& StatsFull
) /* Empty statistics. */
930 if (status
& RxEarly
) { /* Rx early is unused. */
932 outw(AckIntr
| RxEarly
, ioaddr
+ EL3_CMD
);
934 if (status
& TxComplete
) { /* Really Tx error. */
938 while (--i
>0 && (tx_status
= inb(ioaddr
+ TX_STATUS
)) > 0) {
939 if (tx_status
& 0x38) dev
->stats
.tx_aborted_errors
++;
940 if (tx_status
& 0x30) outw(TxReset
, ioaddr
+ EL3_CMD
);
941 if (tx_status
& 0x3C) outw(TxEnable
, ioaddr
+ EL3_CMD
);
942 outb(0x00, ioaddr
+ TX_STATUS
); /* Pop the status stack. */
945 if (status
& AdapterFailure
) {
946 /* Adapter failure requires Rx reset and reinit. */
947 outw(RxReset
, ioaddr
+ EL3_CMD
);
948 /* Set the Rx filter to the current state. */
949 outw(SetRxFilter
| RxStation
| RxBroadcast
950 | (dev
->flags
& IFF_ALLMULTI
? RxMulticast
: 0)
951 | (dev
->flags
& IFF_PROMISC
? RxProm
: 0),
953 outw(RxEnable
, ioaddr
+ EL3_CMD
); /* Re-enable the receiver. */
954 outw(AckIntr
| AdapterFailure
, ioaddr
+ EL3_CMD
);
959 pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
961 /* Clear all interrupts. */
962 outw(AckIntr
| 0xFF, ioaddr
+ EL3_CMD
);
965 /* Acknowledge the IRQ. */
966 outw(AckIntr
| IntReq
| IntLatch
, ioaddr
+ EL3_CMD
); /* Ack IRQ */
970 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev
->name
,
971 inw(ioaddr
+ EL3_STATUS
));
973 spin_unlock(&lp
->lock
);
978 #ifdef CONFIG_NET_POLL_CONTROLLER
980 * Polling receive - used by netconsole and other diagnostic tools
981 * to allow network i/o with interrupts disabled.
983 static void el3_poll_controller(struct net_device
*dev
)
985 disable_irq(dev
->irq
);
986 el3_interrupt(dev
->irq
, dev
);
987 enable_irq(dev
->irq
);
991 static struct net_device_stats
*
992 el3_get_stats(struct net_device
*dev
)
994 struct el3_private
*lp
= netdev_priv(dev
);
998 * This is fast enough not to bother with disable IRQ
1002 spin_lock_irqsave(&lp
->lock
, flags
);
1004 spin_unlock_irqrestore(&lp
->lock
, flags
);
1008 /* Update statistics. We change to register window 6, so this should be run
1009 single-threaded if the device is active. This is expected to be a rare
1010 operation, and it's simpler for the rest of the driver to assume that
1011 window 1 is always valid rather than use a special window-state variable.
1013 static void update_stats(struct net_device
*dev
)
1015 int ioaddr
= dev
->base_addr
;
1018 pr_debug(" Updating the statistics.\n");
1019 /* Turn off statistics updates while reading. */
1020 outw(StatsDisable
, ioaddr
+ EL3_CMD
);
1021 /* Switch to the stats window, and read everything. */
1023 dev
->stats
.tx_carrier_errors
+= inb(ioaddr
+ 0);
1024 dev
->stats
.tx_heartbeat_errors
+= inb(ioaddr
+ 1);
1025 /* Multiple collisions. */ inb(ioaddr
+ 2);
1026 dev
->stats
.collisions
+= inb(ioaddr
+ 3);
1027 dev
->stats
.tx_window_errors
+= inb(ioaddr
+ 4);
1028 dev
->stats
.rx_fifo_errors
+= inb(ioaddr
+ 5);
1029 dev
->stats
.tx_packets
+= inb(ioaddr
+ 6);
1030 /* Rx packets */ inb(ioaddr
+ 7);
1031 /* Tx deferrals */ inb(ioaddr
+ 8);
1032 inw(ioaddr
+ 10); /* Total Rx and Tx octets. */
1035 /* Back to window 1, and turn statistics back on. */
1037 outw(StatsEnable
, ioaddr
+ EL3_CMD
);
1042 el3_rx(struct net_device
*dev
)
1044 int ioaddr
= dev
->base_addr
;
1048 pr_debug(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1049 inw(ioaddr
+EL3_STATUS
), inw(ioaddr
+RX_STATUS
));
1050 while ((rx_status
= inw(ioaddr
+ RX_STATUS
)) > 0) {
1051 if (rx_status
& 0x4000) { /* Error, update stats. */
1052 short error
= rx_status
& 0x3800;
1054 outw(RxDiscard
, ioaddr
+ EL3_CMD
);
1055 dev
->stats
.rx_errors
++;
1057 case 0x0000: dev
->stats
.rx_over_errors
++; break;
1058 case 0x0800: dev
->stats
.rx_length_errors
++; break;
1059 case 0x1000: dev
->stats
.rx_frame_errors
++; break;
1060 case 0x1800: dev
->stats
.rx_length_errors
++; break;
1061 case 0x2000: dev
->stats
.rx_frame_errors
++; break;
1062 case 0x2800: dev
->stats
.rx_crc_errors
++; break;
1065 short pkt_len
= rx_status
& 0x7ff;
1066 struct sk_buff
*skb
;
1068 skb
= dev_alloc_skb(pkt_len
+5);
1070 pr_debug("Receiving packet size %d status %4.4x.\n",
1071 pkt_len
, rx_status
);
1073 skb_reserve(skb
, 2); /* Align IP on 16 byte */
1075 /* 'skb->data' points to the start of sk_buff data area. */
1076 insl(ioaddr
+ RX_FIFO
, skb_put(skb
,pkt_len
),
1077 (pkt_len
+ 3) >> 2);
1079 outw(RxDiscard
, ioaddr
+ EL3_CMD
); /* Pop top Rx packet. */
1080 skb
->protocol
= eth_type_trans(skb
,dev
);
1082 dev
->stats
.rx_bytes
+= pkt_len
;
1083 dev
->stats
.rx_packets
++;
1086 outw(RxDiscard
, ioaddr
+ EL3_CMD
);
1087 dev
->stats
.rx_dropped
++;
1089 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
1090 dev
->name
, pkt_len
);
1092 inw(ioaddr
+ EL3_STATUS
); /* Delay. */
1093 while (inw(ioaddr
+ EL3_STATUS
) & 0x1000)
1094 pr_debug(" Waiting for 3c509 to discard packet, status %x.\n",
1095 inw(ioaddr
+ EL3_STATUS
) );
1102 * Set or clear the multicast filter for this adaptor.
1105 set_multicast_list(struct net_device
*dev
)
1107 unsigned long flags
;
1108 struct el3_private
*lp
= netdev_priv(dev
);
1109 int ioaddr
= dev
->base_addr
;
1111 if (el3_debug
> 1) {
1113 if (old
!= dev
->mc_count
) {
1114 old
= dev
->mc_count
;
1115 pr_debug("%s: Setting Rx mode to %d addresses.\n", dev
->name
, dev
->mc_count
);
1118 spin_lock_irqsave(&lp
->lock
, flags
);
1119 if (dev
->flags
&IFF_PROMISC
) {
1120 outw(SetRxFilter
| RxStation
| RxMulticast
| RxBroadcast
| RxProm
,
1123 else if (dev
->mc_count
|| (dev
->flags
&IFF_ALLMULTI
)) {
1124 outw(SetRxFilter
| RxStation
| RxMulticast
| RxBroadcast
, ioaddr
+ EL3_CMD
);
1127 outw(SetRxFilter
| RxStation
| RxBroadcast
, ioaddr
+ EL3_CMD
);
1128 spin_unlock_irqrestore(&lp
->lock
, flags
);
1132 el3_close(struct net_device
*dev
)
1134 int ioaddr
= dev
->base_addr
;
1135 struct el3_private
*lp
= netdev_priv(dev
);
1138 pr_debug("%s: Shutting down ethercard.\n", dev
->name
);
1142 free_irq(dev
->irq
, dev
);
1143 /* Switching back to window 0 disables the IRQ. */
1145 if (lp
->type
!= EL3_EISA
) {
1146 /* But we explicitly zero the IRQ line select anyway. Don't do
1147 * it on EISA cards, it prevents the module from getting an
1148 * IRQ after unload+reload... */
1149 outw(0x0f00, ioaddr
+ WN0_IRQ
);
1156 el3_link_ok(struct net_device
*dev
)
1158 int ioaddr
= dev
->base_addr
;
1162 tmp
= inw(ioaddr
+ WN4_MEDIA
);
1164 return tmp
& (1<<11);
1168 el3_netdev_get_ecmd(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1171 int ioaddr
= dev
->base_addr
;
1174 /* obtain current transceiver via WN4_MEDIA? */
1175 tmp
= inw(ioaddr
+ WN0_ADDR_CONF
);
1176 ecmd
->transceiver
= XCVR_INTERNAL
;
1177 switch (tmp
>> 14) {
1179 ecmd
->port
= PORT_TP
;
1182 ecmd
->port
= PORT_AUI
;
1183 ecmd
->transceiver
= XCVR_EXTERNAL
;
1186 ecmd
->port
= PORT_BNC
;
1191 ecmd
->duplex
= DUPLEX_HALF
;
1192 ecmd
->supported
= 0;
1193 tmp
= inw(ioaddr
+ WN0_CONF_CTRL
);
1195 ecmd
->supported
|= SUPPORTED_AUI
;
1197 ecmd
->supported
|= SUPPORTED_BNC
;
1199 ecmd
->supported
|= SUPPORTED_TP
| SUPPORTED_10baseT_Half
|
1200 SUPPORTED_10baseT_Full
; /* hmm... */
1202 tmp
= inw(ioaddr
+ WN4_NETDIAG
);
1203 if (tmp
& FD_ENABLE
)
1204 ecmd
->duplex
= DUPLEX_FULL
;
1207 ecmd
->speed
= SPEED_10
;
1213 el3_netdev_set_ecmd(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1216 int ioaddr
= dev
->base_addr
;
1218 if (ecmd
->speed
!= SPEED_10
)
1220 if ((ecmd
->duplex
!= DUPLEX_HALF
) && (ecmd
->duplex
!= DUPLEX_FULL
))
1222 if ((ecmd
->transceiver
!= XCVR_INTERNAL
) && (ecmd
->transceiver
!= XCVR_EXTERNAL
))
1225 /* change XCVR type */
1227 tmp
= inw(ioaddr
+ WN0_ADDR_CONF
);
1228 switch (ecmd
->port
) {
1245 outw(tmp
, ioaddr
+ WN0_ADDR_CONF
);
1246 if (dev
->if_port
== 3) {
1247 /* fire up the DC-DC convertor if BNC gets enabled */
1248 tmp
= inw(ioaddr
+ WN0_ADDR_CONF
);
1249 if (tmp
& (3 << 14)) {
1250 outw(StartCoax
, ioaddr
+ EL3_CMD
);
1257 tmp
= inw(ioaddr
+ WN4_NETDIAG
);
1258 if (ecmd
->duplex
== DUPLEX_FULL
)
1262 outw(tmp
, ioaddr
+ WN4_NETDIAG
);
1268 static void el3_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
1270 strcpy(info
->driver
, DRV_NAME
);
1271 strcpy(info
->version
, DRV_VERSION
);
1274 static int el3_get_settings(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1276 struct el3_private
*lp
= netdev_priv(dev
);
1279 spin_lock_irq(&lp
->lock
);
1280 ret
= el3_netdev_get_ecmd(dev
, ecmd
);
1281 spin_unlock_irq(&lp
->lock
);
1285 static int el3_set_settings(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1287 struct el3_private
*lp
= netdev_priv(dev
);
1290 spin_lock_irq(&lp
->lock
);
1291 ret
= el3_netdev_set_ecmd(dev
, ecmd
);
1292 spin_unlock_irq(&lp
->lock
);
1296 static u32
el3_get_link(struct net_device
*dev
)
1298 struct el3_private
*lp
= netdev_priv(dev
);
1301 spin_lock_irq(&lp
->lock
);
1302 ret
= el3_link_ok(dev
);
1303 spin_unlock_irq(&lp
->lock
);
1307 static u32
el3_get_msglevel(struct net_device
*dev
)
1312 static void el3_set_msglevel(struct net_device
*dev
, u32 v
)
1317 static const struct ethtool_ops ethtool_ops
= {
1318 .get_drvinfo
= el3_get_drvinfo
,
1319 .get_settings
= el3_get_settings
,
1320 .set_settings
= el3_set_settings
,
1321 .get_link
= el3_get_link
,
1322 .get_msglevel
= el3_get_msglevel
,
1323 .set_msglevel
= el3_set_msglevel
,
1327 el3_down(struct net_device
*dev
)
1329 int ioaddr
= dev
->base_addr
;
1331 netif_stop_queue(dev
);
1333 /* Turn off statistics ASAP. We update lp->stats below. */
1334 outw(StatsDisable
, ioaddr
+ EL3_CMD
);
1336 /* Disable the receiver and transmitter. */
1337 outw(RxDisable
, ioaddr
+ EL3_CMD
);
1338 outw(TxDisable
, ioaddr
+ EL3_CMD
);
1340 if (dev
->if_port
== 3)
1341 /* Turn off thinnet power. Green! */
1342 outw(StopCoax
, ioaddr
+ EL3_CMD
);
1343 else if (dev
->if_port
== 0) {
1344 /* Disable link beat and jabber, if_port may change here next open(). */
1346 outw(inw(ioaddr
+ WN4_MEDIA
) & ~MEDIA_TP
, ioaddr
+ WN4_MEDIA
);
1349 outw(SetIntrEnb
| 0x0000, ioaddr
+ EL3_CMD
);
1355 el3_up(struct net_device
*dev
)
1357 int i
, sw_info
, net_diag
;
1358 int ioaddr
= dev
->base_addr
;
1360 /* Activating the board required and does no harm otherwise */
1361 outw(0x0001, ioaddr
+ 4);
1363 /* Set the IRQ line. */
1364 outw((dev
->irq
<< 12) | 0x0f00, ioaddr
+ WN0_IRQ
);
1366 /* Set the station address in window 2 each time opened. */
1369 for (i
= 0; i
< 6; i
++)
1370 outb(dev
->dev_addr
[i
], ioaddr
+ i
);
1372 if ((dev
->if_port
& 0x03) == 3) /* BNC interface */
1373 /* Start the thinnet transceiver. We should really wait 50ms...*/
1374 outw(StartCoax
, ioaddr
+ EL3_CMD
);
1375 else if ((dev
->if_port
& 0x03) == 0) { /* 10baseT interface */
1376 /* Combine secondary sw_info word (the adapter level) and primary
1377 sw_info word (duplex setting plus other useless bits) */
1379 sw_info
= (read_eeprom(ioaddr
, 0x14) & 0x400f) |
1380 (read_eeprom(ioaddr
, 0x0d) & 0xBff0);
1383 net_diag
= inw(ioaddr
+ WN4_NETDIAG
);
1384 net_diag
= (net_diag
| FD_ENABLE
); /* temporarily assume full-duplex will be set */
1385 pr_info("%s: ", dev
->name
);
1386 switch (dev
->if_port
& 0x0c) {
1388 /* force full-duplex mode if 3c5x9b */
1389 if (sw_info
& 0x000f) {
1390 pr_cont("Forcing 3c5x9b full-duplex mode");
1394 /* set full-duplex mode based on eeprom config setting */
1395 if ((sw_info
& 0x000f) && (sw_info
& 0x8000)) {
1396 pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1400 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1401 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1402 net_diag
= (net_diag
& ~FD_ENABLE
); /* disable full duplex */
1405 outw(net_diag
, ioaddr
+ WN4_NETDIAG
);
1406 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev
->if_port
, sw_info
);
1408 pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev
->name
, net_diag
);
1409 /* Enable link beat and jabber check. */
1410 outw(inw(ioaddr
+ WN4_MEDIA
) | MEDIA_TP
, ioaddr
+ WN4_MEDIA
);
1413 /* Switch to the stats window, and clear all stats by reading. */
1414 outw(StatsDisable
, ioaddr
+ EL3_CMD
);
1416 for (i
= 0; i
< 9; i
++)
1421 /* Switch to register set 1 for normal use. */
1424 /* Accept b-case and phys addr only. */
1425 outw(SetRxFilter
| RxStation
| RxBroadcast
, ioaddr
+ EL3_CMD
);
1426 outw(StatsEnable
, ioaddr
+ EL3_CMD
); /* Turn on statistics. */
1428 outw(RxEnable
, ioaddr
+ EL3_CMD
); /* Enable the receiver. */
1429 outw(TxEnable
, ioaddr
+ EL3_CMD
); /* Enable transmitter. */
1430 /* Allow status bits to be seen. */
1431 outw(SetStatusEnb
| 0xff, ioaddr
+ EL3_CMD
);
1432 /* Ack all pending events, and set active indicator mask. */
1433 outw(AckIntr
| IntLatch
| TxAvailable
| RxEarly
| IntReq
,
1435 outw(SetIntrEnb
| IntLatch
|TxAvailable
|TxComplete
|RxComplete
|StatsFull
,
1438 netif_start_queue(dev
);
1441 /* Power Management support functions */
1445 el3_suspend(struct device
*pdev
, pm_message_t state
)
1447 unsigned long flags
;
1448 struct net_device
*dev
;
1449 struct el3_private
*lp
;
1452 dev
= dev_get_drvdata(pdev
);
1453 lp
= netdev_priv(dev
);
1454 ioaddr
= dev
->base_addr
;
1456 spin_lock_irqsave(&lp
->lock
, flags
);
1458 if (netif_running(dev
))
1459 netif_device_detach(dev
);
1462 outw(PowerDown
, ioaddr
+ EL3_CMD
);
1464 spin_unlock_irqrestore(&lp
->lock
, flags
);
1469 el3_resume(struct device
*pdev
)
1471 unsigned long flags
;
1472 struct net_device
*dev
;
1473 struct el3_private
*lp
;
1476 dev
= dev_get_drvdata(pdev
);
1477 lp
= netdev_priv(dev
);
1478 ioaddr
= dev
->base_addr
;
1480 spin_lock_irqsave(&lp
->lock
, flags
);
1482 outw(PowerUp
, ioaddr
+ EL3_CMD
);
1486 if (netif_running(dev
))
1487 netif_device_attach(dev
);
1489 spin_unlock_irqrestore(&lp
->lock
, flags
);
1493 #endif /* CONFIG_PM */
1495 module_param(debug
,int, 0);
1496 module_param_array(irq
, int, NULL
, 0);
1497 module_param(max_interrupt_work
, int, 0);
1498 MODULE_PARM_DESC(debug
, "debug level (0-6)");
1499 MODULE_PARM_DESC(irq
, "IRQ number(s) (assigned)");
1500 MODULE_PARM_DESC(max_interrupt_work
, "maximum events handled per interrupt");
1502 module_param(nopnp
, int, 0);
1503 MODULE_PARM_DESC(nopnp
, "disable ISA PnP support (0-1)");
1504 #endif /* CONFIG_PNP */
1505 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1506 MODULE_LICENSE("GPL");
1508 static int __init
el3_init_module(void)
1517 ret
= pnp_register_driver(&el3_pnp_driver
);
1522 /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1523 /* Start with 0x110 to avoid some sound cards.*/
1524 for (id_port
= 0x110 ; id_port
< 0x200; id_port
+= 0x10) {
1525 if (!request_region(id_port
, 1, "3c509-control"))
1527 outb(0x00, id_port
);
1528 outb(0xff, id_port
);
1529 if (inb(id_port
) & 0x01)
1532 release_region(id_port
, 1);
1534 if (id_port
>= 0x200) {
1536 pr_err("No I/O port available for 3c509 activation.\n");
1538 ret
= isa_register_driver(&el3_isa_driver
, EL3_MAX_CARDS
);
1543 ret
= eisa_driver_register(&el3_eisa_driver
);
1545 eisa_registered
= 1;
1548 ret
= mca_register_driver(&el3_mca_driver
);
1560 if (eisa_registered
)
1570 static void __exit
el3_cleanup_module(void)
1574 pnp_unregister_driver(&el3_pnp_driver
);
1577 isa_unregister_driver(&el3_isa_driver
);
1579 release_region(id_port
, 1);
1581 if (eisa_registered
)
1582 eisa_driver_unregister(&el3_eisa_driver
);
1586 mca_unregister_driver(&el3_mca_driver
);
1590 module_init (el3_init_module
);
1591 module_exit (el3_cleanup_module
);