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