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