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

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