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(struct timer_list *t); 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_set_mac_address = eth_mac_addr, 192 .ndo_validate_addr = eth_validate_addr, 193 }; 194 195 static int tc589_probe(struct pcmcia_device *link) 196 { 197 struct el3_private *lp; 198 struct net_device *dev; 199 200 dev_dbg(&link->dev, "3c589_attach()\n"); 201 202 /* Create new ethernet device */ 203 dev = alloc_etherdev(sizeof(struct el3_private)); 204 if (!dev) 205 return -ENOMEM; 206 lp = netdev_priv(dev); 207 link->priv = dev; 208 lp->p_dev = link; 209 210 spin_lock_init(&lp->lock); 211 link->resource[0]->end = 16; 212 link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16; 213 214 link->config_flags |= CONF_ENABLE_IRQ; 215 link->config_index = 1; 216 217 dev->netdev_ops = &el3_netdev_ops; 218 dev->watchdog_timeo = TX_TIMEOUT; 219 220 dev->ethtool_ops = &netdev_ethtool_ops; 221 222 return tc589_config(link); 223 } 224 225 static void tc589_detach(struct pcmcia_device *link) 226 { 227 struct net_device *dev = link->priv; 228 229 dev_dbg(&link->dev, "3c589_detach\n"); 230 231 unregister_netdev(dev); 232 233 tc589_release(link); 234 235 free_netdev(dev); 236 } /* tc589_detach */ 237 238 static int tc589_config(struct pcmcia_device *link) 239 { 240 struct net_device *dev = link->priv; 241 __be16 *phys_addr; 242 int ret, i, j, multi = 0, fifo; 243 unsigned int ioaddr; 244 static const char * const ram_split[] = {"5:3", "3:1", "1:1", "3:5"}; 245 u8 *buf; 246 size_t len; 247 248 dev_dbg(&link->dev, "3c589_config\n"); 249 250 phys_addr = (__be16 *)dev->dev_addr; 251 /* Is this a 3c562? */ 252 if (link->manf_id != MANFID_3COM) 253 dev_info(&link->dev, "hmmm, is this really a 3Com card??\n"); 254 multi = (link->card_id == PRODID_3COM_3C562); 255 256 link->io_lines = 16; 257 258 /* For the 3c562, the base address must be xx00-xx7f */ 259 for (i = j = 0; j < 0x400; j += 0x10) { 260 if (multi && (j & 0x80)) 261 continue; 262 link->resource[0]->start = j ^ 0x300; 263 i = pcmcia_request_io(link); 264 if (i == 0) 265 break; 266 } 267 if (i != 0) 268 goto failed; 269 270 ret = pcmcia_request_irq(link, el3_interrupt); 271 if (ret) 272 goto failed; 273 274 ret = pcmcia_enable_device(link); 275 if (ret) 276 goto failed; 277 278 dev->irq = link->irq; 279 dev->base_addr = link->resource[0]->start; 280 ioaddr = dev->base_addr; 281 EL3WINDOW(0); 282 283 /* The 3c589 has an extra EEPROM for configuration info, including 284 * the hardware address. The 3c562 puts the address in the CIS. 285 */ 286 len = pcmcia_get_tuple(link, 0x88, &buf); 287 if (buf && len >= 6) { 288 for (i = 0; i < 3; i++) 289 phys_addr[i] = htons(le16_to_cpu(buf[i*2])); 290 kfree(buf); 291 } else { 292 kfree(buf); /* 0 < len < 6 */ 293 for (i = 0; i < 3; i++) 294 phys_addr[i] = htons(read_eeprom(ioaddr, i)); 295 if (phys_addr[0] == htons(0x6060)) { 296 dev_err(&link->dev, "IO port conflict at 0x%03lx-0x%03lx\n", 297 dev->base_addr, dev->base_addr+15); 298 goto failed; 299 } 300 } 301 302 /* The address and resource configuration register aren't loaded from 303 * the EEPROM and *must* be set to 0 and IRQ3 for the PCMCIA version. 304 */ 305 306 outw(0x3f00, ioaddr + 8); 307 fifo = inl(ioaddr); 308 309 /* The if_port symbol can be set when the module is loaded */ 310 if ((if_port >= 0) && (if_port <= 3)) 311 dev->if_port = if_port; 312 else 313 dev_err(&link->dev, "invalid if_port requested\n"); 314 315 SET_NETDEV_DEV(dev, &link->dev); 316 317 if (register_netdev(dev) != 0) { 318 dev_err(&link->dev, "register_netdev() failed\n"); 319 goto failed; 320 } 321 322 netdev_info(dev, "3Com 3c%s, io %#3lx, irq %d, hw_addr %pM\n", 323 (multi ? "562" : "589"), dev->base_addr, dev->irq, 324 dev->dev_addr); 325 netdev_info(dev, " %dK FIFO split %s Rx:Tx, %s xcvr\n", 326 (fifo & 7) ? 32 : 8, ram_split[(fifo >> 16) & 3], 327 if_names[dev->if_port]); 328 return 0; 329 330 failed: 331 tc589_release(link); 332 return -ENODEV; 333 } /* tc589_config */ 334 335 static void tc589_release(struct pcmcia_device *link) 336 { 337 pcmcia_disable_device(link); 338 } 339 340 static int tc589_suspend(struct pcmcia_device *link) 341 { 342 struct net_device *dev = link->priv; 343 344 if (link->open) 345 netif_device_detach(dev); 346 347 return 0; 348 } 349 350 static int tc589_resume(struct pcmcia_device *link) 351 { 352 struct net_device *dev = link->priv; 353 354 if (link->open) { 355 tc589_reset(dev); 356 netif_device_attach(dev); 357 } 358 359 return 0; 360 } 361 362 /*====================================================================*/ 363 364 /* Use this for commands that may take time to finish */ 365 366 static void tc589_wait_for_completion(struct net_device *dev, int cmd) 367 { 368 int i = 100; 369 outw(cmd, dev->base_addr + EL3_CMD); 370 while (--i > 0) 371 if (!(inw(dev->base_addr + EL3_STATUS) & 0x1000)) 372 break; 373 if (i == 0) 374 netdev_warn(dev, "command 0x%04x did not complete!\n", cmd); 375 } 376 377 /* Read a word from the EEPROM using the regular EEPROM access register. 378 * Assume that we are in register window zero. 379 */ 380 381 static u16 read_eeprom(unsigned int ioaddr, int index) 382 { 383 int i; 384 outw(EEPROM_READ + index, ioaddr + 10); 385 /* Reading the eeprom takes 162 us */ 386 for (i = 1620; i >= 0; i--) 387 if ((inw(ioaddr + 10) & EEPROM_BUSY) == 0) 388 break; 389 return inw(ioaddr + 12); 390 } 391 392 /* Set transceiver type, perhaps to something other than what the user 393 * specified in dev->if_port. 394 */ 395 396 static void tc589_set_xcvr(struct net_device *dev, int if_port) 397 { 398 struct el3_private *lp = netdev_priv(dev); 399 unsigned int ioaddr = dev->base_addr; 400 401 EL3WINDOW(0); 402 switch (if_port) { 403 case 0: 404 case 1: 405 outw(0, ioaddr + 6); 406 break; 407 case 2: 408 outw(3<<14, ioaddr + 6); 409 break; 410 case 3: 411 outw(1<<14, ioaddr + 6); 412 break; 413 } 414 /* On PCMCIA, this just turns on the LED */ 415 outw((if_port == 2) ? StartCoax : StopCoax, ioaddr + EL3_CMD); 416 /* 10baseT interface, enable link beat and jabber check. */ 417 EL3WINDOW(4); 418 outw(MEDIA_LED | ((if_port < 2) ? MEDIA_TP : 0), ioaddr + WN4_MEDIA); 419 EL3WINDOW(1); 420 if (if_port == 2) 421 lp->media_status = ((dev->if_port == 0) ? 0x8000 : 0x4000); 422 else 423 lp->media_status = ((dev->if_port == 0) ? 0x4010 : 0x8800); 424 } 425 426 static void dump_status(struct net_device *dev) 427 { 428 unsigned int ioaddr = dev->base_addr; 429 EL3WINDOW(1); 430 netdev_info(dev, " irq status %04x, rx status %04x, tx status %02x tx free %04x\n", 431 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS), 432 inb(ioaddr+TX_STATUS), inw(ioaddr+TX_FREE)); 433 EL3WINDOW(4); 434 netdev_info(dev, " diagnostics: fifo %04x net %04x ethernet %04x media %04x\n", 435 inw(ioaddr+0x04), inw(ioaddr+0x06), inw(ioaddr+0x08), 436 inw(ioaddr+0x0a)); 437 EL3WINDOW(1); 438 } 439 440 /* Reset and restore all of the 3c589 registers. */ 441 static void tc589_reset(struct net_device *dev) 442 { 443 unsigned int ioaddr = dev->base_addr; 444 int i; 445 446 EL3WINDOW(0); 447 outw(0x0001, ioaddr + 4); /* Activate board. */ 448 outw(0x3f00, ioaddr + 8); /* Set the IRQ line. */ 449 450 /* Set the station address in window 2. */ 451 EL3WINDOW(2); 452 for (i = 0; i < 6; i++) 453 outb(dev->dev_addr[i], ioaddr + i); 454 455 tc589_set_xcvr(dev, dev->if_port); 456 457 /* Switch to the stats window, and clear all stats by reading. */ 458 outw(StatsDisable, ioaddr + EL3_CMD); 459 EL3WINDOW(6); 460 for (i = 0; i < 9; i++) 461 inb(ioaddr+i); 462 inw(ioaddr + 10); 463 inw(ioaddr + 12); 464 465 /* Switch to register set 1 for normal use. */ 466 EL3WINDOW(1); 467 468 set_rx_mode(dev); 469 outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */ 470 outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */ 471 outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */ 472 /* Allow status bits to be seen. */ 473 outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD); 474 /* Ack all pending events, and set active indicator mask. */ 475 outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq, 476 ioaddr + EL3_CMD); 477 outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull 478 | AdapterFailure, ioaddr + EL3_CMD); 479 } 480 481 static void netdev_get_drvinfo(struct net_device *dev, 482 struct ethtool_drvinfo *info) 483 { 484 strlcpy(info->driver, DRV_NAME, sizeof(info->driver)); 485 strlcpy(info->version, DRV_VERSION, sizeof(info->version)); 486 snprintf(info->bus_info, sizeof(info->bus_info), 487 "PCMCIA 0x%lx", dev->base_addr); 488 } 489 490 static const struct ethtool_ops netdev_ethtool_ops = { 491 .get_drvinfo = netdev_get_drvinfo, 492 }; 493 494 static int el3_config(struct net_device *dev, struct ifmap *map) 495 { 496 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) { 497 if (map->port <= 3) { 498 dev->if_port = map->port; 499 netdev_info(dev, "switched to %s port\n", if_names[dev->if_port]); 500 tc589_set_xcvr(dev, dev->if_port); 501 } else { 502 return -EINVAL; 503 } 504 } 505 return 0; 506 } 507 508 static int el3_open(struct net_device *dev) 509 { 510 struct el3_private *lp = netdev_priv(dev); 511 struct pcmcia_device *link = lp->p_dev; 512 513 if (!pcmcia_dev_present(link)) 514 return -ENODEV; 515 516 link->open++; 517 netif_start_queue(dev); 518 519 tc589_reset(dev); 520 timer_setup(&lp->media, media_check, 0); 521 mod_timer(&lp->media, jiffies + HZ); 522 523 dev_dbg(&link->dev, "%s: opened, status %4.4x.\n", 524 dev->name, inw(dev->base_addr + EL3_STATUS)); 525 526 return 0; 527 } 528 529 static void el3_tx_timeout(struct net_device *dev) 530 { 531 unsigned int ioaddr = dev->base_addr; 532 533 netdev_warn(dev, "Transmit timed out!\n"); 534 dump_status(dev); 535 dev->stats.tx_errors++; 536 netif_trans_update(dev); /* prevent tx timeout */ 537 /* Issue TX_RESET and TX_START commands. */ 538 tc589_wait_for_completion(dev, TxReset); 539 outw(TxEnable, ioaddr + EL3_CMD); 540 netif_wake_queue(dev); 541 } 542 543 static void pop_tx_status(struct net_device *dev) 544 { 545 unsigned int ioaddr = dev->base_addr; 546 int i; 547 548 /* Clear the Tx status stack. */ 549 for (i = 32; i > 0; i--) { 550 u_char tx_status = inb(ioaddr + TX_STATUS); 551 if (!(tx_status & 0x84)) 552 break; 553 /* reset transmitter on jabber error or underrun */ 554 if (tx_status & 0x30) 555 tc589_wait_for_completion(dev, TxReset); 556 if (tx_status & 0x38) { 557 netdev_dbg(dev, "transmit error: status 0x%02x\n", tx_status); 558 outw(TxEnable, ioaddr + EL3_CMD); 559 dev->stats.tx_aborted_errors++; 560 } 561 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */ 562 } 563 } 564 565 static netdev_tx_t el3_start_xmit(struct sk_buff *skb, 566 struct net_device *dev) 567 { 568 unsigned int ioaddr = dev->base_addr; 569 struct el3_private *priv = netdev_priv(dev); 570 unsigned long flags; 571 572 netdev_dbg(dev, "el3_start_xmit(length = %ld) called, status %4.4x.\n", 573 (long)skb->len, inw(ioaddr + EL3_STATUS)); 574 575 spin_lock_irqsave(&priv->lock, flags); 576 577 dev->stats.tx_bytes += skb->len; 578 579 /* Put out the doubleword header... */ 580 outw(skb->len, ioaddr + TX_FIFO); 581 outw(0x00, ioaddr + TX_FIFO); 582 /* ... and the packet rounded to a doubleword. */ 583 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2); 584 585 if (inw(ioaddr + TX_FREE) <= 1536) { 586 netif_stop_queue(dev); 587 /* Interrupt us when the FIFO has room for max-sized packet. */ 588 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD); 589 } 590 591 pop_tx_status(dev); 592 spin_unlock_irqrestore(&priv->lock, flags); 593 dev_kfree_skb(skb); 594 595 return NETDEV_TX_OK; 596 } 597 598 /* The EL3 interrupt handler. */ 599 static irqreturn_t el3_interrupt(int irq, void *dev_id) 600 { 601 struct net_device *dev = (struct net_device *) dev_id; 602 struct el3_private *lp = netdev_priv(dev); 603 unsigned int ioaddr; 604 __u16 status; 605 int i = 0, handled = 1; 606 607 if (!netif_device_present(dev)) 608 return IRQ_NONE; 609 610 ioaddr = dev->base_addr; 611 612 netdev_dbg(dev, "interrupt, status %4.4x.\n", inw(ioaddr + EL3_STATUS)); 613 614 spin_lock(&lp->lock); 615 while ((status = inw(ioaddr + EL3_STATUS)) & 616 (IntLatch | RxComplete | StatsFull)) { 617 if ((status & 0xe000) != 0x2000) { 618 netdev_dbg(dev, "interrupt from dead card\n"); 619 handled = 0; 620 break; 621 } 622 if (status & RxComplete) 623 el3_rx(dev); 624 if (status & TxAvailable) { 625 netdev_dbg(dev, " TX room bit was handled.\n"); 626 /* There's room in the FIFO for a full-sized packet. */ 627 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD); 628 netif_wake_queue(dev); 629 } 630 if (status & TxComplete) 631 pop_tx_status(dev); 632 if (status & (AdapterFailure | RxEarly | StatsFull)) { 633 /* Handle all uncommon interrupts. */ 634 if (status & StatsFull) /* Empty statistics. */ 635 update_stats(dev); 636 if (status & RxEarly) { 637 /* Rx early is unused. */ 638 el3_rx(dev); 639 outw(AckIntr | RxEarly, ioaddr + EL3_CMD); 640 } 641 if (status & AdapterFailure) { 642 u16 fifo_diag; 643 EL3WINDOW(4); 644 fifo_diag = inw(ioaddr + 4); 645 EL3WINDOW(1); 646 netdev_warn(dev, "adapter failure, FIFO diagnostic register %04x.\n", 647 fifo_diag); 648 if (fifo_diag & 0x0400) { 649 /* Tx overrun */ 650 tc589_wait_for_completion(dev, TxReset); 651 outw(TxEnable, ioaddr + EL3_CMD); 652 } 653 if (fifo_diag & 0x2000) { 654 /* Rx underrun */ 655 tc589_wait_for_completion(dev, RxReset); 656 set_rx_mode(dev); 657 outw(RxEnable, ioaddr + EL3_CMD); 658 } 659 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD); 660 } 661 } 662 if (++i > 10) { 663 netdev_err(dev, "infinite loop in interrupt, status %4.4x.\n", 664 status); 665 /* Clear all interrupts */ 666 outw(AckIntr | 0xFF, ioaddr + EL3_CMD); 667 break; 668 } 669 /* Acknowledge the IRQ. */ 670 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); 671 } 672 lp->last_irq = jiffies; 673 spin_unlock(&lp->lock); 674 netdev_dbg(dev, "exiting interrupt, status %4.4x.\n", 675 inw(ioaddr + EL3_STATUS)); 676 return IRQ_RETVAL(handled); 677 } 678 679 static void media_check(struct timer_list *t) 680 { 681 struct el3_private *lp = from_timer(lp, t, media); 682 struct net_device *dev = lp->p_dev->priv; 683 unsigned int ioaddr = dev->base_addr; 684 u16 media, errs; 685 unsigned long flags; 686 687 if (!netif_device_present(dev)) 688 goto reschedule; 689 690 /* Check for pending interrupt with expired latency timer: with 691 * this, we can limp along even if the interrupt is blocked 692 */ 693 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && 694 (inb(ioaddr + EL3_TIMER) == 0xff)) { 695 if (!lp->fast_poll) 696 netdev_warn(dev, "interrupt(s) dropped!\n"); 697 698 local_irq_save(flags); 699 el3_interrupt(dev->irq, dev); 700 local_irq_restore(flags); 701 702 lp->fast_poll = HZ; 703 } 704 if (lp->fast_poll) { 705 lp->fast_poll--; 706 lp->media.expires = jiffies + HZ/100; 707 add_timer(&lp->media); 708 return; 709 } 710 711 /* lp->lock guards the EL3 window. Window should always be 1 except 712 * when the lock is held 713 */ 714 715 spin_lock_irqsave(&lp->lock, flags); 716 EL3WINDOW(4); 717 media = inw(ioaddr+WN4_MEDIA) & 0xc810; 718 719 /* Ignore collisions unless we've had no irq's recently */ 720 if (time_before(jiffies, lp->last_irq + HZ)) { 721 media &= ~0x0010; 722 } else { 723 /* Try harder to detect carrier errors */ 724 EL3WINDOW(6); 725 outw(StatsDisable, ioaddr + EL3_CMD); 726 errs = inb(ioaddr + 0); 727 outw(StatsEnable, ioaddr + EL3_CMD); 728 dev->stats.tx_carrier_errors += errs; 729 if (errs || (lp->media_status & 0x0010)) 730 media |= 0x0010; 731 } 732 733 if (media != lp->media_status) { 734 if ((media & lp->media_status & 0x8000) && 735 ((lp->media_status ^ media) & 0x0800)) 736 netdev_info(dev, "%s link beat\n", 737 (lp->media_status & 0x0800 ? "lost" : "found")); 738 else if ((media & lp->media_status & 0x4000) && 739 ((lp->media_status ^ media) & 0x0010)) 740 netdev_info(dev, "coax cable %s\n", 741 (lp->media_status & 0x0010 ? "ok" : "problem")); 742 if (dev->if_port == 0) { 743 if (media & 0x8000) { 744 if (media & 0x0800) 745 netdev_info(dev, "flipped to 10baseT\n"); 746 else 747 tc589_set_xcvr(dev, 2); 748 } else if (media & 0x4000) { 749 if (media & 0x0010) 750 tc589_set_xcvr(dev, 1); 751 else 752 netdev_info(dev, "flipped to 10base2\n"); 753 } 754 } 755 lp->media_status = media; 756 } 757 758 EL3WINDOW(1); 759 spin_unlock_irqrestore(&lp->lock, flags); 760 761 reschedule: 762 lp->media.expires = jiffies + HZ; 763 add_timer(&lp->media); 764 } 765 766 static struct net_device_stats *el3_get_stats(struct net_device *dev) 767 { 768 struct el3_private *lp = netdev_priv(dev); 769 unsigned long flags; 770 struct pcmcia_device *link = lp->p_dev; 771 772 if (pcmcia_dev_present(link)) { 773 spin_lock_irqsave(&lp->lock, flags); 774 update_stats(dev); 775 spin_unlock_irqrestore(&lp->lock, flags); 776 } 777 return &dev->stats; 778 } 779 780 /* Update statistics. We change to register window 6, so this should be run 781 * single-threaded if the device is active. This is expected to be a rare 782 * operation, and it's simpler for the rest of the driver to assume that 783 * window 1 is always valid rather than use a special window-state variable. 784 * 785 * Caller must hold the lock for this 786 */ 787 788 static void update_stats(struct net_device *dev) 789 { 790 unsigned int ioaddr = dev->base_addr; 791 792 netdev_dbg(dev, "updating the statistics.\n"); 793 /* Turn off statistics updates while reading. */ 794 outw(StatsDisable, ioaddr + EL3_CMD); 795 /* Switch to the stats window, and read everything. */ 796 EL3WINDOW(6); 797 dev->stats.tx_carrier_errors += inb(ioaddr + 0); 798 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1); 799 /* Multiple collisions. */ 800 inb(ioaddr + 2); 801 dev->stats.collisions += inb(ioaddr + 3); 802 dev->stats.tx_window_errors += inb(ioaddr + 4); 803 dev->stats.rx_fifo_errors += inb(ioaddr + 5); 804 dev->stats.tx_packets += inb(ioaddr + 6); 805 /* Rx packets */ 806 inb(ioaddr + 7); 807 /* Tx deferrals */ 808 inb(ioaddr + 8); 809 /* Rx octets */ 810 inw(ioaddr + 10); 811 /* Tx octets */ 812 inw(ioaddr + 12); 813 814 /* Back to window 1, and turn statistics back on. */ 815 EL3WINDOW(1); 816 outw(StatsEnable, ioaddr + EL3_CMD); 817 } 818 819 static int el3_rx(struct net_device *dev) 820 { 821 unsigned int ioaddr = dev->base_addr; 822 int worklimit = 32; 823 short rx_status; 824 825 netdev_dbg(dev, "in rx_packet(), status %4.4x, rx_status %4.4x.\n", 826 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS)); 827 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) && 828 worklimit > 0) { 829 worklimit--; 830 if (rx_status & 0x4000) { /* Error, update stats. */ 831 short error = rx_status & 0x3800; 832 dev->stats.rx_errors++; 833 switch (error) { 834 case 0x0000: 835 dev->stats.rx_over_errors++; 836 break; 837 case 0x0800: 838 dev->stats.rx_length_errors++; 839 break; 840 case 0x1000: 841 dev->stats.rx_frame_errors++; 842 break; 843 case 0x1800: 844 dev->stats.rx_length_errors++; 845 break; 846 case 0x2000: 847 dev->stats.rx_frame_errors++; 848 break; 849 case 0x2800: 850 dev->stats.rx_crc_errors++; 851 break; 852 } 853 } else { 854 short pkt_len = rx_status & 0x7ff; 855 struct sk_buff *skb; 856 857 skb = netdev_alloc_skb(dev, pkt_len + 5); 858 859 netdev_dbg(dev, " Receiving packet size %d status %4.4x.\n", 860 pkt_len, rx_status); 861 if (skb != NULL) { 862 skb_reserve(skb, 2); 863 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len), 864 (pkt_len+3)>>2); 865 skb->protocol = eth_type_trans(skb, dev); 866 netif_rx(skb); 867 dev->stats.rx_packets++; 868 dev->stats.rx_bytes += pkt_len; 869 } else { 870 netdev_dbg(dev, "couldn't allocate a sk_buff of size %d.\n", 871 pkt_len); 872 dev->stats.rx_dropped++; 873 } 874 } 875 /* Pop the top of the Rx FIFO */ 876 tc589_wait_for_completion(dev, RxDiscard); 877 } 878 if (worklimit == 0) 879 netdev_warn(dev, "too much work in el3_rx!\n"); 880 return 0; 881 } 882 883 static void set_rx_mode(struct net_device *dev) 884 { 885 unsigned int ioaddr = dev->base_addr; 886 u16 opts = SetRxFilter | RxStation | RxBroadcast; 887 888 if (dev->flags & IFF_PROMISC) 889 opts |= RxMulticast | RxProm; 890 else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI)) 891 opts |= RxMulticast; 892 outw(opts, ioaddr + EL3_CMD); 893 } 894 895 static void set_multicast_list(struct net_device *dev) 896 { 897 struct el3_private *priv = netdev_priv(dev); 898 unsigned long flags; 899 900 spin_lock_irqsave(&priv->lock, flags); 901 set_rx_mode(dev); 902 spin_unlock_irqrestore(&priv->lock, flags); 903 } 904 905 static int el3_close(struct net_device *dev) 906 { 907 struct el3_private *lp = netdev_priv(dev); 908 struct pcmcia_device *link = lp->p_dev; 909 unsigned int ioaddr = dev->base_addr; 910 911 dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name); 912 913 if (pcmcia_dev_present(link)) { 914 /* Turn off statistics ASAP. We update dev->stats below. */ 915 outw(StatsDisable, ioaddr + EL3_CMD); 916 917 /* Disable the receiver and transmitter. */ 918 outw(RxDisable, ioaddr + EL3_CMD); 919 outw(TxDisable, ioaddr + EL3_CMD); 920 921 if (dev->if_port == 2) 922 /* Turn off thinnet power. Green! */ 923 outw(StopCoax, ioaddr + EL3_CMD); 924 else if (dev->if_port == 1) { 925 /* Disable link beat and jabber */ 926 EL3WINDOW(4); 927 outw(0, ioaddr + WN4_MEDIA); 928 } 929 930 /* Switching back to window 0 disables the IRQ. */ 931 EL3WINDOW(0); 932 /* But we explicitly zero the IRQ line select anyway. */ 933 outw(0x0f00, ioaddr + WN0_IRQ); 934 935 /* Check if the card still exists */ 936 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000) 937 update_stats(dev); 938 } 939 940 link->open--; 941 netif_stop_queue(dev); 942 del_timer_sync(&lp->media); 943 944 return 0; 945 } 946 947 static const struct pcmcia_device_id tc589_ids[] = { 948 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562), 949 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77), 950 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589), 951 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202), 952 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "cis/3CXEM556.cis"), 953 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "cis/3CXEM556.cis"), 954 PCMCIA_DEVICE_NULL, 955 }; 956 MODULE_DEVICE_TABLE(pcmcia, tc589_ids); 957 958 static struct pcmcia_driver tc589_driver = { 959 .owner = THIS_MODULE, 960 .name = "3c589_cs", 961 .probe = tc589_probe, 962 .remove = tc589_detach, 963 .id_table = tc589_ids, 964 .suspend = tc589_suspend, 965 .resume = tc589_resume, 966 }; 967 module_pcmcia_driver(tc589_driver); 968