SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/3c509.c

   1 /* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
   2 /*
   3         Written 1993-2000 by Donald Becker.
   4
   5         Copyright 1994-2000 by Donald Becker.
   6         Copyright 1993 United States Government as represented by the
   7         Director, National Security Agency.      This software may be used and
   8         distributed according to the terms of the GNU General Public License,
   9         incorporated herein by reference.
  10
  11         This driver is for the 3Com EtherLinkIII series.
  12
  13         The author may be reached as becker@scyld.com, or C/O
  14         Scyld Computing Corporation
  15         410 Severn Ave., Suite 210
  16         Annapolis MD 21403
  17
  18         Known limitations:
  19         Because of the way 3c509 ISA detection works it's difficult to predict
  20         a priori which of several ISA-mode cards will be detected first.
  21
  22         This driver does not use predictive interrupt mode, resulting in higher
  23         packet latency but lower overhead.  If interrupts are disabled for an
  24         unusually long time it could also result in missed packets, but in
  25         practice this rarely happens.
  26
  27
  28         FIXES:
  29                 Alan Cox:       Removed the 'Unexpected interrupt' bug.
  30                 Michael Meskes: Upgraded to Donald Becker's version 1.07.
  31                 Alan Cox:       Increased the eeprom delay. Regardless of
  32                                 what the docs say some people definitely
  33                                 get problems with lower (but in card spec)
  34                                 delays
  35                 v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
  36                                 other cleanups.  -djb
  37                 Andrea Arcangeli:       Upgraded to Donald Becker's version 1.12.
  38                 Rick Payne:     Fixed SMP race condition
  39                 v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
  40                 v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
  41                 v1.15 1/31/98 Faster recovery for Tx errors. -djb
  42                 v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
  43                 v1.18 12Mar2001 Andrew Morton
  44                         - Avoid bogus detect of 3c590's (Andrzej Krzysztofowicz)
  45                         - Reviewed against 1.18 from scyld.com
  46                 v1.18a 17Nov2001 Jeff Garzik <jgarzik@pobox.com>
  47                         - ethtool support
  48                 v1.18b 1Mar2002 Zwane Mwaikambo <zwane@commfireservices.com>
  49                         - Power Management support
  50                 v1.18c 1Mar2002 David Ruggiero <jdr@farfalle.com>
  51                         - Full duplex support
  52                 v1.19  16Oct2002 Zwane Mwaikambo <zwane@linuxpower.ca>
  53                         - Additional ethtool features
  54                 v1.19a 28Oct2002 Davud Ruggiero <jdr@farfalle.com>
  55                         - Increase *read_eeprom udelay to workaround oops with 2 cards.
  56                 v1.19b 08Nov2002 Marc Zyngier <maz@wild-wind.fr.eu.org>
  57                         - Introduce driver model for EISA cards.
  58                 v1.20  04Feb2008 Ondrej Zary <linux@rainbow-software.org>
  59                         - convert to isa_driver and pnp_driver and some cleanups
  60 */
  61
  62 #define DRV_NAME        "3c509"
  63 #define DRV_VERSION     "1.20"
  64 #define DRV_RELDATE     "04Feb2008"
  65
  66 /* A few values that may be tweaked. */
  67
  68 /* Time in jiffies before concluding the transmitter is hung. */
  69 #define TX_TIMEOUT  (400*HZ/1000)
  70
  71 #include <linux/module.h>
  72 #include <linux/mca.h>
  73 #include <linux/isa.h>
  74 #include <linux/pnp.h>
  75 #include <linux/string.h>
  76 #include <linux/interrupt.h>
  77 #include <linux/errno.h>
  78 #include <linux/in.h>
  79 #include <linux/ioport.h>
  80 #include <linux/init.h>
  81 #include <linux/netdevice.h>
  82 #include <linux/etherdevice.h>
  83 #include <linux/pm.h>
  84 #include <linux/skbuff.h>
  85 #include <linux/delay.h>        /* for udelay() */
  86 #include <linux/spinlock.h>
  87 #include <linux/ethtool.h>
  88 #include <linux/device.h>
  89 #include <linux/eisa.h>
  90 #include <linux/bitops.h>
  91
  92 #include <asm/uaccess.h>
  93 #include <asm/io.h>
  94 #include <asm/irq.h>
  95
  96 static char version[] __devinitdata = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n";
  97
  98 #ifdef EL3_DEBUG
  99 static int el3_debug = EL3_DEBUG;
 100 #else
 101 static int el3_debug = 2;
 102 #endif
 103
 104 /* Used to do a global count of all the cards in the system.  Must be
 105  * a global variable so that the mca/eisa probe routines can increment
 106  * it */
 107 static int el3_cards = 0;
 108 #define EL3_MAX_CARDS 8
 109
 110 /* To minimize the size of the driver source I only define operating
 111    constants if they are used several times.  You'll need the manual
 112    anyway if you want to understand driver details. */
 113 /* Offsets from base I/O address. */
 114 #define EL3_DATA 0x00
 115 #define EL3_CMD 0x0e
 116 #define EL3_STATUS 0x0e
 117 #define EEPROM_READ 0x80
 118
 119 #define EL3_IO_EXTENT   16
 120
 121 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
 122
 123
 124 /* The top five bits written to EL3_CMD are a command, the lower
 125    11 bits are the parameter, if applicable. */
 126 enum c509cmd {
 127         TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
 128         RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
 129         TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
 130         FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
 131         SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
 132         SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
 133         StatsDisable = 22<<11, StopCoax = 23<<11, PowerUp = 27<<11,
 134         PowerDown = 28<<11, PowerAuto = 29<<11};
 135
 136 enum c509status {
 137         IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
 138         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
 139         IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
 140
 141 /* The SetRxFilter command accepts the following classes: */
 142 enum RxFilter {
 143         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
 144
 145 /* Register window 1 offsets, the window used in normal operation. */
 146 #define TX_FIFO         0x00
 147 #define RX_FIFO         0x00
 148 #define RX_STATUS       0x08
 149 #define TX_STATUS       0x0B
 150 #define TX_FREE         0x0C            /* Remaining free bytes in Tx buffer. */
 151
 152 #define WN0_CONF_CTRL   0x04            /* Window 0: Configuration control register */
 153 #define WN0_ADDR_CONF   0x06            /* Window 0: Address configuration register */
 154 #define WN0_IRQ         0x08            /* Window 0: Set IRQ line in bits 12-15. */
 155 #define WN4_MEDIA       0x0A            /* Window 4: Various transcvr/media bits. */
 156 #define MEDIA_TP        0x00C0          /* Enable link beat and jabber for 10baseT. */
 157 #define WN4_NETDIAG     0x06            /* Window 4: Net diagnostic */
 158 #define FD_ENABLE       0x8000          /* Enable full-duplex ("external loopback") */
 159
 160 /*
 161  * Must be a power of two (we use a binary and in the
 162  * circular queue)
 163  */
 164 #define SKB_QUEUE_SIZE  64
 165
 166 enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_MCA, EL3_EISA };
 167
 168 struct el3_private {
 169         spinlock_t lock;
 170         /* skb send-queue */
 171         int head, size;
 172         struct sk_buff *queue[SKB_QUEUE_SIZE];
 173         enum el3_cardtype type;
 174 };
 175 static int id_port;
 176 static int current_tag;
 177 static struct net_device *el3_devs[EL3_MAX_CARDS];
 178
 179 /* Parameters that may be passed into the module. */
 180 static int debug = -1;
 181 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
 182 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
 183 static int max_interrupt_work = 10;
 184 #ifdef CONFIG_PNP
 185 static int nopnp;
 186 #endif
 187
 188 static int __devinit el3_common_init(struct net_device *dev);
 189 static void el3_common_remove(struct net_device *dev);
 190 static ushort id_read_eeprom(int index);
 191 static ushort read_eeprom(int ioaddr, int index);
 192 static int el3_open(struct net_device *dev);
 193 static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
 194 static irqreturn_t el3_interrupt(int irq, void *dev_id);
 195 static void update_stats(struct net_device *dev);
 196 static struct net_device_stats *el3_get_stats(struct net_device *dev);
 197 static int el3_rx(struct net_device *dev);
 198 static int el3_close(struct net_device *dev);
 199 static void set_multicast_list(struct net_device *dev);
 200 static void el3_tx_timeout (struct net_device *dev);
 201 static void el3_down(struct net_device *dev);
 202 static void el3_up(struct net_device *dev);
 203 static const struct ethtool_ops ethtool_ops;
 204 #ifdef CONFIG_PM
 205 static int el3_suspend(struct device *, pm_message_t);
 206 static int el3_resume(struct device *);
 207 #else
 208 #define el3_suspend NULL
 209 #define el3_resume NULL
 210 #endif
 211
 212
 213 /* generic device remove for all device types */
 214 static int el3_device_remove (struct device *device);
 215 #ifdef CONFIG_NET_POLL_CONTROLLER
 216 static void el3_poll_controller(struct net_device *dev);
 217 #endif
 218
 219 /* Return 0 on success, 1 on error, 2 when found already detected PnP card */
 220 static int el3_isa_id_sequence(__be16 *phys_addr)
 221 {
 222         short lrs_state = 0xff;
 223         int i;
 224
 225         /* ISA boards are detected by sending the ID sequence to the
 226            ID_PORT.  We find cards past the first by setting the 'current_tag'
 227            on cards as they are found.  Cards with their tag set will not
 228            respond to subsequent ID sequences. */
 229
 230         outb(0x00, id_port);
 231         outb(0x00, id_port);
 232         for (i = 0; i < 255; i++) {
 233                 outb(lrs_state, id_port);
 234                 lrs_state <<= 1;
 235                 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
 236         }
 237         /* For the first probe, clear all board's tag registers. */
 238         if (current_tag == 0)
 239                 outb(0xd0, id_port);
 240         else                    /* Otherwise kill off already-found boards. */
 241                 outb(0xd8, id_port);
 242         if (id_read_eeprom(7) != 0x6d50)
 243                 return 1;
 244         /* Read in EEPROM data, which does contention-select.
 245            Only the lowest address board will stay "on-line".
 246            3Com got the byte order backwards. */
 247         for (i = 0; i < 3; i++)
 248                 phys_addr[i] = htons(id_read_eeprom(i));
 249 #ifdef CONFIG_PNP
 250         if (!nopnp) {
 251                 /* The ISA PnP 3c509 cards respond to the ID sequence too.
 252                    This check is needed in order not to register them twice. */
 253                 for (i = 0; i < el3_cards; i++) {
 254                         struct el3_private *lp = netdev_priv(el3_devs[i]);
 255                         if (lp->type == EL3_PNP &&
 256                             !memcmp(phys_addr, el3_devs[i]->dev_addr,
 257                                     ETH_ALEN)) {
 258                                 if (el3_debug > 3)
 259                                         pr_debug("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
 260                                                 phys_addr[0] & 0xff, phys_addr[0] >> 8,
 261                                                 phys_addr[1] & 0xff, phys_addr[1] >> 8,
 262                                                 phys_addr[2] & 0xff, phys_addr[2] >> 8);
 263                                 /* Set the adaptor tag so that the next card can be found. */
 264                                 outb(0xd0 + ++current_tag, id_port);
 265                                 return 2;
 266                         }
 267                 }
 268         }
 269 #endif /* CONFIG_PNP */
 270         return 0;
 271
 272 }
 273
 274 static void __devinit el3_dev_fill(struct net_device *dev, __be16 *phys_addr,
 275                                    int ioaddr, int irq, int if_port,
 276                                    enum el3_cardtype type)
 277 {
 278         struct el3_private *lp = netdev_priv(dev);
 279
 280         memcpy(dev->dev_addr, phys_addr, ETH_ALEN);
 281         dev->base_addr = ioaddr;
 282         dev->irq = irq;
 283         dev->if_port = if_port;
 284         lp->type = type;
 285 }
 286
 287 static int __devinit el3_isa_match(struct device *pdev,
 288                                    unsigned int ndev)
 289 {
 290         struct net_device *dev;
 291         int ioaddr, isa_irq, if_port, err;
 292         unsigned int iobase;
 293         __be16 phys_addr[3];
 294
 295         while ((err = el3_isa_id_sequence(phys_addr)) == 2)
 296                 ;       /* Skip to next card when PnP card found */
 297         if (err == 1)
 298                 return 0;
 299
 300         iobase = id_read_eeprom(8);
 301         if_port = iobase >> 14;
 302         ioaddr = 0x200 + ((iobase & 0x1f) << 4);
 303         if (irq[el3_cards] > 1 && irq[el3_cards] < 16)
 304                 isa_irq = irq[el3_cards];
 305         else
 306                 isa_irq = id_read_eeprom(9) >> 12;
 307
 308         dev = alloc_etherdev(sizeof(struct el3_private));
 309         if (!dev)
 310                 return -ENOMEM;
 311
 312         netdev_boot_setup_check(dev);
 313
 314         if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-isa")) {
 315                 free_netdev(dev);
 316                 return 0;
 317         }
 318
 319         /* Set the adaptor tag so that the next card can be found. */
 320         outb(0xd0 + ++current_tag, id_port);
 321
 322         /* Activate the adaptor at the EEPROM location. */
 323         outb((ioaddr >> 4) | 0xe0, id_port);
 324
 325         EL3WINDOW(0);
 326         if (inw(ioaddr) != 0x6d50) {
 327                 free_netdev(dev);
 328                 return 0;
 329         }
 330
 331         /* Free the interrupt so that some other card can use it. */
 332         outw(0x0f00, ioaddr + WN0_IRQ);
 333
 334         el3_dev_fill(dev, phys_addr, ioaddr, isa_irq, if_port, EL3_ISA);
 335         dev_set_drvdata(pdev, dev);
 336         if (el3_common_init(dev)) {
 337                 free_netdev(dev);
 338                 return 0;
 339         }
 340
 341         el3_devs[el3_cards++] = dev;
 342         return 1;
 343 }
 344
 345 static int __devexit el3_isa_remove(struct device *pdev,
 346                                     unsigned int ndev)
 347 {
 348         el3_device_remove(pdev);
 349         dev_set_drvdata(pdev, NULL);
 350         return 0;
 351 }
 352
 353 #ifdef CONFIG_PM
 354 static int el3_isa_suspend(struct device *dev, unsigned int n,
 355                            pm_message_t state)
 356 {
 357         current_tag = 0;
 358         return el3_suspend(dev, state);
 359 }
 360
 361 static int el3_isa_resume(struct device *dev, unsigned int n)
 362 {
 363         struct net_device *ndev = dev_get_drvdata(dev);
 364         int ioaddr = ndev->base_addr, err;
 365         __be16 phys_addr[3];
 366
 367         while ((err = el3_isa_id_sequence(phys_addr)) == 2)
 368                 ;       /* Skip to next card when PnP card found */
 369         if (err == 1)
 370                 return 0;
 371         /* Set the adaptor tag so that the next card can be found. */
 372         outb(0xd0 + ++current_tag, id_port);
 373         /* Enable the card */
 374         outb((ioaddr >> 4) | 0xe0, id_port);
 375         EL3WINDOW(0);
 376         if (inw(ioaddr) != 0x6d50)
 377                 return 1;
 378         /* Free the interrupt so that some other card can use it. */
 379         outw(0x0f00, ioaddr + WN0_IRQ);
 380         return el3_resume(dev);
 381 }
 382 #endif
 383
 384 static struct isa_driver el3_isa_driver = {
 385         .match          = el3_isa_match,
 386         .remove         = __devexit_p(el3_isa_remove),
 387 #ifdef CONFIG_PM
 388         .suspend        = el3_isa_suspend,
 389         .resume         = el3_isa_resume,
 390 #endif
 391         .driver         = {
 392                 .name   = "3c509"
 393         },
 394 };
 395 static int isa_registered;
 396
 397 #ifdef CONFIG_PNP
 398 static struct pnp_device_id el3_pnp_ids[] = {
 399         { .id = "TCM5090" }, /* 3Com Etherlink III (TP) */
 400         { .id = "TCM5091" }, /* 3Com Etherlink III */
 401         { .id = "TCM5094" }, /* 3Com Etherlink III (combo) */
 402         { .id = "TCM5095" }, /* 3Com Etherlink III (TPO) */
 403         { .id = "TCM5098" }, /* 3Com Etherlink III (TPC) */
 404         { .id = "PNP80f7" }, /* 3Com Etherlink III compatible */
 405         { .id = "PNP80f8" }, /* 3Com Etherlink III compatible */
 406         { .id = "" }
 407 };
 408 MODULE_DEVICE_TABLE(pnp, el3_pnp_ids);
 409
 410 static int __devinit el3_pnp_probe(struct pnp_dev *pdev,
 411                                     const struct pnp_device_id *id)
 412 {
 413         short i;
 414         int ioaddr, irq, if_port;
 415         __be16 phys_addr[3];
 416         struct net_device *dev = NULL;
 417         int err;
 418
 419         ioaddr = pnp_port_start(pdev, 0);
 420         if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509-pnp"))
 421                 return -EBUSY;
 422         irq = pnp_irq(pdev, 0);
 423         EL3WINDOW(0);
 424         for (i = 0; i < 3; i++)
 425                 phys_addr[i] = htons(read_eeprom(ioaddr, i));
 426         if_port = read_eeprom(ioaddr, 8) >> 14;
 427         dev = alloc_etherdev(sizeof(struct el3_private));
 428         if (!dev) {
 429                 release_region(ioaddr, EL3_IO_EXTENT);
 430                 return -ENOMEM;
 431         }
 432         SET_NETDEV_DEV(dev, &pdev->dev);
 433         netdev_boot_setup_check(dev);
 434
 435         el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_PNP);
 436         pnp_set_drvdata(pdev, dev);
 437         err = el3_common_init(dev);
 438
 439         if (err) {
 440                 pnp_set_drvdata(pdev, NULL);
 441                 free_netdev(dev);
 442                 return err;
 443         }
 444
 445         el3_devs[el3_cards++] = dev;
 446         return 0;
 447 }
 448
 449 static void __devexit el3_pnp_remove(struct pnp_dev *pdev)
 450 {
 451         el3_common_remove(pnp_get_drvdata(pdev));
 452         pnp_set_drvdata(pdev, NULL);
 453 }
 454
 455 #ifdef CONFIG_PM
 456 static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
 457 {
 458         return el3_suspend(&pdev->dev, state);
 459 }
 460
 461 static int el3_pnp_resume(struct pnp_dev *pdev)
 462 {
 463         return el3_resume(&pdev->dev);
 464 }
 465 #endif
 466
 467 static struct pnp_driver el3_pnp_driver = {
 468         .name           = "3c509",
 469         .id_table       = el3_pnp_ids,
 470         .probe          = el3_pnp_probe,
 471         .remove         = __devexit_p(el3_pnp_remove),
 472 #ifdef CONFIG_PM
 473         .suspend        = el3_pnp_suspend,
 474         .resume         = el3_pnp_resume,
 475 #endif
 476 };
 477 static int pnp_registered;
 478 #endif /* CONFIG_PNP */
 479
 480 #ifdef CONFIG_EISA
 481 static struct eisa_device_id el3_eisa_ids[] = {
 482                 { "TCM5090" },
 483                 { "TCM5091" },
 484                 { "TCM5092" },
 485                 { "TCM5093" },
 486                 { "TCM5094" },
 487                 { "TCM5095" },
 488                 { "TCM5098" },
 489                 { "" }
 490 };
 491 MODULE_DEVICE_TABLE(eisa, el3_eisa_ids);
 492
 493 static int el3_eisa_probe (struct device *device);
 494
 495 static struct eisa_driver el3_eisa_driver = {
 496                 .id_table = el3_eisa_ids,
 497                 .driver   = {
 498                                 .name    = "3c579",
 499                                 .probe   = el3_eisa_probe,
 500                                 .remove  = __devexit_p (el3_device_remove),
 501                                 .suspend = el3_suspend,
 502                                 .resume  = el3_resume,
 503                 }
 504 };
 505 static int eisa_registered;
 506 #endif
 507
 508 #ifdef CONFIG_MCA
 509 static int el3_mca_probe(struct device *dev);
 510
 511 static short el3_mca_adapter_ids[] __initdata = {
 512                 0x627c,
 513                 0x627d,
 514                 0x62db,
 515                 0x62f6,
 516                 0x62f7,
 517                 0x0000
 518 };
 519
 520 static char *el3_mca_adapter_names[] __initdata = {
 521                 "3Com 3c529 EtherLink III (10base2)",
 522                 "3Com 3c529 EtherLink III (10baseT)",
 523                 "3Com 3c529 EtherLink III (test mode)",
 524                 "3Com 3c529 EtherLink III (TP or coax)",
 525                 "3Com 3c529 EtherLink III (TP)",
 526                 NULL
 527 };
 528
 529 static struct mca_driver el3_mca_driver = {
 530                 .id_table = el3_mca_adapter_ids,
 531                 .driver = {
 532                                 .name = "3c529",
 533                                 .bus = &mca_bus_type,
 534                                 .probe = el3_mca_probe,
 535                                 .remove = __devexit_p(el3_device_remove),
 536                                 .suspend = el3_suspend,
 537                                 .resume  = el3_resume,
 538                 },
 539 };
 540 static int mca_registered;
 541 #endif /* CONFIG_MCA */
 542
 543 static const struct net_device_ops netdev_ops = {
 544         .ndo_open               = el3_open,
 545         .ndo_stop               = el3_close,
 546         .ndo_start_xmit         = el3_start_xmit,
 547         .ndo_get_stats          = el3_get_stats,
 548         .ndo_set_multicast_list = set_multicast_list,
 549         .ndo_tx_timeout         = el3_tx_timeout,
 550         .ndo_change_mtu         = eth_change_mtu,
 551         .ndo_set_mac_address    = eth_mac_addr,
 552         .ndo_validate_addr      = eth_validate_addr,
 553 #ifdef CONFIG_NET_POLL_CONTROLLER
 554         .ndo_poll_controller    = el3_poll_controller,
 555 #endif
 556 };
 557
 558 static int __devinit el3_common_init(struct net_device *dev)
 559 {
 560         struct el3_private *lp = netdev_priv(dev);
 561         int err;
 562         const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
 563
 564         spin_lock_init(&lp->lock);
 565
 566         if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
 567                 dev->if_port = (dev->mem_start & 0x0f);
 568         } else { /* xcvr codes 0/8 */
 569                 /* use eeprom value, but save user's full-duplex selection */
 570                 dev->if_port |= (dev->mem_start & 0x08);
 571         }
 572
 573         /* The EL3-specific entries in the device structure. */
 574         dev->netdev_ops = &netdev_ops;
 575         dev->watchdog_timeo = TX_TIMEOUT;
 576         SET_ETHTOOL_OPS(dev, &ethtool_ops);
 577
 578         err = register_netdev(dev);
 579         if (err) {
 580                 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
 581                         dev->base_addr, dev->irq);
 582                 release_region(dev->base_addr, EL3_IO_EXTENT);
 583                 return err;
 584         }
 585
 586         pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
 587                dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
 588                dev->dev_addr, dev->irq);
 589
 590         if (el3_debug > 0)
 591                 pr_info("%s", version);
 592         return 0;
 593
 594 }
 595
 596 static void el3_common_remove (struct net_device *dev)
 597 {
 598         unregister_netdev (dev);
 599         release_region(dev->base_addr, EL3_IO_EXTENT);
 600         free_netdev (dev);
 601 }
 602
 603 #ifdef CONFIG_MCA
 604 static int __init el3_mca_probe(struct device *device)
 605 {
 606         /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch,
 607          * heavily modified by Chris Beauregard
 608          * (cpbeaure@csclub.uwaterloo.ca) to support standard MCA
 609          * probing.
 610          *
 611          * redone for multi-card detection by ZP Gu (zpg@castle.net)
 612          * now works as a module */
 613
 614         short i;
 615         int ioaddr, irq, if_port;
 616         __be16 phys_addr[3];
 617         struct net_device *dev = NULL;
 618         u_char pos4, pos5;
 619         struct mca_device *mdev = to_mca_device(device);
 620         int slot = mdev->slot;
 621         int err;
 622
 623         pos4 = mca_device_read_stored_pos(mdev, 4);
 624         pos5 = mca_device_read_stored_pos(mdev, 5);
 625
 626         ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
 627         irq = pos5 & 0x0f;
 628
 629
 630         pr_info("3c529: found %s at slot %d\n",
 631                 el3_mca_adapter_names[mdev->index], slot + 1);
 632
 633         /* claim the slot */
 634         strncpy(mdev->name, el3_mca_adapter_names[mdev->index],
 635                         sizeof(mdev->name));
 636         mca_device_set_claim(mdev, 1);
 637
 638         if_port = pos4 & 0x03;
 639
 640         irq = mca_device_transform_irq(mdev, irq);
 641         ioaddr = mca_device_transform_ioport(mdev, ioaddr);
 642         if (el3_debug > 2) {
 643                 pr_debug("3c529: irq %d  ioaddr 0x%x  ifport %d\n", irq, ioaddr, if_port);
 644         }
 645         EL3WINDOW(0);
 646         for (i = 0; i < 3; i++)
 647                 phys_addr[i] = htons(read_eeprom(ioaddr, i));
 648
 649         dev = alloc_etherdev(sizeof (struct el3_private));
 650         if (dev == NULL) {
 651                 release_region(ioaddr, EL3_IO_EXTENT);
 652                 return -ENOMEM;
 653         }
 654
 655         netdev_boot_setup_check(dev);
 656
 657         el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_MCA);
 658         dev_set_drvdata(device, dev);
 659         err = el3_common_init(dev);
 660
 661         if (err) {
 662                 dev_set_drvdata(device, NULL);
 663                 free_netdev(dev);
 664                 return -ENOMEM;
 665         }
 666
 667         el3_devs[el3_cards++] = dev;
 668         return 0;
 669 }
 670
 671 #endif /* CONFIG_MCA */
 672
 673 #ifdef CONFIG_EISA
 674 static int __init el3_eisa_probe (struct device *device)
 675 {
 676         short i;
 677         int ioaddr, irq, if_port;
 678         __be16 phys_addr[3];
 679         struct net_device *dev = NULL;
 680         struct eisa_device *edev;
 681         int err;
 682
 683         /* Yeepee, The driver framework is calling us ! */
 684         edev = to_eisa_device (device);
 685         ioaddr = edev->base_addr;
 686
 687         if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
 688                 return -EBUSY;
 689
 690         /* Change the register set to the configuration window 0. */
 691         outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
 692
 693         irq = inw(ioaddr + WN0_IRQ) >> 12;
 694         if_port = inw(ioaddr + 6)>>14;
 695         for (i = 0; i < 3; i++)
 696                 phys_addr[i] = htons(read_eeprom(ioaddr, i));
 697
 698         /* Restore the "Product ID" to the EEPROM read register. */
 699         read_eeprom(ioaddr, 3);
 700
 701         dev = alloc_etherdev(sizeof (struct el3_private));
 702         if (dev == NULL) {
 703                 release_region(ioaddr, EL3_IO_EXTENT);
 704                 return -ENOMEM;
 705         }
 706
 707         netdev_boot_setup_check(dev);
 708
 709         el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
 710         eisa_set_drvdata (edev, dev);
 711         err = el3_common_init(dev);
 712
 713         if (err) {
 714                 eisa_set_drvdata (edev, NULL);
 715                 free_netdev(dev);
 716                 return err;
 717         }
 718
 719         el3_devs[el3_cards++] = dev;
 720         return 0;
 721 }
 722 #endif
 723
 724 /* This remove works for all device types.
 725  *
 726  * The net dev must be stored in the driver data field */
 727 static int __devexit el3_device_remove (struct device *device)
 728 {
 729         struct net_device *dev;
 730
 731         dev = dev_get_drvdata(device);
 732
 733         el3_common_remove (dev);
 734         return 0;
 735 }
 736
 737 /* Read a word from the EEPROM using the regular EEPROM access register.
 738    Assume that we are in register window zero.
 739  */
 740 static ushort read_eeprom(int ioaddr, int index)
 741 {
 742         outw(EEPROM_READ + index, ioaddr + 10);
 743         /* Pause for at least 162 us. for the read to take place.
 744            Some chips seem to require much longer */
 745         mdelay(2);
 746         return inw(ioaddr + 12);
 747 }
 748
 749 /* Read a word from the EEPROM when in the ISA ID probe state. */
 750 static ushort id_read_eeprom(int index)
 751 {
 752         int bit, word = 0;
 753
 754         /* Issue read command, and pause for at least 162 us. for it to complete.
 755            Assume extra-fast 16Mhz bus. */
 756         outb(EEPROM_READ + index, id_port);
 757
 758         /* Pause for at least 162 us. for the read to take place. */
 759         /* Some chips seem to require much longer */
 760         mdelay(4);
 761
 762         for (bit = 15; bit >= 0; bit--)
 763                 word = (word << 1) + (inb(id_port) & 0x01);
 764
 765         if (el3_debug > 3)
 766                 pr_debug("  3c509 EEPROM word %d %#4.4x.\n", index, word);
 767
 768         return word;
 769 }
 770
 771
 772 static int
 773 el3_open(struct net_device *dev)
 774 {
 775         int ioaddr = dev->base_addr;
 776         int i;
 777
 778         outw(TxReset, ioaddr + EL3_CMD);
 779         outw(RxReset, ioaddr + EL3_CMD);
 780         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 781
 782         i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
 783         if (i)
 784                 return i;
 785
 786         EL3WINDOW(0);
 787         if (el3_debug > 3)
 788                 pr_debug("%s: Opening, IRQ %d    status@%x %4.4x.\n", dev->name,
 789                            dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
 790
 791         el3_up(dev);
 792
 793         if (el3_debug > 3)
 794                 pr_debug("%s: Opened 3c509  IRQ %d  status %4.4x.\n",
 795                            dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
 796
 797         return 0;
 798 }
 799
 800 static void
 801 el3_tx_timeout (struct net_device *dev)
 802 {
 803         int ioaddr = dev->base_addr;
 804
 805         /* Transmitter timeout, serious problems. */
 806         pr_warning("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d.\n",
 807                    dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
 808                    inw(ioaddr + TX_FREE));
 809         dev->stats.tx_errors++;
 810         dev->trans_start = jiffies;
 811         /* Issue TX_RESET and TX_START commands. */
 812         outw(TxReset, ioaddr + EL3_CMD);
 813         outw(TxEnable, ioaddr + EL3_CMD);
 814         netif_wake_queue(dev);
 815 }
 816
 817
 818 static netdev_tx_t
 819 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 820 {
 821         struct el3_private *lp = netdev_priv(dev);
 822         int ioaddr = dev->base_addr;
 823         unsigned long flags;
 824
 825         netif_stop_queue (dev);
 826
 827         dev->stats.tx_bytes += skb->len;
 828
 829         if (el3_debug > 4) {
 830                 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
 831                            dev->name, skb->len, inw(ioaddr + EL3_STATUS));
 832         }
 833 #if 0
 834 #ifndef final_version
 835         {       /* Error-checking code, delete someday. */
 836                 ushort status = inw(ioaddr + EL3_STATUS);
 837                 if (status & 0x0001 &&          /* IRQ line active, missed one. */
 838                     inw(ioaddr + EL3_STATUS) & 1) {                     /* Make sure. */
 839                         pr_debug("%s: Missed interrupt, status then %04x now %04x"
 840                                    "  Tx %2.2x Rx %4.4x.\n", dev->name, status,
 841                                    inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
 842                                    inw(ioaddr + RX_STATUS));
 843                         /* Fake interrupt trigger by masking, acknowledge interrupts. */
 844                         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 845                         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 846                                  ioaddr + EL3_CMD);
 847                         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
 848                 }
 849         }
 850 #endif
 851 #endif
 852         /*
 853          *      We lock the driver against other processors. Note
 854          *      we don't need to lock versus the IRQ as we suspended
 855          *      that. This means that we lose the ability to take
 856          *      an RX during a TX upload. That sucks a bit with SMP
 857          *      on an original 3c509 (2K buffer)
 858          *
 859          *      Using disable_irq stops us crapping on other
 860          *      time sensitive devices.
 861          */
 862
 863         spin_lock_irqsave(&lp->lock, flags);
 864
 865         /* Put out the doubleword header... */
 866         outw(skb->len, ioaddr + TX_FIFO);
 867         outw(0x00, ioaddr + TX_FIFO);
 868         /* ... and the packet rounded to a doubleword. */
 869         outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 870
 871         dev->trans_start = jiffies;
 872         if (inw(ioaddr + TX_FREE) > 1536)
 873                 netif_start_queue(dev);
 874         else
 875                 /* Interrupt us when the FIFO has room for max-sized packet. */
 876                 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
 877
 878         spin_unlock_irqrestore(&lp->lock, flags);
 879
 880         dev_kfree_skb (skb);
 881
 882         /* Clear the Tx status stack. */
 883         {
 884                 short tx_status;
 885                 int i = 4;
 886
 887                 while (--i > 0  &&      (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 888                         if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
 889                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 890                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 891                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 892                 }
 893         }
 894         return NETDEV_TX_OK;
 895 }
 896
 897 /* The EL3 interrupt handler. */
 898 static irqreturn_t
 899 el3_interrupt(int irq, void *dev_id)
 900 {
 901         struct net_device *dev = dev_id;
 902         struct el3_private *lp;
 903         int ioaddr, status;
 904         int i = max_interrupt_work;
 905
 906         lp = netdev_priv(dev);
 907         spin_lock(&lp->lock);
 908
 909         ioaddr = dev->base_addr;
 910
 911         if (el3_debug > 4) {
 912                 status = inw(ioaddr + EL3_STATUS);
 913                 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
 914         }
 915
 916         while ((status = inw(ioaddr + EL3_STATUS)) &
 917                    (IntLatch | RxComplete | StatsFull)) {
 918
 919                 if (status & RxComplete)
 920                         el3_rx(dev);
 921
 922                 if (status & TxAvailable) {
 923                         if (el3_debug > 5)
 924                                 pr_debug("      TX room bit was handled.\n");
 925                         /* There's room in the FIFO for a full-sized packet. */
 926                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 927                         netif_wake_queue (dev);
 928                 }
 929                 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
 930                         /* Handle all uncommon interrupts. */
 931                         if (status & StatsFull)                         /* Empty statistics. */
 932                                 update_stats(dev);
 933                         if (status & RxEarly) {                         /* Rx early is unused. */
 934                                 el3_rx(dev);
 935                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 936                         }
 937                         if (status & TxComplete) {                      /* Really Tx error. */
 938                                 short tx_status;
 939                                 int i = 4;
 940
 941                                 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 942                                         if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
 943                                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 944                                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 945                                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 946                                 }
 947                         }
 948                         if (status & AdapterFailure) {
 949                                 /* Adapter failure requires Rx reset and reinit. */
 950                                 outw(RxReset, ioaddr + EL3_CMD);
 951                                 /* Set the Rx filter to the current state. */
 952                                 outw(SetRxFilter | RxStation | RxBroadcast
 953                                          | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
 954                                          | (dev->flags & IFF_PROMISC ? RxProm : 0),
 955                                          ioaddr + EL3_CMD);
 956                                 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
 957                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 958                         }
 959                 }
 960
 961                 if (--i < 0) {
 962                         pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
 963                                    dev->name, status);
 964                         /* Clear all interrupts. */
 965                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 966                         break;
 967                 }
 968                 /* Acknowledge the IRQ. */
 969                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
 970         }
 971
 972         if (el3_debug > 4) {
 973                 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
 974                            inw(ioaddr + EL3_STATUS));
 975         }
 976         spin_unlock(&lp->lock);
 977         return IRQ_HANDLED;
 978 }
 979
 980
 981 #ifdef CONFIG_NET_POLL_CONTROLLER
 982 /*
 983  * Polling receive - used by netconsole and other diagnostic tools
 984  * to allow network i/o with interrupts disabled.
 985  */
 986 static void el3_poll_controller(struct net_device *dev)
 987 {
 988         disable_irq(dev->irq);
 989         el3_interrupt(dev->irq, dev);
 990         enable_irq(dev->irq);
 991 }
 992 #endif
 993
 994 static struct net_device_stats *
 995 el3_get_stats(struct net_device *dev)
 996 {
 997         struct el3_private *lp = netdev_priv(dev);
 998         unsigned long flags;
 999
1000         /*
1001          *      This is fast enough not to bother with disable IRQ
1002          *      stuff.
1003          */
1004
1005         spin_lock_irqsave(&lp->lock, flags);
1006         update_stats(dev);
1007         spin_unlock_irqrestore(&lp->lock, flags);
1008         return &dev->stats;
1009 }
1010
1011 /*  Update statistics.  We change to register window 6, so this should be run
1012         single-threaded if the device is active. This is expected to be a rare
1013         operation, and it's simpler for the rest of the driver to assume that
1014         window 1 is always valid rather than use a special window-state variable.
1015         */
1016 static void update_stats(struct net_device *dev)
1017 {
1018         int ioaddr = dev->base_addr;
1019
1020         if (el3_debug > 5)
1021                 pr_debug("   Updating the statistics.\n");
1022         /* Turn off statistics updates while reading. */
1023         outw(StatsDisable, ioaddr + EL3_CMD);
1024         /* Switch to the stats window, and read everything. */
1025         EL3WINDOW(6);
1026         dev->stats.tx_carrier_errors    += inb(ioaddr + 0);
1027         dev->stats.tx_heartbeat_errors  += inb(ioaddr + 1);
1028         /* Multiple collisions. */         inb(ioaddr + 2);
1029         dev->stats.collisions           += inb(ioaddr + 3);
1030         dev->stats.tx_window_errors     += inb(ioaddr + 4);
1031         dev->stats.rx_fifo_errors       += inb(ioaddr + 5);
1032         dev->stats.tx_packets           += inb(ioaddr + 6);
1033         /* Rx packets   */                 inb(ioaddr + 7);
1034         /* Tx deferrals */                 inb(ioaddr + 8);
1035         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
1036         inw(ioaddr + 12);
1037
1038         /* Back to window 1, and turn statistics back on. */
1039         EL3WINDOW(1);
1040         outw(StatsEnable, ioaddr + EL3_CMD);
1041         return;
1042 }
1043
1044 static int
1045 el3_rx(struct net_device *dev)
1046 {
1047         int ioaddr = dev->base_addr;
1048         short rx_status;
1049
1050         if (el3_debug > 5)
1051                 pr_debug("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
1052                            inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
1053         while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
1054                 if (rx_status & 0x4000) { /* Error, update stats. */
1055                         short error = rx_status & 0x3800;
1056
1057                         outw(RxDiscard, ioaddr + EL3_CMD);
1058                         dev->stats.rx_errors++;
1059                         switch (error) {
1060                         case 0x0000:            dev->stats.rx_over_errors++; break;
1061                         case 0x0800:            dev->stats.rx_length_errors++; break;
1062                         case 0x1000:            dev->stats.rx_frame_errors++; break;
1063                         case 0x1800:            dev->stats.rx_length_errors++; break;
1064                         case 0x2000:            dev->stats.rx_frame_errors++; break;
1065                         case 0x2800:            dev->stats.rx_crc_errors++; break;
1066                         }
1067                 } else {
1068                         short pkt_len = rx_status & 0x7ff;
1069                         struct sk_buff *skb;
1070
1071                         skb = dev_alloc_skb(pkt_len+5);
1072                         if (el3_debug > 4)
1073                                 pr_debug("Receiving packet size %d status %4.4x.\n",
1074                                            pkt_len, rx_status);
1075                         if (skb != NULL) {
1076                                 skb_reserve(skb, 2);     /* Align IP on 16 byte */
1077
1078                                 /* 'skb->data' points to the start of sk_buff data area. */
1079                                 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
1080                                          (pkt_len + 3) >> 2);
1081
1082                                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
1083                                 skb->protocol = eth_type_trans(skb,dev);
1084                                 netif_rx(skb);
1085                                 dev->stats.rx_bytes += pkt_len;
1086                                 dev->stats.rx_packets++;
1087                                 continue;
1088                         }
1089                         outw(RxDiscard, ioaddr + EL3_CMD);
1090                         dev->stats.rx_dropped++;
1091                         if (el3_debug)
1092                                 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
1093                                            dev->name, pkt_len);
1094                 }
1095                 inw(ioaddr + EL3_STATUS);                               /* Delay. */
1096                 while (inw(ioaddr + EL3_STATUS) & 0x1000)
1097                         pr_debug("      Waiting for 3c509 to discard packet, status %x.\n",
1098                                    inw(ioaddr + EL3_STATUS) );
1099         }
1100
1101         return 0;
1102 }
1103
1104 /*
1105  *     Set or clear the multicast filter for this adaptor.
1106  */
1107 static void
1108 set_multicast_list(struct net_device *dev)
1109 {
1110         unsigned long flags;
1111         struct el3_private *lp = netdev_priv(dev);
1112         int ioaddr = dev->base_addr;
1113         int mc_count = netdev_mc_count(dev);
1114
1115         if (el3_debug > 1) {
1116                 static int old;
1117                 if (old != mc_count) {
1118                         old = mc_count;
1119                         pr_debug("%s: Setting Rx mode to %d addresses.\n",
1120                                  dev->name, mc_count);
1121                 }
1122         }
1123         spin_lock_irqsave(&lp->lock, flags);
1124         if (dev->flags&IFF_PROMISC) {
1125                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
1126                          ioaddr + EL3_CMD);
1127         }
1128         else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
1129                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1130         }
1131         else
1132                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1133         spin_unlock_irqrestore(&lp->lock, flags);
1134 }
1135
1136 static int
1137 el3_close(struct net_device *dev)
1138 {
1139         int ioaddr = dev->base_addr;
1140         struct el3_private *lp = netdev_priv(dev);
1141
1142         if (el3_debug > 2)
1143                 pr_debug("%s: Shutting down ethercard.\n", dev->name);
1144
1145         el3_down(dev);
1146
1147         free_irq(dev->irq, dev);
1148         /* Switching back to window 0 disables the IRQ. */
1149         EL3WINDOW(0);
1150         if (lp->type != EL3_EISA) {
1151                 /* But we explicitly zero the IRQ line select anyway. Don't do
1152                  * it on EISA cards, it prevents the module from getting an
1153                  * IRQ after unload+reload... */
1154                 outw(0x0f00, ioaddr + WN0_IRQ);
1155         }
1156
1157         return 0;
1158 }
1159
1160 static int
1161 el3_link_ok(struct net_device *dev)
1162 {
1163         int ioaddr = dev->base_addr;
1164         u16 tmp;
1165
1166         EL3WINDOW(4);
1167         tmp = inw(ioaddr + WN4_MEDIA);
1168         EL3WINDOW(1);
1169         return tmp & (1<<11);
1170 }
1171
1172 static int
1173 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1174 {
1175         u16 tmp;
1176         int ioaddr = dev->base_addr;
1177
1178         EL3WINDOW(0);
1179         /* obtain current transceiver via WN4_MEDIA? */
1180         tmp = inw(ioaddr + WN0_ADDR_CONF);
1181         ecmd->transceiver = XCVR_INTERNAL;
1182         switch (tmp >> 14) {
1183         case 0:
1184                 ecmd->port = PORT_TP;
1185                 break;
1186         case 1:
1187                 ecmd->port = PORT_AUI;
1188                 ecmd->transceiver = XCVR_EXTERNAL;
1189                 break;
1190         case 3:
1191                 ecmd->port = PORT_BNC;
1192         default:
1193                 break;
1194         }
1195
1196         ecmd->duplex = DUPLEX_HALF;
1197         ecmd->supported = 0;
1198         tmp = inw(ioaddr + WN0_CONF_CTRL);
1199         if (tmp & (1<<13))
1200                 ecmd->supported |= SUPPORTED_AUI;
1201         if (tmp & (1<<12))
1202                 ecmd->supported |= SUPPORTED_BNC;
1203         if (tmp & (1<<9)) {
1204                 ecmd->supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1205                                 SUPPORTED_10baseT_Full; /* hmm... */
1206                 EL3WINDOW(4);
1207                 tmp = inw(ioaddr + WN4_NETDIAG);
1208                 if (tmp & FD_ENABLE)
1209                         ecmd->duplex = DUPLEX_FULL;
1210         }
1211
1212         ecmd->speed = SPEED_10;
1213         EL3WINDOW(1);
1214         return 0;
1215 }
1216
1217 static int
1218 el3_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
1219 {
1220         u16 tmp;
1221         int ioaddr = dev->base_addr;
1222
1223         if (ecmd->speed != SPEED_10)
1224                 return -EINVAL;
1225         if ((ecmd->duplex != DUPLEX_HALF) && (ecmd->duplex != DUPLEX_FULL))
1226                 return -EINVAL;
1227         if ((ecmd->transceiver != XCVR_INTERNAL) && (ecmd->transceiver != XCVR_EXTERNAL))
1228                 return -EINVAL;
1229
1230         /* change XCVR type */
1231         EL3WINDOW(0);
1232         tmp = inw(ioaddr + WN0_ADDR_CONF);
1233         switch (ecmd->port) {
1234         case PORT_TP:
1235                 tmp &= ~(3<<14);
1236                 dev->if_port = 0;
1237                 break;
1238         case PORT_AUI:
1239                 tmp |= (1<<14);
1240                 dev->if_port = 1;
1241                 break;
1242         case PORT_BNC:
1243                 tmp |= (3<<14);
1244                 dev->if_port = 3;
1245                 break;
1246         default:
1247                 return -EINVAL;
1248         }
1249
1250         outw(tmp, ioaddr + WN0_ADDR_CONF);
1251         if (dev->if_port == 3) {
1252                 /* fire up the DC-DC convertor if BNC gets enabled */
1253                 tmp = inw(ioaddr + WN0_ADDR_CONF);
1254                 if (tmp & (3 << 14)) {
1255                         outw(StartCoax, ioaddr + EL3_CMD);
1256                         udelay(800);
1257                 } else
1258                         return -EIO;
1259         }
1260
1261         EL3WINDOW(4);
1262         tmp = inw(ioaddr + WN4_NETDIAG);
1263         if (ecmd->duplex == DUPLEX_FULL)
1264                 tmp |= FD_ENABLE;
1265         else
1266                 tmp &= ~FD_ENABLE;
1267         outw(tmp, ioaddr + WN4_NETDIAG);
1268         EL3WINDOW(1);
1269
1270         return 0;
1271 }
1272
1273 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1274 {
1275         strcpy(info->driver, DRV_NAME);
1276         strcpy(info->version, DRV_VERSION);
1277 }
1278
1279 static int el3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1280 {
1281         struct el3_private *lp = netdev_priv(dev);
1282         int ret;
1283
1284         spin_lock_irq(&lp->lock);
1285         ret = el3_netdev_get_ecmd(dev, ecmd);
1286         spin_unlock_irq(&lp->lock);
1287         return ret;
1288 }
1289
1290 static int el3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1291 {
1292         struct el3_private *lp = netdev_priv(dev);
1293         int ret;
1294
1295         spin_lock_irq(&lp->lock);
1296         ret = el3_netdev_set_ecmd(dev, ecmd);
1297         spin_unlock_irq(&lp->lock);
1298         return ret;
1299 }
1300
1301 static u32 el3_get_link(struct net_device *dev)
1302 {
1303         struct el3_private *lp = netdev_priv(dev);
1304         u32 ret;
1305
1306         spin_lock_irq(&lp->lock);
1307         ret = el3_link_ok(dev);
1308         spin_unlock_irq(&lp->lock);
1309         return ret;
1310 }
1311
1312 static u32 el3_get_msglevel(struct net_device *dev)
1313 {
1314         return el3_debug;
1315 }
1316
1317 static void el3_set_msglevel(struct net_device *dev, u32 v)
1318 {
1319         el3_debug = v;
1320 }
1321
1322 static const struct ethtool_ops ethtool_ops = {
1323         .get_drvinfo = el3_get_drvinfo,
1324         .get_settings = el3_get_settings,
1325         .set_settings = el3_set_settings,
1326         .get_link = el3_get_link,
1327         .get_msglevel = el3_get_msglevel,
1328         .set_msglevel = el3_set_msglevel,
1329 };
1330
1331 static void
1332 el3_down(struct net_device *dev)
1333 {
1334         int ioaddr = dev->base_addr;
1335
1336         netif_stop_queue(dev);
1337
1338         /* Turn off statistics ASAP.  We update lp->stats below. */
1339         outw(StatsDisable, ioaddr + EL3_CMD);
1340
1341         /* Disable the receiver and transmitter. */
1342         outw(RxDisable, ioaddr + EL3_CMD);
1343         outw(TxDisable, ioaddr + EL3_CMD);
1344
1345         if (dev->if_port == 3)
1346                 /* Turn off thinnet power.  Green! */
1347                 outw(StopCoax, ioaddr + EL3_CMD);
1348         else if (dev->if_port == 0) {
1349                 /* Disable link beat and jabber, if_port may change here next open(). */
1350                 EL3WINDOW(4);
1351                 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
1352         }
1353
1354         outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
1355
1356         update_stats(dev);
1357 }
1358
1359 static void
1360 el3_up(struct net_device *dev)
1361 {
1362         int i, sw_info, net_diag;
1363         int ioaddr = dev->base_addr;
1364
1365         /* Activating the board required and does no harm otherwise */
1366         outw(0x0001, ioaddr + 4);
1367
1368         /* Set the IRQ line. */
1369         outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
1370
1371         /* Set the station address in window 2 each time opened. */
1372         EL3WINDOW(2);
1373
1374         for (i = 0; i < 6; i++)
1375                 outb(dev->dev_addr[i], ioaddr + i);
1376
1377         if ((dev->if_port & 0x03) == 3) /* BNC interface */
1378                 /* Start the thinnet transceiver. We should really wait 50ms...*/
1379                 outw(StartCoax, ioaddr + EL3_CMD);
1380         else if ((dev->if_port & 0x03) == 0) { /* 10baseT interface */
1381                 /* Combine secondary sw_info word (the adapter level) and primary
1382                         sw_info word (duplex setting plus other useless bits) */
1383                 EL3WINDOW(0);
1384                 sw_info = (read_eeprom(ioaddr, 0x14) & 0x400f) |
1385                         (read_eeprom(ioaddr, 0x0d) & 0xBff0);
1386
1387                 EL3WINDOW(4);
1388                 net_diag = inw(ioaddr + WN4_NETDIAG);
1389                 net_diag = (net_diag | FD_ENABLE); /* temporarily assume full-duplex will be set */
1390                 pr_info("%s: ", dev->name);
1391                 switch (dev->if_port & 0x0c) {
1392                         case 12:
1393                                 /* force full-duplex mode if 3c5x9b */
1394                                 if (sw_info & 0x000f) {
1395                                         pr_cont("Forcing 3c5x9b full-duplex mode");
1396                                         break;
1397                                 }
1398                         case 8:
1399                                 /* set full-duplex mode based on eeprom config setting */
1400                                 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1401                                         pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1402                                         break;
1403                                 }
1404                         default:
1405                                 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1406                                 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1407                                 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1408                 }
1409
1410                 outw(net_diag, ioaddr + WN4_NETDIAG);
1411                 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1412                 if (el3_debug > 3)
1413                         pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1414                 /* Enable link beat and jabber check. */
1415                 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1416         }
1417
1418         /* Switch to the stats window, and clear all stats by reading. */
1419         outw(StatsDisable, ioaddr + EL3_CMD);
1420         EL3WINDOW(6);
1421         for (i = 0; i < 9; i++)
1422                 inb(ioaddr + i);
1423         inw(ioaddr + 10);
1424         inw(ioaddr + 12);
1425
1426         /* Switch to register set 1 for normal use. */
1427         EL3WINDOW(1);
1428
1429         /* Accept b-case and phys addr only. */
1430         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1431         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1432
1433         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1434         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1435         /* Allow status bits to be seen. */
1436         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1437         /* Ack all pending events, and set active indicator mask. */
1438         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1439                  ioaddr + EL3_CMD);
1440         outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1441                  ioaddr + EL3_CMD);
1442
1443         netif_start_queue(dev);
1444 }
1445
1446 /* Power Management support functions */
1447 #ifdef CONFIG_PM
1448
1449 static int
1450 el3_suspend(struct device *pdev, pm_message_t state)
1451 {
1452         unsigned long flags;
1453         struct net_device *dev;
1454         struct el3_private *lp;
1455         int ioaddr;
1456
1457         dev = dev_get_drvdata(pdev);
1458         lp = netdev_priv(dev);
1459         ioaddr = dev->base_addr;
1460
1461         spin_lock_irqsave(&lp->lock, flags);
1462
1463         if (netif_running(dev))
1464                 netif_device_detach(dev);
1465
1466         el3_down(dev);
1467         outw(PowerDown, ioaddr + EL3_CMD);
1468
1469         spin_unlock_irqrestore(&lp->lock, flags);
1470         return 0;
1471 }
1472
1473 static int
1474 el3_resume(struct device *pdev)
1475 {
1476         unsigned long flags;
1477         struct net_device *dev;
1478         struct el3_private *lp;
1479         int ioaddr;
1480
1481         dev = dev_get_drvdata(pdev);
1482         lp = netdev_priv(dev);
1483         ioaddr = dev->base_addr;
1484
1485         spin_lock_irqsave(&lp->lock, flags);
1486
1487         outw(PowerUp, ioaddr + EL3_CMD);
1488         EL3WINDOW(0);
1489         el3_up(dev);
1490
1491         if (netif_running(dev))
1492                 netif_device_attach(dev);
1493
1494         spin_unlock_irqrestore(&lp->lock, flags);
1495         return 0;
1496 }
1497
1498 #endif /* CONFIG_PM */
1499
1500 module_param(debug,int, 0);
1501 module_param_array(irq, int, NULL, 0);
1502 module_param(max_interrupt_work, int, 0);
1503 MODULE_PARM_DESC(debug, "debug level (0-6)");
1504 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1505 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1506 #ifdef CONFIG_PNP
1507 module_param(nopnp, int, 0);
1508 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1509 #endif  /* CONFIG_PNP */
1510 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1511 MODULE_LICENSE("GPL");
1512
1513 static int __init el3_init_module(void)
1514 {
1515         int ret = 0;
1516
1517         if (debug >= 0)
1518                 el3_debug = debug;
1519
1520 #ifdef CONFIG_PNP
1521         if (!nopnp) {
1522                 ret = pnp_register_driver(&el3_pnp_driver);
1523                 if (!ret)
1524                         pnp_registered = 1;
1525         }
1526 #endif
1527         /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1528         /* Start with 0x110 to avoid some sound cards.*/
1529         for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1530                 if (!request_region(id_port, 1, "3c509-control"))
1531                         continue;
1532                 outb(0x00, id_port);
1533                 outb(0xff, id_port);
1534                 if (inb(id_port) & 0x01)
1535                         break;
1536                 else
1537                         release_region(id_port, 1);
1538         }
1539         if (id_port >= 0x200) {
1540                 id_port = 0;
1541                 pr_err("No I/O port available for 3c509 activation.\n");
1542         } else {
1543                 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1544                 if (!ret)
1545                         isa_registered = 1;
1546         }
1547 #ifdef CONFIG_EISA
1548         ret = eisa_driver_register(&el3_eisa_driver);
1549         if (!ret)
1550                 eisa_registered = 1;
1551 #endif
1552 #ifdef CONFIG_MCA
1553         ret = mca_register_driver(&el3_mca_driver);
1554         if (!ret)
1555                 mca_registered = 1;
1556 #endif
1557
1558 #ifdef CONFIG_PNP
1559         if (pnp_registered)
1560                 ret = 0;
1561 #endif
1562         if (isa_registered)
1563                 ret = 0;
1564 #ifdef CONFIG_EISA
1565         if (eisa_registered)
1566                 ret = 0;
1567 #endif
1568 #ifdef CONFIG_MCA
1569         if (mca_registered)
1570                 ret = 0;
1571 #endif
1572         return ret;
1573 }
1574
1575 static void __exit el3_cleanup_module(void)
1576 {
1577 #ifdef CONFIG_PNP
1578         if (pnp_registered)
1579                 pnp_unregister_driver(&el3_pnp_driver);
1580 #endif
1581         if (isa_registered)
1582                 isa_unregister_driver(&el3_isa_driver);
1583         if (id_port)
1584                 release_region(id_port, 1);
1585 #ifdef CONFIG_EISA
1586         if (eisa_registered)
1587                 eisa_driver_unregister(&el3_eisa_driver);
1588 #endif
1589 #ifdef CONFIG_MCA
1590         if (mca_registered)
1591                 mca_unregister_driver(&el3_mca_driver);
1592 #endif
1593 }
1594
1595 module_init (el3_init_module);
1596 module_exit (el3_cleanup_module);