drivers/net/ethernet/3com/3c509.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
el3_isa_id_sequence
el3_dev_fill
el3_isa_match
el3_isa_remove
el3_isa_suspend
el3_isa_resume
el3_pnp_probe
el3_pnp_remove
el3_pnp_suspend
el3_pnp_resume
el3_common_init
el3_common_remove
el3_eisa_probe
el3_device_remove
read_eeprom
id_read_eeprom
el3_open
el3_tx_timeout
el3_start_xmit
el3_interrupt
el3_poll_controller
el3_get_stats
update_stats
el3_rx
set_multicast_list
el3_close
el3_link_ok
el3_netdev_get_ecmd
el3_netdev_set_ecmd
el3_get_drvinfo
el3_get_link_ksettings
el3_set_link_ksettings
el3_get_link
el3_get_msglevel
el3_set_msglevel
el3_down
el3_up
el3_suspend
el3_resume
el3_init_module
el3_cleanup_module
   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 <linux/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 const 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 const 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_set_mac_address    = eth_mac_addr,
 512         .ndo_validate_addr      = eth_validate_addr,
 513 #ifdef CONFIG_NET_POLL_CONTROLLER
 514         .ndo_poll_controller    = el3_poll_controller,
 515 #endif
 516 };
 517 
 518 static int el3_common_init(struct net_device *dev)
 519 {
 520         struct el3_private *lp = netdev_priv(dev);
 521         int err;
 522         const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
 523 
 524         spin_lock_init(&lp->lock);
 525 
 526         if (dev->mem_start & 0x05) { /* xcvr codes 1/3/4/12 */
 527                 dev->if_port = (dev->mem_start & 0x0f);
 528         } else { /* xcvr codes 0/8 */
 529                 /* use eeprom value, but save user's full-duplex selection */
 530                 dev->if_port |= (dev->mem_start & 0x08);
 531         }
 532 
 533         /* The EL3-specific entries in the device structure. */
 534         dev->netdev_ops = &netdev_ops;
 535         dev->watchdog_timeo = TX_TIMEOUT;
 536         dev->ethtool_ops = &ethtool_ops;
 537 
 538         err = register_netdev(dev);
 539         if (err) {
 540                 pr_err("Failed to register 3c5x9 at %#3.3lx, IRQ %d.\n",
 541                         dev->base_addr, dev->irq);
 542                 release_region(dev->base_addr, EL3_IO_EXTENT);
 543                 return err;
 544         }
 545 
 546         pr_info("%s: 3c5x9 found at %#3.3lx, %s port, address %pM, IRQ %d.\n",
 547                dev->name, dev->base_addr, if_names[(dev->if_port & 0x03)],
 548                dev->dev_addr, dev->irq);
 549 
 550         if (el3_debug > 0)
 551                 pr_info("%s", version);
 552         return 0;
 553 
 554 }
 555 
 556 static void el3_common_remove (struct net_device *dev)
 557 {
 558         unregister_netdev (dev);
 559         release_region(dev->base_addr, EL3_IO_EXTENT);
 560         free_netdev (dev);
 561 }
 562 
 563 #ifdef CONFIG_EISA
 564 static int el3_eisa_probe(struct device *device)
 565 {
 566         short i;
 567         int ioaddr, irq, if_port;
 568         __be16 phys_addr[3];
 569         struct net_device *dev = NULL;
 570         struct eisa_device *edev;
 571         int err;
 572 
 573         /* Yeepee, The driver framework is calling us ! */
 574         edev = to_eisa_device (device);
 575         ioaddr = edev->base_addr;
 576 
 577         if (!request_region(ioaddr, EL3_IO_EXTENT, "3c579-eisa"))
 578                 return -EBUSY;
 579 
 580         /* Change the register set to the configuration window 0. */
 581         outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
 582 
 583         irq = inw(ioaddr + WN0_IRQ) >> 12;
 584         if_port = inw(ioaddr + 6)>>14;
 585         for (i = 0; i < 3; i++)
 586                 phys_addr[i] = htons(read_eeprom(ioaddr, i));
 587 
 588         /* Restore the "Product ID" to the EEPROM read register. */
 589         read_eeprom(ioaddr, 3);
 590 
 591         dev = alloc_etherdev(sizeof (struct el3_private));
 592         if (dev == NULL) {
 593                 release_region(ioaddr, EL3_IO_EXTENT);
 594                 return -ENOMEM;
 595         }
 596 
 597         SET_NETDEV_DEV(dev, device);
 598         netdev_boot_setup_check(dev);
 599 
 600         el3_dev_fill(dev, phys_addr, ioaddr, irq, if_port, EL3_EISA);
 601         eisa_set_drvdata (edev, dev);
 602         err = el3_common_init(dev);
 603 
 604         if (err) {
 605                 eisa_set_drvdata (edev, NULL);
 606                 free_netdev(dev);
 607                 return err;
 608         }
 609 
 610         el3_devs[el3_cards++] = dev;
 611         return 0;
 612 }
 613 #endif
 614 
 615 /* This remove works for all device types.
 616  *
 617  * The net dev must be stored in the driver data field */
 618 static int el3_device_remove(struct device *device)
 619 {
 620         struct net_device *dev;
 621 
 622         dev = dev_get_drvdata(device);
 623 
 624         el3_common_remove (dev);
 625         return 0;
 626 }
 627 
 628 /* Read a word from the EEPROM using the regular EEPROM access register.
 629    Assume that we are in register window zero.
 630  */
 631 static ushort read_eeprom(int ioaddr, int index)
 632 {
 633         outw(EEPROM_READ + index, ioaddr + 10);
 634         /* Pause for at least 162 us. for the read to take place.
 635            Some chips seem to require much longer */
 636         mdelay(2);
 637         return inw(ioaddr + 12);
 638 }
 639 
 640 /* Read a word from the EEPROM when in the ISA ID probe state. */
 641 static ushort id_read_eeprom(int index)
 642 {
 643         int bit, word = 0;
 644 
 645         /* Issue read command, and pause for at least 162 us. for it to complete.
 646            Assume extra-fast 16Mhz bus. */
 647         outb(EEPROM_READ + index, id_port);
 648 
 649         /* Pause for at least 162 us. for the read to take place. */
 650         /* Some chips seem to require much longer */
 651         mdelay(4);
 652 
 653         for (bit = 15; bit >= 0; bit--)
 654                 word = (word << 1) + (inb(id_port) & 0x01);
 655 
 656         if (el3_debug > 3)
 657                 pr_debug("  3c509 EEPROM word %d %#4.4x.\n", index, word);
 658 
 659         return word;
 660 }
 661 
 662 
 663 static int
 664 el3_open(struct net_device *dev)
 665 {
 666         int ioaddr = dev->base_addr;
 667         int i;
 668 
 669         outw(TxReset, ioaddr + EL3_CMD);
 670         outw(RxReset, ioaddr + EL3_CMD);
 671         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 672 
 673         i = request_irq(dev->irq, el3_interrupt, 0, dev->name, dev);
 674         if (i)
 675                 return i;
 676 
 677         EL3WINDOW(0);
 678         if (el3_debug > 3)
 679                 pr_debug("%s: Opening, IRQ %d    status@%x %4.4x.\n", dev->name,
 680                            dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
 681 
 682         el3_up(dev);
 683 
 684         if (el3_debug > 3)
 685                 pr_debug("%s: Opened 3c509  IRQ %d  status %4.4x.\n",
 686                            dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
 687 
 688         return 0;
 689 }
 690 
 691 static void
 692 el3_tx_timeout (struct net_device *dev)
 693 {
 694         int ioaddr = dev->base_addr;
 695 
 696         /* Transmitter timeout, serious problems. */
 697         pr_warn("%s: transmit timed out, Tx_status %2.2x status %4.4x Tx FIFO room %d\n",
 698                 dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
 699                 inw(ioaddr + TX_FREE));
 700         dev->stats.tx_errors++;
 701         netif_trans_update(dev); /* prevent tx timeout */
 702         /* Issue TX_RESET and TX_START commands. */
 703         outw(TxReset, ioaddr + EL3_CMD);
 704         outw(TxEnable, ioaddr + EL3_CMD);
 705         netif_wake_queue(dev);
 706 }
 707 
 708 
 709 static netdev_tx_t
 710 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 711 {
 712         struct el3_private *lp = netdev_priv(dev);
 713         int ioaddr = dev->base_addr;
 714         unsigned long flags;
 715 
 716         netif_stop_queue (dev);
 717 
 718         dev->stats.tx_bytes += skb->len;
 719 
 720         if (el3_debug > 4) {
 721                 pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
 722                            dev->name, skb->len, inw(ioaddr + EL3_STATUS));
 723         }
 724         /*
 725          *      We lock the driver against other processors. Note
 726          *      we don't need to lock versus the IRQ as we suspended
 727          *      that. This means that we lose the ability to take
 728          *      an RX during a TX upload. That sucks a bit with SMP
 729          *      on an original 3c509 (2K buffer)
 730          *
 731          *      Using disable_irq stops us crapping on other
 732          *      time sensitive devices.
 733          */
 734 
 735         spin_lock_irqsave(&lp->lock, flags);
 736 
 737         /* Put out the doubleword header... */
 738         outw(skb->len, ioaddr + TX_FIFO);
 739         outw(0x00, ioaddr + TX_FIFO);
 740         /* ... and the packet rounded to a doubleword. */
 741         outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 742 
 743         if (inw(ioaddr + TX_FREE) > 1536)
 744                 netif_start_queue(dev);
 745         else
 746                 /* Interrupt us when the FIFO has room for max-sized packet. */
 747                 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
 748 
 749         spin_unlock_irqrestore(&lp->lock, flags);
 750 
 751         dev_consume_skb_any (skb);
 752 
 753         /* Clear the Tx status stack. */
 754         {
 755                 short tx_status;
 756                 int i = 4;
 757 
 758                 while (--i > 0  &&      (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 759                         if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
 760                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 761                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 762                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 763                 }
 764         }
 765         return NETDEV_TX_OK;
 766 }
 767 
 768 /* The EL3 interrupt handler. */
 769 static irqreturn_t
 770 el3_interrupt(int irq, void *dev_id)
 771 {
 772         struct net_device *dev = dev_id;
 773         struct el3_private *lp;
 774         int ioaddr, status;
 775         int i = max_interrupt_work;
 776 
 777         lp = netdev_priv(dev);
 778         spin_lock(&lp->lock);
 779 
 780         ioaddr = dev->base_addr;
 781 
 782         if (el3_debug > 4) {
 783                 status = inw(ioaddr + EL3_STATUS);
 784                 pr_debug("%s: interrupt, status %4.4x.\n", dev->name, status);
 785         }
 786 
 787         while ((status = inw(ioaddr + EL3_STATUS)) &
 788                    (IntLatch | RxComplete | StatsFull)) {
 789 
 790                 if (status & RxComplete)
 791                         el3_rx(dev);
 792 
 793                 if (status & TxAvailable) {
 794                         if (el3_debug > 5)
 795                                 pr_debug("      TX room bit was handled.\n");
 796                         /* There's room in the FIFO for a full-sized packet. */
 797                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 798                         netif_wake_queue (dev);
 799                 }
 800                 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
 801                         /* Handle all uncommon interrupts. */
 802                         if (status & StatsFull)                         /* Empty statistics. */
 803                                 update_stats(dev);
 804                         if (status & RxEarly) {                         /* Rx early is unused. */
 805                                 el3_rx(dev);
 806                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 807                         }
 808                         if (status & TxComplete) {                      /* Really Tx error. */
 809                                 short tx_status;
 810                                 int i = 4;
 811 
 812                                 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 813                                         if (tx_status & 0x38) dev->stats.tx_aborted_errors++;
 814                                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 815                                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 816                                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 817                                 }
 818                         }
 819                         if (status & AdapterFailure) {
 820                                 /* Adapter failure requires Rx reset and reinit. */
 821                                 outw(RxReset, ioaddr + EL3_CMD);
 822                                 /* Set the Rx filter to the current state. */
 823                                 outw(SetRxFilter | RxStation | RxBroadcast
 824                                          | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
 825                                          | (dev->flags & IFF_PROMISC ? RxProm : 0),
 826                                          ioaddr + EL3_CMD);
 827                                 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
 828                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 829                         }
 830                 }
 831 
 832                 if (--i < 0) {
 833                         pr_err("%s: Infinite loop in interrupt, status %4.4x.\n",
 834                                    dev->name, status);
 835                         /* Clear all interrupts. */
 836                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 837                         break;
 838                 }
 839                 /* Acknowledge the IRQ. */
 840                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
 841         }
 842 
 843         if (el3_debug > 4) {
 844                 pr_debug("%s: exiting interrupt, status %4.4x.\n", dev->name,
 845                            inw(ioaddr + EL3_STATUS));
 846         }
 847         spin_unlock(&lp->lock);
 848         return IRQ_HANDLED;
 849 }
 850 
 851 
 852 #ifdef CONFIG_NET_POLL_CONTROLLER
 853 /*
 854  * Polling receive - used by netconsole and other diagnostic tools
 855  * to allow network i/o with interrupts disabled.
 856  */
 857 static void el3_poll_controller(struct net_device *dev)
 858 {
 859         disable_irq(dev->irq);
 860         el3_interrupt(dev->irq, dev);
 861         enable_irq(dev->irq);
 862 }
 863 #endif
 864 
 865 static struct net_device_stats *
 866 el3_get_stats(struct net_device *dev)
 867 {
 868         struct el3_private *lp = netdev_priv(dev);
 869         unsigned long flags;
 870 
 871         /*
 872          *      This is fast enough not to bother with disable IRQ
 873          *      stuff.
 874          */
 875 
 876         spin_lock_irqsave(&lp->lock, flags);
 877         update_stats(dev);
 878         spin_unlock_irqrestore(&lp->lock, flags);
 879         return &dev->stats;
 880 }
 881 
 882 /*  Update statistics.  We change to register window 6, so this should be run
 883         single-threaded if the device is active. This is expected to be a rare
 884         operation, and it's simpler for the rest of the driver to assume that
 885         window 1 is always valid rather than use a special window-state variable.
 886         */
 887 static void update_stats(struct net_device *dev)
 888 {
 889         int ioaddr = dev->base_addr;
 890 
 891         if (el3_debug > 5)
 892                 pr_debug("   Updating the statistics.\n");
 893         /* Turn off statistics updates while reading. */
 894         outw(StatsDisable, ioaddr + EL3_CMD);
 895         /* Switch to the stats window, and read everything. */
 896         EL3WINDOW(6);
 897         dev->stats.tx_carrier_errors    += inb(ioaddr + 0);
 898         dev->stats.tx_heartbeat_errors  += inb(ioaddr + 1);
 899         /* Multiple collisions. */         inb(ioaddr + 2);
 900         dev->stats.collisions           += inb(ioaddr + 3);
 901         dev->stats.tx_window_errors     += inb(ioaddr + 4);
 902         dev->stats.rx_fifo_errors       += inb(ioaddr + 5);
 903         dev->stats.tx_packets           += inb(ioaddr + 6);
 904         /* Rx packets   */                 inb(ioaddr + 7);
 905         /* Tx deferrals */                 inb(ioaddr + 8);
 906         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
 907         inw(ioaddr + 12);
 908 
 909         /* Back to window 1, and turn statistics back on. */
 910         EL3WINDOW(1);
 911         outw(StatsEnable, ioaddr + EL3_CMD);
 912 }
 913 
 914 static int
 915 el3_rx(struct net_device *dev)
 916 {
 917         int ioaddr = dev->base_addr;
 918         short rx_status;
 919 
 920         if (el3_debug > 5)
 921                 pr_debug("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
 922                            inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
 923         while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
 924                 if (rx_status & 0x4000) { /* Error, update stats. */
 925                         short error = rx_status & 0x3800;
 926 
 927                         outw(RxDiscard, ioaddr + EL3_CMD);
 928                         dev->stats.rx_errors++;
 929                         switch (error) {
 930                         case 0x0000:            dev->stats.rx_over_errors++; break;
 931                         case 0x0800:            dev->stats.rx_length_errors++; break;
 932                         case 0x1000:            dev->stats.rx_frame_errors++; break;
 933                         case 0x1800:            dev->stats.rx_length_errors++; break;
 934                         case 0x2000:            dev->stats.rx_frame_errors++; break;
 935                         case 0x2800:            dev->stats.rx_crc_errors++; break;
 936                         }
 937                 } else {
 938                         short pkt_len = rx_status & 0x7ff;
 939                         struct sk_buff *skb;
 940 
 941                         skb = netdev_alloc_skb(dev, pkt_len + 5);
 942                         if (el3_debug > 4)
 943                                 pr_debug("Receiving packet size %d status %4.4x.\n",
 944                                            pkt_len, rx_status);
 945                         if (skb != NULL) {
 946                                 skb_reserve(skb, 2);     /* Align IP on 16 byte */
 947 
 948                                 /* 'skb->data' points to the start of sk_buff data area. */
 949                                 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
 950                                          (pkt_len + 3) >> 2);
 951 
 952                                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
 953                                 skb->protocol = eth_type_trans(skb,dev);
 954                                 netif_rx(skb);
 955                                 dev->stats.rx_bytes += pkt_len;
 956                                 dev->stats.rx_packets++;
 957                                 continue;
 958                         }
 959                         outw(RxDiscard, ioaddr + EL3_CMD);
 960                         dev->stats.rx_dropped++;
 961                         if (el3_debug)
 962                                 pr_debug("%s: Couldn't allocate a sk_buff of size %d.\n",
 963                                            dev->name, pkt_len);
 964                 }
 965                 inw(ioaddr + EL3_STATUS);                               /* Delay. */
 966                 while (inw(ioaddr + EL3_STATUS) & 0x1000)
 967                         pr_debug("      Waiting for 3c509 to discard packet, status %x.\n",
 968                                    inw(ioaddr + EL3_STATUS) );
 969         }
 970 
 971         return 0;
 972 }
 973 
 974 /*
 975  *     Set or clear the multicast filter for this adaptor.
 976  */
 977 static void
 978 set_multicast_list(struct net_device *dev)
 979 {
 980         unsigned long flags;
 981         struct el3_private *lp = netdev_priv(dev);
 982         int ioaddr = dev->base_addr;
 983         int mc_count = netdev_mc_count(dev);
 984 
 985         if (el3_debug > 1) {
 986                 static int old;
 987                 if (old != mc_count) {
 988                         old = mc_count;
 989                         pr_debug("%s: Setting Rx mode to %d addresses.\n",
 990                                  dev->name, mc_count);
 991                 }
 992         }
 993         spin_lock_irqsave(&lp->lock, flags);
 994         if (dev->flags&IFF_PROMISC) {
 995                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
 996                          ioaddr + EL3_CMD);
 997         }
 998         else if (mc_count || (dev->flags&IFF_ALLMULTI)) {
 999                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
1000         }
1001         else
1002                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1003         spin_unlock_irqrestore(&lp->lock, flags);
1004 }
1005 
1006 static int
1007 el3_close(struct net_device *dev)
1008 {
1009         int ioaddr = dev->base_addr;
1010         struct el3_private *lp = netdev_priv(dev);
1011 
1012         if (el3_debug > 2)
1013                 pr_debug("%s: Shutting down ethercard.\n", dev->name);
1014 
1015         el3_down(dev);
1016 
1017         free_irq(dev->irq, dev);
1018         /* Switching back to window 0 disables the IRQ. */
1019         EL3WINDOW(0);
1020         if (lp->type != EL3_EISA) {
1021                 /* But we explicitly zero the IRQ line select anyway. Don't do
1022                  * it on EISA cards, it prevents the module from getting an
1023                  * IRQ after unload+reload... */
1024                 outw(0x0f00, ioaddr + WN0_IRQ);
1025         }
1026 
1027         return 0;
1028 }
1029 
1030 static int
1031 el3_link_ok(struct net_device *dev)
1032 {
1033         int ioaddr = dev->base_addr;
1034         u16 tmp;
1035 
1036         EL3WINDOW(4);
1037         tmp = inw(ioaddr + WN4_MEDIA);
1038         EL3WINDOW(1);
1039         return tmp & (1<<11);
1040 }
1041 
1042 static void
1043 el3_netdev_get_ecmd(struct net_device *dev, struct ethtool_link_ksettings *cmd)
1044 {
1045         u16 tmp;
1046         int ioaddr = dev->base_addr;
1047         u32 supported;
1048 
1049         EL3WINDOW(0);
1050         /* obtain current transceiver via WN4_MEDIA? */
1051         tmp = inw(ioaddr + WN0_ADDR_CONF);
1052         switch (tmp >> 14) {
1053         case 0:
1054                 cmd->base.port = PORT_TP;
1055                 break;
1056         case 1:
1057                 cmd->base.port = PORT_AUI;
1058                 break;
1059         case 3:
1060                 cmd->base.port = PORT_BNC;
1061         default:
1062                 break;
1063         }
1064 
1065         cmd->base.duplex = DUPLEX_HALF;
1066         supported = 0;
1067         tmp = inw(ioaddr + WN0_CONF_CTRL);
1068         if (tmp & (1<<13))
1069                 supported |= SUPPORTED_AUI;
1070         if (tmp & (1<<12))
1071                 supported |= SUPPORTED_BNC;
1072         if (tmp & (1<<9)) {
1073                 supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half |
1074                                 SUPPORTED_10baseT_Full; /* hmm... */
1075                 EL3WINDOW(4);
1076                 tmp = inw(ioaddr + WN4_NETDIAG);
1077                 if (tmp & FD_ENABLE)
1078                         cmd->base.duplex = DUPLEX_FULL;
1079         }
1080 
1081         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
1082                                                 supported);
1083         cmd->base.speed = SPEED_10;
1084         EL3WINDOW(1);
1085 }
1086 
1087 static int
1088 el3_netdev_set_ecmd(struct net_device *dev,
1089                     const struct ethtool_link_ksettings *cmd)
1090 {
1091         u16 tmp;
1092         int ioaddr = dev->base_addr;
1093 
1094         if (cmd->base.speed != SPEED_10)
1095                 return -EINVAL;
1096         if ((cmd->base.duplex != DUPLEX_HALF) &&
1097             (cmd->base.duplex != DUPLEX_FULL))
1098                 return -EINVAL;
1099 
1100         /* change XCVR type */
1101         EL3WINDOW(0);
1102         tmp = inw(ioaddr + WN0_ADDR_CONF);
1103         switch (cmd->base.port) {
1104         case PORT_TP:
1105                 tmp &= ~(3<<14);
1106                 dev->if_port = 0;
1107                 break;
1108         case PORT_AUI:
1109                 tmp |= (1<<14);
1110                 dev->if_port = 1;
1111                 break;
1112         case PORT_BNC:
1113                 tmp |= (3<<14);
1114                 dev->if_port = 3;
1115                 break;
1116         default:
1117                 return -EINVAL;
1118         }
1119 
1120         outw(tmp, ioaddr + WN0_ADDR_CONF);
1121         if (dev->if_port == 3) {
1122                 /* fire up the DC-DC convertor if BNC gets enabled */
1123                 tmp = inw(ioaddr + WN0_ADDR_CONF);
1124                 if (tmp & (3 << 14)) {
1125                         outw(StartCoax, ioaddr + EL3_CMD);
1126                         udelay(800);
1127                 } else
1128                         return -EIO;
1129         }
1130 
1131         EL3WINDOW(4);
1132         tmp = inw(ioaddr + WN4_NETDIAG);
1133         if (cmd->base.duplex == DUPLEX_FULL)
1134                 tmp |= FD_ENABLE;
1135         else
1136                 tmp &= ~FD_ENABLE;
1137         outw(tmp, ioaddr + WN4_NETDIAG);
1138         EL3WINDOW(1);
1139 
1140         return 0;
1141 }
1142 
1143 static void el3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1144 {
1145         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1146         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1147 }
1148 
1149 static int el3_get_link_ksettings(struct net_device *dev,
1150                                   struct ethtool_link_ksettings *cmd)
1151 {
1152         struct el3_private *lp = netdev_priv(dev);
1153 
1154         spin_lock_irq(&lp->lock);
1155         el3_netdev_get_ecmd(dev, cmd);
1156         spin_unlock_irq(&lp->lock);
1157         return 0;
1158 }
1159 
1160 static int el3_set_link_ksettings(struct net_device *dev,
1161                                   const struct ethtool_link_ksettings *cmd)
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, cmd);
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_link = el3_get_link,
1196         .get_msglevel = el3_get_msglevel,
1197         .set_msglevel = el3_set_msglevel,
1198         .get_link_ksettings = el3_get_link_ksettings,
1199         .set_link_ksettings = el3_set_link_ksettings,
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                                 /* fall through */
1270                         case 8:
1271                                 /* set full-duplex mode based on eeprom config setting */
1272                                 if ((sw_info & 0x000f) && (sw_info & 0x8000)) {
1273                                         pr_cont("Setting 3c5x9b full-duplex mode (from EEPROM configuration bit)");
1274                                         break;
1275                                 }
1276                                 /* fall through */
1277                         default:
1278                                 /* xcvr=(0 || 4) OR user has an old 3c5x9 non "B" model */
1279                                 pr_cont("Setting 3c5x9/3c5x9B half-duplex mode");
1280                                 net_diag = (net_diag & ~FD_ENABLE); /* disable full duplex */
1281                 }
1282 
1283                 outw(net_diag, ioaddr + WN4_NETDIAG);
1284                 pr_cont(" if_port: %d, sw_info: %4.4x\n", dev->if_port, sw_info);
1285                 if (el3_debug > 3)
1286                         pr_debug("%s: 3c5x9 net diag word is now: %4.4x.\n", dev->name, net_diag);
1287                 /* Enable link beat and jabber check. */
1288                 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
1289         }
1290 
1291         /* Switch to the stats window, and clear all stats by reading. */
1292         outw(StatsDisable, ioaddr + EL3_CMD);
1293         EL3WINDOW(6);
1294         for (i = 0; i < 9; i++)
1295                 inb(ioaddr + i);
1296         inw(ioaddr + 10);
1297         inw(ioaddr + 12);
1298 
1299         /* Switch to register set 1 for normal use. */
1300         EL3WINDOW(1);
1301 
1302         /* Accept b-case and phys addr only. */
1303         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
1304         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1305 
1306         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1307         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1308         /* Allow status bits to be seen. */
1309         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
1310         /* Ack all pending events, and set active indicator mask. */
1311         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1312                  ioaddr + EL3_CMD);
1313         outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
1314                  ioaddr + EL3_CMD);
1315 
1316         netif_start_queue(dev);
1317 }
1318 
1319 /* Power Management support functions */
1320 #ifdef CONFIG_PM
1321 
1322 static int
1323 el3_suspend(struct device *pdev, pm_message_t state)
1324 {
1325         unsigned long flags;
1326         struct net_device *dev;
1327         struct el3_private *lp;
1328         int ioaddr;
1329 
1330         dev = dev_get_drvdata(pdev);
1331         lp = netdev_priv(dev);
1332         ioaddr = dev->base_addr;
1333 
1334         spin_lock_irqsave(&lp->lock, flags);
1335 
1336         if (netif_running(dev))
1337                 netif_device_detach(dev);
1338 
1339         el3_down(dev);
1340         outw(PowerDown, ioaddr + EL3_CMD);
1341 
1342         spin_unlock_irqrestore(&lp->lock, flags);
1343         return 0;
1344 }
1345 
1346 static int
1347 el3_resume(struct device *pdev)
1348 {
1349         unsigned long flags;
1350         struct net_device *dev;
1351         struct el3_private *lp;
1352         int ioaddr;
1353 
1354         dev = dev_get_drvdata(pdev);
1355         lp = netdev_priv(dev);
1356         ioaddr = dev->base_addr;
1357 
1358         spin_lock_irqsave(&lp->lock, flags);
1359 
1360         outw(PowerUp, ioaddr + EL3_CMD);
1361         EL3WINDOW(0);
1362         el3_up(dev);
1363 
1364         if (netif_running(dev))
1365                 netif_device_attach(dev);
1366 
1367         spin_unlock_irqrestore(&lp->lock, flags);
1368         return 0;
1369 }
1370 
1371 #endif /* CONFIG_PM */
1372 
1373 module_param(debug,int, 0);
1374 module_param_hw_array(irq, int, irq, NULL, 0);
1375 module_param(max_interrupt_work, int, 0);
1376 MODULE_PARM_DESC(debug, "debug level (0-6)");
1377 MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
1378 MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt");
1379 #ifdef CONFIG_PNP
1380 module_param(nopnp, int, 0);
1381 MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)");
1382 #endif  /* CONFIG_PNP */
1383 MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver");
1384 MODULE_LICENSE("GPL");
1385 
1386 static int __init el3_init_module(void)
1387 {
1388         int ret = 0;
1389 
1390         if (debug >= 0)
1391                 el3_debug = debug;
1392 
1393 #ifdef CONFIG_PNP
1394         if (!nopnp) {
1395                 ret = pnp_register_driver(&el3_pnp_driver);
1396                 if (!ret)
1397                         pnp_registered = 1;
1398         }
1399 #endif
1400         /* Select an open I/O location at 0x1*0 to do ISA contention select. */
1401         /* Start with 0x110 to avoid some sound cards.*/
1402         for (id_port = 0x110 ; id_port < 0x200; id_port += 0x10) {
1403                 if (!request_region(id_port, 1, "3c509-control"))
1404                         continue;
1405                 outb(0x00, id_port);
1406                 outb(0xff, id_port);
1407                 if (inb(id_port) & 0x01)
1408                         break;
1409                 else
1410                         release_region(id_port, 1);
1411         }
1412         if (id_port >= 0x200) {
1413                 id_port = 0;
1414                 pr_err("No I/O port available for 3c509 activation.\n");
1415         } else {
1416                 ret = isa_register_driver(&el3_isa_driver, EL3_MAX_CARDS);
1417                 if (!ret)
1418                         isa_registered = 1;
1419         }
1420 #ifdef CONFIG_EISA
1421         ret = eisa_driver_register(&el3_eisa_driver);
1422         if (!ret)
1423                 eisa_registered = 1;
1424 #endif
1425 
1426 #ifdef CONFIG_PNP
1427         if (pnp_registered)
1428                 ret = 0;
1429 #endif
1430         if (isa_registered)
1431                 ret = 0;
1432 #ifdef CONFIG_EISA
1433         if (eisa_registered)
1434                 ret = 0;
1435 #endif
1436         return ret;
1437 }
1438 
1439 static void __exit el3_cleanup_module(void)
1440 {
1441 #ifdef CONFIG_PNP
1442         if (pnp_registered)
1443                 pnp_unregister_driver(&el3_pnp_driver);
1444 #endif
1445         if (isa_registered)
1446                 isa_unregister_driver(&el3_isa_driver);
1447         if (id_port)
1448                 release_region(id_port, 1);
1449 #ifdef CONFIG_EISA
1450         if (eisa_registered)
1451                 eisa_driver_unregister(&el3_eisa_driver);
1452 #endif
1453 }
1454 
1455 module_init (el3_init_module);
1456 module_exit (el3_cleanup_module);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/net/ethernet/3com/3c509.c

DEFINITIONS
