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