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