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