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