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