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