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