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