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