?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.20.7
[linux/fpc-iii.git] / drivers / net / 3c509.c
blobf791bf026e5191711d46308facecdb0d89b9e009
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);
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 MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
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 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
884
885 dev->trans_start = jiffies;
886 if (inw(ioaddr + TX_FREE) > 1536)
887 netif_start_queue(dev);
888 else
889 /* Interrupt us when the FIFO has room for max-sized packet. */
890 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
891
892 spin_unlock_irqrestore(&lp->lock, flags);
893
894 dev_kfree_skb (skb);
895
896 /* Clear the Tx status stack. */
897 {
898 short tx_status;
899 int i = 4;
900
901 while (--i > 0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
902 if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
903 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
904 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
905 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
906 }
907 }
908 return 0;
909 }
910
911 /* The EL3 interrupt handler. */
912 static irqreturn_t
913 el3_interrupt(int irq, void *dev_id)
914 {
915 struct net_device *dev = dev_id;
916 struct el3_private *lp;
917 int ioaddr, status;
918 int i = max_interrupt_work;
919
920 lp = netdev_priv(dev);
921 spin_lock(&lp->lock);
922
923 ioaddr = dev->base_addr;
924
925 if (el3_debug > 4) {
926 status = inw(ioaddr + EL3_STATUS);
927 printk("%s: interrupt, status %4.4x.\n", dev->name, status);
928 }
929
930 while ((status = inw(ioaddr + EL3_STATUS)) &
931 (IntLatch | RxComplete | StatsFull)) {
932
933 if (status & RxComplete)
934 el3_rx(dev);
935
936 if (status & TxAvailable) {
937 if (el3_debug > 5)
938 printk(" TX room bit was handled.\n");
939 /* There's room in the FIFO for a full-sized packet. */
940 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
941 netif_wake_queue (dev);
942 }
943 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
944 /* Handle all uncommon interrupts. */
945 if (status & StatsFull) /* Empty statistics. */
946 update_stats(dev);
947 if (status & RxEarly) { /* Rx early is unused. */
948 el3_rx(dev);
949 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
950 }
951 if (status & TxComplete) { /* Really Tx error. */
952 struct el3_private *lp = netdev_priv(dev);
953 short tx_status;
954 int i = 4;
955
956 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
957 if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
958 if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
959 if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
960 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
961 }
962 }
963 if (status & AdapterFailure) {
964 /* Adapter failure requires Rx reset and reinit. */
965 outw(RxReset, ioaddr + EL3_CMD);
966 /* Set the Rx filter to the current state. */
967 outw(SetRxFilter | RxStation | RxBroadcast
968 | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
969 | (dev->flags & IFF_PROMISC ? RxProm : 0),
970 ioaddr + EL3_CMD);
971 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
972 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
973 }
974 }
975
976 if (--i < 0) {
977 printk("%s: Infinite loop in interrupt, status %4.4x.\n",
978 dev->name, status);
979 /* Clear all interrupts. */
980 outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
981 break;
982 }
983 /* Acknowledge the IRQ. */
984 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
985 }
986
987 if (el3_debug > 4) {
988 printk("%s: exiting interrupt, status %4.4x.\n", dev->name,
989 inw(ioaddr + EL3_STATUS));
990 }
991 spin_unlock(&lp->lock);
992 return IRQ_HANDLED;
993 }
994
995
996 #ifdef CONFIG_NET_POLL_CONTROLLER
997 /*
998 * Polling receive - used by netconsole and other diagnostic tools
999 * to allow network i/o with interrupts disabled.
1000 */
1001 static void el3_poll_controller(struct net_device *dev)
1002 {
1003 disable_irq(dev->irq);
1004 el3_interrupt(dev->irq, dev);
1005 enable_irq(dev->irq);
1006 }
1007 #endif
1008
1009 static struct net_device_stats *
1010 el3_get_stats(struct net_device *dev)
1011 {
1012 struct el3_private *lp = netdev_priv(dev);
1013 unsigned long flags;
1014
1015 /*
1016 * This is fast enough not to bother with disable IRQ
1017 * stuff.
1018 */
1019
1020 spin_lock_irqsave(&lp->lock, flags);
1021 update_stats(dev);
1022 spin_unlock_irqrestore(&lp->lock, flags);
1023 return &lp->stats;
1024 }
1025
1026 /* Update statistics. We change to register window 6, so this should be run
1027 single-threaded if the device is active. This is expected to be a rare
1028 operation, and it's simpler for the rest of the driver to assume that
1029 window 1 is always valid rather than use a special window-state variable.
1030 */
1031 static void update_stats(struct net_device *dev)
1032 {
1033 struct el3_private *lp = netdev_priv(dev);
1034 int ioaddr = dev->base_addr;
1035
1036 if (el3_debug > 5)
1037 printk(" Updating the statistics.\n");
1038 /* Turn off statistics updates while reading. */
1039 outw(StatsDisable, ioaddr + EL3_CMD);
1040 /* Switch to the stats window, and read everything. */
1041 EL3WINDOW(6);
1042 lp->stats.tx_carrier_errors += inb(ioaddr + 0);
1043 lp->stats.tx_heartbeat_errors += inb(ioaddr + 1);
1044 /* Multiple collisions. */ inb(ioaddr + 2);
1045 lp->stats.collisions += inb(ioaddr + 3);
1046 lp->stats.tx_window_errors += inb(ioaddr + 4);
1047 lp->stats.rx_fifo_errors += inb(ioaddr + 5);
1048 lp->stats.tx_packets += inb(ioaddr + 6);
1049 /* Rx packets */ inb(ioaddr + 7);
1050 /* Tx deferrals */ inb(ioaddr + 8);
1051 inw(ioaddr + 10); /* Total Rx and Tx octets. */
1052 inw(ioaddr + 12);
1053
1054 /* Back to window 1, and turn statistics back on. */
1055 EL3WINDOW(1);
1056 outw(StatsEnable, ioaddr + EL3_CMD);
1057 return;
1058 }
1059
1060 static int
1061 el3_rx(struct net_device *dev)
1062 {
1063 struct el3_private *lp = netdev_priv(dev);
1064 int ioaddr = dev->base_addr;
1065 short rx_status;
1066
1067 if (el3_debug > 5)
1068 printk(" In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1069 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1070 while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1071 if (rx_status & 0x4000) { /* Error, update stats. */
1072 short error = rx_status & 0x3800;
1073
1074 outw(RxDiscard, ioaddr + EL3_CMD);
1075 lp->stats.rx_errors++;
1076 switch (error) {
1077 case 0x0000: lp->stats.rx_over_errors++; break;
1078 case 0x0800: lp->stats.rx_length_errors++; break;
1079 case 0x1000: lp->stats.rx_frame_errors++; break;
1080 case 0x1800: lp->stats.rx_length_errors++; break;
1081 case 0x2000: lp->stats.rx_frame_errors++; break;
1082 case 0x2800: lp->stats.rx_crc_errors++; break;
1083 }
1084 } else {
1085 short pkt_len = rx_status & 0x7ff;
1086 struct sk_buff *skb;
1087
1088 skb = dev_alloc_skb(pkt_len+5);
1089 lp->stats.rx_bytes += pkt_len;
1090 if (el3_debug > 4)
1091 printk("Receiving packet size %d status %4.4x.\n",
1092 pkt_len, rx_status);
1093 if (skb != NULL) {
1094 skb->dev = dev;
1095 skb_reserve(skb, 2); /* Align IP on 16 byte */
1096
1097 /* 'skb->data' points to the start of sk_buff data area. */
1098 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1099 (pkt_len + 3) >> 2);
1100
1101 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1102 skb->protocol = eth_type_trans(skb,dev);
1103 netif_rx(skb);
1104 dev->last_rx = jiffies;
1105 lp->stats.rx_packets++;
1106 continue;
1107 }
1108 outw(RxDiscard, ioaddr + EL3_CMD);
1109 lp->stats.rx_dropped++;
1110 if (el3_debug)
1111 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1112 dev->name, pkt_len);
1113 }
1114 inw(ioaddr + EL3_STATUS); /* Delay. */
1115 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1116 printk(KERN_DEBUG " Waiting for 3c509 to discard packet, status %x.\n",
1117 inw(ioaddr + EL3_STATUS) );
1118 }
1119
1120 return 0;
1121 }
1122
1123 /*
1124 * Set or clear the multicast filter for this adaptor.
1125 */
1126 static void
1127 set_multicast_list(struct net_device *dev)
1128 {
1129 unsigned long flags;
1130 struct el3_private *lp = netdev_priv(dev);
1131 int ioaddr = dev->base_addr;
1132
1133 if (el3_debug > 1) {
1134 static int old;
1135 if (old != dev->mc_count) {
1136 old = dev->mc_count;
1137 printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1138 }
1139 }
1140 spin_lock_irqsave(&lp->lock, flags);
1141 if (dev->flags&IFF_PROMISC) {
1142 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1143 ioaddr + EL3_CMD);
1144 }
1145 else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1146 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1147 }
1148 else
1149 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1150 spin_unlock_irqrestore(&lp->lock, flags);
1151 }
1152
1153 static int
1154 el3_close(struct net_device *dev)
1155 {
1156 int ioaddr = dev->base_addr;
1157 struct el3_private *lp = netdev_priv(dev);
1158
1159 if (el3_debug > 2)
1160 printk("%s: Shutting down ethercard.\n", dev->name);
1161
1162 el3_down(dev);
1163
1164 free_irq(dev->irq, dev);
1165 /* Switching back to window 0 disables the IRQ. */
1166 EL3WINDOW(0);
1167 if (lp->type != EL3_EISA) {
1168 /* But we explicitly zero the IRQ line select anyway. Don't do
1169 * it on EISA cards, it prevents the module from getting an
1170 * IRQ after unload+reload... */
1171 outw(0x0f00, ioaddr + WN0_IRQ);
1172 }
1173
1174 return 0;
1175 }
1176
1177 static int
1178 el3_link_ok(struct net_device *dev)
1179 {
1180 int ioaddr = dev->base_addr;
1181 u16 tmp;
1182
1183 EL3WINDOW(4);
1184 tmp = inw(ioaddr + WN4_MEDIA);
1185 EL3WINDOW(1);
1186 return tmp & (1<<11);
1187 }
1188
1189 static int
1190 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1191 {
1192 u16 tmp;
1193 int ioaddr = dev->base_addr;
1194
1195 EL3WINDOW(0);
1196 /* obtain current transceiver via WN4_MEDIA? */
1197 tmp = inw(ioaddr + WN0_ADDR_CONF);
1198 ecmd->transceiver = XCVR_INTERNAL;
1199 switch (tmp >> 14) {
1200 case 0:
1201 ecmd->port = PORT_TP;
1202 break;
1203 case 1:
1204 ecmd->port = PORT_AUI;
1205 ecmd->transceiver = XCVR_EXTERNAL;
1206 break;
1207 case 3:
1208 ecmd->port = PORT_BNC;
1209 default:
1210 break;
1211 }
1212
1213 ecmd->duplex = DUPLEX_HALF;
1214 ecmd->supported = 0;
1215 tmp = inw(ioaddr + WN0_CONF_CTRL);
1216 if (tmp & (1<<13))
1217 ecmd->supported |= SUPPORTED_AUI;
1218 if (tmp & (1<<12))
1219 ecmd->supported |= SUPPORTED_BNC;
1220 if (tmp & (1<<9)) {
1221 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1222 SUPPORTED_10baseT_Full; /* hmm... */
1223 EL3WINDOW(4);
1224 tmp = inw(ioaddr + WN4_NETDIAG);
1225 if (tmp & FD_ENABLE)
1226 ecmd->duplex = DUPLEX_FULL;
1227 }
1228
1229 ecmd->speed = SPEED_10;
1230 EL3WINDOW(1);
1231 return 0;
1232 }
1233
1234 static int
1235 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1236 {
1237 u16 tmp;
1238 int ioaddr = dev->base_addr;
1239
1240 if (ecmd->speed != SPEED_10)
1241 return -EINVAL;
1242 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1243 return -EINVAL;
1244 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1245 return -EINVAL;
1246
1247 /* change XCVR type */
1248 EL3WINDOW(0);
1249 tmp = inw(ioaddr + WN0_ADDR_CONF);
1250 switch (ecmd->port) {
1251 case PORT_TP:
1252 tmp &= ~(3<<14);
1253 dev->if_port = 0;
1254 break;
1255 case PORT_AUI:
1256 tmp |= (1<<14);
1257 dev->if_port = 1;
1258 break;
1259 case PORT_BNC:
1260 tmp |= (3<<14);
1261 dev->if_port = 3;
1262 break;
1263 default:
1264 return -EINVAL;
1265 }
1266
1267 outw(tmp, ioaddr + WN0_ADDR_CONF);
1268 if (dev->if_port == 3) {
1269 /* fire up the DC-DC convertor if BNC gets enabled */
1270 tmp = inw(ioaddr + WN0_ADDR_CONF);
1271 if (tmp & (3 << 14)) {
1272 outw(StartCoax, ioaddr + EL3_CMD);
1273 udelay(800);
1274 } else
1275 return -EIO;
1276 }
1277
1278 EL3WINDOW(4);
1279 tmp = inw(ioaddr + WN4_NETDIAG);
1280 if (ecmd->duplex == DUPLEX_FULL)
1281 tmp |= FD_ENABLE;
1282 else
1283 tmp &= ~FD_ENABLE;
1284 outw(tmp, ioaddr + WN4_NETDIAG);
1285 EL3WINDOW(1);
1286
1287 return 0;
1288 }
1289
1290 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1291 {
1292 strcpy(info->driver, DRV_NAME);
1293 strcpy(info->version, DRV_VERSION);
1294 }
1295
1296 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1297 {
1298 struct el3_private *lp = netdev_priv(dev);
1299 int ret;
1300
1301 spin_lock_irq(&lp->lock);
1302 ret = el3_netdev_get_ecmd(dev, ecmd);
1303 spin_unlock_irq(&lp->lock);
1304 return ret;
1305 }
1306
1307 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1308 {
1309 struct el3_private *lp = netdev_priv(dev);
1310 int ret;
1311
1312 spin_lock_irq(&lp->lock);
1313 ret = el3_netdev_set_ecmd(dev, ecmd);
1314 spin_unlock_irq(&lp->lock);
1315 return ret;
1316 }
1317
1318 static u32 el3_get_link(struct net_device *dev)
1319 {
1320 struct el3_private *lp = netdev_priv(dev);
1321 u32 ret;
1322
1323 spin_lock_irq(&lp->lock);
1324 ret = el3_link_ok(dev);
1325 spin_unlock_irq(&lp->lock);
1326 return ret;
1327 }
1328
1329 static u32 el3_get_msglevel(struct net_device *dev)
1330 {
1331 return el3_debug;
1332 }
1333
1334 static void el3_set_msglevel(struct net_device *dev, u32 v)
1335 {
1336 el3_debug = v;
1337 }
1338
1339 static const struct ethtool_ops ethtool_ops = {
1340 .get_drvinfo = el3_get_drvinfo,
1341 .get_settings = el3_get_settings,
1342 .set_settings = el3_set_settings,
1343 .get_link = el3_get_link,
1344 .get_msglevel = el3_get_msglevel,
1345 .set_msglevel = el3_set_msglevel,
1346 };
1347
1348 static void
1349 el3_down(struct net_device *dev)
1350 {
1351 int ioaddr = dev->base_addr;
1352
1353 netif_stop_queue(dev);
1354
1355 /* Turn off statistics ASAP. We update lp->stats below. */
1356 outw(StatsDisable, ioaddr + EL3_CMD);
1357
1358 /* Disable the receiver and transmitter. */
1359 outw(RxDisable, ioaddr + EL3_CMD);
1360 outw(TxDisable, ioaddr + EL3_CMD);
1361
1362 if (dev->if_port == 3)
1363 /* Turn off thinnet power. Green! */
1364 outw(StopCoax, ioaddr + EL3_CMD);
1365 else if (dev->if_port == 0) {
1366 /* Disable link beat and jabber, if_port may change here next open(). */
1367 EL3WINDOW(4);
1368 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1369 }
1370
1371 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1372
1373 update_stats(dev);
1374 }
1375
1376 static void
1377 el3_up(struct net_device *dev)
1378 {
1379 int i, sw_info, net_diag;
1380 int ioaddr = dev->base_addr;
1381
1382 /* Activating the board required and does no harm otherwise */
1383 outw(0x0001, ioaddr + 4);
1384
1385 /* Set the IRQ line. */
1386 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1387
1388 /* Set the station address in window 2 each time opened. */
1389 EL3WINDOW(2);
1390
1391 for (i = 0; i < 6; i++)
1392 outb(dev->dev_addr[i], ioaddr + i);
1393
1394 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1395 /* Start the thinnet transceiver. We should really wait 50ms...*/
1396 outw(StartCoax, ioaddr + EL3_CMD);
1397 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1398 /* Combine secondary sw_info word (the adapter level) and primary
1399 sw_info word (duplex setting plus other useless bits) */
1400 EL3WINDOW(0);
1401 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1402 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1403
1404 EL3WINDOW(4);
1405 net_diag = inw(ioaddr + WN4_NETDIAG);
1406 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1407 printk("%s: ", dev->name);
1408 switch (dev->if_port & 0x0c) {
1409 case 12:
1410 /* force full-duplex mode if 3c5x9b */
1411 if (sw_info & 0x000f) {
1412 printk("Forcing 3c5x9b full-duplex mode");
1413 break;
1414 }
1415 case 8:
1416 /* set full-duplex mode based on eeprom config setting */
1417 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1418 printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1419 break;
1420 }
1421 default:
1422 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1423 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1424 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1425 }
1426
1427 outw(net_diag, ioaddr + WN4_NETDIAG);
1428 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1429 if (el3_debug > 3)
1430 printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1431 /* Enable link beat and jabber check. */
1432 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1433 }
1434
1435 /* Switch to the stats window, and clear all stats by reading. */
1436 outw(StatsDisable, ioaddr + EL3_CMD);
1437 EL3WINDOW(6);
1438 for (i = 0; i < 9; i++)
1439 inb(ioaddr + i);
1440 inw(ioaddr + 10);
1441 inw(ioaddr + 12);
1442
1443 /* Switch to register set 1 for normal use. */
1444 EL3WINDOW(1);
1445
1446 /* Accept b-case and phys addr only. */
1447 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1448 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1449
1450 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1451 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1452 /* Allow status bits to be seen. */
1453 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1454 /* Ack all pending events, and set active indicator mask. */
1455 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1456 ioaddr + EL3_CMD);
1457 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1458 ioaddr + EL3_CMD);
1459
1460 netif_start_queue(dev);
1461 }
1462
1463 /* Power Management support functions */
1464 #ifdef EL3_SUSPEND
1465
1466 static int
1467 el3_suspend(struct device *pdev, pm_message_t state)
1468 {
1469 unsigned long flags;
1470 struct net_device *dev;
1471 struct el3_private *lp;
1472 int ioaddr;
1473
1474 dev = pdev->driver_data;
1475 lp = netdev_priv(dev);
1476 ioaddr = dev->base_addr;
1477
1478 spin_lock_irqsave(&lp->lock, flags);
1479
1480 if (netif_running(dev))
1481 netif_device_detach(dev);
1482
1483 el3_down(dev);
1484 outw(PowerDown, ioaddr + EL3_CMD);
1485
1486 spin_unlock_irqrestore(&lp->lock, flags);
1487 return 0;
1488 }
1489
1490 static int
1491 el3_resume(struct device *pdev)
1492 {
1493 unsigned long flags;
1494 struct net_device *dev;
1495 struct el3_private *lp;
1496 int ioaddr;
1497
1498 dev = pdev->driver_data;
1499 lp = netdev_priv(dev);
1500 ioaddr = dev->base_addr;
1501
1502 spin_lock_irqsave(&lp->lock, flags);
1503
1504 outw(PowerUp, ioaddr + EL3_CMD);
1505 el3_up(dev);
1506
1507 if (netif_running(dev))
1508 netif_device_attach(dev);
1509
1510 spin_unlock_irqrestore(&lp->lock, flags);
1511 return 0;
1512 }
1513
1514 #endif /* EL3_SUSPEND */
1515
1516 /* Parameters that may be passed into the module. */
1517 static int debug = -1;
1518 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
1519 static int xcvr[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1520
1521 module_param(debug,int, 0);
1522 module_param_array(irq, int, NULL, 0);
1523 module_param_array(xcvr, int, NULL, 0);
1524 module_param(max_interrupt_work, int, 0);
1525 MODULE_PARM_DESC(debug, "debug level (0-6)");
1526 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1527 MODULE_PARM_DESC(xcvr,"transceiver(s) (0=internal, 1=external)");
1528 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1529 #if defined(__ISAPNP__)
1530 module_param(nopnp, int, 0);
1531 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1532 MODULE_DEVICE_TABLE(isapnp, el3_isapnp_adapters);
1533 #endif /* __ISAPNP__ */
1534 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B) ISA/PnP ethernet driver");
1535 MODULE_LICENSE("GPL");
1536
1537 static int __init el3_init_module(void)
1538 {
1539 int ret = 0;
1540 el3_cards = 0;
1541
1542 if (debug >= 0)
1543 el3_debug = debug;
1544
1545 el3_root_dev = NULL;
1546 while (el3_probe(el3_cards) == 0) {
1547 if (irq[el3_cards] > 1)
1548 el3_root_dev->irq = irq[el3_cards];
1549 if (xcvr[el3_cards] >= 0)
1550 el3_root_dev->if_port = xcvr[el3_cards];
1551 el3_cards++;
1552 }
1553
1554 #ifdef CONFIG_EISA
1555 ret = eisa_driver_register(&el3_eisa_driver);
1556 #endif
1557 #ifdef CONFIG_MCA
1558 {
1559 int err = mca_register_driver(&el3_mca_driver);
1560 if (ret == 0)
1561 ret = err;
1562 }
1563 #endif
1564 return ret;
1565 }
1566
1567 static void __exit el3_cleanup_module(void)
1568 {
1569 struct net_device *next_dev;
1570
1571 while (el3_root_dev) {
1572 struct el3_private *lp = netdev_priv(el3_root_dev);
1573
1574 next_dev = lp->next_dev;
1575 el3_common_remove (el3_root_dev);
1576 el3_root_dev = next_dev;
1577 }
1578
1579 #ifdef CONFIG_EISA
1580 eisa_driver_unregister (&el3_eisa_driver);
1581 #endif
1582 #ifdef CONFIG_MCA
1583 mca_unregister_driver(&el3_mca_driver);
1584 #endif
1585 }
1586
1587 module_init (el3_init_module);
1588 module_exit (el3_cleanup_module);
1589
Linux with added FPC-III support