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