?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: Allow autosuspend delay to equal 0
[linux-2.6.git] / drivers / net / 3c509.c
blobc7511c4d3b68f358959183d8e21874026a86f9d7
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_reserve(skb, 2); /* Align IP on 16 byte */
1095
1096 /* 'skb->data' points to the start of sk_buff data area. */
1097 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1098 (pkt_len + 3) >> 2);
1099
1100 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1101 skb->protocol = eth_type_trans(skb,dev);
1102 netif_rx(skb);
1103 dev->last_rx = jiffies;
1104 lp->stats.rx_packets++;
1105 continue;
1106 }
1107 outw(RxDiscard, ioaddr + EL3_CMD);
1108 lp->stats.rx_dropped++;
1109 if (el3_debug)
1110 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1111 dev->name, pkt_len);
1112 }
1113 inw(ioaddr + EL3_STATUS); /* Delay. */
1114 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1115 printk(KERN_DEBUG " Waiting for 3c509 to discard packet, status %x.\n",
1116 inw(ioaddr + EL3_STATUS) );
1117 }
1118
1119 return 0;
1120 }
1121
1122 /*
1123 * Set or clear the multicast filter for this adaptor.
1124 */
1125 static void
1126 set_multicast_list(struct net_device *dev)
1127 {
1128 unsigned long flags;
1129 struct el3_private *lp = netdev_priv(dev);
1130 int ioaddr = dev->base_addr;
1131
1132 if (el3_debug > 1) {
1133 static int old;
1134 if (old != dev->mc_count) {
1135 old = dev->mc_count;
1136 printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1137 }
1138 }
1139 spin_lock_irqsave(&lp->lock, flags);
1140 if (dev->flags&IFF_PROMISC) {
1141 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1142 ioaddr + EL3_CMD);
1143 }
1144 else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1145 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1146 }
1147 else
1148 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1149 spin_unlock_irqrestore(&lp->lock, flags);
1150 }
1151
1152 static int
1153 el3_close(struct net_device *dev)
1154 {
1155 int ioaddr = dev->base_addr;
1156 struct el3_private *lp = netdev_priv(dev);
1157
1158 if (el3_debug > 2)
1159 printk("%s: Shutting down ethercard.\n", dev->name);
1160
1161 el3_down(dev);
1162
1163 free_irq(dev->irq, dev);
1164 /* Switching back to window 0 disables the IRQ. */
1165 EL3WINDOW(0);
1166 if (lp->type != EL3_EISA) {
1167 /* But we explicitly zero the IRQ line select anyway. Don't do
1168 * it on EISA cards, it prevents the module from getting an
1169 * IRQ after unload+reload... */
1170 outw(0x0f00, ioaddr + WN0_IRQ);
1171 }
1172
1173 return 0;
1174 }
1175
1176 static int
1177 el3_link_ok(struct net_device *dev)
1178 {
1179 int ioaddr = dev->base_addr;
1180 u16 tmp;
1181
1182 EL3WINDOW(4);
1183 tmp = inw(ioaddr + WN4_MEDIA);
1184 EL3WINDOW(1);
1185 return tmp & (1<<11);
1186 }
1187
1188 static int
1189 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1190 {
1191 u16 tmp;
1192 int ioaddr = dev->base_addr;
1193
1194 EL3WINDOW(0);
1195 /* obtain current transceiver via WN4_MEDIA? */
1196 tmp = inw(ioaddr + WN0_ADDR_CONF);
1197 ecmd->transceiver = XCVR_INTERNAL;
1198 switch (tmp >> 14) {
1199 case 0:
1200 ecmd->port = PORT_TP;
1201 break;
1202 case 1:
1203 ecmd->port = PORT_AUI;
1204 ecmd->transceiver = XCVR_EXTERNAL;
1205 break;
1206 case 3:
1207 ecmd->port = PORT_BNC;
1208 default:
1209 break;
1210 }
1211
1212 ecmd->duplex = DUPLEX_HALF;
1213 ecmd->supported = 0;
1214 tmp = inw(ioaddr + WN0_CONF_CTRL);
1215 if (tmp & (1<<13))
1216 ecmd->supported |= SUPPORTED_AUI;
1217 if (tmp & (1<<12))
1218 ecmd->supported |= SUPPORTED_BNC;
1219 if (tmp & (1<<9)) {
1220 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1221 SUPPORTED_10baseT_Full; /* hmm... */
1222 EL3WINDOW(4);
1223 tmp = inw(ioaddr + WN4_NETDIAG);
1224 if (tmp & FD_ENABLE)
1225 ecmd->duplex = DUPLEX_FULL;
1226 }
1227
1228 ecmd->speed = SPEED_10;
1229 EL3WINDOW(1);
1230 return 0;
1231 }
1232
1233 static int
1234 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1235 {
1236 u16 tmp;
1237 int ioaddr = dev->base_addr;
1238
1239 if (ecmd->speed != SPEED_10)
1240 return -EINVAL;
1241 if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1242 return -EINVAL;
1243 if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1244 return -EINVAL;
1245
1246 /* change XCVR type */
1247 EL3WINDOW(0);
1248 tmp = inw(ioaddr + WN0_ADDR_CONF);
1249 switch (ecmd->port) {
1250 case PORT_TP:
1251 tmp &= ~(3<<14);
1252 dev->if_port = 0;
1253 break;
1254 case PORT_AUI:
1255 tmp |= (1<<14);
1256 dev->if_port = 1;
1257 break;
1258 case PORT_BNC:
1259 tmp |= (3<<14);
1260 dev->if_port = 3;
1261 break;
1262 default:
1263 return -EINVAL;
1264 }
1265
1266 outw(tmp, ioaddr + WN0_ADDR_CONF);
1267 if (dev->if_port == 3) {
1268 /* fire up the DC-DC convertor if BNC gets enabled */
1269 tmp = inw(ioaddr + WN0_ADDR_CONF);
1270 if (tmp & (3 << 14)) {
1271 outw(StartCoax, ioaddr + EL3_CMD);
1272 udelay(800);
1273 } else
1274 return -EIO;
1275 }
1276
1277 EL3WINDOW(4);
1278 tmp = inw(ioaddr + WN4_NETDIAG);
1279 if (ecmd->duplex == DUPLEX_FULL)
1280 tmp |= FD_ENABLE;
1281 else
1282 tmp &= ~FD_ENABLE;
1283 outw(tmp, ioaddr + WN4_NETDIAG);
1284 EL3WINDOW(1);
1285
1286 return 0;
1287 }
1288
1289 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1290 {
1291 strcpy(info->driver, DRV_NAME);
1292 strcpy(info->version, DRV_VERSION);
1293 }
1294
1295 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1296 {
1297 struct el3_private *lp = netdev_priv(dev);
1298 int ret;
1299
1300 spin_lock_irq(&lp->lock);
1301 ret = el3_netdev_get_ecmd(dev, ecmd);
1302 spin_unlock_irq(&lp->lock);
1303 return ret;
1304 }
1305
1306 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1307 {
1308 struct el3_private *lp = netdev_priv(dev);
1309 int ret;
1310
1311 spin_lock_irq(&lp->lock);
1312 ret = el3_netdev_set_ecmd(dev, ecmd);
1313 spin_unlock_irq(&lp->lock);
1314 return ret;
1315 }
1316
1317 static u32 el3_get_link(struct net_device *dev)
1318 {
1319 struct el3_private *lp = netdev_priv(dev);
1320 u32 ret;
1321
1322 spin_lock_irq(&lp->lock);
1323 ret = el3_link_ok(dev);
1324 spin_unlock_irq(&lp->lock);
1325 return ret;
1326 }
1327
1328 static u32 el3_get_msglevel(struct net_device *dev)
1329 {
1330 return el3_debug;
1331 }
1332
1333 static void el3_set_msglevel(struct net_device *dev, u32 v)
1334 {
1335 el3_debug = v;
1336 }
1337
1338 static const struct ethtool_ops ethtool_ops = {
1339 .get_drvinfo = el3_get_drvinfo,
1340 .get_settings = el3_get_settings,
1341 .set_settings = el3_set_settings,
1342 .get_link = el3_get_link,
1343 .get_msglevel = el3_get_msglevel,
1344 .set_msglevel = el3_set_msglevel,
1345 };
1346
1347 static void
1348 el3_down(struct net_device *dev)
1349 {
1350 int ioaddr = dev->base_addr;
1351
1352 netif_stop_queue(dev);
1353
1354 /* Turn off statistics ASAP. We update lp->stats below. */
1355 outw(StatsDisable, ioaddr + EL3_CMD);
1356
1357 /* Disable the receiver and transmitter. */
1358 outw(RxDisable, ioaddr + EL3_CMD);
1359 outw(TxDisable, ioaddr + EL3_CMD);
1360
1361 if (dev->if_port == 3)
1362 /* Turn off thinnet power. Green! */
1363 outw(StopCoax, ioaddr + EL3_CMD);
1364 else if (dev->if_port == 0) {
1365 /* Disable link beat and jabber, if_port may change here next open(). */
1366 EL3WINDOW(4);
1367 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1368 }
1369
1370 outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1371
1372 update_stats(dev);
1373 }
1374
1375 static void
1376 el3_up(struct net_device *dev)
1377 {
1378 int i, sw_info, net_diag;
1379 int ioaddr = dev->base_addr;
1380
1381 /* Activating the board required and does no harm otherwise */
1382 outw(0x0001, ioaddr + 4);
1383
1384 /* Set the IRQ line. */
1385 outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1386
1387 /* Set the station address in window 2 each time opened. */
1388 EL3WINDOW(2);
1389
1390 for (i = 0; i < 6; i++)
1391 outb(dev->dev_addr[i], ioaddr + i);
1392
1393 if ((dev->if_port & 0x03) == 3) /* BNC interface */
1394 /* Start the thinnet transceiver. We should really wait 50ms...*/
1395 outw(StartCoax, ioaddr + EL3_CMD);
1396 else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1397 /* Combine secondary sw_info word (the adapter level) and primary
1398 sw_info word (duplex setting plus other useless bits) */
1399 EL3WINDOW(0);
1400 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1401 (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1402
1403 EL3WINDOW(4);
1404 net_diag = inw(ioaddr + WN4_NETDIAG);
1405 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1406 printk("%s: ", dev->name);
1407 switch (dev->if_port & 0x0c) {
1408 case 12:
1409 /* force full-duplex mode if 3c5x9b */
1410 if (sw_info & 0x000f) {
1411 printk("Forcing 3c5x9b full-duplex mode");
1412 break;
1413 }
1414 case 8:
1415 /* set full-duplex mode based on eeprom config setting */
1416 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1417 printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1418 break;
1419 }
1420 default:
1421 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1422 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1423 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1424 }
1425
1426 outw(net_diag, ioaddr + WN4_NETDIAG);
1427 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1428 if (el3_debug > 3)
1429 printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1430 /* Enable link beat and jabber check. */
1431 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1432 }
1433
1434 /* Switch to the stats window, and clear all stats by reading. */
1435 outw(StatsDisable, ioaddr + EL3_CMD);
1436 EL3WINDOW(6);
1437 for (i = 0; i < 9; i++)
1438 inb(ioaddr + i);
1439 inw(ioaddr + 10);
1440 inw(ioaddr + 12);
1441
1442 /* Switch to register set 1 for normal use. */
1443 EL3WINDOW(1);
1444
1445 /* Accept b-case and phys addr only. */
1446 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1447 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1448
1449 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1450 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1451 /* Allow status bits to be seen. */
1452 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1453 /* Ack all pending events, and set active indicator mask. */
1454 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1455 ioaddr + EL3_CMD);
1456 outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1457 ioaddr + EL3_CMD);
1458
1459 netif_start_queue(dev);
1460 }
1461
1462 /* Power Management support functions */
1463 #ifdef EL3_SUSPEND
1464
1465 static int
1466 el3_suspend(struct device *pdev, pm_message_t state)
1467 {
1468 unsigned long flags;
1469 struct net_device *dev;
1470 struct el3_private *lp;
1471 int ioaddr;
1472
1473 dev = pdev->driver_data;
1474 lp = netdev_priv(dev);
1475 ioaddr = dev->base_addr;
1476
1477 spin_lock_irqsave(&lp->lock, flags);
1478
1479 if (netif_running(dev))
1480 netif_device_detach(dev);
1481
1482 el3_down(dev);
1483 outw(PowerDown, ioaddr + EL3_CMD);
1484
1485 spin_unlock_irqrestore(&lp->lock, flags);
1486 return 0;
1487 }
1488
1489 static int
1490 el3_resume(struct device *pdev)
1491 {
1492 unsigned long flags;
1493 struct net_device *dev;
1494 struct el3_private *lp;
1495 int ioaddr;
1496
1497 dev = pdev->driver_data;
1498 lp = netdev_priv(dev);
1499 ioaddr = dev->base_addr;
1500
1501 spin_lock_irqsave(&lp->lock, flags);
1502
1503 outw(PowerUp, ioaddr + EL3_CMD);
1504 el3_up(dev);
1505
1506 if (netif_running(dev))
1507 netif_device_attach(dev);
1508
1509 spin_unlock_irqrestore(&lp->lock, flags);
1510 return 0;
1511 }
1512
1513 #endif /* EL3_SUSPEND */
1514
1515 /* Parameters that may be passed into the module. */
1516 static int debug = -1;
1517 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
1518 static int xcvr[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1519
1520 module_param(debug,int, 0);
1521 module_param_array(irq, int, NULL, 0);
1522 module_param_array(xcvr, int, NULL, 0);
1523 module_param(max_interrupt_work, int, 0);
1524 MODULE_PARM_DESC(debug, "debug level (0-6)");
1525 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1526 MODULE_PARM_DESC(xcvr,"transceiver(s) (0=internal, 1=external)");
1527 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1528 #if defined(__ISAPNP__)
1529 module_param(nopnp, int, 0);
1530 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1531 MODULE_DEVICE_TABLE(isapnp, el3_isapnp_adapters);
1532 #endif /* __ISAPNP__ */
1533 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B) ISA/PnP ethernet driver");
1534 MODULE_LICENSE("GPL");
1535
1536 static int __init el3_init_module(void)
1537 {
1538 int ret = 0;
1539 el3_cards = 0;
1540
1541 if (debug >= 0)
1542 el3_debug = debug;
1543
1544 el3_root_dev = NULL;
1545 while (el3_probe(el3_cards) == 0) {
1546 if (irq[el3_cards] > 1)
1547 el3_root_dev->irq = irq[el3_cards];
1548 if (xcvr[el3_cards] >= 0)
1549 el3_root_dev->if_port = xcvr[el3_cards];
1550 el3_cards++;
1551 }
1552
1553 #ifdef CONFIG_EISA
1554 ret = eisa_driver_register(&el3_eisa_driver);
1555 #endif
1556 #ifdef CONFIG_MCA
1557 {
1558 int err = mca_register_driver(&el3_mca_driver);
1559 if (ret == 0)
1560 ret = err;
1561 }
1562 #endif
1563 return ret;
1564 }
1565
1566 static void __exit el3_cleanup_module(void)
1567 {
1568 struct net_device *next_dev;
1569
1570 while (el3_root_dev) {
1571 struct el3_private *lp = netdev_priv(el3_root_dev);
1572
1573 next_dev = lp->next_dev;
1574 el3_common_remove (el3_root_dev);
1575 el3_root_dev = next_dev;
1576 }
1577
1578 #ifdef CONFIG_EISA
1579 eisa_driver_unregister (&el3_eisa_driver);
1580 #endif
1581 #ifdef CONFIG_MCA
1582 mca_unregister_driver(&el3_mca_driver);
1583 #endif
1584 }
1585
1586 module_init (el3_init_module);
1587 module_exit (el3_cleanup_module);
1588
Linus' kernel tree