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