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