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