drivers/net/tulip/interrupt.c

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