drivers/net/3c509.c

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