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