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