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