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/pm_legacy.h>
  87 #include <linux/skbuff.h>
  88 #include <linux/delay.h>        /* for udelay() */
  89 #include <linux/spinlock.h>
  90 #include <linux/ethtool.h>
  91 #include <linux/device.h>
  92 #include <linux/eisa.h>
  93 #include <linux/bitops.h>
  94
  95 #include <asm/uaccess.h>
  96 #include <asm/io.h>
  97 #include <asm/irq.h>
  98
  99 static char versionA[] __initdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
 100 static char versionB[] __initdata = "http://www.scyld.com/network/3c509.html\n";
 101
 102 #if defined(CONFIG_PM) && (defined(CONFIG_MCA) || defined(CONFIG_EISA))
 103 #define EL3_SUSPEND
 104 #endif
 105
 106 #ifdef EL3_DEBUG
 107 static int el3_debug = EL3_DEBUG;
 108 #else
 109 static int el3_debug = 2;
 110 #endif
 111
 112 /* Used to do a global count of all the cards in the system.  Must be
 113  * a global variable so that the mca/eisa probe routines can increment
 114  * it */
 115 static int el3_cards = 0;
 116
 117 /* To minimize the size of the driver source I only define operating
 118    constants if they are used several times.  You'll need the manual
 119    anyway if you want to understand driver details. */
 120 /* Offsets from base I/O address. */
 121 #define EL3_DATA 0x00
 122 #define EL3_CMD 0x0e
 123 #define EL3_STATUS 0x0e
 124 #define  EEPROM_READ 0x80
 125
 126 #define EL3_IO_EXTENT   16
 127
 128 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
 129
 130
 131 /* The top five bits written to EL3_CMD are a command, the lower
 132    11 bits are the parameter, if applicable. */
 133 enum c509cmd {
 134         TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
 135         RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
 136         TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
 137         FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
 138         SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
 139         SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
 140         StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
 141         PowerDown = 28<<11, PowerAuto = 29<<11};
 142
 143 enum c509status {
 144         IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
 145         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
 146         IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
 147
 148 /* The SetRxFilter command accepts the following classes: */
 149 enum RxFilter {
 150         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
 151
 152 /* Register window 1 offsets, the window used in normal operation. */
 153 #define TX_FIFO         0x00
 154 #define RX_FIFO         0x00
 155 #define RX_STATUS       0x08
 156 #define TX_STATUS       0x0B
 157 #define TX_FREE         0x0C            /* Remaining free bytes in Tx buffer. */
 158
 159 #define WN0_CONF_CTRL   0x04            /* Window 0: Configuration control register */
 160 #define WN0_ADDR_CONF   0x06            /* Window 0: Address configuration register */
 161 #define WN0_IRQ         0x08            /* Window 0: Set IRQ line in bits 12-15. */
 162 #define WN4_MEDIA       0x0A            /* Window 4: Various transcvr/media bits. */
 163 #define MEDIA_TP        0x00C0          /* Enable link beat and jabber for 10baseT. */
 164 #define WN4_NETDIAG     0x06            /* Window 4: Net diagnostic */
 165 #define FD_ENABLE       0x8000          /* Enable full-duplex ("external loopback") */
 166
 167 /*
 168  * Must be a power of two (we use a binary and in the
 169  * circular queue)
 170  */
 171 #define SKB_QUEUE_SIZE  64
 172
 173 struct el3_private {
 174         struct net_device_stats stats;
 175         struct net_device *next_dev;
 176         spinlock_t lock;
 177         /* skb send-queue */
 178         int head, size;
 179         struct sk_buff *queue[SKB_QUEUE_SIZE];
 180         enum {
 181                 EL3_MCA,
 182                 EL3_PNP,
 183                 EL3_EISA,
 184         } type;                                         /* type of device */
 185         struct device *dev;
 186 };
 187 static int id_port __initdata = 0x110;  /* Start with 0x110 to avoid new sound cards.*/
 188 static struct net_device *el3_root_dev;
 189
 190 static ushort id_read_eeprom(int index);
 191 static ushort read_eeprom(int ioaddr, int index);
 192 static int el3_open(struct net_device *dev);
 193 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
 194 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 195 static void update_stats(struct net_device *dev);
 196 static struct net_device_stats *el3_get_stats(struct net_device *dev);
 197 static int el3_rx(struct net_device *dev);
 198 static int el3_close(struct net_device *dev);
 199 static void set_multicast_list(struct net_device *dev);
 200 static void el3_tx_timeout (struct net_device *dev);
 201 static void el3_down(struct net_device *dev);
 202 static void el3_up(struct net_device *dev);
 203 static const struct ethtool_ops ethtool_ops;
 204 #ifdef EL3_SUSPEND
 205 static int el3_suspend(struct device *, pm_message_t);
 206 static int el3_resume(struct device *);
 207 #else
 208 #define el3_suspend NULL
 209 #define el3_resume NULL
 210 #endif
 211
 212
 213 /* generic device remove for all device types */
 214 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
 215 static int el3_device_remove (struct device *device);
 216 #endif
 217 #ifdef CONFIG_NET_POLL_CONTROLLER
 218 static void el3_poll_controller(struct net_device *dev);
 219 #endif
 220
 221 #ifdef CONFIG_EISA
 222 static struct eisa_device_id el3_eisa_ids[] = {
 223                 { "TCM5092" },
 224                 { "TCM5093" },
 225                 { "TCM5095" },
 226                 { "" }
 227 };
 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, struct pt_regs *regs)
 913 {
 914         struct net_device *dev = (struct net_device *)dev_id;
 915         struct el3_private *lp;
 916         int ioaddr, status;
 917         int i = max_interrupt_work;
 918
 919         if (dev == NULL) {
 920                 printk ("el3_interrupt(): irq %d for unknown device.\n", irq);
 921                 return IRQ_NONE;
 922         }
 923
 924         lp = netdev_priv(dev);
 925         spin_lock(&lp->lock);
 926
 927         ioaddr = dev->base_addr;
 928
 929         if (el3_debug > 4) {
 930                 status = inw(ioaddr + EL3_STATUS);
 931                 printk("%s: interrupt, status %4.4x.\n", dev->name, status);
 932         }
 933
 934         while ((status = inw(ioaddr + EL3_STATUS)) &
 935                    (IntLatch | RxComplete | StatsFull)) {
 936
 937                 if (status & RxComplete)
 938                         el3_rx(dev);
 939
 940                 if (status & TxAvailable) {
 941                         if (el3_debug > 5)
 942                                 printk("        TX room bit was handled.\n");
 943                         /* There's room in the FIFO for a full-sized packet. */
 944                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 945                         netif_wake_queue (dev);
 946                 }
 947                 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
 948                         /* Handle all uncommon interrupts. */
 949                         if (status & StatsFull)                         /* Empty statistics. */
 950                                 update_stats(dev);
 951                         if (status & RxEarly) {                         /* Rx early is unused. */
 952                                 el3_rx(dev);
 953                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 954                         }
 955                         if (status & TxComplete) {                      /* Really Tx error. */
 956                                 struct el3_private *lp = netdev_priv(dev);
 957                                 short tx_status;
 958                                 int i = 4;
 959
 960                                 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 961                                         if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
 962                                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 963                                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 964                                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 965                                 }
 966                         }
 967                         if (status & AdapterFailure) {
 968                                 /* Adapter failure requires Rx reset and reinit. */
 969                                 outw(RxReset, ioaddr + EL3_CMD);
 970                                 /* Set the Rx filter to the current state. */
 971                                 outw(SetRxFilter | RxStation | RxBroadcast
 972                                          | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
 973                                          | (dev->flags & IFF_PROMISC ? RxProm : 0),
 974                                          ioaddr + EL3_CMD);
 975                                 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
 976                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 977                         }
 978                 }
 979
 980                 if (--i < 0) {
 981                         printk("%s: Infinite loop in interrupt, status %4.4x.\n",
 982                                    dev->name, status);
 983                         /* Clear all interrupts. */
 984                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 985                         break;
 986                 }
 987                 /* Acknowledge the IRQ. */
 988                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
 989         }
 990
 991         if (el3_debug > 4) {
 992                 printk("%s: exiting interrupt, status %4.4x.\n", dev->name,
 993                            inw(ioaddr + EL3_STATUS));
 994         }
 995         spin_unlock(&lp->lock);
 996         return IRQ_HANDLED;
 997 }
 998
 999
1000 #ifdef CONFIG_NET_POLL_CONTROLLER
1001 /*
1002  * Polling receive - used by netconsole and other diagnostic tools
1003  * to allow network i/o with interrupts disabled.
1004  */
1005 static void el3_poll_controller(struct net_device *dev)
1006 {
1007         disable_irq(dev->irq);
1008         el3_interrupt(dev->irq, dev, NULL);
1009         enable_irq(dev->irq);
1010 }
1011 #endif
1012
1013 static struct net_device_stats *
1014 el3_get_stats(struct net_device *dev)
1015 {
1016         struct el3_private *lp = netdev_priv(dev);
1017         unsigned long flags;
1018
1019         /*
1020          *      This is fast enough not to bother with disable IRQ
1021          *      stuff.
1022          */
1023
1024         spin_lock_irqsave(&lp->lock, flags);
1025         update_stats(dev);
1026         spin_unlock_irqrestore(&lp->lock, flags);
1027         return &lp->stats;
1028 }
1029
1030 /*  Update statistics.  We change to register window 6, so this should be run
1031         single-threaded if the device is active. This is expected to be a rare
1032         operation, and it's simpler for the rest of the driver to assume that
1033         window 1 is always valid rather than use a special window-state variable.
1034         */
1035 static void update_stats(struct net_device *dev)
1036 {
1037         struct el3_private *lp = netdev_priv(dev);
1038         int ioaddr = dev->base_addr;
1039
1040         if (el3_debug > 5)
1041                 printk("   Updating the statistics.\n");
1042         /* Turn off statistics updates while reading. */
1043         outw(StatsDisable, ioaddr + EL3_CMD);
1044         /* Switch to the stats window, and read everything. */
1045         EL3WINDOW(6);
1046         lp->stats.tx_carrier_errors     += inb(ioaddr + 0);
1047         lp->stats.tx_heartbeat_errors   += inb(ioaddr + 1);
1048         /* Multiple collisions. */         inb(ioaddr + 2);
1049         lp->stats.collisions            += inb(ioaddr + 3);
1050         lp->stats.tx_window_errors      += inb(ioaddr + 4);
1051         lp->stats.rx_fifo_errors        += inb(ioaddr + 5);
1052         lp->stats.tx_packets            += inb(ioaddr + 6);
1053         /* Rx packets   */                 inb(ioaddr + 7);
1054         /* Tx deferrals */                 inb(ioaddr + 8);
1055         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1056         inw(ioaddr + 12);
1057
1058         /* Back to window 1, and turn statistics back on. */
1059         EL3WINDOW(1);
1060         outw(StatsEnable, ioaddr + EL3_CMD);
1061         return;
1062 }
1063
1064 static int
1065 el3_rx(struct net_device *dev)
1066 {
1067         struct el3_private *lp = netdev_priv(dev);
1068         int ioaddr = dev->base_addr;
1069         short rx_status;
1070
1071         if (el3_debug > 5)
1072                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1073                            inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1074         while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1075                 if (rx_status & 0x4000) { /* Error, update stats. */
1076                         short error = rx_status & 0x3800;
1077
1078                         outw(RxDiscard, ioaddr + EL3_CMD);
1079                         lp->stats.rx_errors++;
1080                         switch (error) {
1081                         case 0x0000:            lp->stats.rx_over_errors++; break;
1082                         case 0x0800:            lp->stats.rx_length_errors++; break;
1083                         case 0x1000:            lp->stats.rx_frame_errors++; break;
1084                         case 0x1800:            lp->stats.rx_length_errors++; break;
1085                         case 0x2000:            lp->stats.rx_frame_errors++; break;
1086                         case 0x2800:            lp->stats.rx_crc_errors++; break;
1087                         }
1088                 } else {
1089                         short pkt_len = rx_status & 0x7ff;
1090                         struct sk_buff *skb;
1091
1092                         skb = dev_alloc_skb(pkt_len+5);
1093                         lp->stats.rx_bytes += pkt_len;
1094                         if (el3_debug > 4)
1095                                 printk("Receiving packet size %d status %4.4x.\n",
1096                                            pkt_len, rx_status);
1097                         if (skb != NULL) {
1098                                 skb->dev = dev;
1099                                 skb_reserve(skb, 2);     /* Align IP on 16 byte */
1100
1101                                 /* 'skb->data' points to the start of sk_buff data area. */
1102                                 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1103                                          (pkt_len + 3) >> 2);
1104
1105                                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1106                                 skb->protocol = eth_type_trans(skb,dev);
1107                                 netif_rx(skb);
1108                                 dev->last_rx = jiffies;
1109                                 lp->stats.rx_packets++;
1110                                 continue;
1111                         }
1112                         outw(RxDiscard, ioaddr + EL3_CMD);
1113                         lp->stats.rx_dropped++;
1114                         if (el3_debug)
1115                                 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1116                                            dev->name, pkt_len);
1117                 }
1118                 inw(ioaddr + EL3_STATUS);                               /* Delay. */
1119                 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1120                         printk(KERN_DEBUG "     Waiting for 3c509 to discard packet, status %x.\n",
1121                                    inw(ioaddr + EL3_STATUS) );
1122         }
1123
1124         return 0;
1125 }
1126
1127 /*
1128  *     Set or clear the multicast filter for this adaptor.
1129  */
1130 static void
1131 set_multicast_list(struct net_device *dev)
1132 {
1133         unsigned long flags;
1134         struct el3_private *lp = netdev_priv(dev);
1135         int ioaddr = dev->base_addr;
1136
1137         if (el3_debug > 1) {
1138                 static int old;
1139                 if (old != dev->mc_count) {
1140                         old = dev->mc_count;
1141                         printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1142                 }
1143         }
1144         spin_lock_irqsave(&lp->lock, flags);
1145         if (dev->flags&IFF_PROMISC) {
1146                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1147                          ioaddr + EL3_CMD);
1148         }
1149         else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1150                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1151         }
1152         else
1153                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1154         spin_unlock_irqrestore(&lp->lock, flags);
1155 }
1156
1157 static int
1158 el3_close(struct net_device *dev)
1159 {
1160         int ioaddr = dev->base_addr;
1161         struct el3_private *lp = netdev_priv(dev);
1162
1163         if (el3_debug > 2)
1164                 printk("%s: Shutting down ethercard.\n", dev->name);
1165
1166         el3_down(dev);
1167
1168         free_irq(dev->irq, dev);
1169         /* Switching back to window 0 disables the IRQ. */
1170         EL3WINDOW(0);
1171         if (lp->type != EL3_EISA) {
1172                 /* But we explicitly zero the IRQ line select anyway. Don't do
1173                  * it on EISA cards, it prevents the module from getting an
1174                  * IRQ after unload+reload... */
1175                 outw(0x0f00, ioaddr + WN0_IRQ);
1176         }
1177
1178         return 0;
1179 }
1180
1181 static int
1182 el3_link_ok(struct net_device *dev)
1183 {
1184         int ioaddr = dev->base_addr;
1185         u16 tmp;
1186
1187         EL3WINDOW(4);
1188         tmp = inw(ioaddr + WN4_MEDIA);
1189         EL3WINDOW(1);
1190         return tmp & (1<<11);
1191 }
1192
1193 static int
1194 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1195 {
1196         u16 tmp;
1197         int ioaddr = dev->base_addr;
1198
1199         EL3WINDOW(0);
1200         /* obtain current transceiver via WN4_MEDIA? */
1201         tmp = inw(ioaddr + WN0_ADDR_CONF);
1202         ecmd->transceiver = XCVR_INTERNAL;
1203         switch (tmp >> 14) {
1204         case 0:
1205                 ecmd->port = PORT_TP;
1206                 break;
1207         case 1:
1208                 ecmd->port = PORT_AUI;
1209                 ecmd->transceiver = XCVR_EXTERNAL;
1210                 break;
1211         case 3:
1212                 ecmd->port = PORT_BNC;
1213         default:
1214                 break;
1215         }
1216
1217         ecmd->duplex = DUPLEX_HALF;
1218         ecmd->supported = 0;
1219         tmp = inw(ioaddr + WN0_CONF_CTRL);
1220         if (tmp & (1<<13))
1221                 ecmd->supported |= SUPPORTED_AUI;
1222         if (tmp & (1<<12))
1223                 ecmd->supported |= SUPPORTED_BNC;
1224         if (tmp & (1<<9)) {
1225                 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1226                                 SUPPORTED_10baseT_Full; /* hmm... */
1227                 EL3WINDOW(4);
1228                 tmp = inw(ioaddr + WN4_NETDIAG);
1229                 if (tmp & FD_ENABLE)
1230                         ecmd->duplex = DUPLEX_FULL;
1231         }
1232
1233         ecmd->speed = SPEED_10;
1234         EL3WINDOW(1);
1235         return 0;
1236 }
1237
1238 static int
1239 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1240 {
1241         u16 tmp;
1242         int ioaddr = dev->base_addr;
1243
1244         if (ecmd->speed != SPEED_10)
1245                 return -EINVAL;
1246         if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1247                 return -EINVAL;
1248         if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1249                 return -EINVAL;
1250
1251         /* change XCVR type */
1252         EL3WINDOW(0);
1253         tmp = inw(ioaddr + WN0_ADDR_CONF);
1254         switch (ecmd->port) {
1255         case PORT_TP:
1256                 tmp &= ~(3<<14);
1257                 dev->if_port = 0;
1258                 break;
1259         case PORT_AUI:
1260                 tmp |= (1<<14);
1261                 dev->if_port = 1;
1262                 break;
1263         case PORT_BNC:
1264                 tmp |= (3<<14);
1265                 dev->if_port = 3;
1266                 break;
1267         default:
1268                 return -EINVAL;
1269         }
1270
1271         outw(tmp, ioaddr + WN0_ADDR_CONF);
1272         if (dev->if_port == 3) {
1273                 /* fire up the DC-DC convertor if BNC gets enabled */
1274                 tmp = inw(ioaddr + WN0_ADDR_CONF);
1275                 if (tmp & (3 << 14)) {
1276                         outw(StartCoax, ioaddr + EL3_CMD);
1277                         udelay(800);
1278                 } else
1279                         return -EIO;
1280         }
1281
1282         EL3WINDOW(4);
1283         tmp = inw(ioaddr + WN4_NETDIAG);
1284         if (ecmd->duplex == DUPLEX_FULL)
1285                 tmp |= FD_ENABLE;
1286         else
1287                 tmp &= ~FD_ENABLE;
1288         outw(tmp, ioaddr + WN4_NETDIAG);
1289         EL3WINDOW(1);
1290
1291         return 0;
1292 }
1293
1294 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1295 {
1296         strcpy(info->driver, DRV_NAME);
1297         strcpy(info->version, DRV_VERSION);
1298 }
1299
1300 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1301 {
1302         struct el3_private *lp = netdev_priv(dev);
1303         int ret;
1304
1305         spin_lock_irq(&lp->lock);
1306         ret = el3_netdev_get_ecmd(dev, ecmd);
1307         spin_unlock_irq(&lp->lock);
1308         return ret;
1309 }
1310
1311 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1312 {
1313         struct el3_private *lp = netdev_priv(dev);
1314         int ret;
1315
1316         spin_lock_irq(&lp->lock);
1317         ret = el3_netdev_set_ecmd(dev, ecmd);
1318         spin_unlock_irq(&lp->lock);
1319         return ret;
1320 }
1321
1322 static u32 el3_get_link(struct net_device *dev)
1323 {
1324         struct el3_private *lp = netdev_priv(dev);
1325         u32 ret;
1326
1327         spin_lock_irq(&lp->lock);
1328         ret = el3_link_ok(dev);
1329         spin_unlock_irq(&lp->lock);
1330         return ret;
1331 }
1332
1333 static u32 el3_get_msglevel(struct net_device *dev)
1334 {
1335         return el3_debug;
1336 }
1337
1338 static void el3_set_msglevel(struct net_device *dev, u32 v)
1339 {
1340         el3_debug = v;
1341 }
1342
1343 static const struct ethtool_ops ethtool_ops = {
1344         .get_drvinfo = el3_get_drvinfo,
1345         .get_settings = el3_get_settings,
1346         .set_settings = el3_set_settings,
1347         .get_link = el3_get_link,
1348         .get_msglevel = el3_get_msglevel,
1349         .set_msglevel = el3_set_msglevel,
1350 };
1351
1352 static void
1353 el3_down(struct net_device *dev)
1354 {
1355         int ioaddr = dev->base_addr;
1356
1357         netif_stop_queue(dev);
1358
1359         /* Turn off statistics ASAP.  We update lp->stats below. */
1360         outw(StatsDisable, ioaddr + EL3_CMD);
1361
1362         /* Disable the receiver and transmitter. */
1363         outw(RxDisable, ioaddr + EL3_CMD);
1364         outw(TxDisable, ioaddr + EL3_CMD);
1365
1366         if (dev->if_port == 3)
1367                 /* Turn off thinnet power.  Green! */
1368                 outw(StopCoax, ioaddr + EL3_CMD);
1369         else if (dev->if_port == 0) {
1370                 /* Disable link beat and jabber, if_port may change here next open(). */
1371                 EL3WINDOW(4);
1372                 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1373         }
1374
1375         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1376
1377         update_stats(dev);
1378 }
1379
1380 static void
1381 el3_up(struct net_device *dev)
1382 {
1383         int i, sw_info, net_diag;
1384         int ioaddr = dev->base_addr;
1385
1386         /* Activating the board required and does no harm otherwise */
1387         outw(0x0001, ioaddr + 4);
1388
1389         /* Set the IRQ line. */
1390         outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1391
1392         /* Set the station address in window 2 each time opened. */
1393         EL3WINDOW(2);
1394
1395         for (i = 0; i < 6; i++)
1396                 outb(dev->dev_addr[i], ioaddr + i);
1397
1398         if ((dev->if_port & 0x03) == 3) /* BNC interface */
1399                 /* Start the thinnet transceiver. We should really wait 50ms...*/
1400                 outw(StartCoax, ioaddr + EL3_CMD);
1401         else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1402                 /* Combine secondary sw_info word (the adapter level) and primary
1403                         sw_info word (duplex setting plus other useless bits) */
1404                 EL3WINDOW(0);
1405                 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1406                         (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1407
1408                 EL3WINDOW(4);
1409                 net_diag = inw(ioaddr + WN4_NETDIAG);
1410                 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1411                 printk("%s: ", dev->name);
1412                 switch (dev->if_port & 0x0c) {
1413                         case 12:
1414                                 /* force full-duplex mode if 3c5x9b */
1415                                 if (sw_info & 0x000f) {
1416                                         printk("Forcing 3c5x9b full-duplex mode");
1417                                         break;
1418                                 }
1419                         case 8:
1420                                 /* set full-duplex mode based on eeprom config setting */
1421                                 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1422                                         printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1423                                         break;
1424                                 }
1425                         default:
1426                                 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1427                                 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1428                                 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1429                 }
1430
1431                 outw(net_diag, ioaddr + WN4_NETDIAG);
1432                 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1433                 if (el3_debug > 3)
1434                         printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1435                 /* Enable link beat and jabber check. */
1436                 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1437         }
1438
1439         /* Switch to the stats window, and clear all stats by reading. */
1440         outw(StatsDisable, ioaddr + EL3_CMD);
1441         EL3WINDOW(6);
1442         for (i = 0; i < 9; i++)
1443                 inb(ioaddr + i);
1444         inw(ioaddr + 10);
1445         inw(ioaddr + 12);
1446
1447         /* Switch to register set 1 for normal use. */
1448         EL3WINDOW(1);
1449
1450         /* Accept b-case and phys addr only. */
1451         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1452         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1453
1454         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1455         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1456         /* Allow status bits to be seen. */
1457         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1458         /* Ack all pending events, and set active indicator mask. */
1459         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1460                  ioaddr + EL3_CMD);
1461         outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1462                  ioaddr + EL3_CMD);
1463
1464         netif_start_queue(dev);
1465 }
1466
1467 /* Power Management support functions */
1468 #ifdef EL3_SUSPEND
1469
1470 static int
1471 el3_suspend(struct device *pdev, pm_message_t state)
1472 {
1473         unsigned long flags;
1474         struct net_device *dev;
1475         struct el3_private *lp;
1476         int ioaddr;
1477
1478         dev = pdev->driver_data;
1479         lp = netdev_priv(dev);
1480         ioaddr = dev->base_addr;
1481
1482         spin_lock_irqsave(&lp->lock, flags);
1483
1484         if (netif_running(dev))
1485                 netif_device_detach(dev);
1486
1487         el3_down(dev);
1488         outw(PowerDown, ioaddr + EL3_CMD);
1489
1490         spin_unlock_irqrestore(&lp->lock, flags);
1491         return 0;
1492 }
1493
1494 static int
1495 el3_resume(struct device *pdev)
1496 {
1497         unsigned long flags;
1498         struct net_device *dev;
1499         struct el3_private *lp;
1500         int ioaddr;
1501
1502         dev = pdev->driver_data;
1503         lp = netdev_priv(dev);
1504         ioaddr = dev->base_addr;
1505
1506         spin_lock_irqsave(&lp->lock, flags);
1507
1508         outw(PowerUp, ioaddr + EL3_CMD);
1509         el3_up(dev);
1510
1511         if (netif_running(dev))
1512                 netif_device_attach(dev);
1513
1514         spin_unlock_irqrestore(&lp->lock, flags);
1515         return 0;
1516 }
1517
1518 #endif /* EL3_SUSPEND */
1519
1520 /* Parameters that may be passed into the module. */
1521 static int debug = -1;
1522 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
1523 static int xcvr[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1524
1525 module_param(debug,int, 0);
1526 module_param_array(irq, int, NULL, 0);
1527 module_param_array(xcvr, int, NULL, 0);
1528 module_param(max_interrupt_work, int, 0);
1529 MODULE_PARM_DESC(debug, "debug level (0-6)");
1530 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1531 MODULE_PARM_DESC(xcvr,"transceiver(s) (0=internal, 1=external)");
1532 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1533 #if defined(__ISAPNP__)
1534 module_param(nopnp, int, 0);
1535 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1536 MODULE_DEVICE_TABLE(isapnp, el3_isapnp_adapters);
1537 #endif  /* __ISAPNP__ */
1538 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B) ISA/PnP ethernet driver");
1539 MODULE_LICENSE("GPL");
1540
1541 static int __init el3_init_module(void)
1542 {
1543         int ret = 0;
1544         el3_cards = 0;
1545
1546         if (debug >= 0)
1547                 el3_debug = debug;
1548
1549         el3_root_dev = NULL;
1550         while (el3_probe(el3_cards) == 0) {
1551                 if (irq[el3_cards] > 1)
1552                         el3_root_dev->irq = irq[el3_cards];
1553                 if (xcvr[el3_cards] >= 0)
1554                         el3_root_dev->if_port = xcvr[el3_cards];
1555                 el3_cards++;
1556         }
1557
1558 #ifdef CONFIG_EISA
1559         ret = eisa_driver_register(&el3_eisa_driver);
1560 #endif
1561 #ifdef CONFIG_MCA
1562         {
1563                 int err = mca_register_driver(&el3_mca_driver);
1564                 if (ret == 0)
1565                         ret = err;
1566         }
1567 #endif
1568         return ret;
1569 }
1570
1571 static void __exit el3_cleanup_module(void)
1572 {
1573         struct net_device *next_dev;
1574
1575         while (el3_root_dev) {
1576                 struct el3_private *lp = netdev_priv(el3_root_dev);
1577
1578                 next_dev = lp->next_dev;
1579                 el3_common_remove (el3_root_dev);
1580                 el3_root_dev = next_dev;
1581         }
1582
1583 #ifdef CONFIG_EISA
1584         eisa_driver_unregister (&el3_eisa_driver);
1585 #endif
1586 #ifdef CONFIG_MCA
1587         mca_unregister_driver(&el3_mca_driver);
1588 #endif
1589 }
1590
1591 module_init (el3_init_module);
1592 module_exit (el3_cleanup_module);
1593