LXR linux/drivers/net/ethernet/dec/tulip/interrupt.c

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