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