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