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