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