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