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 95static char version[] = DRV_NAME ".c:" DRV_VERSION " " DRV_RELDATE " becker@scyld.com\n"; 96 97#ifdef EL3_DEBUG 98static int el3_debug = EL3_DEBUG; 99#else 100static 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 */ 106static 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. */ 125enum 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 135enum 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: */ 141enum 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 165enum el3_cardtype { EL3_ISA, EL3_PNP, EL3_EISA }; 166 167struct 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}; 174static int id_port; 175static int current_tag; 176static struct net_device *el3_devs[EL3_MAX_CARDS]; 177 178/* Parameters that may be passed into the module. */ 179static int debug = -1; 180static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1}; 181/* Maximum events (Rx packets, etc.) to handle at each interrupt. */ 182static int max_interrupt_work = 10; 183#ifdef CONFIG_PNP 184static int nopnp; 185#endif 186 187static int el3_common_init(struct net_device *dev); 188static void el3_common_remove(struct net_device *dev); 189static ushort id_read_eeprom(int index); 190static ushort read_eeprom(int ioaddr, int index); 191static int el3_open(struct net_device *dev); 192static netdev_tx_t el3_start_xmit(struct sk_buff *skb, struct net_device *dev); 193static irqreturn_t el3_interrupt(int irq, void *dev_id); 194static void update_stats(struct net_device *dev); 195static struct net_device_stats *el3_get_stats(struct net_device *dev); 196static int el3_rx(struct net_device *dev); 197static int el3_close(struct net_device *dev); 198static void set_multicast_list(struct net_device *dev); 199static void el3_tx_timeout (struct net_device *dev); 200static void el3_down(struct net_device *dev); 201static void el3_up(struct net_device *dev); 202static const struct ethtool_ops ethtool_ops; 203#ifdef CONFIG_PM 204static int el3_suspend(struct device *, pm_message_t); 205static 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 */ 213static int el3_device_remove (struct device *device); 214#ifdef CONFIG_NET_POLL_CONTROLLER 215static 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 */ 219static 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 272static 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 284static 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 342static 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 351static 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 358static 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 381static 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}; 392static int isa_registered; 393 394#ifdef CONFIG_PNP 395static 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}; 405MODULE_DEVICE_TABLE(pnp, el3_pnp_ids); 406 407static 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 445static 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 452static int el3_pnp_suspend(struct pnp_dev *pdev, pm_message_t state) 453{ 454 return el3_suspend(&pdev->dev, state); 455} 456 457static int el3_pnp_resume(struct pnp_dev *pdev) 458{ 459 return el3_resume(&pdev->dev); 460} 461#endif 462 463static 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}; 473static int pnp_registered; 474#endif /* CONFIG_PNP */ 475 476#ifdef CONFIG_EISA 477static struct eisa_device_id el3_eisa_ids[] = { 478 { "TCM5090" }, 479 { "TCM5091" }, 480 { "TCM5092" }, 481 { "TCM5093" }, 482 { "TCM5094" }, 483 { "TCM5095" }, 484 { "TCM5098" }, 485 { "" } 486}; 487MODULE_DEVICE_TABLE(eisa, el3_eisa_ids); 488 489static int el3_eisa_probe (struct device *device); 490 491static 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}; 501static int eisa_registered; 502#endif 503 504static 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 519static 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 dev->ethtool_ops = ðtool_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 557static 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 565static 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 */ 619static 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 */ 632static 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. */ 642static 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 664static int 665el3_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 692static void 693el3_tx_timeout (struct net_device *dev) 694{ 695 int ioaddr = dev->base_addr; 696 697 /* Transmitter timeout, serious problems. */ 698 pr_warn("%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 710static netdev_tx_t 711el3_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_consume_skb_any (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. */ 770static irqreturn_t 771el3_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 */ 858static 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 866static struct net_device_stats * 867el3_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 */ 888static 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 915static int 916el3_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 */ 978static void 979set_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 1007static int 1008el3_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 1031static int 1032el3_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 1043static int 1044el3_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 1088static int 1089el3_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 1144static 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 1150static 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 1161static 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 1172static 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 1183static u32 el3_get_msglevel(struct net_device *dev) 1184{ 1185 return el3_debug; 1186} 1187 1188static void el3_set_msglevel(struct net_device *dev, u32 v) 1189{ 1190 el3_debug = v; 1191} 1192 1193static 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 1202static void 1203el3_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 1230static void 1231el3_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 1320static int 1321el3_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 1344static int 1345el3_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 1371module_param(debug,int, 0); 1372module_param_array(irq, int, NULL, 0); 1373module_param(max_interrupt_work, int, 0); 1374MODULE_PARM_DESC(debug, "debug level (0-6)"); 1375MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)"); 1376MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt"); 1377#ifdef CONFIG_PNP 1378module_param(nopnp, int, 0); 1379MODULE_PARM_DESC(nopnp, "disable ISA PnP support (0-1)"); 1380#endif /* CONFIG_PNP */ 1381MODULE_DESCRIPTION("3Com Etherlink III (3c509, 3c509B, 3c529, 3c579) ethernet driver"); 1382MODULE_LICENSE("GPL"); 1383 1384static 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 1437static 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 1453module_init (el3_init_module); 1454module_exit (el3_cleanup_module); 1455