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