root/drivers/net/ethernet/dec/tulip/interrupt.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. tulip_refill_rx
  2. oom_timer
  3. tulip_poll
  4. tulip_rx
  5. phy_interrupt
  6. tulip_interrupt

   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 
  17 int tulip_rx_copybreak;
  18 unsigned 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 
  24 static 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 
  59 int 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 
 105 void oom_timer(struct timer_list *t)
 106 {
 107         struct tulip_private *tp = from_timer(tp, t, oom_timer);
 108 
 109         napi_schedule(&tp->napi);
 110 }
 111 
 112 int 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                                        skb_put_data(skb,
 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_done(napi, work_done);
 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_done(napi, work_done);
 359 
 360          return work_done;
 361 }
 362 
 363 #else /* CONFIG_TULIP_NAPI */
 364 
 365 static 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                                 skb_put_data(skb,
 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 
 489 static 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. */
 515 irqreturn_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 }

/* [<][>][^][v][top][bottom][index][help] */