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