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