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