1/* 2 drivers/net/ethernet/dec/tulip/interrupt.c 3 4 Copyright 2000,2001 The Linux Kernel Team 5 Written/copyright 1994-2001 by Donald Becker. 6 7 This software may be used and distributed according to the terms 8 of the GNU General Public License, incorporated herein by reference. 9 10 Please submit bugs to http://bugzilla.kernel.org/ . 11*/ 12 13#include <linux/pci.h> 14#include "tulip.h" 15#include <linux/etherdevice.h> 16 17int tulip_rx_copybreak; 18unsigned int tulip_max_interrupt_work; 19 20#ifdef CONFIG_TULIP_NAPI_HW_MITIGATION 21#define MIT_SIZE 15 22#define MIT_TABLE 15 /* We use 0 or max */ 23 24static unsigned int mit_table[MIT_SIZE+1] = 25{ 26 /* CRS11 21143 hardware Mitigation Control Interrupt 27 We use only RX mitigation we other techniques for 28 TX intr. mitigation. 29 30 31 Cycle Size (timer control) 31 30:27 TX timer in 16 * Cycle size 32 26:24 TX No pkts before Int. 33 23:20 RX timer in Cycle size 34 19:17 RX No pkts before Int. 35 16 Continues Mode (CM) 36 */ 37 38 0x0, /* IM disabled */ 39 0x80150000, /* RX time = 1, RX pkts = 2, CM = 1 */ 40 0x80150000, 41 0x80270000, 42 0x80370000, 43 0x80490000, 44 0x80590000, 45 0x80690000, 46 0x807B0000, 47 0x808B0000, 48 0x809D0000, 49 0x80AD0000, 50 0x80BD0000, 51 0x80CF0000, 52 0x80DF0000, 53// 0x80FF0000 /* RX time = 16, RX pkts = 7, CM = 1 */ 54 0x80F10000 /* RX time = 16, RX pkts = 0, CM = 1 */ 55}; 56#endif 57 58 59int tulip_refill_rx(struct net_device *dev) 60{ 61 struct tulip_private *tp = netdev_priv(dev); 62 int entry; 63 int refilled = 0; 64 65 /* Refill the Rx ring buffers. */ 66 for (; tp->cur_rx - tp->dirty_rx > 0; tp->dirty_rx++) { 67 entry = tp->dirty_rx % RX_RING_SIZE; 68 if (tp->rx_buffers[entry].skb == NULL) { 69 struct sk_buff *skb; 70 dma_addr_t mapping; 71 72 skb = tp->rx_buffers[entry].skb = 73 netdev_alloc_skb(dev, PKT_BUF_SZ); 74 if (skb == NULL) 75 break; 76 77 mapping = pci_map_single(tp->pdev, skb->data, PKT_BUF_SZ, 78 PCI_DMA_FROMDEVICE); 79 tp->rx_buffers[entry].mapping = mapping; 80 81 tp->rx_ring[entry].buffer1 = cpu_to_le32(mapping); 82 refilled++; 83 } 84 tp->rx_ring[entry].status = cpu_to_le32(DescOwned); 85 } 86 if(tp->chip_id == LC82C168) { 87 if(((ioread32(tp->base_addr + CSR5)>>17)&0x07) == 4) { 88 /* Rx stopped due to out of buffers, 89 * restart it 90 */ 91 iowrite32(0x01, tp->base_addr + CSR2); 92 } 93 } 94 return refilled; 95} 96 97#ifdef CONFIG_TULIP_NAPI 98 99void oom_timer(unsigned long data) 100{ 101 struct net_device *dev = (struct net_device *)data; 102 struct tulip_private *tp = netdev_priv(dev); 103 napi_schedule(&tp->napi); 104} 105 106int tulip_poll(struct napi_struct *napi, int budget) 107{ 108 struct tulip_private *tp = container_of(napi, struct tulip_private, napi); 109 struct net_device *dev = tp->dev; 110 int entry = tp->cur_rx % RX_RING_SIZE; 111 int work_done = 0; 112#ifdef CONFIG_TULIP_NAPI_HW_MITIGATION 113 int received = 0; 114#endif 115 116#ifdef CONFIG_TULIP_NAPI_HW_MITIGATION 117 118/* that one buffer is needed for mit activation; or might be a 119 bug in the ring buffer code; check later -- JHS*/ 120 121 if (budget >=RX_RING_SIZE) budget--; 122#endif 123 124 if (tulip_debug > 4) 125 netdev_dbg(dev, " In tulip_rx(), entry %d %08x\n", 126 entry, tp->rx_ring[entry].status); 127 128 do { 129 if (ioread32(tp->base_addr + CSR5) == 0xffffffff) { 130 netdev_dbg(dev, " In tulip_poll(), hardware disappeared\n"); 131 break; 132 } 133 /* Acknowledge current RX interrupt sources. */ 134 iowrite32((RxIntr | RxNoBuf), tp->base_addr + CSR5); 135 136 137 /* If we own the next entry, it is a new packet. Send it up. */ 138 while ( ! (tp->rx_ring[entry].status & cpu_to_le32(DescOwned))) { 139 s32 status = le32_to_cpu(tp->rx_ring[entry].status); 140 short pkt_len; 141 142 if (tp->dirty_rx + RX_RING_SIZE == tp->cur_rx) 143 break; 144 145 if (tulip_debug > 5) 146 netdev_dbg(dev, "In tulip_rx(), entry %d %08x\n", 147 entry, status); 148 149 if (++work_done >= budget) 150 goto not_done; 151 152 /* 153 * Omit the four octet CRC from the length. 154 * (May not be considered valid until we have 155 * checked status for RxLengthOver2047 bits) 156 */ 157 pkt_len = ((status >> 16) & 0x7ff) - 4; 158 159 /* 160 * Maximum pkt_len is 1518 (1514 + vlan header) 161 * Anything higher than this is always invalid 162 * regardless of RxLengthOver2047 bits 163 */ 164 165 if ((status & (RxLengthOver2047 | 166 RxDescCRCError | 167 RxDescCollisionSeen | 168 RxDescRunt | 169 RxDescDescErr | 170 RxWholePkt)) != RxWholePkt || 171 pkt_len > 1518) { 172 if ((status & (RxLengthOver2047 | 173 RxWholePkt)) != RxWholePkt) { 174 /* Ingore earlier buffers. */ 175 if ((status & 0xffff) != 0x7fff) { 176 if (tulip_debug > 1) 177 dev_warn(&dev->dev, 178 "Oversized Ethernet frame spanned multiple buffers, status %08x!\n", 179 status); 180 dev->stats.rx_length_errors++; 181 } 182 } else { 183 /* There was a fatal error. */ 184 if (tulip_debug > 2) 185 netdev_dbg(dev, "Receive error, Rx status %08x\n", 186 status); 187 dev->stats.rx_errors++; /* end of a packet.*/ 188 if (pkt_len > 1518 || 189 (status & RxDescRunt)) 190 dev->stats.rx_length_errors++; 191 192 if (status & 0x0004) 193 dev->stats.rx_frame_errors++; 194 if (status & 0x0002) 195 dev->stats.rx_crc_errors++; 196 if (status & 0x0001) 197 dev->stats.rx_fifo_errors++; 198 } 199 } else { 200 struct sk_buff *skb; 201 202 /* Check if the packet is long enough to accept without copying 203 to a minimally-sized skbuff. */ 204 if (pkt_len < tulip_rx_copybreak && 205 (skb = netdev_alloc_skb(dev, pkt_len + 2)) != NULL) { 206 skb_reserve(skb, 2); /* 16 byte align the IP header */ 207 pci_dma_sync_single_for_cpu(tp->pdev, 208 tp->rx_buffers[entry].mapping, 209 pkt_len, PCI_DMA_FROMDEVICE); 210#if ! defined(__alpha__) 211 skb_copy_to_linear_data(skb, tp->rx_buffers[entry].skb->data, 212 pkt_len); 213 skb_put(skb, pkt_len); 214#else 215 memcpy(skb_put(skb, pkt_len), 216 tp->rx_buffers[entry].skb->data, 217 pkt_len); 218#endif 219 pci_dma_sync_single_for_device(tp->pdev, 220 tp->rx_buffers[entry].mapping, 221 pkt_len, PCI_DMA_FROMDEVICE); 222 } else { /* Pass up the skb already on the Rx ring. */ 223 char *temp = skb_put(skb = tp->rx_buffers[entry].skb, 224 pkt_len); 225 226#ifndef final_version 227 if (tp->rx_buffers[entry].mapping != 228 le32_to_cpu(tp->rx_ring[entry].buffer1)) { 229 dev_err(&dev->dev, 230 "Internal fault: The skbuff addresses do not match in tulip_rx: %08x vs. %08llx %p / %p\n", 231 le32_to_cpu(tp->rx_ring[entry].buffer1), 232 (unsigned long long)tp->rx_buffers[entry].mapping, 233 skb->head, temp); 234 } 235#endif 236 237 pci_unmap_single(tp->pdev, tp->rx_buffers[entry].mapping, 238 PKT_BUF_SZ, PCI_DMA_FROMDEVICE); 239 240 tp->rx_buffers[entry].skb = NULL; 241 tp->rx_buffers[entry].mapping = 0; 242 } 243 skb->protocol = eth_type_trans(skb, dev); 244 245 netif_receive_skb(skb); 246 247 dev->stats.rx_packets++; 248 dev->stats.rx_bytes += pkt_len; 249 } 250#ifdef CONFIG_TULIP_NAPI_HW_MITIGATION 251 received++; 252#endif 253 254 entry = (++tp->cur_rx) % RX_RING_SIZE; 255 if (tp->cur_rx - tp->dirty_rx > RX_RING_SIZE/4) 256 tulip_refill_rx(dev); 257 258 } 259 260 /* New ack strategy... irq does not ack Rx any longer 261 hopefully this helps */ 262 263 /* Really bad things can happen here... If new packet arrives 264 * and an irq arrives (tx or just due to occasionally unset 265 * mask), it will be acked by irq handler, but new thread 266 * is not scheduled. It is major hole in design. 267 * No idea how to fix this if "playing with fire" will fail 268 * tomorrow (night 011029). If it will not fail, we won 269 * finally: amount of IO did not increase at all. */ 270 } while ((ioread32(tp->base_addr + CSR5) & RxIntr)); 271 272 #ifdef CONFIG_TULIP_NAPI_HW_MITIGATION 273 274 /* We use this simplistic scheme for IM. It's proven by 275 real life installations. We can have IM enabled 276 continuesly but this would cause unnecessary latency. 277 Unfortunely we can't use all the NET_RX_* feedback here. 278 This would turn on IM for devices that is not contributing 279 to backlog congestion with unnecessary latency. 280 281 We monitor the device RX-ring and have: 282 283 HW Interrupt Mitigation either ON or OFF. 284 285 ON: More then 1 pkt received (per intr.) OR we are dropping 286 OFF: Only 1 pkt received 287 288 Note. We only use min and max (0, 15) settings from mit_table */ 289 290 291 if( tp->flags & HAS_INTR_MITIGATION) { 292 if( received > 1 ) { 293 if( ! tp->mit_on ) { 294 tp->mit_on = 1; 295 iowrite32(mit_table[MIT_TABLE], tp->base_addr + CSR11); 296 } 297 } 298 else { 299 if( tp->mit_on ) { 300 tp->mit_on = 0; 301 iowrite32(0, tp->base_addr + CSR11); 302 } 303 } 304 } 305 306#endif /* CONFIG_TULIP_NAPI_HW_MITIGATION */ 307 308 tulip_refill_rx(dev); 309 310 /* If RX ring is not full we are out of memory. */ 311 if (tp->rx_buffers[tp->dirty_rx % RX_RING_SIZE].skb == NULL) 312 goto oom; 313 314 /* Remove us from polling list and enable RX intr. */ 315 316 napi_complete(napi); 317 iowrite32(tulip_tbl[tp->chip_id].valid_intrs, tp->base_addr+CSR7); 318 319 /* The last op happens after poll completion. Which means the following: 320 * 1. it can race with disabling irqs in irq handler 321 * 2. it can race with dise/enabling irqs in other poll threads 322 * 3. if an irq raised after beginning loop, it will be immediately 323 * triggered here. 324 * 325 * Summarizing: the logic results in some redundant irqs both 326 * due to races in masking and due to too late acking of already 327 * processed irqs. But it must not result in losing events. 328 */ 329 330 return work_done; 331 332 not_done: 333 if (tp->cur_rx - tp->dirty_rx > RX_RING_SIZE/2 || 334 tp->rx_buffers[tp->dirty_rx % RX_RING_SIZE].skb == NULL) 335 tulip_refill_rx(dev); 336 337 if (tp->rx_buffers[tp->dirty_rx % RX_RING_SIZE].skb == NULL) 338 goto oom; 339 340 return work_done; 341 342 oom: /* Executed with RX ints disabled */ 343 344 /* Start timer, stop polling, but do not enable rx interrupts. */ 345 mod_timer(&tp->oom_timer, jiffies+1); 346 347 /* Think: timer_pending() was an explicit signature of bug. 348 * Timer can be pending now but fired and completed 349 * before we did napi_complete(). See? We would lose it. */ 350 351 /* remove ourselves from the polling list */ 352 napi_complete(napi); 353 354 return work_done; 355} 356 357#else /* CONFIG_TULIP_NAPI */ 358 359static int tulip_rx(struct net_device *dev) 360{ 361 struct tulip_private *tp = netdev_priv(dev); 362 int entry = tp->cur_rx % RX_RING_SIZE; 363 int rx_work_limit = tp->dirty_rx + RX_RING_SIZE - tp->cur_rx; 364 int received = 0; 365 366 if (tulip_debug > 4) 367 netdev_dbg(dev, "In tulip_rx(), entry %d %08x\n", 368 entry, tp->rx_ring[entry].status); 369 /* If we own the next entry, it is a new packet. Send it up. */ 370 while ( ! (tp->rx_ring[entry].status & cpu_to_le32(DescOwned))) { 371 s32 status = le32_to_cpu(tp->rx_ring[entry].status); 372 short pkt_len; 373 374 if (tulip_debug > 5) 375 netdev_dbg(dev, "In tulip_rx(), entry %d %08x\n", 376 entry, status); 377 if (--rx_work_limit < 0) 378 break; 379 380 /* 381 Omit the four octet CRC from the length. 382 (May not be considered valid until we have 383 checked status for RxLengthOver2047 bits) 384 */ 385 pkt_len = ((status >> 16) & 0x7ff) - 4; 386 /* 387 Maximum pkt_len is 1518 (1514 + vlan header) 388 Anything higher than this is always invalid 389 regardless of RxLengthOver2047 bits 390 */ 391 392 if ((status & (RxLengthOver2047 | 393 RxDescCRCError | 394 RxDescCollisionSeen | 395 RxDescRunt | 396 RxDescDescErr | 397 RxWholePkt)) != RxWholePkt || 398 pkt_len > 1518) { 399 if ((status & (RxLengthOver2047 | 400 RxWholePkt)) != RxWholePkt) { 401 /* Ingore earlier buffers. */ 402 if ((status & 0xffff) != 0x7fff) { 403 if (tulip_debug > 1) 404 netdev_warn(dev, 405 "Oversized Ethernet frame spanned multiple buffers, status %08x!\n", 406 status); 407 dev->stats.rx_length_errors++; 408 } 409 } else { 410 /* There was a fatal error. */ 411 if (tulip_debug > 2) 412 netdev_dbg(dev, "Receive error, Rx status %08x\n", 413 status); 414 dev->stats.rx_errors++; /* end of a packet.*/ 415 if (pkt_len > 1518 || 416 (status & RxDescRunt)) 417 dev->stats.rx_length_errors++; 418 if (status & 0x0004) 419 dev->stats.rx_frame_errors++; 420 if (status & 0x0002) 421 dev->stats.rx_crc_errors++; 422 if (status & 0x0001) 423 dev->stats.rx_fifo_errors++; 424 } 425 } else { 426 struct sk_buff *skb; 427 428 /* Check if the packet is long enough to accept without copying 429 to a minimally-sized skbuff. */ 430 if (pkt_len < tulip_rx_copybreak && 431 (skb = netdev_alloc_skb(dev, pkt_len + 2)) != NULL) { 432 skb_reserve(skb, 2); /* 16 byte align the IP header */ 433 pci_dma_sync_single_for_cpu(tp->pdev, 434 tp->rx_buffers[entry].mapping, 435 pkt_len, PCI_DMA_FROMDEVICE); 436#if ! defined(__alpha__) 437 skb_copy_to_linear_data(skb, tp->rx_buffers[entry].skb->data, 438 pkt_len); 439 skb_put(skb, pkt_len); 440#else 441 memcpy(skb_put(skb, pkt_len), 442 tp->rx_buffers[entry].skb->data, 443 pkt_len); 444#endif 445 pci_dma_sync_single_for_device(tp->pdev, 446 tp->rx_buffers[entry].mapping, 447 pkt_len, PCI_DMA_FROMDEVICE); 448 } else { /* Pass up the skb already on the Rx ring. */ 449 char *temp = skb_put(skb = tp->rx_buffers[entry].skb, 450 pkt_len); 451 452#ifndef final_version 453 if (tp->rx_buffers[entry].mapping != 454 le32_to_cpu(tp->rx_ring[entry].buffer1)) { 455 dev_err(&dev->dev, 456 "Internal fault: The skbuff addresses do not match in tulip_rx: %08x vs. %Lx %p / %p\n", 457 le32_to_cpu(tp->rx_ring[entry].buffer1), 458 (long long)tp->rx_buffers[entry].mapping, 459 skb->head, temp); 460 } 461#endif 462 463 pci_unmap_single(tp->pdev, tp->rx_buffers[entry].mapping, 464 PKT_BUF_SZ, PCI_DMA_FROMDEVICE); 465 466 tp->rx_buffers[entry].skb = NULL; 467 tp->rx_buffers[entry].mapping = 0; 468 } 469 skb->protocol = eth_type_trans(skb, dev); 470 471 netif_rx(skb); 472 473 dev->stats.rx_packets++; 474 dev->stats.rx_bytes += pkt_len; 475 } 476 received++; 477 entry = (++tp->cur_rx) % RX_RING_SIZE; 478 } 479 return received; 480} 481#endif /* CONFIG_TULIP_NAPI */ 482 483static inline unsigned int phy_interrupt (struct net_device *dev) 484{ 485#ifdef __hppa__ 486 struct tulip_private *tp = netdev_priv(dev); 487 int csr12 = ioread32(tp->base_addr + CSR12) & 0xff; 488 489 if (csr12 != tp->csr12_shadow) { 490 /* ack interrupt */ 491 iowrite32(csr12 | 0x02, tp->base_addr + CSR12); 492 tp->csr12_shadow = csr12; 493 /* do link change stuff */ 494 spin_lock(&tp->lock); 495 tulip_check_duplex(dev); 496 spin_unlock(&tp->lock); 497 /* clear irq ack bit */ 498 iowrite32(csr12 & ~0x02, tp->base_addr + CSR12); 499 500 return 1; 501 } 502#endif 503 504 return 0; 505} 506 507/* The interrupt handler does all of the Rx thread work and cleans up 508 after the Tx thread. */ 509irqreturn_t tulip_interrupt(int irq, void *dev_instance) 510{ 511 struct net_device *dev = (struct net_device *)dev_instance; 512 struct tulip_private *tp = netdev_priv(dev); 513 void __iomem *ioaddr = tp->base_addr; 514 int csr5; 515 int missed; 516 int rx = 0; 517 int tx = 0; 518 int oi = 0; 519 int maxrx = RX_RING_SIZE; 520 int maxtx = TX_RING_SIZE; 521 int maxoi = TX_RING_SIZE; 522#ifdef CONFIG_TULIP_NAPI 523 int rxd = 0; 524#else 525 int entry; 526#endif 527 unsigned int work_count = tulip_max_interrupt_work; 528 unsigned int handled = 0; 529 530 /* Let's see whether the interrupt really is for us */ 531 csr5 = ioread32(ioaddr + CSR5); 532 533 if (tp->flags & HAS_PHY_IRQ) 534 handled = phy_interrupt (dev); 535 536 if ((csr5 & (NormalIntr|AbnormalIntr)) == 0) 537 return IRQ_RETVAL(handled); 538 539 tp->nir++; 540 541 do { 542 543#ifdef CONFIG_TULIP_NAPI 544 545 if (!rxd && (csr5 & (RxIntr | RxNoBuf))) { 546 rxd++; 547 /* Mask RX intrs and add the device to poll list. */ 548 iowrite32(tulip_tbl[tp->chip_id].valid_intrs&~RxPollInt, ioaddr + CSR7); 549 napi_schedule(&tp->napi); 550 551 if (!(csr5&~(AbnormalIntr|NormalIntr|RxPollInt|TPLnkPass))) 552 break; 553 } 554 555 /* Acknowledge the interrupt sources we handle here ASAP 556 the poll function does Rx and RxNoBuf acking */ 557 558 iowrite32(csr5 & 0x0001ff3f, ioaddr + CSR5); 559 560#else 561 /* Acknowledge all of the current interrupt sources ASAP. */ 562 iowrite32(csr5 & 0x0001ffff, ioaddr + CSR5); 563 564 565 if (csr5 & (RxIntr | RxNoBuf)) { 566 rx += tulip_rx(dev); 567 tulip_refill_rx(dev); 568 } 569 570#endif /* CONFIG_TULIP_NAPI */ 571 572 if (tulip_debug > 4) 573 netdev_dbg(dev, "interrupt csr5=%#8.8x new csr5=%#8.8x\n", 574 csr5, ioread32(ioaddr + CSR5)); 575 576 577 if (csr5 & (TxNoBuf | TxDied | TxIntr | TimerInt)) { 578 unsigned int dirty_tx; 579 580 spin_lock(&tp->lock); 581 582 for (dirty_tx = tp->dirty_tx; tp->cur_tx - dirty_tx > 0; 583 dirty_tx++) { 584 int entry = dirty_tx % TX_RING_SIZE; 585 int status = le32_to_cpu(tp->tx_ring[entry].status); 586 587 if (status < 0) 588 break; /* It still has not been Txed */ 589 590 /* Check for Rx filter setup frames. */ 591 if (tp->tx_buffers[entry].skb == NULL) { 592 /* test because dummy frames not mapped */ 593 if (tp->tx_buffers[entry].mapping) 594 pci_unmap_single(tp->pdev, 595 tp->tx_buffers[entry].mapping, 596 sizeof(tp->setup_frame), 597 PCI_DMA_TODEVICE); 598 continue; 599 } 600 601 if (status & 0x8000) { 602 /* There was an major error, log it. */ 603#ifndef final_version 604 if (tulip_debug > 1) 605 netdev_dbg(dev, "Transmit error, Tx status %08x\n", 606 status); 607#endif 608 dev->stats.tx_errors++; 609 if (status & 0x4104) 610 dev->stats.tx_aborted_errors++; 611 if (status & 0x0C00) 612 dev->stats.tx_carrier_errors++; 613 if (status & 0x0200) 614 dev->stats.tx_window_errors++; 615 if (status & 0x0002) 616 dev->stats.tx_fifo_errors++; 617 if ((status & 0x0080) && tp->full_duplex == 0) 618 dev->stats.tx_heartbeat_errors++; 619 } else { 620 dev->stats.tx_bytes += 621 tp->tx_buffers[entry].skb->len; 622 dev->stats.collisions += (status >> 3) & 15; 623 dev->stats.tx_packets++; 624 } 625 626 pci_unmap_single(tp->pdev, tp->tx_buffers[entry].mapping, 627 tp->tx_buffers[entry].skb->len, 628 PCI_DMA_TODEVICE); 629 630 /* Free the original skb. */ 631 dev_kfree_skb_irq(tp->tx_buffers[entry].skb); 632 tp->tx_buffers[entry].skb = NULL; 633 tp->tx_buffers[entry].mapping = 0; 634 tx++; 635 } 636 637#ifndef final_version 638 if (tp->cur_tx - dirty_tx > TX_RING_SIZE) { 639 dev_err(&dev->dev, 640 "Out-of-sync dirty pointer, %d vs. %d\n", 641 dirty_tx, tp->cur_tx); 642 dirty_tx += TX_RING_SIZE; 643 } 644#endif 645 646 if (tp->cur_tx - dirty_tx < TX_RING_SIZE - 2) 647 netif_wake_queue(dev); 648 649 tp->dirty_tx = dirty_tx; 650 if (csr5 & TxDied) { 651 if (tulip_debug > 2) 652 dev_warn(&dev->dev, 653 "The transmitter stopped. CSR5 is %x, CSR6 %x, new CSR6 %x\n", 654 csr5, ioread32(ioaddr + CSR6), 655 tp->csr6); 656 tulip_restart_rxtx(tp); 657 } 658 spin_unlock(&tp->lock); 659 } 660 661 /* Log errors. */ 662 if (csr5 & AbnormalIntr) { /* Abnormal error summary bit. */ 663 if (csr5 == 0xffffffff) 664 break; 665 if (csr5 & TxJabber) 666 dev->stats.tx_errors++; 667 if (csr5 & TxFIFOUnderflow) { 668 if ((tp->csr6 & 0xC000) != 0xC000) 669 tp->csr6 += 0x4000; /* Bump up the Tx threshold */ 670 else 671 tp->csr6 |= 0x00200000; /* Store-n-forward. */ 672 /* Restart the transmit process. */ 673 tulip_restart_rxtx(tp); 674 iowrite32(0, ioaddr + CSR1); 675 } 676 if (csr5 & (RxDied | RxNoBuf)) { 677 if (tp->flags & COMET_MAC_ADDR) { 678 iowrite32(tp->mc_filter[0], ioaddr + 0xAC); 679 iowrite32(tp->mc_filter[1], ioaddr + 0xB0); 680 } 681 } 682 if (csr5 & RxDied) { /* Missed a Rx frame. */ 683 dev->stats.rx_missed_errors += ioread32(ioaddr + CSR8) & 0xffff; 684 dev->stats.rx_errors++; 685 tulip_start_rxtx(tp); 686 } 687 /* 688 * NB: t21142_lnk_change() does a del_timer_sync(), so be careful if this 689 * call is ever done under the spinlock 690 */ 691 if (csr5 & (TPLnkPass | TPLnkFail | 0x08000000)) { 692 if (tp->link_change) 693 (tp->link_change)(dev, csr5); 694 } 695 if (csr5 & SystemError) { 696 int error = (csr5 >> 23) & 7; 697 /* oops, we hit a PCI error. The code produced corresponds 698 * to the reason: 699 * 0 - parity error 700 * 1 - master abort 701 * 2 - target abort 702 * Note that on parity error, we should do a software reset 703 * of the chip to get it back into a sane state (according 704 * to the 21142/3 docs that is). 705 * -- rmk 706 */ 707 dev_err(&dev->dev, 708 "(%lu) System Error occurred (%d)\n", 709 tp->nir, error); 710 } 711 /* Clear all error sources, included undocumented ones! */ 712 iowrite32(0x0800f7ba, ioaddr + CSR5); 713 oi++; 714 } 715 if (csr5 & TimerInt) { 716 717 if (tulip_debug > 2) 718 dev_err(&dev->dev, 719 "Re-enabling interrupts, %08x\n", 720 csr5); 721 iowrite32(tulip_tbl[tp->chip_id].valid_intrs, ioaddr + CSR7); 722 tp->ttimer = 0; 723 oi++; 724 } 725 if (tx > maxtx || rx > maxrx || oi > maxoi) { 726 if (tulip_debug > 1) 727 dev_warn(&dev->dev, "Too much work during an interrupt, csr5=0x%08x. (%lu) (%d,%d,%d)\n", 728 csr5, tp->nir, tx, rx, oi); 729 730 /* Acknowledge all interrupt sources. */ 731 iowrite32(0x8001ffff, ioaddr + CSR5); 732 if (tp->flags & HAS_INTR_MITIGATION) { 733 /* Josip Loncaric at ICASE did extensive experimentation 734 to develop a good interrupt mitigation setting.*/ 735 iowrite32(0x8b240000, ioaddr + CSR11); 736 } else if (tp->chip_id == LC82C168) { 737 /* the LC82C168 doesn't have a hw timer.*/ 738 iowrite32(0x00, ioaddr + CSR7); 739 mod_timer(&tp->timer, RUN_AT(HZ/50)); 740 } else { 741 /* Mask all interrupting sources, set timer to 742 re-enable. */ 743 iowrite32(((~csr5) & 0x0001ebef) | AbnormalIntr | TimerInt, ioaddr + CSR7); 744 iowrite32(0x0012, ioaddr + CSR11); 745 } 746 break; 747 } 748 749 work_count--; 750 if (work_count == 0) 751 break; 752 753 csr5 = ioread32(ioaddr + CSR5); 754 755#ifdef CONFIG_TULIP_NAPI 756 if (rxd) 757 csr5 &= ~RxPollInt; 758 } while ((csr5 & (TxNoBuf | 759 TxDied | 760 TxIntr | 761 TimerInt | 762 /* Abnormal intr. */ 763 RxDied | 764 TxFIFOUnderflow | 765 TxJabber | 766 TPLnkFail | 767 SystemError )) != 0); 768#else 769 } while ((csr5 & (NormalIntr|AbnormalIntr)) != 0); 770 771 tulip_refill_rx(dev); 772 773 /* check if the card is in suspend mode */ 774 entry = tp->dirty_rx % RX_RING_SIZE; 775 if (tp->rx_buffers[entry].skb == NULL) { 776 if (tulip_debug > 1) 777 dev_warn(&dev->dev, 778 "in rx suspend mode: (%lu) (tp->cur_rx = %u, ttimer = %d, rx = %d) go/stay in suspend mode\n", 779 tp->nir, tp->cur_rx, tp->ttimer, rx); 780 if (tp->chip_id == LC82C168) { 781 iowrite32(0x00, ioaddr + CSR7); 782 mod_timer(&tp->timer, RUN_AT(HZ/50)); 783 } else { 784 if (tp->ttimer == 0 || (ioread32(ioaddr + CSR11) & 0xffff) == 0) { 785 if (tulip_debug > 1) 786 dev_warn(&dev->dev, 787 "in rx suspend mode: (%lu) set timer\n", 788 tp->nir); 789 iowrite32(tulip_tbl[tp->chip_id].valid_intrs | TimerInt, 790 ioaddr + CSR7); 791 iowrite32(TimerInt, ioaddr + CSR5); 792 iowrite32(12, ioaddr + CSR11); 793 tp->ttimer = 1; 794 } 795 } 796 } 797#endif /* CONFIG_TULIP_NAPI */ 798 799 if ((missed = ioread32(ioaddr + CSR8) & 0x1ffff)) { 800 dev->stats.rx_dropped += missed & 0x10000 ? 0x10000 : missed; 801 } 802 803 if (tulip_debug > 4) 804 netdev_dbg(dev, "exiting interrupt, csr5=%#04x\n", 805 ioread32(ioaddr + CSR5)); 806 807 return IRQ_HANDLED; 808} 809