Create platform_device.h to contain all the platform device details.
[linux-2.6.git] / drivers / net / 3c509.c
1 /* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
2 /*
3         Written 1993-2000 by Donald Becker.
4
5         Copyright 1994-2000 by Donald Becker.
6         Copyright 1993 United States Government as represented by the
7         Director, National Security Agency.      This software may be used and
8         distributed according to the terms of the GNU General Public License,
9         incorporated herein by reference.
10
11         This driver is for the 3Com EtherLinkIII series.
12
13         The author may be reached as becker@scyld.com, or C/O
14         Scyld Computing Corporation
15         410 Severn Ave., Suite 210
16         Annapolis MD 21403
17
18         Known limitations:
19         Because of the way 3c509 ISA detection works it's difficult to predict
20         a priori which of several ISA-mode cards will be detected first.
21
22         This driver does not use predictive interrupt mode, resulting in higher
23         packet latency but lower overhead.  If interrupts are disabled for an
24         unusually long time it could also result in missed packets, but in
25         practice this rarely happens.
26
27
28         FIXES:
29                 Alan Cox:       Removed the 'Unexpected interrupt' bug.
30                 Michael Meskes: Upgraded to Donald Becker's version 1.07.
31                 Alan Cox:       Increased the eeprom delay. Regardless of 
32                                 what the docs say some people definitely
33                                 get problems with lower (but in card spec)
34                                 delays
35                 v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
36                                 other cleanups.  -djb
37                 Andrea Arcangeli:       Upgraded to Donald Becker's version 1.12.
38                 Rick Payne:     Fixed SMP race condition
39                 v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
40                 v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
41                 v1.15 1/31/98 Faster recovery for Tx errors. -djb
42                 v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
43                 v1.18 12Mar2001 Andrew Morton <andrewm@uow.edu.au>
44                         - Avoid bogus detect of 3c590's (Andrzej Krzysztofowicz)
45                         - Reviewed against 1.18 from scyld.com
46                 v1.18a 17Nov2001 Jeff Garzik <jgarzik@pobox.com>
47                         - ethtool support
48                 v1.18b 1Mar2002 Zwane Mwaikambo <zwane@commfireservices.com>
49                         - Power Management support
50                 v1.18c 1Mar2002 David Ruggiero <jdr@farfalle.com>
51                         - Full duplex support
52                 v1.19  16Oct2002 Zwane Mwaikambo <zwane@linuxpower.ca>
53                         - Additional ethtool features
54                 v1.19a 28Oct2002 Davud Ruggiero <jdr@farfalle.com>
55                         - Increase *read_eeprom udelay to workaround oops with 2 cards.
56                 v1.19b 08Nov2002 Marc Zyngier <maz@wild-wind.fr.eu.org>
57                     - Introduce driver model for EISA cards.
58 */
59
60 #define DRV_NAME        "3c509"
61 #define DRV_VERSION     "1.19b"
62 #define DRV_RELDATE     "08Nov2002"
63
64 /* A few values that may be tweaked. */
65
66 /* Time in jiffies before concluding the transmitter is hung. */
67 #define TX_TIMEOUT  (400*HZ/1000)
68 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
69 static int max_interrupt_work = 10;
70
71 #include <linux/config.h>
72 #include <linux/module.h>
73 #ifdef CONFIG_MCA
74 #include <linux/mca.h>
75 #endif
76 #include <linux/isapnp.h>
77 #include <linux/string.h>
78 #include <linux/interrupt.h>
79 #include <linux/errno.h>
80 #include <linux/in.h>
81 #include <linux/slab.h>
82 #include <linux/ioport.h>
83 #include <linux/init.h>
84 #include <linux/netdevice.h>
85 #include <linux/etherdevice.h>
86 #include <linux/pm.h>
87 #include <linux/skbuff.h>
88 #include <linux/delay.h>        /* for udelay() */
89 #include <linux/spinlock.h>
90 #include <linux/ethtool.h>
91 #include <linux/device.h>
92 #include <linux/eisa.h>
93 #include <linux/bitops.h>
94
95 #include <asm/uaccess.h>
96 #include <asm/io.h>
97 #include <asm/irq.h>
98
99 static char versionA[] __initdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
100 static char versionB[] __initdata = "http://www.scyld.com/network/3c509.html\n";
101
102 #ifdef EL3_DEBUG
103 static int el3_debug = EL3_DEBUG;
104 #else
105 static int el3_debug = 2;
106 #endif
107
108 /* Used to do a global count of all the cards in the system.  Must be
109  * a global variable so that the mca/eisa probe routines can increment
110  * it */
111 static int el3_cards = 0;
112
113 /* To minimize the size of the driver source I only define operating
114    constants if they are used several times.  You'll need the manual
115    anyway if you want to understand driver details. */
116 /* Offsets from base I/O address. */
117 #define EL3_DATA 0x00
118 #define EL3_CMD 0x0e
119 #define EL3_STATUS 0x0e
120 #define  EEPROM_READ 0x80
121
122 #define EL3_IO_EXTENT   16
123
124 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
125
126
127 /* The top five bits written to EL3_CMD are a command, the lower
128    11 bits are the parameter, if applicable. */
129 enum c509cmd {
130         TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
131         RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
132         TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
133         FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
134         SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
135         SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
136         StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
137         PowerDown = 28<<11, PowerAuto = 29<<11};
138
139 enum c509status {
140         IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
141         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
142         IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
143
144 /* The SetRxFilter command accepts the following classes: */
145 enum RxFilter {
146         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
147
148 /* Register window 1 offsets, the window used in normal operation. */
149 #define TX_FIFO         0x00
150 #define RX_FIFO         0x00
151 #define RX_STATUS       0x08
152 #define TX_STATUS       0x0B
153 #define TX_FREE         0x0C            /* Remaining free bytes in Tx buffer. */
154
155 #define WN0_CONF_CTRL   0x04            /* Window 0: Configuration control register */
156 #define WN0_ADDR_CONF   0x06            /* Window 0: Address configuration register */
157 #define WN0_IRQ         0x08            /* Window 0: Set IRQ line in bits 12-15. */
158 #define WN4_MEDIA       0x0A            /* Window 4: Various transcvr/media bits. */
159 #define MEDIA_TP        0x00C0          /* Enable link beat and jabber for 10baseT. */
160 #define WN4_NETDIAG     0x06            /* Window 4: Net diagnostic */
161 #define FD_ENABLE       0x8000          /* Enable full-duplex ("external loopback") */  
162
163 /*
164  * Must be a power of two (we use a binary and in the
165  * circular queue)
166  */
167 #define SKB_QUEUE_SIZE  64
168
169 struct el3_private {
170         struct net_device_stats stats;
171         struct net_device *next_dev;
172         spinlock_t lock;
173         /* skb send-queue */
174         int head, size;
175         struct sk_buff *queue[SKB_QUEUE_SIZE];
176 #ifdef CONFIG_PM
177         struct pm_dev *pmdev;
178 #endif
179         enum {
180                 EL3_MCA,
181                 EL3_PNP,
182                 EL3_EISA,
183         } type;                                         /* type of device */
184         struct device *dev;
185 };
186 static int id_port __initdata = 0x110;  /* Start with 0x110 to avoid new sound cards.*/
187 static struct net_device *el3_root_dev;
188
189 static ushort id_read_eeprom(int index);
190 static ushort read_eeprom(int ioaddr, int index);
191 static int el3_open(struct net_device *dev);
192 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
193 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
194 static void update_stats(struct net_device *dev);
195 static struct net_device_stats *el3_get_stats(struct net_device *dev);
196 static int el3_rx(struct net_device *dev);
197 static int el3_close(struct net_device *dev);
198 static void set_multicast_list(struct net_device *dev);
199 static void el3_tx_timeout (struct net_device *dev);
200 static void el3_down(struct net_device *dev);
201 static void el3_up(struct net_device *dev);
202 static struct ethtool_ops ethtool_ops;
203 #ifdef CONFIG_PM
204 static int el3_suspend(struct pm_dev *pdev);
205 static int el3_resume(struct pm_dev *pdev);
206 static int el3_pm_callback(struct pm_dev *pdev, pm_request_t rqst, void *data);
207 #endif
208 /* generic device remove for all device types */
209 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
210 static int el3_device_remove (struct device *device);
211 #endif
212 #ifdef CONFIG_NET_POLL_CONTROLLER
213 static void el3_poll_controller(struct net_device *dev);
214 #endif
215
216 #ifdef CONFIG_EISA
217 static struct eisa_device_id el3_eisa_ids[] = {
218                 { "TCM5092" },
219                 { "TCM5093" },
220                 { "TCM5095" },
221                 { "" }
222 };
223
224 static int el3_eisa_probe (struct device *device);
225
226 static struct eisa_driver el3_eisa_driver = {
227                 .id_table = el3_eisa_ids,
228                 .driver   = {
229                                 .name    = "3c509",
230                                 .probe   = el3_eisa_probe,
231                                 .remove  = __devexit_p (el3_device_remove)
232                 }
233 };
234 #endif
235
236 #ifdef CONFIG_MCA
237 static int el3_mca_probe(struct device *dev);
238
239 static short el3_mca_adapter_ids[] __initdata = {
240                 0x627c,
241                 0x627d,
242                 0x62db,
243                 0x62f6,
244                 0x62f7,
245                 0x0000
246 };
247
248 static char *el3_mca_adapter_names[] __initdata = {
249                 "3Com 3c529 EtherLink III (10base2)",
250                 "3Com 3c529 EtherLink III (10baseT)",
251                 "3Com 3c529 EtherLink III (test mode)",
252                 "3Com 3c529 EtherLink III (TP or coax)",
253                 "3Com 3c529 EtherLink III (TP)",
254                 NULL
255 };
256
257 static struct mca_driver el3_mca_driver = {
258                 .id_table = el3_mca_adapter_ids,
259                 .driver = {
260                                 .name = "3c529",
261                                 .bus = &mca_bus_type,
262                                 .probe = el3_mca_probe,
263                                 .remove = __devexit_p(el3_device_remove),
264                 },
265 };
266 #endif /* CONFIG_MCA */
267
268 #if defined(__ISAPNP__)
269 static struct isapnp_device_id el3_isapnp_adapters[] __initdata = {
270         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
271                 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5090),
272                 (long) "3Com Etherlink III (TP)" },
273         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
274                 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5091),
275                 (long) "3Com Etherlink III" },
276         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
277                 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5094),
278                 (long) "3Com Etherlink III (combo)" },
279         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
280                 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5095),
281                 (long) "3Com Etherlink III (TPO)" },
282         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
283                 ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5098),
284                 (long) "3Com Etherlink III (TPC)" },
285         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
286                 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f7),
287                 (long) "3Com Etherlink III compatible" },
288         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
289                 ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f8),
290                 (long) "3Com Etherlink III compatible" },
291         { }     /* terminate list */
292 };
293
294 static u16 el3_isapnp_phys_addr[8][3];
295 static int nopnp;
296 #endif /* __ISAPNP__ */
297
298 /* With the driver model introduction for EISA devices, both init
299  * and cleanup have been split :
300  * - EISA devices probe/remove starts in el3_eisa_probe/el3_device_remove
301  * - MCA/ISA still use el3_probe
302  *
303  * Both call el3_common_init/el3_common_remove. */
304
305 static int __init el3_common_init(struct net_device *dev)
306 {
307         struct el3_private *lp = netdev_priv(dev);
308         short i;
309         int err;
310
311         spin_lock_init(&lp->lock);
312
313         if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
314                 dev->if_port = (dev->mem_start & 0x0f);
315         } else { /* xcvr codes 0/8 */
316                 /* use eeprom value, but save user's full-duplex selection */
317                 dev->if_port |= (dev->mem_start & 0x08);
318         }
319
320         /* The EL3-specific entries in the device structure. */
321         dev->open = &el3_open;
322         dev->hard_start_xmit = &el3_start_xmit;
323         dev->stop = &el3_close;
324         dev->get_stats = &el3_get_stats;
325         dev->set_multicast_list = &set_multicast_list;
326         dev->tx_timeout = el3_tx_timeout;
327         dev->watchdog_timeo = TX_TIMEOUT;
328 #ifdef CONFIG_NET_POLL_CONTROLLER
329         dev->poll_controller = el3_poll_controller;
330 #endif
331         SET_ETHTOOL_OPS(dev, &ethtool_ops);
332
333         err = register_netdev(dev);
334         if (err) {
335                 printk(KERN_ERR "Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
336                         dev->base_addr, dev->irq);
337                 release_region(dev->base_addr, EL3_IO_EXTENT);
338                 return err;
339         }
340
341         {
342                 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
343                 printk("%s: 3c5x9 found at %#3.3lx, %s port, address ",
344                         dev->name, dev->base_addr, 
345                         if_names[(dev->if_port & 0x03)]);
346         }
347
348         /* Read in the station address. */
349         for (i = 0; i < 6; i++)
350                 printk(" %2.2x", dev->dev_addr[i]);
351         printk(", IRQ %d.\n", dev->irq);
352
353         if (el3_debug > 0)
354                 printk(KERN_INFO "%s" KERN_INFO "%s", versionA, versionB);
355         return 0;
356
357 }
358
359 static void el3_common_remove (struct net_device *dev)
360 {
361         struct el3_private *lp = netdev_priv(dev);
362
363         (void) lp;                              /* Keep gcc quiet... */
364 #ifdef CONFIG_PM
365         if (lp->pmdev)
366                 pm_unregister(lp->pmdev);
367 #endif
368 #if defined(__ISAPNP__)
369         if (lp->type == EL3_PNP)
370                 pnp_device_detach(to_pnp_dev(lp->dev));
371 #endif
372
373         unregister_netdev (dev);
374         release_region(dev->base_addr, EL3_IO_EXTENT);
375         free_netdev (dev);
376 }
377
378 static int __init el3_probe(int card_idx)
379 {
380         struct net_device *dev;
381         struct el3_private *lp;
382         short lrs_state = 0xff, i;
383         int ioaddr, irq, if_port;
384         u16 phys_addr[3];
385         static int current_tag;
386         int err = -ENODEV;
387 #if defined(__ISAPNP__)
388         static int pnp_cards;
389         struct pnp_dev *idev = NULL;
390
391         if (nopnp == 1)
392                 goto no_pnp;
393
394         for (i=0; el3_isapnp_adapters[i].vendor != 0; i++) {
395                 int j;
396                 while ((idev = pnp_find_dev(NULL,
397                                             el3_isapnp_adapters[i].vendor,
398                                             el3_isapnp_adapters[i].function,
399                                             idev))) {
400                         if (pnp_device_attach(idev) < 0)
401                                 continue;
402                         if (pnp_activate_dev(idev) < 0) {
403 __again:
404                                 pnp_device_detach(idev);
405                                 continue;
406                         }
407                         if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
408                                 goto __again;
409                         ioaddr = pnp_port_start(idev, 0);
410                         if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509 PnP")) {
411                                 pnp_device_detach(idev);
412                                 return -EBUSY;
413                         }
414                         irq = pnp_irq(idev, 0);
415                         if (el3_debug > 3)
416                                 printk ("ISAPnP reports %s at i/o 0x%x, irq %d\n",
417                                         (char*) el3_isapnp_adapters[i].driver_data, ioaddr, irq);
418                         EL3WINDOW(0);
419                         for (j = 0; j < 3; j++)
420                                 el3_isapnp_phys_addr[pnp_cards][j] =
421                                         phys_addr[j] =
422                                                 htons(read_eeprom(ioaddr, j));
423                         if_port = read_eeprom(ioaddr, 8) >> 14;
424                         dev = alloc_etherdev(sizeof (struct el3_private));
425                         if (!dev) {
426                                         release_region(ioaddr, EL3_IO_EXTENT);
427                                         pnp_device_detach(idev);
428                                         return -ENOMEM;
429                         }
430
431                         SET_MODULE_OWNER(dev);
432                         SET_NETDEV_DEV(dev, &idev->dev);
433                         pnp_cards++;
434
435                         netdev_boot_setup_check(dev);
436                         goto found;
437                 }
438         }
439 no_pnp:
440 #endif /* __ISAPNP__ */
441
442         /* Select an open I/O location at 0x1*0 to do contention select. */
443         for ( ; id_port < 0x200; id_port += 0x10) {
444                 if (!request_region(id_port, 1, "3c509"))
445                         continue;
446                 outb(0x00, id_port);
447                 outb(0xff, id_port);
448                 if (inb(id_port) & 0x01){
449                         release_region(id_port, 1);
450                         break;
451                 } else
452                         release_region(id_port, 1);
453         }
454         if (id_port >= 0x200) {
455                 /* Rare -- do we really need a warning? */
456                 printk(" WARNING: No I/O port available for 3c509 activation.\n");
457                 return -ENODEV;
458         }
459
460         /* Next check for all ISA bus boards by sending the ID sequence to the
461            ID_PORT.  We find cards past the first by setting the 'current_tag'
462            on cards as they are found.  Cards with their tag set will not
463            respond to subsequent ID sequences. */
464
465         outb(0x00, id_port);
466         outb(0x00, id_port);
467         for(i = 0; i < 255; i++) {
468                 outb(lrs_state, id_port);
469                 lrs_state <<= 1;
470                 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
471         }
472
473         /* For the first probe, clear all board's tag registers. */
474         if (current_tag == 0)
475                 outb(0xd0, id_port);
476         else                            /* Otherwise kill off already-found boards. */
477                 outb(0xd8, id_port);
478
479         if (id_read_eeprom(7) != 0x6d50) {
480                 return -ENODEV;
481         }
482
483         /* Read in EEPROM data, which does contention-select.
484            Only the lowest address board will stay "on-line".
485            3Com got the byte order backwards. */
486         for (i = 0; i < 3; i++) {
487                 phys_addr[i] = htons(id_read_eeprom(i));
488         }
489
490 #if defined(__ISAPNP__)
491         if (nopnp == 0) {
492                 /* The ISA PnP 3c509 cards respond to the ID sequence.
493                    This check is needed in order not to register them twice. */
494                 for (i = 0; i < pnp_cards; i++) {
495                         if (phys_addr[0] == el3_isapnp_phys_addr[i][0] &&
496                             phys_addr[1] == el3_isapnp_phys_addr[i][1] &&
497                             phys_addr[2] == el3_isapnp_phys_addr[i][2])
498                         {
499                                 if (el3_debug > 3)
500                                         printk("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
501                                                 phys_addr[0] & 0xff, phys_addr[0] >> 8,
502                                                 phys_addr[1] & 0xff, phys_addr[1] >> 8,
503                                                 phys_addr[2] & 0xff, phys_addr[2] >> 8);
504                                 /* Set the adaptor tag so that the next card can be found. */
505                                 outb(0xd0 + ++current_tag, id_port);
506                                 goto no_pnp;
507                         }
508                 }
509         }
510 #endif /* __ISAPNP__ */
511
512         {
513                 unsigned int iobase = id_read_eeprom(8);
514                 if_port = iobase >> 14;
515                 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
516         }
517         irq = id_read_eeprom(9) >> 12;
518
519         dev = alloc_etherdev(sizeof (struct el3_private));
520         if (!dev)
521                 return -ENOMEM;
522
523         SET_MODULE_OWNER(dev);
524
525         netdev_boot_setup_check(dev);
526         
527         /* Set passed-in IRQ or I/O Addr. */
528         if (dev->irq > 1  &&  dev->irq < 16)
529                         irq = dev->irq;
530
531         if (dev->base_addr) {
532                 if (dev->mem_end == 0x3c509     /* Magic key */
533                     && dev->base_addr >= 0x200  &&  dev->base_addr <= 0x3e0)
534                         ioaddr = dev->base_addr & 0x3f0;
535                 else if (dev->base_addr != ioaddr)
536                         goto out;
537         }
538
539         if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509")) {
540                 err = -EBUSY;
541                 goto out;
542         }
543
544         /* Set the adaptor tag so that the next card can be found. */
545         outb(0xd0 + ++current_tag, id_port);
546
547         /* Activate the adaptor at the EEPROM location. */
548         outb((ioaddr >> 4) | 0xe0, id_port);
549
550         EL3WINDOW(0);
551         if (inw(ioaddr) != 0x6d50)
552                 goto out1;
553
554         /* Free the interrupt so that some other card can use it. */
555         outw(0x0f00, ioaddr + WN0_IRQ);
556
557 #if defined(__ISAPNP__)
558  found:                                                 /* PNP jumps here... */
559 #endif /* __ISAPNP__ */
560
561         memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
562         dev->base_addr = ioaddr;
563         dev->irq = irq;
564         dev->if_port = if_port;
565         lp = netdev_priv(dev);
566 #if defined(__ISAPNP__)
567         lp->dev = &idev->dev;
568 #endif
569         err = el3_common_init(dev);
570
571         if (err)
572                 goto out1;
573
574 #ifdef CONFIG_PM
575         /* register power management */
576         lp->pmdev = pm_register(PM_ISA_DEV, card_idx, el3_pm_callback);
577         if (lp->pmdev) {
578                 struct pm_dev *p;
579                 p = lp->pmdev;
580                 p->data = (struct net_device *)dev;
581         }
582 #endif
583
584         el3_cards++;
585         lp->next_dev = el3_root_dev;
586         el3_root_dev = dev;
587         return 0;
588
589 out1:
590 #if defined(__ISAPNP__)
591         if (idev)
592                 pnp_device_detach(idev);
593 #endif
594 out:
595         free_netdev(dev);
596         return err;
597 }
598
599 #ifdef CONFIG_MCA
600 static int __init el3_mca_probe(struct device *device)
601 {
602         /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
603          * heavily modified by Chris Beauregard
604          * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
605          * probing.
606          *
607          * redone for multi-card detection by ZP Gu (zpg@castle.net)
608          * now works as a module */
609
610         struct el3_private *lp;
611         short i;
612         int ioaddr, irq, if_port;
613         u16 phys_addr[3];
614         struct net_device *dev = NULL;
615         u_char pos4, pos5;
616         struct mca_device *mdev = to_mca_device(device);
617         int slot = mdev->slot;
618         int err;
619
620         pos4 = mca_device_read_stored_pos(mdev, 4);
621         pos5 = mca_device_read_stored_pos(mdev, 5);
622
623         ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
624         irq = pos5 & 0x0f;
625
626
627         printk("3c529: found %s at slot %d\n",
628                    el3_mca_adapter_names[mdev->index], slot + 1);
629
630         /* claim the slot */
631         strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
632                         sizeof(mdev->name));
633         mca_device_set_claim(mdev, 1);
634
635         if_port = pos4 & 0x03;
636
637         irq = mca_device_transform_irq(mdev, irq);
638         ioaddr = mca_device_transform_ioport(mdev, ioaddr); 
639         if (el3_debug > 2) {
640                         printk("3c529: irq %d  ioaddr 0x%x  ifport %d\n", irq, ioaddr, if_port);
641         }
642         EL3WINDOW(0);
643         for (i = 0; i < 3; i++) {
644                         phys_addr[i] = htons(read_eeprom(ioaddr, i));
645         }
646
647         dev = alloc_etherdev(sizeof (struct el3_private));
648         if (dev == NULL) {
649                         release_region(ioaddr, EL3_IO_EXTENT);
650                         return -ENOMEM;
651         }
652
653         SET_MODULE_OWNER(dev);
654         netdev_boot_setup_check(dev);
655
656         memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
657         dev->base_addr = ioaddr;
658         dev->irq = irq;
659         dev->if_port = if_port;
660         lp = netdev_priv(dev);
661         lp->dev = device;
662         lp->type = EL3_MCA;
663         device->driver_data = dev;
664         err = el3_common_init(dev);
665
666         if (err) {
667                 device->driver_data = NULL;
668                 free_netdev(dev);
669                 return -ENOMEM;
670         }
671
672         el3_cards++;
673         return 0;
674 }
675                 
676 #endif /* CONFIG_MCA */
677
678 #ifdef CONFIG_EISA
679 static int __init el3_eisa_probe (struct device *device)
680 {
681         struct el3_private *lp;
682         short i;
683         int ioaddr, irq, if_port;
684         u16 phys_addr[3];
685         struct net_device *dev = NULL;
686         struct eisa_device *edev;
687         int err;
688
689         /* Yeepee, The driver framework is calling us ! */
690         edev = to_eisa_device (device);
691         ioaddr = edev->base_addr;
692         
693         if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509"))
694                 return -EBUSY;
695
696         /* Change the register set to the configuration window 0. */
697         outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
698
699         irq = inw(ioaddr + WN0_IRQ) >> 12;
700         if_port = inw(ioaddr + 6)>>14;
701         for (i = 0; i < 3; i++)
702                 phys_addr[i] = htons(read_eeprom(ioaddr, i));
703
704         /* Restore the "Product ID" to the EEPROM read register. */
705         read_eeprom(ioaddr, 3);
706
707         dev = alloc_etherdev(sizeof (struct el3_private));
708         if (dev == NULL) {
709                 release_region(ioaddr, EL3_IO_EXTENT);
710                 return -ENOMEM;
711         }
712
713         SET_MODULE_OWNER(dev);
714
715         netdev_boot_setup_check(dev);
716
717         memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
718         dev->base_addr = ioaddr;
719         dev->irq = irq;
720         dev->if_port = if_port;
721         lp = netdev_priv(dev);
722         lp->dev = device;
723         lp->type = EL3_EISA;
724         eisa_set_drvdata (edev, dev);
725         err = el3_common_init(dev);
726
727         if (err) {
728                 eisa_set_drvdata (edev, NULL);
729                 free_netdev(dev);
730                 return err;
731         }
732
733         el3_cards++;
734         return 0;
735 }
736 #endif
737
738 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
739 /* This remove works for all device types.
740  *
741  * The net dev must be stored in the driver_data field */
742 static int __devexit el3_device_remove (struct device *device)
743 {
744         struct net_device *dev;
745
746         dev  = device->driver_data;
747
748         el3_common_remove (dev);
749         return 0;
750 }
751 #endif
752
753 /* Read a word from the EEPROM using the regular EEPROM access register.
754    Assume that we are in register window zero.
755  */
756 static ushort read_eeprom(int ioaddr, int index)
757 {
758         outw(EEPROM_READ + index, ioaddr + 10);
759         /* Pause for at least 162 us. for the read to take place. 
760            Some chips seem to require much longer */
761         mdelay(2);
762         return inw(ioaddr + 12);
763 }
764
765 /* Read a word from the EEPROM when in the ISA ID probe state. */
766 static ushort __init id_read_eeprom(int index)
767 {
768         int bit, word = 0;
769
770         /* Issue read command, and pause for at least 162 us. for it to complete.
771            Assume extra-fast 16Mhz bus. */
772         outb(EEPROM_READ + index, id_port);
773
774         /* Pause for at least 162 us. for the read to take place. */
775         /* Some chips seem to require much longer */
776         mdelay(4);
777         
778         for (bit = 15; bit >= 0; bit--)
779                 word = (word << 1) + (inb(id_port) & 0x01);
780
781         if (el3_debug > 3)
782                 printk("  3c509 EEPROM word %d %#4.4x.\n", index, word);
783
784         return word;
785 }
786
787
788 static int
789 el3_open(struct net_device *dev)
790 {
791         int ioaddr = dev->base_addr;
792         int i;
793
794         outw(TxReset, ioaddr + EL3_CMD);
795         outw(RxReset, ioaddr + EL3_CMD);
796         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
797
798         i = request_irq(dev->irq, &el3_interrupt, 0, dev->name, dev);
799         if (i)
800                 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 = netdev_priv(dev);
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 = netdev_priv(dev);
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 = netdev_priv(dev);
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 = netdev_priv(dev);
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 #ifdef CONFIG_NET_POLL_CONTROLLER
1010 /*
1011  * Polling receive - used by netconsole and other diagnostic tools
1012  * to allow network i/o with interrupts disabled.
1013  */
1014 static void el3_poll_controller(struct net_device *dev)
1015 {
1016         disable_irq(dev->irq);
1017         el3_interrupt(dev->irq, dev, NULL);
1018         enable_irq(dev->irq);
1019 }
1020 #endif
1021
1022 static struct net_device_stats *
1023 el3_get_stats(struct net_device *dev)
1024 {
1025         struct el3_private *lp = netdev_priv(dev);
1026         unsigned long flags;
1027
1028         /*
1029          *      This is fast enough not to bother with disable IRQ
1030          *      stuff.
1031          */
1032          
1033         spin_lock_irqsave(&lp->lock, flags);
1034         update_stats(dev);
1035         spin_unlock_irqrestore(&lp->lock, flags);
1036         return &lp->stats;
1037 }
1038
1039 /*  Update statistics.  We change to register window 6, so this should be run
1040         single-threaded if the device is active. This is expected to be a rare
1041         operation, and it's simpler for the rest of the driver to assume that
1042         window 1 is always valid rather than use a special window-state variable.
1043         */
1044 static void update_stats(struct net_device *dev)
1045 {
1046         struct el3_private *lp = netdev_priv(dev);
1047         int ioaddr = dev->base_addr;
1048
1049         if (el3_debug > 5)
1050                 printk("   Updating the statistics.\n");
1051         /* Turn off statistics updates while reading. */
1052         outw(StatsDisable, ioaddr + EL3_CMD);
1053         /* Switch to the stats window, and read everything. */
1054         EL3WINDOW(6);
1055         lp->stats.tx_carrier_errors     += inb(ioaddr + 0);
1056         lp->stats.tx_heartbeat_errors   += inb(ioaddr + 1);
1057         /* Multiple collisions. */         inb(ioaddr + 2);
1058         lp->stats.collisions            += inb(ioaddr + 3);
1059         lp->stats.tx_window_errors      += inb(ioaddr + 4);
1060         lp->stats.rx_fifo_errors        += inb(ioaddr + 5);
1061         lp->stats.tx_packets            += inb(ioaddr + 6);
1062         /* Rx packets   */                 inb(ioaddr + 7);
1063         /* Tx deferrals */                 inb(ioaddr + 8);
1064         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1065         inw(ioaddr + 12);
1066
1067         /* Back to window 1, and turn statistics back on. */
1068         EL3WINDOW(1);
1069         outw(StatsEnable, ioaddr + EL3_CMD);
1070         return;
1071 }
1072
1073 static int
1074 el3_rx(struct net_device *dev)
1075 {
1076         struct el3_private *lp = netdev_priv(dev);
1077         int ioaddr = dev->base_addr;
1078         short rx_status;
1079
1080         if (el3_debug > 5)
1081                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1082                            inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1083         while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1084                 if (rx_status & 0x4000) { /* Error, update stats. */
1085                         short error = rx_status & 0x3800;
1086
1087                         outw(RxDiscard, ioaddr + EL3_CMD);
1088                         lp->stats.rx_errors++;
1089                         switch (error) {
1090                         case 0x0000:            lp->stats.rx_over_errors++; break;
1091                         case 0x0800:            lp->stats.rx_length_errors++; break;
1092                         case 0x1000:            lp->stats.rx_frame_errors++; break;
1093                         case 0x1800:            lp->stats.rx_length_errors++; break;
1094                         case 0x2000:            lp->stats.rx_frame_errors++; break;
1095                         case 0x2800:            lp->stats.rx_crc_errors++; break;
1096                         }
1097                 } else {
1098                         short pkt_len = rx_status & 0x7ff;
1099                         struct sk_buff *skb;
1100
1101                         skb = dev_alloc_skb(pkt_len+5);
1102                         lp->stats.rx_bytes += pkt_len;
1103                         if (el3_debug > 4)
1104                                 printk("Receiving packet size %d status %4.4x.\n",
1105                                            pkt_len, rx_status);
1106                         if (skb != NULL) {
1107                                 skb->dev = dev;
1108                                 skb_reserve(skb, 2);     /* Align IP on 16 byte */
1109
1110                                 /* 'skb->data' points to the start of sk_buff data area. */
1111 #ifdef  __powerpc__
1112                                 insl_ns(ioaddr+RX_FIFO, skb_put(skb,pkt_len),
1113                                                            (pkt_len + 3) >> 2);
1114 #else
1115                                 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1116                                          (pkt_len + 3) >> 2);
1117 #endif
1118
1119                                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1120                                 skb->protocol = eth_type_trans(skb,dev);
1121                                 netif_rx(skb);
1122                                 dev->last_rx = jiffies;
1123                                 lp->stats.rx_packets++;
1124                                 continue;
1125                         }
1126                         outw(RxDiscard, ioaddr + EL3_CMD);
1127                         lp->stats.rx_dropped++;
1128                         if (el3_debug)
1129                                 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1130                                            dev->name, pkt_len);
1131                 }
1132                 inw(ioaddr + EL3_STATUS);                               /* Delay. */
1133                 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1134                         printk(KERN_DEBUG "     Waiting for 3c509 to discard packet, status %x.\n",
1135                                    inw(ioaddr + EL3_STATUS) );
1136         }
1137
1138         return 0;
1139 }
1140
1141 /*
1142  *     Set or clear the multicast filter for this adaptor.
1143  */
1144 static void
1145 set_multicast_list(struct net_device *dev)
1146 {
1147         unsigned long flags;
1148         struct el3_private *lp = netdev_priv(dev);
1149         int ioaddr = dev->base_addr;
1150
1151         if (el3_debug > 1) {
1152                 static int old;
1153                 if (old != dev->mc_count) {
1154                         old = dev->mc_count;
1155                         printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1156                 }
1157         }
1158         spin_lock_irqsave(&lp->lock, flags);
1159         if (dev->flags&IFF_PROMISC) {
1160                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1161                          ioaddr + EL3_CMD);
1162         }
1163         else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1164                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1165         }
1166         else
1167                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1168         spin_unlock_irqrestore(&lp->lock, flags);
1169 }
1170
1171 static int
1172 el3_close(struct net_device *dev)
1173 {
1174         int ioaddr = dev->base_addr;
1175         struct el3_private *lp = netdev_priv(dev);
1176         
1177         if (el3_debug > 2)
1178                 printk("%s: Shutting down ethercard.\n", dev->name);
1179
1180         el3_down(dev);
1181
1182         free_irq(dev->irq, dev);
1183         /* Switching back to window 0 disables the IRQ. */
1184         EL3WINDOW(0);
1185         if (lp->type != EL3_EISA) {
1186                 /* But we explicitly zero the IRQ line select anyway. Don't do
1187                  * it on EISA cards, it prevents the module from getting an
1188                  * IRQ after unload+reload... */
1189                 outw(0x0f00, ioaddr + WN0_IRQ);
1190         }
1191
1192         return 0;
1193 }
1194
1195 static int 
1196 el3_link_ok(struct net_device *dev)
1197 {
1198         int ioaddr = dev->base_addr;
1199         u16 tmp;
1200
1201         EL3WINDOW(4);
1202         tmp = inw(ioaddr + WN4_MEDIA);
1203         EL3WINDOW(1);
1204         return tmp & (1<<11);
1205 }
1206
1207 static int
1208 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1209 {
1210         u16 tmp;
1211         int ioaddr = dev->base_addr;
1212         
1213         EL3WINDOW(0);
1214         /* obtain current transceiver via WN4_MEDIA? */ 
1215         tmp = inw(ioaddr + WN0_ADDR_CONF);
1216         ecmd->transceiver = XCVR_INTERNAL;
1217         switch (tmp >> 14) {
1218         case 0:
1219                 ecmd->port = PORT_TP;
1220                 break;
1221         case 1:
1222                 ecmd->port = PORT_AUI;
1223                 ecmd->transceiver = XCVR_EXTERNAL;
1224                 break;
1225         case 3:
1226                 ecmd->port = PORT_BNC;
1227         default:
1228                 break;
1229         }
1230
1231         ecmd->duplex = DUPLEX_HALF;
1232         ecmd->supported = 0;
1233         tmp = inw(ioaddr + WN0_CONF_CTRL);
1234         if (tmp & (1<<13))
1235                 ecmd->supported |= SUPPORTED_AUI;
1236         if (tmp & (1<<12))
1237                 ecmd->supported |= SUPPORTED_BNC;
1238         if (tmp & (1<<9)) {
1239                 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1240                                 SUPPORTED_10baseT_Full; /* hmm... */
1241                 EL3WINDOW(4);
1242                 tmp = inw(ioaddr + WN4_NETDIAG);
1243                 if (tmp & FD_ENABLE)
1244                         ecmd->duplex = DUPLEX_FULL;
1245         }
1246
1247         ecmd->speed = SPEED_10;
1248         EL3WINDOW(1);
1249         return 0;
1250 }
1251
1252 static int
1253 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1254 {
1255         u16 tmp;
1256         int ioaddr = dev->base_addr;
1257
1258         if (ecmd->speed != SPEED_10)
1259                 return -EINVAL;
1260         if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1261                 return -EINVAL;
1262         if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1263                 return -EINVAL;
1264
1265         /* change XCVR type */
1266         EL3WINDOW(0);
1267         tmp = inw(ioaddr + WN0_ADDR_CONF);
1268         switch (ecmd->port) {
1269         case PORT_TP:
1270                 tmp &= ~(3<<14);
1271                 dev->if_port = 0;
1272                 break;
1273         case PORT_AUI:
1274                 tmp |= (1<<14);
1275                 dev->if_port = 1;
1276                 break;
1277         case PORT_BNC:
1278                 tmp |= (3<<14);
1279                 dev->if_port = 3;
1280                 break;
1281         default:
1282                 return -EINVAL;
1283         }
1284
1285         outw(tmp, ioaddr + WN0_ADDR_CONF);
1286         if (dev->if_port == 3) {
1287                 /* fire up the DC-DC convertor if BNC gets enabled */
1288                 tmp = inw(ioaddr + WN0_ADDR_CONF);
1289                 if (tmp & (3 << 14)) {
1290                         outw(StartCoax, ioaddr + EL3_CMD);
1291                         udelay(800);
1292                 } else
1293                         return -EIO;
1294         }
1295
1296         EL3WINDOW(4);
1297         tmp = inw(ioaddr + WN4_NETDIAG);
1298         if (ecmd->duplex == DUPLEX_FULL)
1299                 tmp |= FD_ENABLE;
1300         else
1301                 tmp &= ~FD_ENABLE;
1302         outw(tmp, ioaddr + WN4_NETDIAG);
1303         EL3WINDOW(1);
1304
1305         return 0;
1306 }
1307
1308 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1309 {
1310         strcpy(info->driver, DRV_NAME);
1311         strcpy(info->version, DRV_VERSION);
1312 }
1313
1314 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1315 {
1316         struct el3_private *lp = netdev_priv(dev);
1317         int ret;
1318
1319         spin_lock_irq(&lp->lock);
1320         ret = el3_netdev_get_ecmd(dev, ecmd);
1321         spin_unlock_irq(&lp->lock);
1322         return ret;
1323 }
1324
1325 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1326 {
1327         struct el3_private *lp = netdev_priv(dev);
1328         int ret;
1329
1330         spin_lock_irq(&lp->lock);
1331         ret = el3_netdev_set_ecmd(dev, ecmd);
1332         spin_unlock_irq(&lp->lock);
1333         return ret;
1334 }
1335
1336 static u32 el3_get_link(struct net_device *dev)
1337 {
1338         struct el3_private *lp = netdev_priv(dev);
1339         u32 ret;
1340
1341         spin_lock_irq(&lp->lock);
1342         ret = el3_link_ok(dev);
1343         spin_unlock_irq(&lp->lock);
1344         return ret;
1345 }
1346
1347 static u32 el3_get_msglevel(struct net_device *dev)
1348 {
1349         return el3_debug;
1350 }
1351
1352 static void el3_set_msglevel(struct net_device *dev, u32 v)
1353 {
1354         el3_debug = v;
1355 }
1356
1357 static struct ethtool_ops ethtool_ops = {
1358         .get_drvinfo = el3_get_drvinfo,
1359         .get_settings = el3_get_settings,
1360         .set_settings = el3_set_settings,
1361         .get_link = el3_get_link,
1362         .get_msglevel = el3_get_msglevel,
1363         .set_msglevel = el3_set_msglevel,
1364 };
1365
1366 static void
1367 el3_down(struct net_device *dev)
1368 {
1369         int ioaddr = dev->base_addr;
1370
1371         netif_stop_queue(dev);
1372
1373         /* Turn off statistics ASAP.  We update lp->stats below. */
1374         outw(StatsDisable, ioaddr + EL3_CMD);
1375
1376         /* Disable the receiver and transmitter. */
1377         outw(RxDisable, ioaddr + EL3_CMD);
1378         outw(TxDisable, ioaddr + EL3_CMD);
1379
1380         if (dev->if_port == 3)
1381                 /* Turn off thinnet power.  Green! */
1382                 outw(StopCoax, ioaddr + EL3_CMD);
1383         else if (dev->if_port == 0) {
1384                 /* Disable link beat and jabber, if_port may change here next open(). */
1385                 EL3WINDOW(4);
1386                 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1387         }
1388
1389         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1390
1391         update_stats(dev);
1392 }
1393
1394 static void
1395 el3_up(struct net_device *dev)
1396 {
1397         int i, sw_info, net_diag;
1398         int ioaddr = dev->base_addr;
1399         
1400         /* Activating the board required and does no harm otherwise */
1401         outw(0x0001, ioaddr + 4);
1402
1403         /* Set the IRQ line. */
1404         outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1405
1406         /* Set the station address in window 2 each time opened. */
1407         EL3WINDOW(2);
1408
1409         for (i = 0; i < 6; i++)
1410                 outb(dev->dev_addr[i], ioaddr + i);
1411
1412         if ((dev->if_port & 0x03) == 3) /* BNC interface */
1413                 /* Start the thinnet transceiver. We should really wait 50ms...*/
1414                 outw(StartCoax, ioaddr + EL3_CMD);
1415         else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1416                 /* Combine secondary sw_info word (the adapter level) and primary
1417                         sw_info word (duplex setting plus other useless bits) */
1418                 EL3WINDOW(0);
1419                 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) | 
1420                         (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1421
1422                 EL3WINDOW(4);
1423                 net_diag = inw(ioaddr + WN4_NETDIAG);
1424                 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1425                 printk("%s: ", dev->name);
1426                 switch (dev->if_port & 0x0c) {
1427                         case 12:
1428                                 /* force full-duplex mode if 3c5x9b */
1429                                 if (sw_info & 0x000f) {
1430                                         printk("Forcing 3c5x9b full-duplex mode");
1431                                         break;
1432                                 }
1433                         case 8:
1434                                 /* set full-duplex mode based on eeprom config setting */
1435                                 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1436                                         printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1437                                         break;
1438                                 }
1439                         default:
1440                                 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1441                                 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1442                                 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1443                 }
1444
1445                 outw(net_diag, ioaddr + WN4_NETDIAG);
1446                 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1447                 if (el3_debug > 3)
1448                         printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1449                 /* Enable link beat and jabber check. */
1450                 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1451         }
1452
1453         /* Switch to the stats window, and clear all stats by reading. */
1454         outw(StatsDisable, ioaddr + EL3_CMD);
1455         EL3WINDOW(6);
1456         for (i = 0; i < 9; i++)
1457                 inb(ioaddr + i);
1458         inw(ioaddr + 10);
1459         inw(ioaddr + 12);
1460
1461         /* Switch to register set 1 for normal use. */
1462         EL3WINDOW(1);
1463
1464         /* Accept b-case and phys addr only. */
1465         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1466         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1467
1468         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1469         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1470         /* Allow status bits to be seen. */
1471         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1472         /* Ack all pending events, and set active indicator mask. */
1473         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1474                  ioaddr + EL3_CMD);
1475         outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1476                  ioaddr + EL3_CMD);
1477
1478         netif_start_queue(dev);
1479 }
1480
1481 /* Power Management support functions */
1482 #ifdef CONFIG_PM
1483
1484 static int
1485 el3_suspend(struct pm_dev *pdev)
1486 {
1487         unsigned long flags;
1488         struct net_device *dev;
1489         struct el3_private *lp;
1490         int ioaddr;
1491         
1492         if (!pdev && !pdev->data)
1493                 return -EINVAL;
1494
1495         dev = (struct net_device *)pdev->data;
1496         lp = netdev_priv(dev);
1497         ioaddr = dev->base_addr;
1498
1499         spin_lock_irqsave(&lp->lock, flags);
1500
1501         if (netif_running(dev))
1502                 netif_device_detach(dev);
1503
1504         el3_down(dev);
1505         outw(PowerDown, ioaddr + EL3_CMD);
1506
1507         spin_unlock_irqrestore(&lp->lock, flags);
1508         return 0;
1509 }
1510
1511 static int
1512 el3_resume(struct pm_dev *pdev)
1513 {
1514         unsigned long flags;
1515         struct net_device *dev;
1516         struct el3_private *lp;
1517         int ioaddr;
1518         
1519         if (!pdev && !pdev->data)
1520                 return -EINVAL;
1521
1522         dev = (struct net_device *)pdev->data;
1523         lp = netdev_priv(dev);
1524         ioaddr = dev->base_addr;
1525
1526         spin_lock_irqsave(&lp->lock, flags);
1527
1528         outw(PowerUp, ioaddr + EL3_CMD);
1529         el3_up(dev);
1530
1531         if (netif_running(dev))
1532                 netif_device_attach(dev);
1533                 
1534         spin_unlock_irqrestore(&lp->lock, flags);
1535         return 0;
1536 }
1537
1538 static int
1539 el3_pm_callback(struct pm_dev *pdev, pm_request_t rqst, void *data)
1540 {
1541         switch (rqst) {
1542                 case PM_SUSPEND:
1543                         return el3_suspend(pdev);
1544
1545                 case PM_RESUME:
1546                         return el3_resume(pdev);
1547         }
1548         return 0;
1549 }
1550
1551 #endif /* CONFIG_PM */
1552
1553 /* Parameters that may be passed into the module. */
1554 static int debug = -1;
1555 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
1556 static int xcvr[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1557
1558 module_param(debug,int, 0);
1559 module_param_array(irq, int, NULL, 0);
1560 module_param_array(xcvr, int, NULL, 0);
1561 module_param(max_interrupt_work, int, 0);
1562 MODULE_PARM_DESC(debug, "debug level (0-6)");
1563 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1564 MODULE_PARM_DESC(xcvr,"transceiver(s) (0=internal, 1=external)");
1565 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1566 #if defined(__ISAPNP__)
1567 module_param(nopnp, int, 0);
1568 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1569 MODULE_DEVICE_TABLE(isapnp, el3_isapnp_adapters);
1570 #endif  /* __ISAPNP__ */
1571 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B) ISA/PnP ethernet driver");
1572 MODULE_LICENSE("GPL");
1573
1574 static int __init el3_init_module(void)
1575 {
1576         el3_cards = 0;
1577
1578         if (debug >= 0)
1579                 el3_debug = debug;
1580
1581         el3_root_dev = NULL;
1582         while (el3_probe(el3_cards) == 0) {
1583                 if (irq[el3_cards] > 1)
1584                         el3_root_dev->irq = irq[el3_cards];
1585                 if (xcvr[el3_cards] >= 0)
1586                         el3_root_dev->if_port = xcvr[el3_cards];
1587                 el3_cards++;
1588         }
1589
1590 #ifdef CONFIG_EISA
1591         if (eisa_driver_register (&el3_eisa_driver) < 0) {
1592                 eisa_driver_unregister (&el3_eisa_driver);
1593         }
1594 #endif
1595 #ifdef CONFIG_MCA
1596         mca_register_driver(&el3_mca_driver);
1597 #endif
1598         return 0;
1599 }
1600
1601 static void __exit el3_cleanup_module(void)
1602 {
1603         struct net_device *next_dev;
1604
1605         while (el3_root_dev) {
1606                 struct el3_private *lp = netdev_priv(el3_root_dev);
1607
1608                 next_dev = lp->next_dev;
1609                 el3_common_remove (el3_root_dev);
1610                 el3_root_dev = next_dev;
1611         }
1612
1613 #ifdef CONFIG_EISA
1614         eisa_driver_unregister (&el3_eisa_driver);
1615 #endif
1616 #ifdef CONFIG_MCA
1617         mca_unregister_driver(&el3_mca_driver);
1618 #endif
1619 }
1620
1621 module_init (el3_init_module);
1622 module_exit (el3_cleanup_module);
1623