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

   1 /* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
   2 /*
   3         Written 1993-2000 by Donald Becker.
   4
   5         Copyright 1994-2000 by Donald Becker.
   6         Copyright 1993 United States Government as represented by the
   7         Director, National Security Agency.      This software may be used and
   8         distributed according to the terms of the GNU General Public License,
   9         incorporated herein by reference.
  10
  11         This driver is for the 3Com EtherLinkIII series.
  12
  13         The author may be reached as becker@scyld.com, or C/O
  14         Scyld Computing Corporation
  15         410 Severn Ave., Suite 210
  16         Annapolis MD 21403
  17
  18         Known limitations:
  19         Because of the way 3c509 ISA detection works it's difficult to predict
  20         a priori which of several ISA-mode cards will be detected first.
  21
  22         This driver does not use predictive interrupt mode, resulting in higher
  23         packet latency but lower overhead.  If interrupts are disabled for an
  24         unusually long time it could also result in missed packets, but in
  25         practice this rarely happens.
  26
  27
  28         FIXES:
  29                 Alan Cox:       Removed the 'Unexpected interrupt' bug.
  30                 Michael Meskes: Upgraded to Donald Becker's version 1.07.
  31                 Alan Cox:       Increased the eeprom delay. Regardless of
  32                                 what the docs say some people definitely
  33                                 get problems with lower (but in card spec)
  34                                 delays
  35                 v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
  36                                 other cleanups.  -djb
  37                 Andrea Arcangeli:       Upgraded to Donald Becker's version 1.12.
  38                 Rick Payne:     Fixed SMP race condition
  39                 v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
  40                 v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
  41                 v1.15 1/31/98 Faster recovery for Tx errors. -djb
  42                 v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
  43                 v1.18 12Mar2001 Andrew Morton <andrewm@uow.edu.au>
  44                         - Avoid bogus detect of 3c590's (Andrzej Krzysztofowicz)
  45                         - Reviewed against 1.18 from scyld.com
  46                 v1.18a 17Nov2001 Jeff Garzik <jgarzik@pobox.com>
  47                         - ethtool support
  48                 v1.18b 1Mar2002 Zwane Mwaikambo <zwane@commfireservices.com>
  49                         - Power Management support
  50                 v1.18c 1Mar2002 David Ruggiero <jdr@farfalle.com>
  51                         - Full duplex support
  52                 v1.19  16Oct2002 Zwane Mwaikambo <zwane@linuxpower.ca>
  53                         - Additional ethtool features
  54                 v1.19a 28Oct2002 Davud Ruggiero <jdr@farfalle.com>
  55                         - Increase *read_eeprom udelay to workaround oops with 2 cards.
  56                 v1.19b 08Nov2002 Marc Zyngier <maz@wild-wind.fr.eu.org>
  57                     - Introduce driver model for EISA cards.
  58 */
  59
  60 #define DRV_NAME        "3c509"
  61 #define DRV_VERSION     "1.19b"
  62 #define DRV_RELDATE     "08Nov2002"
  63
  64 /* A few values that may be tweaked. */
  65
  66 /* Time in jiffies before concluding the transmitter is hung. */
  67 #define TX_TIMEOUT  (400*HZ/1000)
  68 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  69 static int max_interrupt_work = 10;
  70
  71 #include <linux/config.h>
  72 #include <linux/module.h>
  73 #ifdef CONFIG_MCA
  74 #include <linux/mca.h>
  75 #endif
  76 #include <linux/isapnp.h>
  77 #include <linux/string.h>
  78 #include <linux/interrupt.h>
  79 #include <linux/errno.h>
  80 #include <linux/in.h>
  81 #include <linux/slab.h>
  82 #include <linux/ioport.h>
  83 #include <linux/init.h>
  84 #include <linux/netdevice.h>
  85 #include <linux/etherdevice.h>
  86 #include <linux/pm.h>
  87 #include <linux/pm_legacy.h>
  88 #include <linux/skbuff.h>
  89 #include <linux/delay.h>        /* for udelay() */
  90 #include <linux/spinlock.h>
  91 #include <linux/ethtool.h>
  92 #include <linux/device.h>
  93 #include <linux/eisa.h>
  94 #include <linux/bitops.h>
  95
  96 #include <asm/uaccess.h>
  97 #include <asm/io.h>
  98 #include <asm/irq.h>
  99
 100 static char versionA[] __initdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
 101 static char versionB[] __initdata = "http://www.scyld.com/network/3c509.html\n";
 102
 103 #if defined(CONFIG_PM) && (defined(CONFIG_MCA) || defined(CONFIG_EISA))
 104 #define EL3_SUSPEND
 105 #endif
 106
 107 #ifdef EL3_DEBUG
 108 static int el3_debug = EL3_DEBUG;
 109 #else
 110 static int el3_debug = 2;
 111 #endif
 112
 113 /* Used to do a global count of all the cards in the system.  Must be
 114  * a global variable so that the mca/eisa probe routines can increment
 115  * it */
 116 static int el3_cards = 0;
 117
 118 /* To minimize the size of the driver source I only define operating
 119    constants if they are used several times.  You'll need the manual
 120    anyway if you want to understand driver details. */
 121 /* Offsets from base I/O address. */
 122 #define EL3_DATA 0x00
 123 #define EL3_CMD 0x0e
 124 #define EL3_STATUS 0x0e
 125 #define  EEPROM_READ 0x80
 126
 127 #define EL3_IO_EXTENT   16
 128
 129 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
 130
 131
 132 /* The top five bits written to EL3_CMD are a command, the lower
 133    11 bits are the parameter, if applicable. */
 134 enum c509cmd {
 135         TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
 136         RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
 137         TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
 138         FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
 139         SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
 140         SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
 141         StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
 142         PowerDown = 28<<11, PowerAuto = 29<<11};
 143
 144 enum c509status {
 145         IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
 146         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
 147         IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
 148
 149 /* The SetRxFilter command accepts the following classes: */
 150 enum RxFilter {
 151         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
 152
 153 /* Register window 1 offsets, the window used in normal operation. */
 154 #define TX_FIFO         0x00
 155 #define RX_FIFO         0x00
 156 #define RX_STATUS       0x08
 157 #define TX_STATUS       0x0B
 158 #define TX_FREE         0x0C            /* Remaining free bytes in Tx buffer. */
 159
 160 #define WN0_CONF_CTRL   0x04            /* Window 0: Configuration control register */
 161 #define WN0_ADDR_CONF   0x06            /* Window 0: Address configuration register */
 162 #define WN0_IRQ         0x08            /* Window 0: Set IRQ line in bits 12-15. */
 163 #define WN4_MEDIA       0x0A            /* Window 4: Various transcvr/media bits. */
 164 #define MEDIA_TP        0x00C0          /* Enable link beat and jabber for 10baseT. */
 165 #define WN4_NETDIAG     0x06            /* Window 4: Net diagnostic */
 166 #define FD_ENABLE       0x8000          /* Enable full-duplex ("external loopback") */
 167
 168 /*
 169  * Must be a power of two (we use a binary and in the
 170  * circular queue)
 171  */
 172 #define SKB_QUEUE_SIZE  64
 173
 174 struct el3_private {
 175         struct net_device_stats stats;
 176         struct net_device *next_dev;
 177         spinlock_t lock;
 178         /* skb send-queue */
 179         int head, size;
 180         struct sk_buff *queue[SKB_QUEUE_SIZE];
 181         enum {
 182                 EL3_MCA,
 183                 EL3_PNP,
 184                 EL3_EISA,
 185         } type;                                         /* type of device */
 186         struct device *dev;
 187 };
 188 static int id_port __initdata = 0x110;  /* Start with 0x110 to avoid new sound cards.*/
 189 static struct net_device *el3_root_dev;
 190
 191 static ushort id_read_eeprom(int index);
 192 static ushort read_eeprom(int ioaddr, int index);
 193 static int el3_open(struct net_device *dev);
 194 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
 195 static irqreturn_t el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 196 static void update_stats(struct net_device *dev);
 197 static struct net_device_stats *el3_get_stats(struct net_device *dev);
 198 static int el3_rx(struct net_device *dev);
 199 static int el3_close(struct net_device *dev);
 200 static void set_multicast_list(struct net_device *dev);
 201 static void el3_tx_timeout (struct net_device *dev);
 202 static void el3_down(struct net_device *dev);
 203 static void el3_up(struct net_device *dev);
 204 static struct ethtool_ops ethtool_ops;
 205 #ifdef EL3_SUSPEND
 206 static int el3_suspend(struct device *, pm_message_t);
 207 static int el3_resume(struct device *);
 208 #else
 209 #define el3_suspend NULL
 210 #define el3_resume NULL
 211 #endif
 212
 213
 214 /* generic device remove for all device types */
 215 #if defined(CONFIG_EISA) || defined(CONFIG_MCA)
 216 static int el3_device_remove (struct device *device);
 217 #endif
 218 #ifdef CONFIG_NET_POLL_CONTROLLER
 219 static void el3_poll_controller(struct net_device *dev);
 220 #endif
 221
 222 #ifdef CONFIG_EISA
 223 static struct eisa_device_id el3_eisa_ids[] = {
 224                 { "TCM5092" },
 225                 { "TCM5093" },
 226                 { "TCM5095" },
 227                 { "" }
 228 };
 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 #ifdef  __powerpc__
 884         outsl_ns(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 885 #else
 886         outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 887 #endif
 888
 889         dev->trans_start = jiffies;
 890         if (inw(ioaddr + TX_FREE) > 1536)
 891                 netif_start_queue(dev);
 892         else
 893                 /* Interrupt us when the FIFO has room for max-sized packet. */
 894                 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
 895
 896         spin_unlock_irqrestore(&lp->lock, flags);
 897
 898         dev_kfree_skb (skb);
 899
 900         /* Clear the Tx status stack. */
 901         {
 902                 short tx_status;
 903                 int i = 4;
 904
 905                 while (--i > 0  &&      (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 906                         if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
 907                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 908                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 909                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 910                 }
 911         }
 912         return 0;
 913 }
 914
 915 /* The EL3 interrupt handler. */
 916 static irqreturn_t
 917 el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 918 {
 919         struct net_device *dev = (struct net_device *)dev_id;
 920         struct el3_private *lp;
 921         int ioaddr, status;
 922         int i = max_interrupt_work;
 923
 924         if (dev == NULL) {
 925                 printk ("el3_interrupt(): irq %d for unknown device.\n", irq);
 926                 return IRQ_NONE;
 927         }
 928
 929         lp = netdev_priv(dev);
 930         spin_lock(&lp->lock);
 931
 932         ioaddr = dev->base_addr;
 933
 934         if (el3_debug > 4) {
 935                 status = inw(ioaddr + EL3_STATUS);
 936                 printk("%s: interrupt, status %4.4x.\n", dev->name, status);
 937         }
 938
 939         while ((status = inw(ioaddr + EL3_STATUS)) &
 940                    (IntLatch | RxComplete | StatsFull)) {
 941
 942                 if (status & RxComplete)
 943                         el3_rx(dev);
 944
 945                 if (status & TxAvailable) {
 946                         if (el3_debug > 5)
 947                                 printk("        TX room bit was handled.\n");
 948                         /* There's room in the FIFO for a full-sized packet. */
 949                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 950                         netif_wake_queue (dev);
 951                 }
 952                 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
 953                         /* Handle all uncommon interrupts. */
 954                         if (status & StatsFull)                         /* Empty statistics. */
 955                                 update_stats(dev);
 956                         if (status & RxEarly) {                         /* Rx early is unused. */
 957                                 el3_rx(dev);
 958                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 959                         }
 960                         if (status & TxComplete) {                      /* Really Tx error. */
 961                                 struct el3_private *lp = netdev_priv(dev);
 962                                 short tx_status;
 963                                 int i = 4;
 964
 965                                 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 966                                         if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
 967                                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 968                                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 969                                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 970                                 }
 971                         }
 972                         if (status & AdapterFailure) {
 973                                 /* Adapter failure requires Rx reset and reinit. */
 974                                 outw(RxReset, ioaddr + EL3_CMD);
 975                                 /* Set the Rx filter to the current state. */
 976                                 outw(SetRxFilter | RxStation | RxBroadcast
 977                                          | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
 978                                          | (dev->flags & IFF_PROMISC ? RxProm : 0),
 979                                          ioaddr + EL3_CMD);
 980                                 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
 981                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 982                         }
 983                 }
 984
 985                 if (--i < 0) {
 986                         printk("%s: Infinite loop in interrupt, status %4.4x.\n",
 987                                    dev->name, status);
 988                         /* Clear all interrupts. */
 989                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 990                         break;
 991                 }
 992                 /* Acknowledge the IRQ. */
 993                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
 994         }
 995
 996         if (el3_debug > 4) {
 997                 printk("%s: exiting interrupt, status %4.4x.\n", dev->name,
 998                            inw(ioaddr + EL3_STATUS));
 999         }
1000         spin_unlock(&lp->lock);
1001         return IRQ_HANDLED;
1002 }
1003
1004
1005 #ifdef CONFIG_NET_POLL_CONTROLLER
1006 /*
1007  * Polling receive - used by netconsole and other diagnostic tools
1008  * to allow network i/o with interrupts disabled.
1009  */
1010 static void el3_poll_controller(struct net_device *dev)
1011 {
1012         disable_irq(dev->irq);
1013         el3_interrupt(dev->irq, dev, NULL);
1014         enable_irq(dev->irq);
1015 }
1016 #endif
1017
1018 static struct net_device_stats *
1019 el3_get_stats(struct net_device *dev)
1020 {
1021         struct el3_private *lp = netdev_priv(dev);
1022         unsigned long flags;
1023
1024         /*
1025          *      This is fast enough not to bother with disable IRQ
1026          *      stuff.
1027          */
1028
1029         spin_lock_irqsave(&lp->lock, flags);
1030         update_stats(dev);
1031         spin_unlock_irqrestore(&lp->lock, flags);
1032         return &lp->stats;
1033 }
1034
1035 /*  Update statistics.  We change to register window 6, so this should be run
1036         single-threaded if the device is active. This is expected to be a rare
1037         operation, and it's simpler for the rest of the driver to assume that
1038         window 1 is always valid rather than use a special window-state variable.
1039         */
1040 static void update_stats(struct net_device *dev)
1041 {
1042         struct el3_private *lp = netdev_priv(dev);
1043         int ioaddr = dev->base_addr;
1044
1045         if (el3_debug > 5)
1046                 printk("   Updating the statistics.\n");
1047         /* Turn off statistics updates while reading. */
1048         outw(StatsDisable, ioaddr + EL3_CMD);
1049         /* Switch to the stats window, and read everything. */
1050         EL3WINDOW(6);
1051         lp->stats.tx_carrier_errors     += inb(ioaddr + 0);
1052         lp->stats.tx_heartbeat_errors   += inb(ioaddr + 1);
1053         /* Multiple collisions. */         inb(ioaddr + 2);
1054         lp->stats.collisions            += inb(ioaddr + 3);
1055         lp->stats.tx_window_errors      += inb(ioaddr + 4);
1056         lp->stats.rx_fifo_errors        += inb(ioaddr + 5);
1057         lp->stats.tx_packets            += inb(ioaddr + 6);
1058         /* Rx packets   */                 inb(ioaddr + 7);
1059         /* Tx deferrals */                 inb(ioaddr + 8);
1060         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1061         inw(ioaddr + 12);
1062
1063         /* Back to window 1, and turn statistics back on. */
1064         EL3WINDOW(1);
1065         outw(StatsEnable, ioaddr + EL3_CMD);
1066         return;
1067 }
1068
1069 static int
1070 el3_rx(struct net_device *dev)
1071 {
1072         struct el3_private *lp = netdev_priv(dev);
1073         int ioaddr = dev->base_addr;
1074         short rx_status;
1075
1076         if (el3_debug > 5)
1077                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1078                            inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1079         while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1080                 if (rx_status & 0x4000) { /* Error, update stats. */
1081                         short error = rx_status & 0x3800;
1082
1083                         outw(RxDiscard, ioaddr + EL3_CMD);
1084                         lp->stats.rx_errors++;
1085                         switch (error) {
1086                         case 0x0000:            lp->stats.rx_over_errors++; break;
1087                         case 0x0800:            lp->stats.rx_length_errors++; break;
1088                         case 0x1000:            lp->stats.rx_frame_errors++; break;
1089                         case 0x1800:            lp->stats.rx_length_errors++; break;
1090                         case 0x2000:            lp->stats.rx_frame_errors++; break;
1091                         case 0x2800:            lp->stats.rx_crc_errors++; break;
1092                         }
1093                 } else {
1094                         short pkt_len = rx_status & 0x7ff;
1095                         struct sk_buff *skb;
1096
1097                         skb = dev_alloc_skb(pkt_len+5);
1098                         lp->stats.rx_bytes += pkt_len;
1099                         if (el3_debug > 4)
1100                                 printk("Receiving packet size %d status %4.4x.\n",
1101                                            pkt_len, rx_status);
1102                         if (skb != NULL) {
1103                                 skb->dev = dev;
1104                                 skb_reserve(skb, 2);     /* Align IP on 16 byte */
1105
1106                                 /* 'skb->data' points to the start of sk_buff data area. */
1107 #ifdef  __powerpc__
1108                                 insl_ns(ioaddr+RX_FIFO, skb_put(skb,pkt_len),
1109                                                            (pkt_len + 3) >> 2);
1110 #else
1111                                 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1112                                          (pkt_len + 3) >> 2);
1113 #endif
1114
1115                                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1116                                 skb->protocol = eth_type_trans(skb,dev);
1117                                 netif_rx(skb);
1118                                 dev->last_rx = jiffies;
1119                                 lp->stats.rx_packets++;
1120                                 continue;
1121                         }
1122                         outw(RxDiscard, ioaddr + EL3_CMD);
1123                         lp->stats.rx_dropped++;
1124                         if (el3_debug)
1125                                 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
1126                                            dev->name, pkt_len);
1127                 }
1128                 inw(ioaddr + EL3_STATUS);                               /* Delay. */
1129                 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1130                         printk(KERN_DEBUG "     Waiting for 3c509 to discard packet, status %x.\n",
1131                                    inw(ioaddr + EL3_STATUS) );
1132         }
1133
1134         return 0;
1135 }
1136
1137 /*
1138  *     Set or clear the multicast filter for this adaptor.
1139  */
1140 static void
1141 set_multicast_list(struct net_device *dev)
1142 {
1143         unsigned long flags;
1144         struct el3_private *lp = netdev_priv(dev);
1145         int ioaddr = dev->base_addr;
1146
1147         if (el3_debug > 1) {
1148                 static int old;
1149                 if (old != dev->mc_count) {
1150                         old = dev->mc_count;
1151                         printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
1152                 }
1153         }
1154         spin_lock_irqsave(&lp->lock, flags);
1155         if (dev->flags&IFF_PROMISC) {
1156                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1157                          ioaddr + EL3_CMD);
1158         }
1159         else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
1160                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1161         }
1162         else
1163                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1164         spin_unlock_irqrestore(&lp->lock, flags);
1165 }
1166
1167 static int
1168 el3_close(struct net_device *dev)
1169 {
1170         int ioaddr = dev->base_addr;
1171         struct el3_private *lp = netdev_priv(dev);
1172
1173         if (el3_debug > 2)
1174                 printk("%s: Shutting down ethercard.\n", dev->name);
1175
1176         el3_down(dev);
1177
1178         free_irq(dev->irq, dev);
1179         /* Switching back to window 0 disables the IRQ. */
1180         EL3WINDOW(0);
1181         if (lp->type != EL3_EISA) {
1182                 /* But we explicitly zero the IRQ line select anyway. Don't do
1183                  * it on EISA cards, it prevents the module from getting an
1184                  * IRQ after unload+reload... */
1185                 outw(0x0f00, ioaddr + WN0_IRQ);
1186         }
1187
1188         return 0;
1189 }
1190
1191 static int
1192 el3_link_ok(struct net_device *dev)
1193 {
1194         int ioaddr = dev->base_addr;
1195         u16 tmp;
1196
1197         EL3WINDOW(4);
1198         tmp = inw(ioaddr + WN4_MEDIA);
1199         EL3WINDOW(1);
1200         return tmp & (1<<11);
1201 }
1202
1203 static int
1204 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1205 {
1206         u16 tmp;
1207         int ioaddr = dev->base_addr;
1208
1209         EL3WINDOW(0);
1210         /* obtain current transceiver via WN4_MEDIA? */
1211         tmp = inw(ioaddr + WN0_ADDR_CONF);
1212         ecmd->transceiver = XCVR_INTERNAL;
1213         switch (tmp >> 14) {
1214         case 0:
1215                 ecmd->port = PORT_TP;
1216                 break;
1217         case 1:
1218                 ecmd->port = PORT_AUI;
1219                 ecmd->transceiver = XCVR_EXTERNAL;
1220                 break;
1221         case 3:
1222                 ecmd->port = PORT_BNC;
1223         default:
1224                 break;
1225         }
1226
1227         ecmd->duplex = DUPLEX_HALF;
1228         ecmd->supported = 0;
1229         tmp = inw(ioaddr + WN0_CONF_CTRL);
1230         if (tmp & (1<<13))
1231                 ecmd->supported |= SUPPORTED_AUI;
1232         if (tmp & (1<<12))
1233                 ecmd->supported |= SUPPORTED_BNC;
1234         if (tmp & (1<<9)) {
1235                 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1236                                 SUPPORTED_10baseT_Full; /* hmm... */
1237                 EL3WINDOW(4);
1238                 tmp = inw(ioaddr + WN4_NETDIAG);
1239                 if (tmp & FD_ENABLE)
1240                         ecmd->duplex = DUPLEX_FULL;
1241         }
1242
1243         ecmd->speed = SPEED_10;
1244         EL3WINDOW(1);
1245         return 0;
1246 }
1247
1248 static int
1249 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1250 {
1251         u16 tmp;
1252         int ioaddr = dev->base_addr;
1253
1254         if (ecmd->speed != SPEED_10)
1255                 return -EINVAL;
1256         if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1257                 return -EINVAL;
1258         if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1259                 return -EINVAL;
1260
1261         /* change XCVR type */
1262         EL3WINDOW(0);
1263         tmp = inw(ioaddr + WN0_ADDR_CONF);
1264         switch (ecmd->port) {
1265         case PORT_TP:
1266                 tmp &= ~(3<<14);
1267                 dev->if_port = 0;
1268                 break;
1269         case PORT_AUI:
1270                 tmp |= (1<<14);
1271                 dev->if_port = 1;
1272                 break;
1273         case PORT_BNC:
1274                 tmp |= (3<<14);
1275                 dev->if_port = 3;
1276                 break;
1277         default:
1278                 return -EINVAL;
1279         }
1280
1281         outw(tmp, ioaddr + WN0_ADDR_CONF);
1282         if (dev->if_port == 3) {
1283                 /* fire up the DC-DC convertor if BNC gets enabled */
1284                 tmp = inw(ioaddr + WN0_ADDR_CONF);
1285                 if (tmp & (3 << 14)) {
1286                         outw(StartCoax, ioaddr + EL3_CMD);
1287                         udelay(800);
1288                 } else
1289                         return -EIO;
1290         }
1291
1292         EL3WINDOW(4);
1293         tmp = inw(ioaddr + WN4_NETDIAG);
1294         if (ecmd->duplex == DUPLEX_FULL)
1295                 tmp |= FD_ENABLE;
1296         else
1297                 tmp &= ~FD_ENABLE;
1298         outw(tmp, ioaddr + WN4_NETDIAG);
1299         EL3WINDOW(1);
1300
1301         return 0;
1302 }
1303
1304 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1305 {
1306         strcpy(info->driver, DRV_NAME);
1307         strcpy(info->version, DRV_VERSION);
1308 }
1309
1310 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1311 {
1312         struct el3_private *lp = netdev_priv(dev);
1313         int ret;
1314
1315         spin_lock_irq(&lp->lock);
1316         ret = el3_netdev_get_ecmd(dev, ecmd);
1317         spin_unlock_irq(&lp->lock);
1318         return ret;
1319 }
1320
1321 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1322 {
1323         struct el3_private *lp = netdev_priv(dev);
1324         int ret;
1325
1326         spin_lock_irq(&lp->lock);
1327         ret = el3_netdev_set_ecmd(dev, ecmd);
1328         spin_unlock_irq(&lp->lock);
1329         return ret;
1330 }
1331
1332 static u32 el3_get_link(struct net_device *dev)
1333 {
1334         struct el3_private *lp = netdev_priv(dev);
1335         u32 ret;
1336
1337         spin_lock_irq(&lp->lock);
1338         ret = el3_link_ok(dev);
1339         spin_unlock_irq(&lp->lock);
1340         return ret;
1341 }
1342
1343 static u32 el3_get_msglevel(struct net_device *dev)
1344 {
1345         return el3_debug;
1346 }
1347
1348 static void el3_set_msglevel(struct net_device *dev, u32 v)
1349 {
1350         el3_debug = v;
1351 }
1352
1353 static struct ethtool_ops ethtool_ops = {
1354         .get_drvinfo = el3_get_drvinfo,
1355         .get_settings = el3_get_settings,
1356         .set_settings = el3_set_settings,
1357         .get_link = el3_get_link,
1358         .get_msglevel = el3_get_msglevel,
1359         .set_msglevel = el3_set_msglevel,
1360 };
1361
1362 static void
1363 el3_down(struct net_device *dev)
1364 {
1365         int ioaddr = dev->base_addr;
1366
1367         netif_stop_queue(dev);
1368
1369         /* Turn off statistics ASAP.  We update lp->stats below. */
1370         outw(StatsDisable, ioaddr + EL3_CMD);
1371
1372         /* Disable the receiver and transmitter. */
1373         outw(RxDisable, ioaddr + EL3_CMD);
1374         outw(TxDisable, ioaddr + EL3_CMD);
1375
1376         if (dev->if_port == 3)
1377                 /* Turn off thinnet power.  Green! */
1378                 outw(StopCoax, ioaddr + EL3_CMD);
1379         else if (dev->if_port == 0) {
1380                 /* Disable link beat and jabber, if_port may change here next open(). */
1381                 EL3WINDOW(4);
1382                 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1383         }
1384
1385         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1386
1387         update_stats(dev);
1388 }
1389
1390 static void
1391 el3_up(struct net_device *dev)
1392 {
1393         int i, sw_info, net_diag;
1394         int ioaddr = dev->base_addr;
1395
1396         /* Activating the board required and does no harm otherwise */
1397         outw(0x0001, ioaddr + 4);
1398
1399         /* Set the IRQ line. */
1400         outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1401
1402         /* Set the station address in window 2 each time opened. */
1403         EL3WINDOW(2);
1404
1405         for (i = 0; i < 6; i++)
1406                 outb(dev->dev_addr[i], ioaddr + i);
1407
1408         if ((dev->if_port & 0x03) == 3) /* BNC interface */
1409                 /* Start the thinnet transceiver. We should really wait 50ms...*/
1410                 outw(StartCoax, ioaddr + EL3_CMD);
1411         else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1412                 /* Combine secondary sw_info word (the adapter level) and primary
1413                         sw_info word (duplex setting plus other useless bits) */
1414                 EL3WINDOW(0);
1415                 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1416                         (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1417
1418                 EL3WINDOW(4);
1419                 net_diag = inw(ioaddr + WN4_NETDIAG);
1420                 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1421                 printk("%s: ", dev->name);
1422                 switch (dev->if_port & 0x0c) {
1423                         case 12:
1424                                 /* force full-duplex mode if 3c5x9b */
1425                                 if (sw_info & 0x000f) {
1426                                         printk("Forcing 3c5x9b full-duplex mode");
1427                                         break;
1428                                 }
1429                         case 8:
1430                                 /* set full-duplex mode based on eeprom config setting */
1431                                 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1432                                         printk("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1433                                         break;
1434                                 }
1435                         default:
1436                                 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1437                                 printk("Setting 3c5x9/3c5x9B half-duplex mode");
1438                                 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1439                 }
1440
1441                 outw(net_diag, ioaddr + WN4_NETDIAG);
1442                 printk(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1443                 if (el3_debug > 3)
1444                         printk("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1445                 /* Enable link beat and jabber check. */
1446                 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1447         }
1448
1449         /* Switch to the stats window, and clear all stats by reading. */
1450         outw(StatsDisable, ioaddr + EL3_CMD);
1451         EL3WINDOW(6);
1452         for (i = 0; i < 9; i++)
1453                 inb(ioaddr + i);
1454         inw(ioaddr + 10);
1455         inw(ioaddr + 12);
1456
1457         /* Switch to register set 1 for normal use. */
1458         EL3WINDOW(1);
1459
1460         /* Accept b-case and phys addr only. */
1461         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1462         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1463
1464         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1465         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1466         /* Allow status bits to be seen. */
1467         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1468         /* Ack all pending events, and set active indicator mask. */
1469         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1470                  ioaddr + EL3_CMD);
1471         outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1472                  ioaddr + EL3_CMD);
1473
1474         netif_start_queue(dev);
1475 }
1476
1477 /* Power Management support functions */
1478 #ifdef EL3_SUSPEND
1479
1480 static int
1481 el3_suspend(struct device *pdev, pm_message_t state)
1482 {
1483         unsigned long flags;
1484         struct net_device *dev;
1485         struct el3_private *lp;
1486         int ioaddr;
1487
1488         dev = pdev->driver_data;
1489         lp = netdev_priv(dev);
1490         ioaddr = dev->base_addr;
1491
1492         spin_lock_irqsave(&lp->lock, flags);
1493
1494         if (netif_running(dev))
1495                 netif_device_detach(dev);
1496
1497         el3_down(dev);
1498         outw(PowerDown, ioaddr + EL3_CMD);
1499
1500         spin_unlock_irqrestore(&lp->lock, flags);
1501         return 0;
1502 }
1503
1504 static int
1505 el3_resume(struct device *pdev)
1506 {
1507         unsigned long flags;
1508         struct net_device *dev;
1509         struct el3_private *lp;
1510         int ioaddr;
1511
1512         dev = pdev->driver_data;
1513         lp = netdev_priv(dev);
1514         ioaddr = dev->base_addr;
1515
1516         spin_lock_irqsave(&lp->lock, flags);
1517
1518         outw(PowerUp, ioaddr + EL3_CMD);
1519         el3_up(dev);
1520
1521         if (netif_running(dev))
1522                 netif_device_attach(dev);
1523
1524         spin_unlock_irqrestore(&lp->lock, flags);
1525         return 0;
1526 }
1527
1528 #endif /* EL3_SUSPEND */
1529
1530 /* Parameters that may be passed into the module. */
1531 static int debug = -1;
1532 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
1533 static int xcvr[] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1534
1535 module_param(debug,int, 0);
1536 module_param_array(irq, int, NULL, 0);
1537 module_param_array(xcvr, int, NULL, 0);
1538 module_param(max_interrupt_work, int, 0);
1539 MODULE_PARM_DESC(debug, "debug level (0-6)");
1540 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1541 MODULE_PARM_DESC(xcvr,"transceiver(s) (0=internal, 1=external)");
1542 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1543 #if defined(__ISAPNP__)
1544 module_param(nopnp, int, 0);
1545 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1546 MODULE_DEVICE_TABLE(isapnp, el3_isapnp_adapters);
1547 #endif  /* __ISAPNP__ */
1548 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B) ISA/PnP ethernet driver");
1549 MODULE_LICENSE("GPL");
1550
1551 static int __init el3_init_module(void)
1552 {
1553         int ret = 0;
1554         el3_cards = 0;
1555
1556         if (debug >= 0)
1557                 el3_debug = debug;
1558
1559         el3_root_dev = NULL;
1560         while (el3_probe(el3_cards) == 0) {
1561                 if (irq[el3_cards] > 1)
1562                         el3_root_dev->irq = irq[el3_cards];
1563                 if (xcvr[el3_cards] >= 0)
1564                         el3_root_dev->if_port = xcvr[el3_cards];
1565                 el3_cards++;
1566         }
1567
1568 #ifdef CONFIG_EISA
1569         ret = eisa_driver_register(&el3_eisa_driver);
1570 #endif
1571 #ifdef CONFIG_MCA
1572         {
1573                 int err = mca_register_driver(&el3_mca_driver);
1574                 if (ret == 0)
1575                         ret = err;
1576         }
1577 #endif
1578         return ret;
1579 }
1580
1581 static void __exit el3_cleanup_module(void)
1582 {
1583         struct net_device *next_dev;
1584
1585         while (el3_root_dev) {
1586                 struct el3_private *lp = netdev_priv(el3_root_dev);
1587
1588                 next_dev = lp->next_dev;
1589                 el3_common_remove (el3_root_dev);
1590                 el3_root_dev = next_dev;
1591         }
1592
1593 #ifdef CONFIG_EISA
1594         eisa_driver_unregister (&el3_eisa_driver);
1595 #endif
1596 #ifdef CONFIG_MCA
1597         mca_unregister_driver(&el3_mca_driver);
1598 #endif
1599 }
1600
1601 module_init (el3_init_module);
1602 module_exit (el3_cleanup_module);
1603