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