git.oblomov.eu Git - linux-2.6/blob - drivers/net/3c509.c

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