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