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