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