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 dev->ethtool_ops = &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 setup_timer(&lp->media, media_check, (unsigned long)dev); 522 mod_timer(&lp->media, jiffies + HZ); 523 524 dev_dbg(&link->dev, "%s: opened, status %4.4x.\n", 525 dev->name, inw(dev->base_addr + EL3_STATUS)); 526 527 return 0; 528 } 529 530 static void el3_tx_timeout(struct net_device *dev) 531 { 532 unsigned int ioaddr = dev->base_addr; 533 534 netdev_warn(dev, "Transmit timed out!\n"); 535 dump_status(dev); 536 dev->stats.tx_errors++; 537 netif_trans_update(dev); /* prevent tx timeout */ 538 /* Issue TX_RESET and TX_START commands. */ 539 tc589_wait_for_completion(dev, TxReset); 540 outw(TxEnable, ioaddr + EL3_CMD); 541 netif_wake_queue(dev); 542 } 543 544 static void pop_tx_status(struct net_device *dev) 545 { 546 unsigned int ioaddr = dev->base_addr; 547 int i; 548 549 /* Clear the Tx status stack. */ 550 for (i = 32; i > 0; i--) { 551 u_char tx_status = inb(ioaddr + TX_STATUS); 552 if (!(tx_status & 0x84)) 553 break; 554 /* reset transmitter on jabber error or underrun */ 555 if (tx_status & 0x30) 556 tc589_wait_for_completion(dev, TxReset); 557 if (tx_status & 0x38) { 558 netdev_dbg(dev, "transmit error: status 0x%02x\n", tx_status); 559 outw(TxEnable, ioaddr + EL3_CMD); 560 dev->stats.tx_aborted_errors++; 561 } 562 outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */ 563 } 564 } 565 566 static netdev_tx_t el3_start_xmit(struct sk_buff *skb, 567 struct net_device *dev) 568 { 569 unsigned int ioaddr = dev->base_addr; 570 struct el3_private *priv = netdev_priv(dev); 571 unsigned long flags; 572 573 netdev_dbg(dev, "el3_start_xmit(length = %ld) called, status %4.4x.\n", 574 (long)skb->len, inw(ioaddr + EL3_STATUS)); 575 576 spin_lock_irqsave(&priv->lock, flags); 577 578 dev->stats.tx_bytes += skb->len; 579 580 /* Put out the doubleword header... */ 581 outw(skb->len, ioaddr + TX_FIFO); 582 outw(0x00, ioaddr + TX_FIFO); 583 /* ... and the packet rounded to a doubleword. */ 584 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2); 585 586 if (inw(ioaddr + TX_FREE) <= 1536) { 587 netif_stop_queue(dev); 588 /* Interrupt us when the FIFO has room for max-sized packet. */ 589 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD); 590 } 591 592 pop_tx_status(dev); 593 spin_unlock_irqrestore(&priv->lock, flags); 594 dev_kfree_skb(skb); 595 596 return NETDEV_TX_OK; 597 } 598 599 /* The EL3 interrupt handler. */ 600 static irqreturn_t el3_interrupt(int irq, void *dev_id) 601 { 602 struct net_device *dev = (struct net_device *) dev_id; 603 struct el3_private *lp = netdev_priv(dev); 604 unsigned int ioaddr; 605 __u16 status; 606 int i = 0, handled = 1; 607 608 if (!netif_device_present(dev)) 609 return IRQ_NONE; 610 611 ioaddr = dev->base_addr; 612 613 netdev_dbg(dev, "interrupt, status %4.4x.\n", inw(ioaddr + EL3_STATUS)); 614 615 spin_lock(&lp->lock); 616 while ((status = inw(ioaddr + EL3_STATUS)) & 617 (IntLatch | RxComplete | StatsFull)) { 618 if ((status & 0xe000) != 0x2000) { 619 netdev_dbg(dev, "interrupt from dead card\n"); 620 handled = 0; 621 break; 622 } 623 if (status & RxComplete) 624 el3_rx(dev); 625 if (status & TxAvailable) { 626 netdev_dbg(dev, " TX room bit was handled.\n"); 627 /* There's room in the FIFO for a full-sized packet. */ 628 outw(AckIntr | TxAvailable, ioaddr + EL3_CMD); 629 netif_wake_queue(dev); 630 } 631 if (status & TxComplete) 632 pop_tx_status(dev); 633 if (status & (AdapterFailure | RxEarly | StatsFull)) { 634 /* Handle all uncommon interrupts. */ 635 if (status & StatsFull) /* Empty statistics. */ 636 update_stats(dev); 637 if (status & RxEarly) { 638 /* Rx early is unused. */ 639 el3_rx(dev); 640 outw(AckIntr | RxEarly, ioaddr + EL3_CMD); 641 } 642 if (status & AdapterFailure) { 643 u16 fifo_diag; 644 EL3WINDOW(4); 645 fifo_diag = inw(ioaddr + 4); 646 EL3WINDOW(1); 647 netdev_warn(dev, "adapter failure, FIFO diagnostic register %04x.\n", 648 fifo_diag); 649 if (fifo_diag & 0x0400) { 650 /* Tx overrun */ 651 tc589_wait_for_completion(dev, TxReset); 652 outw(TxEnable, ioaddr + EL3_CMD); 653 } 654 if (fifo_diag & 0x2000) { 655 /* Rx underrun */ 656 tc589_wait_for_completion(dev, RxReset); 657 set_rx_mode(dev); 658 outw(RxEnable, ioaddr + EL3_CMD); 659 } 660 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD); 661 } 662 } 663 if (++i > 10) { 664 netdev_err(dev, "infinite loop in interrupt, status %4.4x.\n", 665 status); 666 /* Clear all interrupts */ 667 outw(AckIntr | 0xFF, ioaddr + EL3_CMD); 668 break; 669 } 670 /* Acknowledge the IRQ. */ 671 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); 672 } 673 lp->last_irq = jiffies; 674 spin_unlock(&lp->lock); 675 netdev_dbg(dev, "exiting interrupt, status %4.4x.\n", 676 inw(ioaddr + EL3_STATUS)); 677 return IRQ_RETVAL(handled); 678 } 679 680 static void media_check(unsigned long arg) 681 { 682 struct net_device *dev = (struct net_device *)(arg); 683 struct el3_private *lp = netdev_priv(dev); 684 unsigned int ioaddr = dev->base_addr; 685 u16 media, errs; 686 unsigned long flags; 687 688 if (!netif_device_present(dev)) 689 goto reschedule; 690 691 /* Check for pending interrupt with expired latency timer: with 692 * this, we can limp along even if the interrupt is blocked 693 */ 694 if ((inw(ioaddr + EL3_STATUS) & IntLatch) && 695 (inb(ioaddr + EL3_TIMER) == 0xff)) { 696 if (!lp->fast_poll) 697 netdev_warn(dev, "interrupt(s) dropped!\n"); 698 699 local_irq_save(flags); 700 el3_interrupt(dev->irq, dev); 701 local_irq_restore(flags); 702 703 lp->fast_poll = HZ; 704 } 705 if (lp->fast_poll) { 706 lp->fast_poll--; 707 lp->media.expires = jiffies + HZ/100; 708 add_timer(&lp->media); 709 return; 710 } 711 712 /* lp->lock guards the EL3 window. Window should always be 1 except 713 * when the lock is held 714 */ 715 716 spin_lock_irqsave(&lp->lock, flags); 717 EL3WINDOW(4); 718 media = inw(ioaddr+WN4_MEDIA) & 0xc810; 719 720 /* Ignore collisions unless we've had no irq's recently */ 721 if (time_before(jiffies, lp->last_irq + HZ)) { 722 media &= ~0x0010; 723 } else { 724 /* Try harder to detect carrier errors */ 725 EL3WINDOW(6); 726 outw(StatsDisable, ioaddr + EL3_CMD); 727 errs = inb(ioaddr + 0); 728 outw(StatsEnable, ioaddr + EL3_CMD); 729 dev->stats.tx_carrier_errors += errs; 730 if (errs || (lp->media_status & 0x0010)) 731 media |= 0x0010; 732 } 733 734 if (media != lp->media_status) { 735 if ((media & lp->media_status & 0x8000) && 736 ((lp->media_status ^ media) & 0x0800)) 737 netdev_info(dev, "%s link beat\n", 738 (lp->media_status & 0x0800 ? "lost" : "found")); 739 else if ((media & lp->media_status & 0x4000) && 740 ((lp->media_status ^ media) & 0x0010)) 741 netdev_info(dev, "coax cable %s\n", 742 (lp->media_status & 0x0010 ? "ok" : "problem")); 743 if (dev->if_port == 0) { 744 if (media & 0x8000) { 745 if (media & 0x0800) 746 netdev_info(dev, "flipped to 10baseT\n"); 747 else 748 tc589_set_xcvr(dev, 2); 749 } else if (media & 0x4000) { 750 if (media & 0x0010) 751 tc589_set_xcvr(dev, 1); 752 else 753 netdev_info(dev, "flipped to 10base2\n"); 754 } 755 } 756 lp->media_status = media; 757 } 758 759 EL3WINDOW(1); 760 spin_unlock_irqrestore(&lp->lock, flags); 761 762 reschedule: 763 lp->media.expires = jiffies + HZ; 764 add_timer(&lp->media); 765 } 766 767 static struct net_device_stats *el3_get_stats(struct net_device *dev) 768 { 769 struct el3_private *lp = netdev_priv(dev); 770 unsigned long flags; 771 struct pcmcia_device *link = lp->p_dev; 772 773 if (pcmcia_dev_present(link)) { 774 spin_lock_irqsave(&lp->lock, flags); 775 update_stats(dev); 776 spin_unlock_irqrestore(&lp->lock, flags); 777 } 778 return &dev->stats; 779 } 780 781 /* Update statistics. We change to register window 6, so this should be run 782 * single-threaded if the device is active. This is expected to be a rare 783 * operation, and it's simpler for the rest of the driver to assume that 784 * window 1 is always valid rather than use a special window-state variable. 785 * 786 * Caller must hold the lock for this 787 */ 788 789 static void update_stats(struct net_device *dev) 790 { 791 unsigned int ioaddr = dev->base_addr; 792 793 netdev_dbg(dev, "updating the statistics.\n"); 794 /* Turn off statistics updates while reading. */ 795 outw(StatsDisable, ioaddr + EL3_CMD); 796 /* Switch to the stats window, and read everything. */ 797 EL3WINDOW(6); 798 dev->stats.tx_carrier_errors += inb(ioaddr + 0); 799 dev->stats.tx_heartbeat_errors += inb(ioaddr + 1); 800 /* Multiple collisions. */ 801 inb(ioaddr + 2); 802 dev->stats.collisions += inb(ioaddr + 3); 803 dev->stats.tx_window_errors += inb(ioaddr + 4); 804 dev->stats.rx_fifo_errors += inb(ioaddr + 5); 805 dev->stats.tx_packets += inb(ioaddr + 6); 806 /* Rx packets */ 807 inb(ioaddr + 7); 808 /* Tx deferrals */ 809 inb(ioaddr + 8); 810 /* Rx octets */ 811 inw(ioaddr + 10); 812 /* Tx octets */ 813 inw(ioaddr + 12); 814 815 /* Back to window 1, and turn statistics back on. */ 816 EL3WINDOW(1); 817 outw(StatsEnable, ioaddr + EL3_CMD); 818 } 819 820 static int el3_rx(struct net_device *dev) 821 { 822 unsigned int ioaddr = dev->base_addr; 823 int worklimit = 32; 824 short rx_status; 825 826 netdev_dbg(dev, "in rx_packet(), status %4.4x, rx_status %4.4x.\n", 827 inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS)); 828 while (!((rx_status = inw(ioaddr + RX_STATUS)) & 0x8000) && 829 worklimit > 0) { 830 worklimit--; 831 if (rx_status & 0x4000) { /* Error, update stats. */ 832 short error = rx_status & 0x3800; 833 dev->stats.rx_errors++; 834 switch (error) { 835 case 0x0000: 836 dev->stats.rx_over_errors++; 837 break; 838 case 0x0800: 839 dev->stats.rx_length_errors++; 840 break; 841 case 0x1000: 842 dev->stats.rx_frame_errors++; 843 break; 844 case 0x1800: 845 dev->stats.rx_length_errors++; 846 break; 847 case 0x2000: 848 dev->stats.rx_frame_errors++; 849 break; 850 case 0x2800: 851 dev->stats.rx_crc_errors++; 852 break; 853 } 854 } else { 855 short pkt_len = rx_status & 0x7ff; 856 struct sk_buff *skb; 857 858 skb = netdev_alloc_skb(dev, pkt_len + 5); 859 860 netdev_dbg(dev, " Receiving packet size %d status %4.4x.\n", 861 pkt_len, rx_status); 862 if (skb != NULL) { 863 skb_reserve(skb, 2); 864 insl(ioaddr+RX_FIFO, skb_put(skb, pkt_len), 865 (pkt_len+3)>>2); 866 skb->protocol = eth_type_trans(skb, dev); 867 netif_rx(skb); 868 dev->stats.rx_packets++; 869 dev->stats.rx_bytes += pkt_len; 870 } else { 871 netdev_dbg(dev, "couldn't allocate a sk_buff of size %d.\n", 872 pkt_len); 873 dev->stats.rx_dropped++; 874 } 875 } 876 /* Pop the top of the Rx FIFO */ 877 tc589_wait_for_completion(dev, RxDiscard); 878 } 879 if (worklimit == 0) 880 netdev_warn(dev, "too much work in el3_rx!\n"); 881 return 0; 882 } 883 884 static void set_rx_mode(struct net_device *dev) 885 { 886 unsigned int ioaddr = dev->base_addr; 887 u16 opts = SetRxFilter | RxStation | RxBroadcast; 888 889 if (dev->flags & IFF_PROMISC) 890 opts |= RxMulticast | RxProm; 891 else if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI)) 892 opts |= RxMulticast; 893 outw(opts, ioaddr + EL3_CMD); 894 } 895 896 static void set_multicast_list(struct net_device *dev) 897 { 898 struct el3_private *priv = netdev_priv(dev); 899 unsigned long flags; 900 901 spin_lock_irqsave(&priv->lock, flags); 902 set_rx_mode(dev); 903 spin_unlock_irqrestore(&priv->lock, flags); 904 } 905 906 static int el3_close(struct net_device *dev) 907 { 908 struct el3_private *lp = netdev_priv(dev); 909 struct pcmcia_device *link = lp->p_dev; 910 unsigned int ioaddr = dev->base_addr; 911 912 dev_dbg(&link->dev, "%s: shutting down ethercard.\n", dev->name); 913 914 if (pcmcia_dev_present(link)) { 915 /* Turn off statistics ASAP. We update dev->stats below. */ 916 outw(StatsDisable, ioaddr + EL3_CMD); 917 918 /* Disable the receiver and transmitter. */ 919 outw(RxDisable, ioaddr + EL3_CMD); 920 outw(TxDisable, ioaddr + EL3_CMD); 921 922 if (dev->if_port == 2) 923 /* Turn off thinnet power. Green! */ 924 outw(StopCoax, ioaddr + EL3_CMD); 925 else if (dev->if_port == 1) { 926 /* Disable link beat and jabber */ 927 EL3WINDOW(4); 928 outw(0, ioaddr + WN4_MEDIA); 929 } 930 931 /* Switching back to window 0 disables the IRQ. */ 932 EL3WINDOW(0); 933 /* But we explicitly zero the IRQ line select anyway. */ 934 outw(0x0f00, ioaddr + WN0_IRQ); 935 936 /* Check if the card still exists */ 937 if ((inw(ioaddr+EL3_STATUS) & 0xe000) == 0x2000) 938 update_stats(dev); 939 } 940 941 link->open--; 942 netif_stop_queue(dev); 943 del_timer_sync(&lp->media); 944 945 return 0; 946 } 947 948 static const struct pcmcia_device_id tc589_ids[] = { 949 PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x0101, 0x0562), 950 PCMCIA_MFC_DEVICE_PROD_ID1(0, "Motorola MARQUIS", 0xf03e4e77), 951 PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0589), 952 PCMCIA_DEVICE_PROD_ID12("Farallon", "ENet", 0x58d93fc4, 0x992c2202), 953 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x0035, "cis/3CXEM556.cis"), 954 PCMCIA_MFC_DEVICE_CIS_MANF_CARD(0, 0x0101, 0x003d, "cis/3CXEM556.cis"), 955 PCMCIA_DEVICE_NULL, 956 }; 957 MODULE_DEVICE_TABLE(pcmcia, tc589_ids); 958 959 static struct pcmcia_driver tc589_driver = { 960 .owner = THIS_MODULE, 961 .name = "3c589_cs", 962 .probe = tc589_probe, 963 .remove = tc589_detach, 964 .id_table = tc589_ids, 965 .suspend = tc589_suspend, 966 .resume = tc589_resume, 967 }; 968 module_pcmcia_driver(tc589_driver); 969