drivers/net/tulip/interrupt.c

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