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