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