Pileus Git - ~andy/linux/blob - drivers/net/ethernet/3com/3c509.c

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