err.no Git - linux-2.6/blob - drivers/net/3c509.c

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