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