drivers/net/tulip/interrupt.c

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