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