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 = ðtool_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); 1457