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