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