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