← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/net/ethernet/dec/tulip/interrupt.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

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