tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
20int tulip_rx_copybreak;
21unsigned 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
27static 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
62int 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
102void 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
109int 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
360static 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
482static 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. */
508irqreturn_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}