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