drivers/net/ethernet/3com/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
  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
  95 static char version[] = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
  96
  97 #ifdef EL3_DEBUG
  98 static int el3_debug = EL3_DEBUG;
  99 #else
 100 static 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 */
 106 static 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. */
 125 enum 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
 135 enum 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: */
 141 enum 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
 165 enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_EISA };
 166
 167 struct 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 };
 174 static int id_port;
 175 static int current_tag;
 176 static struct net_device *el3_devs[EL3_MAX_CARDS];
 177
 178 /* Parameters that may be passed into the module. */
 179 static int debug = -1;
 180 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
 181 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
 182 static int max_interrupt_work = 10;
 183 #ifdef CONFIG_PNP
 184 static int nopnp;
 185 #endif
 186
 187 static int el3_common_init(struct net_device *dev);
 188 static void el3_common_remove(struct net_device *dev);
 189 static ushort id_read_eeprom(int index);
 190 static ushort read_eeprom(int ioaddr, int index);
 191 static int el3_open(struct net_device *dev);
 192 static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
 193 static irqreturn_t el3_interrupt(int irq, void *dev_id);
 194 static void update_stats(struct net_device *dev);
 195 static struct net_device_stats *el3_get_stats(struct net_device *dev);
 196 static int el3_rx(struct net_device *dev);
 197 static int el3_close(struct net_device *dev);
 198 static void set_multicast_list(struct net_device *dev);
 199 static void el3_tx_timeout (struct net_device *dev);
 200 static void el3_down(struct net_device *dev);
 201 static void el3_up(struct net_device *dev);
 202 static const struct ethtool_ops ethtool_ops;
 203 #ifdef CONFIG_PM
 204 static int el3_suspend(struct device *, pm_message_t);
 205 static 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 */
 213 static int el3_device_remove (struct device *device);
 214 #ifdef CONFIG_NET_POLL_CONTROLLER
 215 static 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 */
 219 static 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                             !memcmp(phys_addr, el3_devs[i]->dev_addr,
 256                                     ETH_ALEN)) {
 257                                 if (el3_debug > 3)
 258                                         pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
 259                                                 phys_addr[0] & 0xff, phys_addr[0] >> 8,
 260                                                 phys_addr[1] & 0xff, phys_addr[1] >> 8,
 261                                                 phys_addr[2] & 0xff, phys_addr[2] >> 8);
 262                                 /* Set the adaptor tag so that the next card can be found. */
 263                                 outb(0xd0 + ++current_tag, id_port);
 264                                 return 2;
 265                         }
 266                 }
 267         }
 268 #endif /* CONFIG_PNP */
 269         return 0;
 270
 271 }
 272
 273 static void el3_dev_fill(struct net_device *dev, __be16 *phys_addr, int ioaddr,
 274                          int irq, int if_port, enum el3_cardtype type)
 275 {
 276         struct el3_private *lp = netdev_priv(dev);
 277
 278         memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
 279         dev->base_addr = ioaddr;
 280         dev->irq = irq;
 281         dev->if_port = if_port;
 282         lp->type = type;
 283 }
 284
 285 static int el3_isa_match(struct device *pdev, unsigned int ndev)
 286 {
 287         struct net_device *dev;
 288         int ioaddr, isa_irq, if_port, err;
 289         unsigned int iobase;
 290         __be16 phys_addr[3];
 291
 292         while ((err = el3_isa_id_sequence(phys_addr)) == 2)
 293                 ;       /* Skip to next card when PnP card found */
 294         if (err == 1)
 295                 return 0;
 296
 297         iobase = id_read_eeprom(8);
 298         if_port = iobase >> 14;
 299         ioaddr = 0x200 + ((iobase & 0x1f) << 4);
 300         if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
 301                 isa_irq = irq[el3_cards];
 302         else
 303                 isa_irq = id_read_eeprom(9) >> 12;
 304
 305         dev = alloc_etherdev(sizeof(struct el3_private));
 306         if (!dev)
 307                 return -ENOMEM;
 308
 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
 342 static 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
 351 static 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
 358 static 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
 381 static 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 };
 392 static int isa_registered;
 393
 394 #ifdef CONFIG_PNP
 395 static 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 };
 405 MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
 406
 407 static 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
 445 static 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
 452 static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
 453 {
 454         return el3_suspend(&pdev->dev, state);
 455 }
 456
 457 static int el3_pnp_resume(struct pnp_dev *pdev)
 458 {
 459         return el3_resume(&pdev->dev);
 460 }
 461 #endif
 462
 463 static 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 };
 473 static int pnp_registered;
 474 #endif /* CONFIG_PNP */
 475
 476 #ifdef CONFIG_EISA
 477 static struct eisa_device_id el3_eisa_ids[] = {
 478                 { "TCM5090" },
 479                 { "TCM5091" },
 480                 { "TCM5092" },
 481                 { "TCM5093" },
 482                 { "TCM5094" },
 483                 { "TCM5095" },
 484                 { "TCM5098" },
 485                 { "" }
 486 };
 487 MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
 488
 489 static int el3_eisa_probe (struct device *device);
 490
 491 static 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 };
 501 static int eisa_registered;
 502 #endif
 503
 504 static 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
 519 static 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         SET_ETHTOOL_OPS(dev, &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
 557 static 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
 565 static 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         netdev_boot_setup_check(dev);
 599
 600         el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
 601         eisa_set_drvdata (edev, dev);
 602         err = el3_common_init(dev);
 603
 604         if (err) {
 605                 eisa_set_drvdata (edev, NULL);
 606                 free_netdev(dev);
 607                 return err;
 608         }
 609
 610         el3_devs[el3_cards++] = dev;
 611         return 0;
 612 }
 613 #endif
 614
 615 /* This remove works for all device types.
 616  *
 617  * The net dev must be stored in the driver data field */
 618 static int el3_device_remove(struct device *device)
 619 {
 620         struct net_device *dev;
 621
 622         dev = dev_get_drvdata(device);
 623
 624         el3_common_remove (dev);
 625         return 0;
 626 }
 627
 628 /* Read a word from the EEPROM using the regular EEPROM access register.
 629    Assume that we are in register window zero.
 630  */
 631 static ushort read_eeprom(int ioaddr, int index)
 632 {
 633         outw(EEPROM_READ + index, ioaddr + 10);
 634         /* Pause for at least 162 us. for the read to take place.
 635            Some chips seem to require much longer */
 636         mdelay(2);
 637         return inw(ioaddr + 12);
 638 }
 639
 640 /* Read a word from the EEPROM when in the ISA ID probe state. */
 641 static ushort id_read_eeprom(int index)
 642 {
 643         int bit, word = 0;
 644
 645         /* Issue read command, and pause for at least 162 us. for it to complete.
 646            Assume extra-fast 16Mhz bus. */
 647         outb(EEPROM_READ + index, id_port);
 648
 649         /* Pause for at least 162 us. for the read to take place. */
 650         /* Some chips seem to require much longer */
 651         mdelay(4);
 652
 653         for (bit = 15; bit >= 0; bit--)
 654                 word = (word << 1) + (inb(id_port) & 0x01);
 655
 656         if (el3_debug > 3)
 657                 pr_debug("  3c509 EEPROM word %d %#4.4x.\n", index, word);
 658
 659         return word;
 660 }
 661
 662
 663 static int
 664 el3_open(struct net_device *dev)
 665 {
 666         int ioaddr = dev->base_addr;
 667         int i;
 668
 669         outw(TxReset, ioaddr + EL3_CMD);
 670         outw(RxReset, ioaddr + EL3_CMD);
 671         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 672
 673         i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
 674         if (i)
 675                 return i;
 676
 677         EL3WINDOW(0);
 678         if (el3_debug > 3)
 679                 pr_debug("%s: Opening, IRQ %d    status@%x %4.4x.\n", dev->name,
 680                            dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
 681
 682         el3_up(dev);
 683
 684         if (el3_debug > 3)
 685                 pr_debug("%s: Opened 3c509  IRQ %d  status %4.4x.\n",
 686                            dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
 687
 688         return 0;
 689 }
 690
 691 static void
 692 el3_tx_timeout (struct net_device *dev)
 693 {
 694         int ioaddr = dev->base_addr;
 695
 696         /* Transmitter timeout, serious problems. */
 697         pr_warning("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d.\n",
 698                    dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
 699                    inw(ioaddr + TX_FREE));
 700         dev->stats.tx_errors++;
 701         dev->trans_start = jiffies; /* prevent tx timeout */
 702         /* Issue TX_RESET and TX_START commands. */
 703         outw(TxReset, ioaddr + EL3_CMD);
 704         outw(TxEnable, ioaddr + EL3_CMD);
 705         netif_wake_queue(dev);
 706 }
 707
 708
 709 static netdev_tx_t
 710 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 711 {
 712         struct el3_private *lp = netdev_priv(dev);
 713         int ioaddr = dev->base_addr;
 714         unsigned long flags;
 715
 716         netif_stop_queue (dev);
 717
 718         dev->stats.tx_bytes += skb->len;
 719
 720         if (el3_debug > 4) {
 721                 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
 722                            dev->name, skb->len, inw(ioaddr + EL3_STATUS));
 723         }
 724 #if 0
 725 #ifndef final_version
 726         {       /* Error-checking code, delete someday. */
 727                 ushort status = inw(ioaddr + EL3_STATUS);
 728                 if (status & 0x0001 &&          /* IRQ line active, missed one. */
 729                     inw(ioaddr + EL3_STATUS) & 1) {                     /* Make sure. */
 730                         pr_debug("%s: Missed interrupt, status then %04x now %04x"
 731                                    "  Tx %2.2x Rx %4.4x.\n", dev->name, status,
 732                                    inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
 733                                    inw(ioaddr + RX_STATUS));
 734                         /* Fake interrupt trigger by masking, acknowledge interrupts. */
 735                         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 736                         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 737                                  ioaddr + EL3_CMD);
 738                         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
 739                 }
 740         }
 741 #endif
 742 #endif
 743         /*
 744          *      We lock the driver against other processors. Note
 745          *      we don't need to lock versus the IRQ as we suspended
 746          *      that. This means that we lose the ability to take
 747          *      an RX during a TX upload. That sucks a bit with SMP
 748          *      on an original 3c509 (2K buffer)
 749          *
 750          *      Using disable_irq stops us crapping on other
 751          *      time sensitive devices.
 752          */
 753
 754         spin_lock_irqsave(&lp->lock, flags);
 755
 756         /* Put out the doubleword header... */
 757         outw(skb->len, ioaddr + TX_FIFO);
 758         outw(0x00, ioaddr + TX_FIFO);
 759         /* ... and the packet rounded to a doubleword. */
 760         outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 761
 762         if (inw(ioaddr + TX_FREE) > 1536)
 763                 netif_start_queue(dev);
 764         else
 765                 /* Interrupt us when the FIFO has room for max-sized packet. */
 766                 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
 767
 768         spin_unlock_irqrestore(&lp->lock, flags);
 769
 770         dev_kfree_skb (skb);
 771
 772         /* Clear the Tx status stack. */
 773         {
 774                 short tx_status;
 775                 int i = 4;
 776
 777                 while (--i > 0  &&      (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 778                         if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
 779                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 780                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 781                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 782                 }
 783         }
 784         return NETDEV_TX_OK;
 785 }
 786
 787 /* The EL3 interrupt handler. */
 788 static irqreturn_t
 789 el3_interrupt(int irq, void *dev_id)
 790 {
 791         struct net_device *dev = dev_id;
 792         struct el3_private *lp;
 793         int ioaddr, status;
 794         int i = max_interrupt_work;
 795
 796         lp = netdev_priv(dev);
 797         spin_lock(&lp->lock);
 798
 799         ioaddr = dev->base_addr;
 800
 801         if (el3_debug > 4) {
 802                 status = inw(ioaddr + EL3_STATUS);
 803                 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
 804         }
 805
 806         while ((status = inw(ioaddr + EL3_STATUS)) &
 807                    (IntLatch | RxComplete | StatsFull)) {
 808
 809                 if (status & RxComplete)
 810                         el3_rx(dev);
 811
 812                 if (status & TxAvailable) {
 813                         if (el3_debug > 5)
 814                                 pr_debug("      TX room bit was handled.\n");
 815                         /* There's room in the FIFO for a full-sized packet. */
 816                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 817                         netif_wake_queue (dev);
 818                 }
 819                 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
 820                         /* Handle all uncommon interrupts. */
 821                         if (status & StatsFull)                         /* Empty statistics. */
 822                                 update_stats(dev);
 823                         if (status & RxEarly) {                         /* Rx early is unused. */
 824                                 el3_rx(dev);
 825                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 826                         }
 827                         if (status & TxComplete) {                      /* Really Tx error. */
 828                                 short tx_status;
 829                                 int i = 4;
 830
 831                                 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 832                                         if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
 833                                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 834                                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 835                                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 836                                 }
 837                         }
 838                         if (status & AdapterFailure) {
 839                                 /* Adapter failure requires Rx reset and reinit. */
 840                                 outw(RxReset, ioaddr + EL3_CMD);
 841                                 /* Set the Rx filter to the current state. */
 842                                 outw(SetRxFilter | RxStation | RxBroadcast
 843                                          | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
 844                                          | (dev->flags & IFF_PROMISC ? RxProm : 0),
 845                                          ioaddr + EL3_CMD);
 846                                 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
 847                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 848                         }
 849                 }
 850
 851                 if (--i < 0) {
 852                         pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
 853                                    dev->name, status);
 854                         /* Clear all interrupts. */
 855                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 856                         break;
 857                 }
 858                 /* Acknowledge the IRQ. */
 859                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
 860         }
 861
 862         if (el3_debug > 4) {
 863                 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
 864                            inw(ioaddr + EL3_STATUS));
 865         }
 866         spin_unlock(&lp->lock);
 867         return IRQ_HANDLED;
 868 }
 869
 870
 871 #ifdef CONFIG_NET_POLL_CONTROLLER
 872 /*
 873  * Polling receive - used by netconsole and other diagnostic tools
 874  * to allow network i/o with interrupts disabled.
 875  */
 876 static void el3_poll_controller(struct net_device *dev)
 877 {
 878         disable_irq(dev->irq);
 879         el3_interrupt(dev->irq, dev);
 880         enable_irq(dev->irq);
 881 }
 882 #endif
 883
 884 static struct net_device_stats *
 885 el3_get_stats(struct net_device *dev)
 886 {
 887         struct el3_private *lp = netdev_priv(dev);
 888         unsigned long flags;
 889
 890         /*
 891          *      This is fast enough not to bother with disable IRQ
 892          *      stuff.
 893          */
 894
 895         spin_lock_irqsave(&lp->lock, flags);
 896         update_stats(dev);
 897         spin_unlock_irqrestore(&lp->lock, flags);
 898         return &dev->stats;
 899 }
 900
 901 /*  Update statistics.  We change to register window 6, so this should be run
 902         single-threaded if the device is active. This is expected to be a rare
 903         operation, and it's simpler for the rest of the driver to assume that
 904         window 1 is always valid rather than use a special window-state variable.
 905         */
 906 static void update_stats(struct net_device *dev)
 907 {
 908         int ioaddr = dev->base_addr;
 909
 910         if (el3_debug > 5)
 911                 pr_debug("   Updating the statistics.\n");
 912         /* Turn off statistics updates while reading. */
 913         outw(StatsDisable, ioaddr + EL3_CMD);
 914         /* Switch to the stats window, and read everything. */
 915         EL3WINDOW(6);
 916         dev->stats.tx_carrier_errors    += inb(ioaddr + 0);
 917         dev->stats.tx_heartbeat_errors  += inb(ioaddr + 1);
 918         /* Multiple collisions. */         inb(ioaddr + 2);
 919         dev->stats.collisions           += inb(ioaddr + 3);
 920         dev->stats.tx_window_errors     += inb(ioaddr + 4);
 921         dev->stats.rx_fifo_errors       += inb(ioaddr + 5);
 922         dev->stats.tx_packets           += inb(ioaddr + 6);
 923         /* Rx packets   */                 inb(ioaddr + 7);
 924         /* Tx deferrals */                 inb(ioaddr + 8);
 925         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
 926         inw(ioaddr + 12);
 927
 928         /* Back to window 1, and turn statistics back on. */
 929         EL3WINDOW(1);
 930         outw(StatsEnable, ioaddr + EL3_CMD);
 931 }
 932
 933 static int
 934 el3_rx(struct net_device *dev)
 935 {
 936         int ioaddr = dev->base_addr;
 937         short rx_status;
 938
 939         if (el3_debug > 5)
 940                 pr_debug("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
 941                            inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
 942         while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
 943                 if (rx_status & 0x4000) { /* Error, update stats. */
 944                         short error = rx_status & 0x3800;
 945
 946                         outw(RxDiscard, ioaddr + EL3_CMD);
 947                         dev->stats.rx_errors++;
 948                         switch (error) {
 949                         case 0x0000:            dev->stats.rx_over_errors++; break;
 950                         case 0x0800:            dev->stats.rx_length_errors++; break;
 951                         case 0x1000:            dev->stats.rx_frame_errors++; break;
 952                         case 0x1800:            dev->stats.rx_length_errors++; break;
 953                         case 0x2000:            dev->stats.rx_frame_errors++; break;
 954                         case 0x2800:            dev->stats.rx_crc_errors++; break;
 955                         }
 956                 } else {
 957                         short pkt_len = rx_status & 0x7ff;
 958                         struct sk_buff *skb;
 959
 960                         skb = netdev_alloc_skb(dev, pkt_len + 5);
 961                         if (el3_debug > 4)
 962                                 pr_debug("Receiving packet size %d status %4.4x.\n",
 963                                            pkt_len, rx_status);
 964                         if (skb != NULL) {
 965                                 skb_reserve(skb, 2);     /* Align IP on 16 byte */
 966
 967                                 /* 'skb->data' points to the start of sk_buff data area. */
 968                                 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
 969                                          (pkt_len + 3) >> 2);
 970
 971                                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
 972                                 skb->protocol = eth_type_trans(skb,dev);
 973                                 netif_rx(skb);
 974                                 dev->stats.rx_bytes += pkt_len;
 975                                 dev->stats.rx_packets++;
 976                                 continue;
 977                         }
 978                         outw(RxDiscard, ioaddr + EL3_CMD);
 979                         dev->stats.rx_dropped++;
 980                         if (el3_debug)
 981                                 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
 982                                            dev->name, pkt_len);
 983                 }
 984                 inw(ioaddr + EL3_STATUS);                               /* Delay. */
 985                 while (inw(ioaddr + EL3_STATUS) & 0x1000)
 986                         pr_debug("      Waiting for 3c509 to discard packet, status %x.\n",
 987                                    inw(ioaddr + EL3_STATUS) );
 988         }
 989
 990         return 0;
 991 }
 992
 993 /*
 994  *     Set or clear the multicast filter for this adaptor.
 995  */
 996 static void
 997 set_multicast_list(struct net_device *dev)
 998 {
 999         unsigned long flags;
1000         struct el3_private *lp = netdev_priv(dev);
1001         int ioaddr = dev->base_addr;
1002         int mc_count = netdev_mc_count(dev);
1003
1004         if (el3_debug > 1) {
1005                 static int old;
1006                 if (old != mc_count) {
1007                         old = mc_count;
1008                         pr_debug("%s: Setting Rx mode to %d addresses.\n",
1009                                  dev->name, mc_count);
1010                 }
1011         }
1012         spin_lock_irqsave(&lp->lock, flags);
1013         if (dev->flags&IFF_PROMISC) {
1014                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1015                          ioaddr + EL3_CMD);
1016         }
1017         else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
1018                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1019         }
1020         else
1021                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1022         spin_unlock_irqrestore(&lp->lock, flags);
1023 }
1024
1025 static int
1026 el3_close(struct net_device *dev)
1027 {
1028         int ioaddr = dev->base_addr;
1029         struct el3_private *lp = netdev_priv(dev);
1030
1031         if (el3_debug > 2)
1032                 pr_debug("%s: Shutting down ethercard.\n", dev->name);
1033
1034         el3_down(dev);
1035
1036         free_irq(dev->irq, dev);
1037         /* Switching back to window 0 disables the IRQ. */
1038         EL3WINDOW(0);
1039         if (lp->type != EL3_EISA) {
1040                 /* But we explicitly zero the IRQ line select anyway. Don't do
1041                  * it on EISA cards, it prevents the module from getting an
1042                  * IRQ after unload+reload... */
1043                 outw(0x0f00, ioaddr + WN0_IRQ);
1044         }
1045
1046         return 0;
1047 }
1048
1049 static int
1050 el3_link_ok(struct net_device *dev)
1051 {
1052         int ioaddr = dev->base_addr;
1053         u16 tmp;
1054
1055         EL3WINDOW(4);
1056         tmp = inw(ioaddr + WN4_MEDIA);
1057         EL3WINDOW(1);
1058         return tmp & (1<<11);
1059 }
1060
1061 static int
1062 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1063 {
1064         u16 tmp;
1065         int ioaddr = dev->base_addr;
1066
1067         EL3WINDOW(0);
1068         /* obtain current transceiver via WN4_MEDIA? */
1069         tmp = inw(ioaddr + WN0_ADDR_CONF);
1070         ecmd->transceiver = XCVR_INTERNAL;
1071         switch (tmp >> 14) {
1072         case 0:
1073                 ecmd->port = PORT_TP;
1074                 break;
1075         case 1:
1076                 ecmd->port = PORT_AUI;
1077                 ecmd->transceiver = XCVR_EXTERNAL;
1078                 break;
1079         case 3:
1080                 ecmd->port = PORT_BNC;
1081         default:
1082                 break;
1083         }
1084
1085         ecmd->duplex = DUPLEX_HALF;
1086         ecmd->supported = 0;
1087         tmp = inw(ioaddr + WN0_CONF_CTRL);
1088         if (tmp & (1<<13))
1089                 ecmd->supported |= SUPPORTED_AUI;
1090         if (tmp & (1<<12))
1091                 ecmd->supported |= SUPPORTED_BNC;
1092         if (tmp & (1<<9)) {
1093                 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1094                                 SUPPORTED_10baseT_Full; /* hmm... */
1095                 EL3WINDOW(4);
1096                 tmp = inw(ioaddr + WN4_NETDIAG);
1097                 if (tmp & FD_ENABLE)
1098                         ecmd->duplex = DUPLEX_FULL;
1099         }
1100
1101         ethtool_cmd_speed_set(ecmd, SPEED_10);
1102         EL3WINDOW(1);
1103         return 0;
1104 }
1105
1106 static int
1107 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1108 {
1109         u16 tmp;
1110         int ioaddr = dev->base_addr;
1111
1112         if (ecmd->speed != SPEED_10)
1113                 return -EINVAL;
1114         if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1115                 return -EINVAL;
1116         if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1117                 return -EINVAL;
1118
1119         /* change XCVR type */
1120         EL3WINDOW(0);
1121         tmp = inw(ioaddr + WN0_ADDR_CONF);
1122         switch (ecmd->port) {
1123         case PORT_TP:
1124                 tmp &= ~(3<<14);
1125                 dev->if_port = 0;
1126                 break;
1127         case PORT_AUI:
1128                 tmp |= (1<<14);
1129                 dev->if_port = 1;
1130                 break;
1131         case PORT_BNC:
1132                 tmp |= (3<<14);
1133                 dev->if_port = 3;
1134                 break;
1135         default:
1136                 return -EINVAL;
1137         }
1138
1139         outw(tmp, ioaddr + WN0_ADDR_CONF);
1140         if (dev->if_port == 3) {
1141                 /* fire up the DC-DC convertor if BNC gets enabled */
1142                 tmp = inw(ioaddr + WN0_ADDR_CONF);
1143                 if (tmp & (3 << 14)) {
1144                         outw(StartCoax, ioaddr + EL3_CMD);
1145                         udelay(800);
1146                 } else
1147                         return -EIO;
1148         }
1149
1150         EL3WINDOW(4);
1151         tmp = inw(ioaddr + WN4_NETDIAG);
1152         if (ecmd->duplex == DUPLEX_FULL)
1153                 tmp |= FD_ENABLE;
1154         else
1155                 tmp &= ~FD_ENABLE;
1156         outw(tmp, ioaddr + WN4_NETDIAG);
1157         EL3WINDOW(1);
1158
1159         return 0;
1160 }
1161
1162 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1163 {
1164         strcpy(info->driver, DRV_NAME);
1165         strcpy(info->version, DRV_VERSION);
1166 }
1167
1168 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1169 {
1170         struct el3_private *lp = netdev_priv(dev);
1171         int ret;
1172
1173         spin_lock_irq(&lp->lock);
1174         ret = el3_netdev_get_ecmd(dev, ecmd);
1175         spin_unlock_irq(&lp->lock);
1176         return ret;
1177 }
1178
1179 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1180 {
1181         struct el3_private *lp = netdev_priv(dev);
1182         int ret;
1183
1184         spin_lock_irq(&lp->lock);
1185         ret = el3_netdev_set_ecmd(dev, ecmd);
1186         spin_unlock_irq(&lp->lock);
1187         return ret;
1188 }
1189
1190 static u32 el3_get_link(struct net_device *dev)
1191 {
1192         struct el3_private *lp = netdev_priv(dev);
1193         u32 ret;
1194
1195         spin_lock_irq(&lp->lock);
1196         ret = el3_link_ok(dev);
1197         spin_unlock_irq(&lp->lock);
1198         return ret;
1199 }
1200
1201 static u32 el3_get_msglevel(struct net_device *dev)
1202 {
1203         return el3_debug;
1204 }
1205
1206 static void el3_set_msglevel(struct net_device *dev, u32 v)
1207 {
1208         el3_debug = v;
1209 }
1210
1211 static const struct ethtool_ops ethtool_ops = {
1212         .get_drvinfo = el3_get_drvinfo,
1213         .get_settings = el3_get_settings,
1214         .set_settings = el3_set_settings,
1215         .get_link = el3_get_link,
1216         .get_msglevel = el3_get_msglevel,
1217         .set_msglevel = el3_set_msglevel,
1218 };
1219
1220 static void
1221 el3_down(struct net_device *dev)
1222 {
1223         int ioaddr = dev->base_addr;
1224
1225         netif_stop_queue(dev);
1226
1227         /* Turn off statistics ASAP.  We update lp->stats below. */
1228         outw(StatsDisable, ioaddr + EL3_CMD);
1229
1230         /* Disable the receiver and transmitter. */
1231         outw(RxDisable, ioaddr + EL3_CMD);
1232         outw(TxDisable, ioaddr + EL3_CMD);
1233
1234         if (dev->if_port == 3)
1235                 /* Turn off thinnet power.  Green! */
1236                 outw(StopCoax, ioaddr + EL3_CMD);
1237         else if (dev->if_port == 0) {
1238                 /* Disable link beat and jabber, if_port may change here next open(). */
1239                 EL3WINDOW(4);
1240                 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1241         }
1242
1243         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1244
1245         update_stats(dev);
1246 }
1247
1248 static void
1249 el3_up(struct net_device *dev)
1250 {
1251         int i, sw_info, net_diag;
1252         int ioaddr = dev->base_addr;
1253
1254         /* Activating the board required and does no harm otherwise */
1255         outw(0x0001, ioaddr + 4);
1256
1257         /* Set the IRQ line. */
1258         outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1259
1260         /* Set the station address in window 2 each time opened. */
1261         EL3WINDOW(2);
1262
1263         for (i = 0; i < 6; i++)
1264                 outb(dev->dev_addr[i], ioaddr + i);
1265
1266         if ((dev->if_port & 0x03) == 3) /* BNC interface */
1267                 /* Start the thinnet transceiver. We should really wait 50ms...*/
1268                 outw(StartCoax, ioaddr + EL3_CMD);
1269         else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1270                 /* Combine secondary sw_info word (the adapter level) and primary
1271                         sw_info word (duplex setting plus other useless bits) */
1272                 EL3WINDOW(0);
1273                 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1274                         (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1275
1276                 EL3WINDOW(4);
1277                 net_diag = inw(ioaddr + WN4_NETDIAG);
1278                 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1279                 pr_info("%s: ", dev->name);
1280                 switch (dev->if_port & 0x0c) {
1281                         case 12:
1282                                 /* force full-duplex mode if 3c5x9b */
1283                                 if (sw_info & 0x000f) {
1284                                         pr_cont("Forcing 3c5x9b full-duplex mode");
1285                                         break;
1286                                 }
1287                         case 8:
1288                                 /* set full-duplex mode based on eeprom config setting */
1289                                 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1290                                         pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1291                                         break;
1292                                 }
1293                         default:
1294                                 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1295                                 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1296                                 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1297                 }
1298
1299                 outw(net_diag, ioaddr + WN4_NETDIAG);
1300                 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1301                 if (el3_debug > 3)
1302                         pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1303                 /* Enable link beat and jabber check. */
1304                 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1305         }
1306
1307         /* Switch to the stats window, and clear all stats by reading. */
1308         outw(StatsDisable, ioaddr + EL3_CMD);
1309         EL3WINDOW(6);
1310         for (i = 0; i < 9; i++)
1311                 inb(ioaddr + i);
1312         inw(ioaddr + 10);
1313         inw(ioaddr + 12);
1314
1315         /* Switch to register set 1 for normal use. */
1316         EL3WINDOW(1);
1317
1318         /* Accept b-case and phys addr only. */
1319         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1320         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1321
1322         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1323         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1324         /* Allow status bits to be seen. */
1325         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1326         /* Ack all pending events, and set active indicator mask. */
1327         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1328                  ioaddr + EL3_CMD);
1329         outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1330                  ioaddr + EL3_CMD);
1331
1332         netif_start_queue(dev);
1333 }
1334
1335 /* Power Management support functions */
1336 #ifdef CONFIG_PM
1337
1338 static int
1339 el3_suspend(struct device *pdev, pm_message_t state)
1340 {
1341         unsigned long flags;
1342         struct net_device *dev;
1343         struct el3_private *lp;
1344         int ioaddr;
1345
1346         dev = dev_get_drvdata(pdev);
1347         lp = netdev_priv(dev);
1348         ioaddr = dev->base_addr;
1349
1350         spin_lock_irqsave(&lp->lock, flags);
1351
1352         if (netif_running(dev))
1353                 netif_device_detach(dev);
1354
1355         el3_down(dev);
1356         outw(PowerDown, ioaddr + EL3_CMD);
1357
1358         spin_unlock_irqrestore(&lp->lock, flags);
1359         return 0;
1360 }
1361
1362 static int
1363 el3_resume(struct device *pdev)
1364 {
1365         unsigned long flags;
1366         struct net_device *dev;
1367         struct el3_private *lp;
1368         int ioaddr;
1369
1370         dev = dev_get_drvdata(pdev);
1371         lp = netdev_priv(dev);
1372         ioaddr = dev->base_addr;
1373
1374         spin_lock_irqsave(&lp->lock, flags);
1375
1376         outw(PowerUp, ioaddr + EL3_CMD);
1377         EL3WINDOW(0);
1378         el3_up(dev);
1379
1380         if (netif_running(dev))
1381                 netif_device_attach(dev);
1382
1383         spin_unlock_irqrestore(&lp->lock, flags);
1384         return 0;
1385 }
1386
1387 #endif /* CONFIG_PM */
1388
1389 module_param(debug,int, 0);
1390 module_param_array(irq, int, NULL, 0);
1391 module_param(max_interrupt_work, int, 0);
1392 MODULE_PARM_DESC(debug, "debug level (0-6)");
1393 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1394 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1395 #ifdef CONFIG_PNP
1396 module_param(nopnp, int, 0);
1397 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1398 #endif  /* CONFIG_PNP */
1399 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1400 MODULE_LICENSE("GPL");
1401
1402 static int __init el3_init_module(void)
1403 {
1404         int ret = 0;
1405
1406         if (debug >= 0)
1407                 el3_debug = debug;
1408
1409 #ifdef CONFIG_PNP
1410         if (!nopnp) {
1411                 ret = pnp_register_driver(&el3_pnp_driver);
1412                 if (!ret)
1413                         pnp_registered = 1;
1414         }
1415 #endif
1416         /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1417         /* Start with 0x110 to avoid some sound cards.*/
1418         for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1419                 if (!request_region(id_port, 1, "3c509-control"))
1420                         continue;
1421                 outb(0x00, id_port);
1422                 outb(0xff, id_port);
1423                 if (inb(id_port) & 0x01)
1424                         break;
1425                 else
1426                         release_region(id_port, 1);
1427         }
1428         if (id_port >= 0x200) {
1429                 id_port = 0;
1430                 pr_err("No I/O port available for 3c509 activation.\n");
1431         } else {
1432                 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1433                 if (!ret)
1434                         isa_registered = 1;
1435         }
1436 #ifdef CONFIG_EISA
1437         ret = eisa_driver_register(&el3_eisa_driver);
1438         if (!ret)
1439                 eisa_registered = 1;
1440 #endif
1441
1442 #ifdef CONFIG_PNP
1443         if (pnp_registered)
1444                 ret = 0;
1445 #endif
1446         if (isa_registered)
1447                 ret = 0;
1448 #ifdef CONFIG_EISA
1449         if (eisa_registered)
1450                 ret = 0;
1451 #endif
1452         return ret;
1453 }
1454
1455 static void __exit el3_cleanup_module(void)
1456 {
1457 #ifdef CONFIG_PNP
1458         if (pnp_registered)
1459                 pnp_unregister_driver(&el3_pnp_driver);
1460 #endif
1461         if (isa_registered)
1462                 isa_unregister_driver(&el3_isa_driver);
1463         if (id_port)
1464                 release_region(id_port, 1);
1465 #ifdef CONFIG_EISA
1466         if (eisa_registered)
1467                 eisa_driver_unregister(&el3_eisa_driver);
1468 #endif
1469 }
1470
1471 module_init (el3_init_module);
1472 module_exit (el3_cleanup_module);