1 /* ====================================================================== 2 * 3 * A PCMCIA ethernet driver for the 3com 3c589 card. 4 * 5 * Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net 6 * 7 * 3c589_cs.c 1.162 2001/10/13 00:08:50 8 * 9 * The network driver code is based on Donald Becker's 3c589 code: 10 * 11 * Written 1994 by Donald Becker. 12 * Copyright 1993 United States Government as represented by the 13 * Director, National Security Agency. This software may be used and 14 * distributed according to the terms of the GNU General Public License, 15 * incorporated herein by reference. 16 * Donald Becker may be reached at becker@scyld.com 17 * 18 * Updated for 2.5.x by Alan Cox <alan@lxorguk.ukuu.org.uk> 19 * 20 * ====================================================================== 21 */ 22 23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 24 25 #define DRV_NAME "3c589_cs" 26 #define DRV_VERSION "1.162-ac" 27 28 #include <linux/module.h> 29 #include <linux/kernel.h> 30 #include <linux/ptrace.h> 31 #include <linux/slab.h> 32 #include <linux/string.h> 33 #include <linux/timer.h> 34 #include <linux/interrupt.h> 35 #include <linux/in.h> 36 #include <linux/delay.h> 37 #include <linux/ethtool.h> 38 #include <linux/netdevice.h> 39 #include <linux/etherdevice.h> 40 #include <linux/skbuff.h> 41 #include <linux/if_arp.h> 42 #include <linux/ioport.h> 43 #include <linux/bitops.h> 44 #include <linux/jiffies.h> 45 #include <linux/uaccess.h> 46 #include <linux/io.h> 47 48 #include <pcmcia/cistpl.h> 49 #include <pcmcia/cisreg.h> 50 #include <pcmcia/ciscode.h> 51 #include <pcmcia/ds.h> 52 53 54 /* To minimize the size of the driver source I only define operating 55 * constants if they are used several times. You'll need the manual 56 * if you want to understand driver details. 57 */ 58 59 /* Offsets from base I/O address. */ 60 #define EL3_DATA 0x00 61 #define EL3_TIMER 0x0a 62 #define EL3_CMD 0x0e 63 #define EL3_STATUS 0x0e 64 65 #define EEPROM_READ 0x0080 66 #define EEPROM_BUSY 0x8000 67 68 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD) 69 70 /* The top five bits written to EL3_CMD are a command, the lower 71 * 11 bits are the parameter, if applicable. 72 */ 73 74 enum c509cmd { 75 TotalReset = 0<<11, 76 SelectWindow = 1<<11, 77 StartCoax = 2<<11, 78 RxDisable = 3<<11, 79 RxEnable = 4<<11, 80 RxReset = 5<<11, 81 RxDiscard = 8<<11, 82 TxEnable = 9<<11, 83 TxDisable = 10<<11, 84 TxReset = 11<<11, 85 FakeIntr = 12<<11, 86 AckIntr = 13<<11, 87 SetIntrEnb = 14<<11, 88 SetStatusEnb = 15<<11, 89 SetRxFilter = 16<<11, 90 SetRxThreshold = 17<<11, 91 SetTxThreshold = 18<<11, 92 SetTxStart = 19<<11, 93 StatsEnable = 21<<11, 94 StatsDisable = 22<<11, 95 StopCoax = 23<<11 96 }; 97 98 enum c509status { 99 IntLatch = 0x0001, 100 AdapterFailure = 0x0002, 101 TxComplete = 0x0004, 102 TxAvailable = 0x0008, 103 RxComplete = 0x0010, 104 RxEarly = 0x0020, 105 IntReq = 0x0040, 106 StatsFull = 0x0080, 107 CmdBusy = 0x1000 108 }; 109 110 /* The SetRxFilter command accepts the following classes: */ 111 enum RxFilter { 112 RxStation = 1, 113 RxMulticast = 2, 114 RxBroadcast = 4, 115 RxProm = 8 116 }; 117 118 /* Register window 1 offsets, the window used in normal operation. */ 119 #define TX_FIFO 0x00 120 #define RX_FIFO 0x00 121 #define RX_STATUS 0x08 122 #define TX_STATUS 0x0B 123 #define TX_FREE 0x0C /* Remaining free bytes in Tx buffer. */ 124 125 #define WN0_IRQ 0x08 /* Window 0: Set IRQ line in bits 12-15. */ 126 #define WN4_MEDIA 0x0A /* Window 4: Various transcvr/media bits. */ 127 #define MEDIA_TP 0x00C0 /* Enable link beat and jabber for 10baseT. */ 128 #define MEDIA_LED 0x0001 /* Enable link light on 3C589E cards. */ 129 130 /* Time in jiffies before concluding Tx hung */ 131 #define TX_TIMEOUT ((400*HZ)/1000) 132 133 struct el3_private { 134 struct pcmcia_device *p_dev; 135 /* For transceiver monitoring */ 136 struct timer_list media; 137 u16 media_status; 138 u16 fast_poll; 139 unsigned long last_irq; 140 spinlock_t lock; 141 }; 142 143 static const char *if_names[] = { "auto", "10baseT", "10base2", "AUI" }; 144 145 /*====================================================================*/ 146 147 /* Module parameters */ 148 149 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>"); 150 MODULE_DESCRIPTION("3Com 3c589 series PCMCIA ethernet driver"); 151 MODULE_LICENSE("GPL"); 152 153 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0) 154 155 /* Special hook for setting if_port when module is loaded */ 156 INT_MODULE_PARM(if_port, 0); 157 158 159 /*====================================================================*/ 160 161 static int tc589_config(struct pcmcia_device *link); 162 static void tc589_release(struct pcmcia_device *link); 163 164 static u16 read_eeprom(unsigned int ioaddr, int index); 165 static void tc589_reset(struct net_device *dev); 166 static void media_check(unsigned long arg); 167 static int el3_config(struct net_device *dev, struct ifmap *map); 168 static int el3_open(struct net_device *dev); 169 static netdev_tx_t el3_start_xmit(struct sk_buff *skb, 170 struct net_device *dev); 171 static irqreturn_t el3_interrupt(int irq, void *dev_id); 172 static void update_stats(struct net_device *dev); 173 static struct net_device_stats *el3_get_stats(struct net_device *dev); 174 static int el3_rx(struct net_device *dev); 175 static int el3_close(struct net_device *dev); 176 static void el3_tx_timeout(struct net_device *dev); 177 static void set_rx_mode(struct net_device *dev); 178 static void set_multicast_list(struct net_device *dev); 179 static const struct ethtool_ops netdev_ethtool_ops; 180 181 static void tc589_detach(struct pcmcia_device *p_dev); 182 183 static const struct net_device_ops el3_netdev_ops = { 184 .ndo_open = el3_open, 185 .ndo_stop = el3_close, 186 .ndo_start_xmit = el3_start_xmit, 187 .ndo_tx_timeout = el3_tx_timeout, 188 .ndo_set_config = el3_config, 189 .ndo_get_stats = el3_get_stats, 190 .ndo_set_rx_mode = set_multicast_list, 191 .ndo_change_mtu = eth_change_mtu, 192 .ndo_set_mac_address = eth_mac_addr, 193 .ndo_validate_addr = eth_validate_addr, 194 }; 195 196 static int tc589_probe(struct pcmcia_device *link) 197 { 198 struct el3_private *lp; 199 struct net_device *dev; 200 201 dev_dbg(&link->dev, "3c589_attach()\n"); 202 203 /* Create new ethernet device */ 204 dev = alloc_etherdev(sizeof(struct el3_private)); 205 if (!dev) 206 return -ENOMEM; 207 lp = netdev_priv(dev); 208 link->priv = dev; 209 lp->p_dev = link; 210 211 spin_lock_init(&lp->lock); 212 link->resource[0]->end = 16; 213 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16; 214 215 link->config_flags |= CONF_ENABLE_IRQ; 216 link->config_index = 1; 217 218 dev->netdev_ops = &el3_netdev_ops; 219 dev->watchdog_timeo = TX_TIMEOUT; 220 221 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops); 222 223 return tc589_config(link); 224 } 225 226 static void tc589_detach(struct pcmcia_device *link) 227 { 228 struct net_device *dev = link->priv; 229 230 dev_dbg(&link->dev, "3c589_detach\n"); 231 232 unregister_netdev(dev); 233 234 tc589_release(link); 235 236 free_netdev(dev); 237 } /* tc589_detach */ 238 239 static int tc589_config(struct pcmcia_device *link) 240 { 241 struct net_device *dev = link->priv; 242 __be16 *phys_addr; 243 int ret, i, j, multi = 0, fifo; 244 unsigned int ioaddr; 245 static const char * const ram_split[] = {"5:3", "3:1", "1:1", "3:5"}; 246 u8 *buf; 247 size_t len; 248 249 dev_dbg(&link->dev, "3c589_config\n"); 250 251 phys_addr = (__be16 *)dev->dev_addr; 252 /* Is this a 3c562? */ 253 if (link->manf_id != MANFID_3COM) 254 dev_info(&link->dev, "hmmm, is this really a 3Com card??\n"); 255 multi = (link->card_id == PRODID_3COM_3C562); 256 257 link->io_lines = 16; 258 259 /* For the 3c562, the base address must be xx00-xx7f */ 260 for (i = j = 0; j < 0x400; j += 0x10) { 261 if (multi && (j & 0x80)) 262 continue; 263 link->resource[0]->start = j ^ 0x300; 264 i = pcmcia_request_io(link); 265 if (i == 0) 266 break; 267 } 268 if (i != 0) 269 goto failed; 270 271 ret = pcmcia_request_irq(link, el3_interrupt); 272 if (ret) 273 goto failed; 274 275 ret = pcmcia_enable_device(link); 276 if (ret) 277 goto failed; 278 279 dev->irq = link->irq; 280 dev->base_addr = link->resource[0]->start; 281 ioaddr = dev->base_addr; 282 EL3WINDOW(0); 283 284 /* The 3c589 has an extra EEPROM for configuration info, including 285 * the hardware address. The 3c562 puts the address in the CIS. 286 */ 287 len = pcmcia_get_tuple(link, 0x88, &buf); 288 if (buf && len >= 6) { 289 for (i = 0; i < 3; i++) 290 phys_addr[i] = htons(le16_to_cpu(buf[i*2])); 291 kfree(buf); 292 } else { 293 kfree(buf); /* 0 < len < 6 */ 294 for (i = 0; i < 3; i++) 295 phys_addr[i] = htons(read_eeprom(ioaddr, i)); 296 if (phys_addr[0] == htons(0x6060)) { 297 dev_err(&link->dev, "IO port conflict at 0x%03lx-0x%03lx\n", 298 dev->base_addr, dev->base_addr+15); 299 goto failed; 300 } 301 } 302 303 /* The address and resource configuration register aren't loaded from 304 * the EEPROM and *must* be set to 0 and IRQ3 for the PCMCIA version. 305 */ 306 307 outw(0x3f00, ioaddr + 8); 308 fifo = inl(ioaddr); 309 310 /* The if_port symbol can be set when the module is loaded */ 311 if ((if_port >= 0) && (if_port <= 3)) 312 dev->if_port = if_port; 313 else 314 dev_err(&link->dev, "invalid if_port requested\n"); 315 316 SET_NETDEV_DEV(dev, &link->dev); 317 318 if (register_netdev(dev) != 0) { 319 dev_err(&link->dev, "register_netdev() failed\n"); 320 goto failed; 321 } 322 323 netdev_info(dev, "3Com 3c%s, io %#3lx, irq %d, hw_addr %pM\n", 324 (multi ? "562" : "589"), dev->base_addr, dev->irq, 325 dev->dev_addr); 326 netdev_info(dev, " %dK FIFO split %s Rx:Tx, %s xcvr\n", 327 (fifo & 7) ? 32 : 8, ram_split[(fifo >> 16) & 3], 328 if_names[dev->if_port]); 329 return 0; 330 331 failed: 332 tc589_release(link); 333 return -ENODEV; 334 } /* tc589_config */ 335 336 static void tc589_release(struct pcmcia_device *link) 337 { 338 pcmcia_disable_device(link); 339 } 340 341 static int tc589_suspend(struct pcmcia_device *link) 342 { 343 struct net_device *dev = link->priv; 344 345 if (link->open) 346 netif_device_detach(dev); 347 348 return 0; 349 } 350 351 static int tc589_resume(struct pcmcia_device *link) 352 { 353 struct net_device *dev = link->priv; 354 355 if (link->open) { 356 tc589_reset(dev); 357 netif_device_attach(dev); 358 } 359 360 return 0; 361 } 362 363 /*====================================================================*/ 364 365 /* Use this for commands that may take time to finish */ 366 367 static void tc589_wait_for_completion(struct net_device *dev, int cmd) 368 { 369 int i = 100; 370 outw(cmd, dev->base_addr + EL3_CMD); 371 while (--i > 0) 372 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) 373 break; 374 if (i == 0) 375 netdev_warn(dev, "command 0x%04x did not complete!\n", cmd); 376 } 377 378 /* Read a word from the EEPROM using the regular EEPROM access register. 379 * Assume that we are in register window zero. 380 */ 381 382 static u16 read_eeprom(unsigned int ioaddr, int index) 383 { 384 int i; 385 outw(EEPROM_READ + index, ioaddr + 10); 386 /* Reading the eeprom takes 162 us */ 387 for (i = 1620; i >= 0; i--) 388 if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0) 389 break; 390 return inw(ioaddr + 12); 391 } 392 393 /* Set transceiver type, perhaps to something other than what the user 394 * specified in dev->if_port. 395 */ 396 397 static void tc589_set_xcvr(struct net_device *dev, int if_port) 398 { 399 struct el3_private *lp = netdev_priv(dev); 400 unsigned int ioaddr = dev->base_addr; 401 402 EL3WINDOW(0); 403 switch (if_port) { 404 case 0: 405 case 1: 406 outw(0, ioaddr + 6); 407 break; 408 case 2: 409 outw(3<<14, ioaddr + 6); 410 break; 411 case 3: 412 outw(1<<14, ioaddr + 6); 413 break; 414 } 415 /* On PCMCIA, this just turns on the LED */ 416 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD); 417 /* 10baseT interface, enable link beat and jabber check. */ 418 EL3WINDOW(4); 419 outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA); 420 EL3WINDOW(1); 421 if (if_port == 2) 422 lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000); 423 else 424 lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800); 425 } 426 427 static void dump_status(struct net_device *dev) 428 { 429 unsigned int ioaddr = dev->base_addr; 430 EL3WINDOW(1); 431 netdev_info(dev, " irq status %04x, rx status %04x, tx status %02x tx free %04x\n", 432 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS), 433 inb(ioaddr+TX_STATUS), inw(ioaddr+TX_FREE)); 434 EL3WINDOW(4); 435 netdev_info(dev, " diagnostics: fifo %04x net %04x ethernet %04x media %04x\n", 436 inw(ioaddr+0x04), inw(ioaddr+0x06), inw(ioaddr+0x08), 437 inw(ioaddr+0x0a)); 438 EL3WINDOW(1); 439 } 440 441 /* Reset and restore all of the 3c589 registers. */ 442 static void tc589_reset(struct net_device *dev) 443 { 444 unsigned int ioaddr = dev->base_addr; 445 int i; 446 447 EL3WINDOW(0); 448 outw(0x0001, ioaddr + 4); /* Activate board. */ 449 outw(0x3f00, ioaddr + 8); /* Set the IRQ line. */ 450 451 /* Set the station address in window 2. */ 452 EL3WINDOW(2); 453 for (i = 0; i < 6; i++) 454 outb(dev->dev_addr[i], ioaddr + i); 455 456 tc589_set_xcvr(dev, dev->if_port); 457 458 /* Switch to the stats window, and clear all stats by reading. */ 459 outw(StatsDisable, ioaddr + EL3_CMD); 460 EL3WINDOW(6); 461 for (i = 0; i < 9; i++) 462 inb(ioaddr+i); 463 inw(ioaddr + 10); 464 inw(ioaddr + 12); 465 466 /* Switch to register set 1 for normal use. */ 467 EL3WINDOW(1); 468 469 set_rx_mode(dev); 470 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */ 471 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */ 472 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */ 473 /* Allow status bits to be seen. */ 474 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD); 475 /* Ack all pending events, and set active indicator mask. */ 476 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq, 477 ioaddr + EL3_CMD); 478 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull 479 | AdapterFailure, ioaddr + EL3_CMD); 480 } 481 482 static void netdev_get_drvinfo(struct net_device *dev, 483 struct ethtool_drvinfo *info) 484 { 485 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 486 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 487 snprintf(info->bus_info, sizeof(info->bus_info), 488 "PCMCIA 0x%lx", dev->base_addr); 489 } 490 491 static const struct ethtool_ops netdev_ethtool_ops = { 492 .get_drvinfo = netdev_get_drvinfo, 493 }; 494 495 static int el3_config(struct net_device *dev, struct ifmap *map) 496 { 497 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) { 498 if (map->port <= 3) { 499 dev->if_port = map->port; 500 netdev_info(dev, "switched to %s port\n", if_names[dev->if_port]); 501 tc589_set_xcvr(dev, dev->if_port); 502 } else { 503 return -EINVAL; 504 } 505 } 506 return 0; 507 } 508 509 static int el3_open(struct net_device *dev) 510 { 511 struct el3_private *lp = netdev_priv(dev); 512 struct pcmcia_device *link = lp->p_dev; 513 514 if (!pcmcia_dev_present(link)) 515 return -ENODEV; 516 517 link->open++; 518 netif_start_queue(dev); 519 520 tc589_reset(dev); 521 init_timer(&lp->media); 522 lp->media.function = media_check; 523 lp->media.data = (unsigned long) dev; 524 lp->media.expires = jiffies + HZ; 525 add_timer(&lp->media); 526 527 dev_dbg(&link->dev, "%s: opened, status %4.4x.\n", 528 dev->name, inw(dev->base_addr + EL3_STATUS)); 529 530 return 0; 531 } 532 533 static void el3_tx_timeout(struct net_device *dev) 534 { 535 unsigned int ioaddr = dev->base_addr; 536 537 netdev_warn(dev, "Transmit timed out!\n"); 538 dump_status(dev); 539 dev->stats.tx_errors++; 540 dev->trans_start = jiffies; /* prevent tx timeout */ 541 /* Issue TX_RESET and TX_START commands. */ 542 tc589_wait_for_completion(dev, TxReset); 543 outw(TxEnable, ioaddr + EL3_CMD); 544 netif_wake_queue(dev); 545 } 546 547 static void pop_tx_status(struct net_device *dev) 548 { 549 unsigned int ioaddr = dev->base_addr; 550 int i; 551 552 /* Clear the Tx status stack. */ 553 for (i = 32; i > 0; i--) { 554 u_char tx_status = inb(ioaddr + TX_STATUS); 555 if (!(tx_status & 0x84)) 556 break; 557 /* reset transmitter on jabber error or underrun */ 558 if (tx_status & 0x30) 559 tc589_wait_for_completion(dev, TxReset); 560 if (tx_status & 0x38) { 561 netdev_dbg(dev, "transmit error: status 0x%02x\n", tx_status); 562 outw(TxEnable, ioaddr + EL3_CMD); 563 dev->stats.tx_aborted_errors++; 564 } 565 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */ 566 } 567 } 568 569 static netdev_tx_t el3_start_xmit(struct sk_buff *skb, 570 struct net_device *dev) 571 { 572 unsigned int ioaddr = dev->base_addr; 573 struct el3_private *priv = netdev_priv(dev); 574 unsigned long flags; 575 576 netdev_dbg(dev, "el3_start_xmit(length = %ld) called, status %4.4x.\n", 577 (long)skb->len, inw(ioaddr + EL3_STATUS)); 578 579 spin_lock_irqsave(&priv->lock, flags); 580 581 dev->stats.tx_bytes += skb->len; 582 583 /* Put out the doubleword header... */ 584 outw(skb->len, ioaddr + TX_FIFO); 585 outw(0x00, ioaddr + TX_FIFO); 586 /* ... and the packet rounded to a doubleword. */ 587 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2); 588 589 if (inw(ioaddr + TX_FREE) <= 1536) { 590 netif_stop_queue(dev); 591 /* Interrupt us when the FIFO has room for max-sized packet. */ 592 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD); 593 } 594 595 pop_tx_status(dev); 596 spin_unlock_irqrestore(&priv->lock, flags); 597 dev_kfree_skb(skb); 598 599 return NETDEV_TX_OK; 600 } 601 602 /* The EL3 interrupt handler. */ 603 static irqreturn_t el3_interrupt(int irq, void *dev_id) 604 { 605 struct net_device *dev = (struct net_device *) dev_id; 606 struct el3_private *lp = netdev_priv(dev); 607 unsigned int ioaddr; 608 __u16 status; 609 int i = 0, handled = 1; 610 611 if (!netif_device_present(dev)) 612 return IRQ_NONE; 613 614 ioaddr = dev->base_addr; 615 616 netdev_dbg(dev, "interrupt, status %4.4x.\n", inw(ioaddr + EL3_STATUS)); 617 618 spin_lock(&lp->lock); 619 while ((status = inw(ioaddr + EL3_STATUS)) & 620 (IntLatch | RxComplete | StatsFull)) { 621 if ((status & 0xe000) != 0x2000) { 622 netdev_dbg(dev, "interrupt from dead card\n"); 623 handled = 0; 624 break; 625 } 626 if (status & RxComplete) 627 el3_rx(dev); 628 if (status & TxAvailable) { 629 netdev_dbg(dev, " TX room bit was handled.\n"); 630 /* There's room in the FIFO for a full-sized packet. */ 631 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD); 632 netif_wake_queue(dev); 633 } 634 if (status & TxComplete) 635 pop_tx_status(dev); 636 if (status & (AdapterFailure | RxEarly | StatsFull)) { 637 /* Handle all uncommon interrupts. */ 638 if (status & StatsFull) /* Empty statistics. */ 639 update_stats(dev); 640 if (status & RxEarly) { 641 /* Rx early is unused. */ 642 el3_rx(dev); 643 outw(AckIntr | RxEarly, ioaddr + EL3_CMD); 644 } 645 if (status & AdapterFailure) { 646 u16 fifo_diag; 647 EL3WINDOW(4); 648 fifo_diag = inw(ioaddr + 4); 649 EL3WINDOW(1); 650 netdev_warn(dev, "adapter failure, FIFO diagnostic register %04x.\n", 651 fifo_diag); 652 if (fifo_diag & 0x0400) { 653 /* Tx overrun */ 654 tc589_wait_for_completion(dev, TxReset); 655 outw(TxEnable, ioaddr + EL3_CMD); 656 } 657 if (fifo_diag & 0x2000) { 658 /* Rx underrun */ 659 tc589_wait_for_completion(dev, RxReset); 660 set_rx_mode(dev); 661 outw(RxEnable, ioaddr + EL3_CMD); 662 } 663 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD); 664 } 665 } 666 if (++i > 10) { 667 netdev_err(dev, "infinite loop in interrupt, status %4.4x.\n", 668 status); 669 /* Clear all interrupts */ 670 outw(AckIntr | 0xFF, ioaddr + EL3_CMD); 671 break; 672 } 673 /* Acknowledge the IRQ. */ 674 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); 675 } 676 lp->last_irq = jiffies; 677 spin_unlock(&lp->lock); 678 netdev_dbg(dev, "exiting interrupt, status %4.4x.\n", 679 inw(ioaddr + EL3_STATUS)); 680 return IRQ_RETVAL(handled); 681 } 682 683 static void media_check(unsigned long arg) 684 { 685 struct net_device *dev = (struct net_device *)(arg); 686 struct el3_private *lp = netdev_priv(dev); 687 unsigned int ioaddr = dev->base_addr; 688 u16 media, errs; 689 unsigned long flags; 690 691 if (!netif_device_present(dev)) 692 goto reschedule; 693 694 /* Check for pending interrupt with expired latency timer: with 695 * this, we can limp along even if the interrupt is blocked 696 */ 697 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && 698 (inb(ioaddr + EL3_TIMER) == 0xff)) { 699 if (!lp->fast_poll) 700 netdev_warn(dev, "interrupt(s) dropped!\n"); 701 702 local_irq_save(flags); 703 el3_interrupt(dev->irq, dev); 704 local_irq_restore(flags); 705 706 lp->fast_poll = HZ; 707 } 708 if (lp->fast_poll) { 709 lp->fast_poll--; 710 lp->media.expires = jiffies + HZ/100; 711 add_timer(&lp->media); 712 return; 713 } 714 715 /* lp->lock guards the EL3 window. Window should always be 1 except 716 * when the lock is held 717 */ 718 719 spin_lock_irqsave(&lp->lock, flags); 720 EL3WINDOW(4); 721 media = inw(ioaddr+WN4_MEDIA) & 0xc810; 722 723 /* Ignore collisions unless we've had no irq's recently */ 724 if (time_before(jiffies, lp->last_irq + HZ)) { 725 media &= ~0x0010; 726 } else { 727 /* Try harder to detect carrier errors */ 728 EL3WINDOW(6); 729 outw(StatsDisable, ioaddr + EL3_CMD); 730 errs = inb(ioaddr + 0); 731 outw(StatsEnable, ioaddr + EL3_CMD); 732 dev->stats.tx_carrier_errors += errs; 733 if (errs || (lp->media_status & 0x0010)) 734 media |= 0x0010; 735 } 736 737 if (media != lp->media_status) { 738 if ((media & lp->media_status & 0x8000) && 739 ((lp->media_status ^ media) & 0x0800)) 740 netdev_info(dev, "%s link beat\n", 741 (lp->media_status & 0x0800 ? "lost" : "found")); 742 else if ((media & lp->media_status & 0x4000) && 743 ((lp->media_status ^ media) & 0x0010)) 744 netdev_info(dev, "coax cable %s\n", 745 (lp->media_status & 0x0010 ? "ok" : "problem")); 746 if (dev->if_port == 0) { 747 if (media & 0x8000) { 748 if (media & 0x0800) 749 netdev_info(dev, "flipped to 10baseT\n"); 750 else 751 tc589_set_xcvr(dev, 2); 752 } else if (media & 0x4000) { 753 if (media & 0x0010) 754 tc589_set_xcvr(dev, 1); 755 else 756 netdev_info(dev, "flipped to 10base2\n"); 757 } 758 } 759 lp->media_status = media; 760 } 761 762 EL3WINDOW(1); 763 spin_unlock_irqrestore(&lp->lock, flags); 764 765 reschedule: 766 lp->media.expires = jiffies + HZ; 767 add_timer(&lp->media); 768 } 769 770 static struct net_device_stats *el3_get_stats(struct net_device *dev) 771 { 772 struct el3_private *lp = netdev_priv(dev); 773 unsigned long flags; 774 struct pcmcia_device *link = lp->p_dev; 775 776 if (pcmcia_dev_present(link)) { 777 spin_lock_irqsave(&lp->lock, flags); 778 update_stats(dev); 779 spin_unlock_irqrestore(&lp->lock, flags); 780 } 781 return &dev->stats; 782 } 783 784 /* Update statistics. We change to register window 6, so this should be run 785 * single-threaded if the device is active. This is expected to be a rare 786 * operation, and it's simpler for the rest of the driver to assume that 787 * window 1 is always valid rather than use a special window-state variable. 788 * 789 * Caller must hold the lock for this 790 */ 791 792 static void update_stats(struct net_device *dev) 793 { 794 unsigned int ioaddr = dev->base_addr; 795 796 netdev_dbg(dev, "updating the statistics.\n"); 797 /* Turn off statistics updates while reading. */ 798 outw(StatsDisable, ioaddr + EL3_CMD); 799 /* Switch to the stats window, and read everything. */ 800 EL3WINDOW(6); 801 dev->stats.tx_carrier_errors += inb(ioaddr + 0); 802 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1); 803 /* Multiple collisions. */ 804 inb(ioaddr + 2); 805 dev->stats.collisions += inb(ioaddr + 3); 806 dev->stats.tx_window_errors += inb(ioaddr + 4); 807 dev->stats.rx_fifo_errors += inb(ioaddr + 5); 808 dev->stats.tx_packets += inb(ioaddr + 6); 809 /* Rx packets */ 810 inb(ioaddr + 7); 811 /* Tx deferrals */ 812 inb(ioaddr + 8); 813 /* Rx octets */ 814 inw(ioaddr + 10); 815 /* Tx octets */ 816 inw(ioaddr + 12); 817 818 /* Back to window 1, and turn statistics back on. */ 819 EL3WINDOW(1); 820 outw(StatsEnable, ioaddr + EL3_CMD); 821 } 822 823 static int el3_rx(struct net_device *dev) 824 { 825 unsigned int ioaddr = dev->base_addr; 826 int worklimit = 32; 827 short rx_status; 828 829 netdev_dbg(dev, "in rx_packet(), status %4.4x, rx_status %4.4x.\n", 830 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS)); 831 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) && 832 worklimit > 0) { 833 worklimit--; 834 if (rx_status & 0x4000) { /* Error, update stats. */ 835 short error = rx_status & 0x3800; 836 dev->stats.rx_errors++; 837 switch (error) { 838 case 0x0000: 839 dev->stats.rx_over_errors++; 840 break; 841 case 0x0800: 842 dev->stats.rx_length_errors++; 843 break; 844 case 0x1000: 845 dev->stats.rx_frame_errors++; 846 break; 847 case 0x1800: 848 dev->stats.rx_length_errors++; 849 break; 850 case 0x2000: 851 dev->stats.rx_frame_errors++; 852 break; 853 case 0x2800: 854 dev->stats.rx_crc_errors++; 855 break; 856 } 857 } else { 858 short pkt_len = rx_status & 0x7ff; 859 struct sk_buff *skb; 860 861 skb = netdev_alloc_skb(dev, pkt_len + 5); 862 863 netdev_dbg(dev, " Receiving packet size %d status %4.4x.\n", 864 pkt_len, rx_status); 865 if (skb != NULL) { 866 skb_reserve(skb, 2); 867 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len), 868 (pkt_len+3)>>2); 869 skb->protocol = eth_type_trans(skb, dev); 870 netif_rx(skb); 871 dev->stats.rx_packets++; 872 dev->stats.rx_bytes += pkt_len; 873 } else { 874 netdev_dbg(dev, "couldn't allocate a sk_buff of size %d.\n", 875 pkt_len); 876 dev->stats.rx_dropped++; 877 } 878 } 879 /* Pop the top of the Rx FIFO */ 880 tc589_wait_for_completion(dev, RxDiscard); 881 } 882 if (worklimit == 0) 883 netdev_warn(dev, "too much work in el3_rx!\n"); 884 return 0; 885 } 886 887 static void set_rx_mode(struct net_device *dev) 888 { 889 unsigned int ioaddr = dev->base_addr; 890 u16 opts = SetRxFilter | RxStation | RxBroadcast; 891 892 if (dev->flags & IFF_PROMISC) 893 opts |= RxMulticast | RxProm; 894 else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI)) 895 opts |= RxMulticast; 896 outw(opts, ioaddr + EL3_CMD); 897 } 898 899 static void set_multicast_list(struct net_device *dev) 900 { 901 struct el3_private *priv = netdev_priv(dev); 902 unsigned long flags; 903 904 spin_lock_irqsave(&priv->lock, flags); 905 set_rx_mode(dev); 906 spin_unlock_irqrestore(&priv->lock, flags); 907 } 908 909 static int el3_close(struct net_device *dev) 910 { 911 struct el3_private *lp = netdev_priv(dev); 912 struct pcmcia_device *link = lp->p_dev; 913 unsigned int ioaddr = dev->base_addr; 914 915 dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name); 916 917 if (pcmcia_dev_present(link)) { 918 /* Turn off statistics ASAP. We update dev->stats below. */ 919 outw(StatsDisable, ioaddr + EL3_CMD); 920 921 /* Disable the receiver and transmitter. */ 922 outw(RxDisable, ioaddr + EL3_CMD); 923 outw(TxDisable, ioaddr + EL3_CMD); 924 925 if (dev->if_port == 2) 926 /* Turn off thinnet power. Green! */ 927 outw(StopCoax, ioaddr + EL3_CMD); 928 else if (dev->if_port == 1) { 929 /* Disable link beat and jabber */ 930 EL3WINDOW(4); 931 outw(0, ioaddr + WN4_MEDIA); 932 } 933 934 /* Switching back to window 0 disables the IRQ. */ 935 EL3WINDOW(0); 936 /* But we explicitly zero the IRQ line select anyway. */ 937 outw(0x0f00, ioaddr + WN0_IRQ); 938 939 /* Check if the card still exists */ 940 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000) 941 update_stats(dev); 942 } 943 944 link->open--; 945 netif_stop_queue(dev); 946 del_timer_sync(&lp->media); 947 948 return 0; 949 } 950 951 static const struct pcmcia_device_id tc589_ids[] = { 952 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562), 953 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77), 954 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589), 955 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202), 956 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "cis/3CXEM556.cis"), 957 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "cis/3CXEM556.cis"), 958 PCMCIA_DEVICE_NULL, 959 }; 960 MODULE_DEVICE_TABLE(pcmcia, tc589_ids); 961 962 static struct pcmcia_driver tc589_driver = { 963 .owner = THIS_MODULE, 964 .name = "3c589_cs", 965 .probe = tc589_probe, 966 .remove = tc589_detach, 967 .id_table = tc589_ids, 968 .suspend = tc589_suspend, 969 .resume = tc589_resume, 970 }; 971 module_pcmcia_driver(tc589_driver); 972