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