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