2 * Copyright (c) 2006 QLogic, Inc. All rights reserved.
3 * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
34 #include <linux/pci.h>
36 #include "ipath_kernel.h"
37 #include "ipath_verbs.h"
38 #include "ipath_common.h"
40 /* These are all rcv-related errors which we want to count for stats */
41 #define E_SUM_PKTERRS \
42 (INFINIPATH_E_RHDRLEN | INFINIPATH_E_RBADTID | \
43 INFINIPATH_E_RBADVERSION | INFINIPATH_E_RHDR | \
44 INFINIPATH_E_RLONGPKTLEN | INFINIPATH_E_RSHORTPKTLEN | \
45 INFINIPATH_E_RMAXPKTLEN | INFINIPATH_E_RMINPKTLEN | \
46 INFINIPATH_E_RFORMATERR | INFINIPATH_E_RUNSUPVL | \
47 INFINIPATH_E_RUNEXPCHAR | INFINIPATH_E_REBP)
49 /* These are all send-related errors which we want to count for stats */
51 (INFINIPATH_E_SPIOARMLAUNCH | INFINIPATH_E_SUNEXPERRPKTNUM | \
52 INFINIPATH_E_SDROPPEDDATAPKT | INFINIPATH_E_SDROPPEDSMPPKT | \
53 INFINIPATH_E_SMAXPKTLEN | INFINIPATH_E_SUNSUPVL | \
54 INFINIPATH_E_SMINPKTLEN | INFINIPATH_E_SPKTLEN | \
55 INFINIPATH_E_INVALIDADDR)
58 * these are errors that can occur when the link changes state while
59 * a packet is being sent or received. This doesn't cover things
60 * like EBP or VCRC that can be the result of a sending having the
61 * link change state, so we receive a "known bad" packet.
63 #define E_SUM_LINK_PKTERRS \
64 (INFINIPATH_E_SDROPPEDDATAPKT | INFINIPATH_E_SDROPPEDSMPPKT | \
65 INFINIPATH_E_SMINPKTLEN | INFINIPATH_E_SPKTLEN | \
66 INFINIPATH_E_RSHORTPKTLEN | INFINIPATH_E_RMINPKTLEN | \
67 INFINIPATH_E_RUNEXPCHAR)
69 static u64
handle_e_sum_errs(struct ipath_devdata
*dd
, ipath_err_t errs
)
71 unsigned long sbuf
[4];
72 u64 ignore_this_time
= 0;
75 /* if possible that sendbuffererror could be valid */
76 piobcnt
= dd
->ipath_piobcnt2k
+ dd
->ipath_piobcnt4k
;
77 /* read these before writing errorclear */
78 sbuf
[0] = ipath_read_kreg64(
79 dd
, dd
->ipath_kregs
->kr_sendbuffererror
);
80 sbuf
[1] = ipath_read_kreg64(
81 dd
, dd
->ipath_kregs
->kr_sendbuffererror
+ 1);
83 sbuf
[2] = ipath_read_kreg64(
84 dd
, dd
->ipath_kregs
->kr_sendbuffererror
+ 2);
85 sbuf
[3] = ipath_read_kreg64(
86 dd
, dd
->ipath_kregs
->kr_sendbuffererror
+ 3);
89 if (sbuf
[0] || sbuf
[1] || (piobcnt
> 128 && (sbuf
[2] || sbuf
[3]))) {
92 ipath_cdbg(PKT
, "SendbufErrs %lx %lx ", sbuf
[0], sbuf
[1]);
93 if (ipath_debug
& __IPATH_PKTDBG
&& piobcnt
> 128)
94 printk("%lx %lx ", sbuf
[2], sbuf
[3]);
95 for (i
= 0; i
< piobcnt
; i
++) {
96 if (test_bit(i
, sbuf
)) {
98 if (i
< dd
->ipath_piobcnt2k
)
99 piobuf
= (u32 __iomem
*)
100 (dd
->ipath_pio2kbase
+
101 i
* dd
->ipath_palign
);
103 piobuf
= (u32 __iomem
*)
104 (dd
->ipath_pio4kbase
+
105 (i
- dd
->ipath_piobcnt2k
) *
109 "PIObuf[%u] @%p pbc is %x; ",
110 i
, piobuf
, readl(piobuf
));
112 ipath_disarm_piobufs(dd
, i
, 1);
115 if (ipath_debug
& __IPATH_PKTDBG
)
118 if ((errs
& E_SUM_LINK_PKTERRS
) &&
119 !(dd
->ipath_flags
& IPATH_LINKACTIVE
)) {
121 * This can happen when SMA is trying to bring the link
122 * up, but the IB link changes state at the "wrong" time.
123 * The IB logic then complains that the packet isn't
124 * valid. We don't want to confuse people, so we just
125 * don't print them, except at debug
127 ipath_dbg("Ignoring packet errors %llx, because link not "
128 "ACTIVE\n", (unsigned long long) errs
);
129 ignore_this_time
= errs
& E_SUM_LINK_PKTERRS
;
132 return ignore_this_time
;
135 /* return the strings for the most common link states */
136 static char *ib_linkstate(u32 linkstate
)
141 case IPATH_IBSTATE_INIT
:
144 case IPATH_IBSTATE_ARM
:
147 case IPATH_IBSTATE_ACTIVE
:
157 static void handle_e_ibstatuschanged(struct ipath_devdata
*dd
,
158 ipath_err_t errs
, int noprint
)
164 * even if diags are enabled, we want to notice LINKINIT, etc.
165 * We just don't want to change the LED state, or
166 * dd->ipath_kregs->kr_ibcctrl
168 val
= ipath_read_kreg64(dd
, dd
->ipath_kregs
->kr_ibcstatus
);
169 lstate
= val
& IPATH_IBSTATE_MASK
;
172 * this is confusing enough when it happens that I want to always put it
173 * on the console and in the logs. If it was a requested state change,
174 * we'll have already cleared the flags, so we won't print this warning
176 if ((lstate
!= IPATH_IBSTATE_ARM
&& lstate
!= IPATH_IBSTATE_ACTIVE
)
177 && (dd
->ipath_flags
& (IPATH_LINKARMED
| IPATH_LINKACTIVE
))) {
178 dev_info(&dd
->pcidev
->dev
, "Link state changed from %s to %s\n",
179 (dd
->ipath_flags
& IPATH_LINKARMED
) ? "ARM" : "ACTIVE",
180 ib_linkstate(lstate
));
182 * Flush all queued sends when link went to DOWN or INIT,
183 * to be sure that they don't block SMA and other MAD packets
185 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_sendctrl
,
187 ipath_disarm_piobufs(dd
, dd
->ipath_lastport_piobuf
,
188 (unsigned)(dd
->ipath_piobcnt2k
+
189 dd
->ipath_piobcnt4k
) -
190 dd
->ipath_lastport_piobuf
);
192 else if (lstate
== IPATH_IBSTATE_INIT
|| lstate
== IPATH_IBSTATE_ARM
||
193 lstate
== IPATH_IBSTATE_ACTIVE
) {
195 * only print at SMA if there is a change, debug if not
196 * (sometimes we want to know that, usually not).
198 if (lstate
== ((unsigned) dd
->ipath_lastibcstat
199 & IPATH_IBSTATE_MASK
)) {
200 ipath_dbg("Status change intr but no change (%s)\n",
201 ib_linkstate(lstate
));
204 ipath_cdbg(SMA
, "Unit %u link state %s, last "
205 "was %s\n", dd
->ipath_unit
,
206 ib_linkstate(lstate
),
207 ib_linkstate((unsigned)
208 dd
->ipath_lastibcstat
209 & IPATH_IBSTATE_MASK
));
212 lstate
= dd
->ipath_lastibcstat
& IPATH_IBSTATE_MASK
;
213 if (lstate
== IPATH_IBSTATE_INIT
||
214 lstate
== IPATH_IBSTATE_ARM
||
215 lstate
== IPATH_IBSTATE_ACTIVE
)
216 ipath_cdbg(SMA
, "Unit %u link state down"
217 " (state 0x%x), from %s\n",
219 (u32
)val
& IPATH_IBSTATE_MASK
,
220 ib_linkstate(lstate
));
222 ipath_cdbg(VERBOSE
, "Unit %u link state changed "
223 "to 0x%x from down (%x)\n",
224 dd
->ipath_unit
, (u32
) val
, lstate
);
226 ltstate
= (val
>> INFINIPATH_IBCS_LINKTRAININGSTATE_SHIFT
) &
227 INFINIPATH_IBCS_LINKTRAININGSTATE_MASK
;
228 lstate
= (val
>> INFINIPATH_IBCS_LINKSTATE_SHIFT
) &
229 INFINIPATH_IBCS_LINKSTATE_MASK
;
231 if (ltstate
== INFINIPATH_IBCS_LT_STATE_POLLACTIVE
||
232 ltstate
== INFINIPATH_IBCS_LT_STATE_POLLQUIET
) {
236 * Ignore cycling back and forth from Polling.Active
237 * to Polling.Quiet while waiting for the other end of
238 * the link to come up. We will cycle back and forth
239 * between them if no cable is plugged in,
240 * the other device is powered off or disabled, etc.
242 last_ltstate
= (dd
->ipath_lastibcstat
>>
243 INFINIPATH_IBCS_LINKTRAININGSTATE_SHIFT
)
244 & INFINIPATH_IBCS_LINKTRAININGSTATE_MASK
;
245 if (last_ltstate
== INFINIPATH_IBCS_LT_STATE_POLLACTIVE
247 INFINIPATH_IBCS_LT_STATE_POLLQUIET
) {
248 if (dd
->ipath_ibpollcnt
> 40) {
249 dd
->ipath_flags
|= IPATH_NOCABLE
;
250 *dd
->ipath_statusp
|=
251 IPATH_STATUS_IB_NOCABLE
;
253 dd
->ipath_ibpollcnt
++;
257 dd
->ipath_ibpollcnt
= 0; /* some state other than 2 or 3 */
258 ipath_stats
.sps_iblink
++;
259 if (ltstate
!= INFINIPATH_IBCS_LT_STATE_LINKUP
) {
260 dd
->ipath_flags
|= IPATH_LINKDOWN
;
261 dd
->ipath_flags
&= ~(IPATH_LINKUNK
| IPATH_LINKINIT
264 *dd
->ipath_statusp
&= ~IPATH_STATUS_IB_READY
;
265 dd
->ipath_lli_counter
= 0;
267 if (((dd
->ipath_lastibcstat
>>
268 INFINIPATH_IBCS_LINKSTATE_SHIFT
) &
269 INFINIPATH_IBCS_LINKSTATE_MASK
)
270 == INFINIPATH_IBCS_L_STATE_ACTIVE
)
271 /* if from up to down be more vocal */
273 "Unit %u link now down (%s)\n",
275 ipath_ibcstatus_str
[ltstate
]);
277 ipath_cdbg(VERBOSE
, "Unit %u link is "
278 "down (%s)\n", dd
->ipath_unit
,
279 ipath_ibcstatus_str
[ltstate
]);
282 dd
->ipath_f_setextled(dd
, lstate
, ltstate
);
283 } else if ((val
& IPATH_IBSTATE_MASK
) == IPATH_IBSTATE_ACTIVE
) {
284 dd
->ipath_flags
|= IPATH_LINKACTIVE
;
286 ~(IPATH_LINKUNK
| IPATH_LINKINIT
| IPATH_LINKDOWN
|
287 IPATH_LINKARMED
| IPATH_NOCABLE
);
288 *dd
->ipath_statusp
&= ~IPATH_STATUS_IB_NOCABLE
;
289 *dd
->ipath_statusp
|=
290 IPATH_STATUS_IB_READY
| IPATH_STATUS_IB_CONF
;
291 dd
->ipath_f_setextled(dd
, lstate
, ltstate
);
292 } else if ((val
& IPATH_IBSTATE_MASK
) == IPATH_IBSTATE_INIT
) {
294 * set INIT and DOWN. Down is checked by most of the other
295 * code, but INIT is useful to know in a few places.
297 dd
->ipath_flags
|= IPATH_LINKINIT
| IPATH_LINKDOWN
;
299 ~(IPATH_LINKUNK
| IPATH_LINKACTIVE
| IPATH_LINKARMED
301 *dd
->ipath_statusp
&= ~(IPATH_STATUS_IB_NOCABLE
302 | IPATH_STATUS_IB_READY
);
303 dd
->ipath_f_setextled(dd
, lstate
, ltstate
);
304 } else if ((val
& IPATH_IBSTATE_MASK
) == IPATH_IBSTATE_ARM
) {
305 dd
->ipath_flags
|= IPATH_LINKARMED
;
307 ~(IPATH_LINKUNK
| IPATH_LINKDOWN
| IPATH_LINKINIT
|
308 IPATH_LINKACTIVE
| IPATH_NOCABLE
);
309 *dd
->ipath_statusp
&= ~(IPATH_STATUS_IB_NOCABLE
310 | IPATH_STATUS_IB_READY
);
311 dd
->ipath_f_setextled(dd
, lstate
, ltstate
);
314 ipath_dbg("IBstatuschange unit %u: %s (%x)\n",
316 ipath_ibcstatus_str
[ltstate
], ltstate
);
319 dd
->ipath_lastibcstat
= val
;
322 static void handle_supp_msgs(struct ipath_devdata
*dd
,
323 unsigned supp_msgs
, char msg
[512])
326 * Print the message unless it's ibc status change only, which
327 * happens so often we never want to count it.
329 if (dd
->ipath_lasterror
& ~INFINIPATH_E_IBSTATUSCHANGED
) {
330 ipath_decode_err(msg
, sizeof msg
, dd
->ipath_lasterror
&
331 ~INFINIPATH_E_IBSTATUSCHANGED
);
332 if (dd
->ipath_lasterror
&
333 ~(INFINIPATH_E_RRCVEGRFULL
| INFINIPATH_E_RRCVHDRFULL
))
334 ipath_dev_err(dd
, "Suppressed %u messages for "
335 "fast-repeating errors (%s) (%llx)\n",
338 dd
->ipath_lasterror
);
341 * rcvegrfull and rcvhdrqfull are "normal", for some
342 * types of processes (mostly benchmarks) that send
343 * huge numbers of messages, while not processing
344 * them. So only complain about these at debug
347 ipath_dbg("Suppressed %u messages for %s\n",
353 static unsigned handle_frequent_errors(struct ipath_devdata
*dd
,
354 ipath_err_t errs
, char msg
[512],
358 static unsigned long nextmsg_time
;
359 static unsigned nmsgs
, supp_msgs
;
362 * Throttle back "fast" messages to no more than 10 per 5 seconds.
363 * This isn't perfect, but it's a reasonable heuristic. If we get
364 * more than 10, give a 6x longer delay.
368 if (time_before(nc
, nextmsg_time
)) {
371 nextmsg_time
= nc
+ HZ
* 3;
373 else if (supp_msgs
) {
374 handle_supp_msgs(dd
, supp_msgs
, msg
);
379 else if (!nmsgs
++ || time_after(nc
, nextmsg_time
))
380 nextmsg_time
= nc
+ HZ
/ 2;
385 static int handle_errors(struct ipath_devdata
*dd
, ipath_err_t errs
)
388 u64 ignore_this_time
= 0;
390 int chkerrpkts
= 0, noprint
= 0;
393 supp_msgs
= handle_frequent_errors(dd
, errs
, msg
, &noprint
);
396 * don't report errors that are masked (includes those always
399 errs
&= ~dd
->ipath_maskederrs
;
401 /* do these first, they are most important */
402 if (errs
& INFINIPATH_E_HARDWARE
) {
403 /* reuse same msg buf */
404 dd
->ipath_f_handle_hwerrors(dd
, msg
, sizeof msg
);
407 if (!noprint
&& (errs
& ~infinipath_e_bitsextant
))
408 ipath_dev_err(dd
, "error interrupt with unknown errors "
409 "%llx set\n", (unsigned long long)
410 (errs
& ~infinipath_e_bitsextant
));
412 if (errs
& E_SUM_ERRS
)
413 ignore_this_time
= handle_e_sum_errs(dd
, errs
);
414 else if ((errs
& E_SUM_LINK_PKTERRS
) &&
415 !(dd
->ipath_flags
& IPATH_LINKACTIVE
)) {
417 * This can happen when SMA is trying to bring the link
418 * up, but the IB link changes state at the "wrong" time.
419 * The IB logic then complains that the packet isn't
420 * valid. We don't want to confuse people, so we just
421 * don't print them, except at debug
423 ipath_dbg("Ignoring packet errors %llx, because link not "
424 "ACTIVE\n", (unsigned long long) errs
);
425 ignore_this_time
= errs
& E_SUM_LINK_PKTERRS
;
428 if (supp_msgs
== 250000) {
430 * It's not entirely reasonable assuming that the errors set
431 * in the last clear period are all responsible for the
432 * problem, but the alternative is to assume it's the only
433 * ones on this particular interrupt, which also isn't great
435 dd
->ipath_maskederrs
|= dd
->ipath_lasterror
| errs
;
436 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_errormask
,
437 ~dd
->ipath_maskederrs
);
438 ipath_decode_err(msg
, sizeof msg
,
439 (dd
->ipath_maskederrs
& ~dd
->
442 if ((dd
->ipath_maskederrs
& ~dd
->ipath_ignorederrs
) &
443 ~(INFINIPATH_E_RRCVEGRFULL
| INFINIPATH_E_RRCVHDRFULL
))
444 ipath_dev_err(dd
, "Disabling error(s) %llx because "
445 "occurring too frequently (%s)\n",
447 (dd
->ipath_maskederrs
&
448 ~dd
->ipath_ignorederrs
), msg
);
451 * rcvegrfull and rcvhdrqfull are "normal",
452 * for some types of processes (mostly benchmarks)
453 * that send huge numbers of messages, while not
454 * processing them. So only complain about
455 * these at debug level.
457 ipath_dbg("Disabling frequent queue full errors "
462 * Re-enable the masked errors after around 3 minutes. in
463 * ipath_get_faststats(). If we have a series of fast
464 * repeating but different errors, the interval will keep
465 * stretching out, but that's OK, as that's pretty
468 dd
->ipath_unmasktime
= jiffies
+ HZ
* 180;
471 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_errorclear
, errs
);
472 if (ignore_this_time
)
473 errs
&= ~ignore_this_time
;
474 if (errs
& ~dd
->ipath_lasterror
) {
475 errs
&= ~dd
->ipath_lasterror
;
476 /* never suppress duplicate hwerrors or ibstatuschange */
477 dd
->ipath_lasterror
|= errs
&
478 ~(INFINIPATH_E_HARDWARE
|
479 INFINIPATH_E_IBSTATUSCHANGED
);
486 * the ones we mask off are handled specially below or above
488 ipath_decode_err(msg
, sizeof msg
,
489 errs
& ~(INFINIPATH_E_IBSTATUSCHANGED
|
490 INFINIPATH_E_RRCVEGRFULL
|
491 INFINIPATH_E_RRCVHDRFULL
|
492 INFINIPATH_E_HARDWARE
));
494 /* so we don't need if (!noprint) at strlcat's below */
497 if (errs
& E_SUM_PKTERRS
) {
498 ipath_stats
.sps_pkterrs
++;
501 if (errs
& E_SUM_ERRS
)
502 ipath_stats
.sps_errs
++;
504 if (errs
& (INFINIPATH_E_RICRC
| INFINIPATH_E_RVCRC
)) {
505 ipath_stats
.sps_crcerrs
++;
510 * We don't want to print these two as they happen, or we can make
511 * the situation even worse, because it takes so long to print
512 * messages to serial consoles. Kernel ports get printed from
513 * fast_stats, no more than every 5 seconds, user ports get printed
516 if (errs
& INFINIPATH_E_RRCVHDRFULL
) {
519 ipath_stats
.sps_hdrqfull
++;
520 for (any
= i
= 0; i
< dd
->ipath_cfgports
; i
++) {
521 struct ipath_portdata
*pd
= dd
->ipath_pd
[i
];
523 hd
= dd
->ipath_port0head
;
524 tl
= (u32
) le64_to_cpu(
525 *dd
->ipath_hdrqtailptr
);
526 } else if (pd
&& pd
->port_cnt
&&
527 pd
->port_rcvhdrtail_kvaddr
) {
529 * don't report same point multiple times,
532 tl
= (u32
) * pd
->port_rcvhdrtail_kvaddr
;
533 if (tl
== dd
->ipath_lastrcvhdrqtails
[i
])
535 hd
= ipath_read_ureg32(dd
, ur_rcvhdrhead
,
539 if (hd
== (tl
+ 1) ||
540 (!hd
&& tl
== dd
->ipath_hdrqlast
)) {
543 dd
->ipath_lastrcvhdrqtails
[i
] = tl
;
548 if (errs
& INFINIPATH_E_RRCVEGRFULL
) {
550 * since this is of less importance and not likely to
551 * happen without also getting hdrfull, only count
552 * occurrences; don't check each port (or even the kernel
555 ipath_stats
.sps_etidfull
++;
556 if (dd
->ipath_port0head
!=
557 (u32
) le64_to_cpu(*dd
->ipath_hdrqtailptr
))
562 * do this before IBSTATUSCHANGED, in case both bits set in a single
563 * interrupt; we want the STATUSCHANGE to "win", so we do our
564 * internal copy of state machine correctly
566 if (errs
& INFINIPATH_E_RIBLOSTLINK
) {
568 * force through block below
570 errs
|= INFINIPATH_E_IBSTATUSCHANGED
;
571 ipath_stats
.sps_iblink
++;
572 dd
->ipath_flags
|= IPATH_LINKDOWN
;
573 dd
->ipath_flags
&= ~(IPATH_LINKUNK
| IPATH_LINKINIT
574 | IPATH_LINKARMED
| IPATH_LINKACTIVE
);
575 *dd
->ipath_statusp
&= ~IPATH_STATUS_IB_READY
;
577 u64 st
= ipath_read_kreg64(
578 dd
, dd
->ipath_kregs
->kr_ibcstatus
);
580 ipath_dbg("Lost link, link now down (%s)\n",
581 ipath_ibcstatus_str
[st
& 0xf]);
584 if (errs
& INFINIPATH_E_IBSTATUSCHANGED
)
585 handle_e_ibstatuschanged(dd
, errs
, noprint
);
587 if (errs
& INFINIPATH_E_RESET
) {
589 ipath_dev_err(dd
, "Got reset, requires re-init "
590 "(unload and reload driver)\n");
591 dd
->ipath_flags
&= ~IPATH_INITTED
; /* needs re-init */
592 /* mark as having had error */
593 *dd
->ipath_statusp
|= IPATH_STATUS_HWERROR
;
594 *dd
->ipath_statusp
&= ~IPATH_STATUS_IB_CONF
;
597 if (!noprint
&& *msg
)
598 ipath_dev_err(dd
, "%s error\n", msg
);
599 if (dd
->ipath_sma_state_wanted
& dd
->ipath_flags
) {
600 ipath_cdbg(VERBOSE
, "sma wanted state %x, iflags now %x, "
601 "waking\n", dd
->ipath_sma_state_wanted
,
603 wake_up_interruptible(&ipath_sma_state_wait
);
609 /* this is separate to allow for better optimization of ipath_intr() */
611 static void ipath_bad_intr(struct ipath_devdata
*dd
, u32
* unexpectp
)
614 * sometimes happen during driver init and unload, don't want
615 * to process any interrupts at that point
618 /* this is just a bandaid, not a fix, if something goes badly
620 if (++*unexpectp
> 100) {
621 if (++*unexpectp
> 105) {
623 * ok, we must be taking somebody else's interrupts,
624 * due to a messed up mptable and/or PIRQ table, so
625 * unregister the interrupt. We've seen this during
626 * linuxbios development work, and it may happen in
629 if (dd
->pcidev
&& dd
->pcidev
->irq
) {
630 ipath_dev_err(dd
, "Now %u unexpected "
631 "interrupts, unregistering "
632 "interrupt handler\n",
634 ipath_dbg("free_irq of irq %x\n",
636 free_irq(dd
->pcidev
->irq
, dd
);
639 if (ipath_read_kreg32(dd
, dd
->ipath_kregs
->kr_intmask
)) {
640 ipath_dev_err(dd
, "%u unexpected interrupts, "
641 "disabling interrupts completely\n",
644 * disable all interrupts, something is very wrong
646 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_intmask
,
649 } else if (*unexpectp
> 1)
650 ipath_dbg("Interrupt when not ready, should not happen, "
654 static void ipath_bad_regread(struct ipath_devdata
*dd
)
658 /* separate routine, for better optimization of ipath_intr() */
661 * We print the message and disable interrupts, in hope of
662 * having a better chance of debugging the problem.
665 "Read of interrupt status failed (all bits set)\n");
667 /* disable all interrupts, something is very wrong */
668 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_intmask
, 0ULL);
670 ipath_dev_err(dd
, "Still bad interrupt status, "
671 "unregistering interrupt\n");
672 free_irq(dd
->pcidev
->irq
, dd
);
673 } else if (allbits
> 2) {
674 if ((allbits
% 10000) == 0)
677 ipath_dev_err(dd
, "Disabling interrupts, "
678 "multiple errors\n");
682 static void handle_port_pioavail(struct ipath_devdata
*dd
)
686 * start from port 1, since for now port 0 is never using
689 for (i
= 1; dd
->ipath_portpiowait
&& i
< dd
->ipath_cfgports
; i
++) {
690 struct ipath_portdata
*pd
= dd
->ipath_pd
[i
];
692 if (pd
&& pd
->port_cnt
&&
693 dd
->ipath_portpiowait
& (1U << i
)) {
694 clear_bit(i
, &dd
->ipath_portpiowait
);
695 if (test_bit(IPATH_PORT_WAITING_PIO
,
697 clear_bit(IPATH_PORT_WAITING_PIO
,
699 wake_up_interruptible(&pd
->port_wait
);
705 static void handle_layer_pioavail(struct ipath_devdata
*dd
)
709 ret
= ipath_ib_piobufavail(dd
->verbs_dev
);
715 set_bit(IPATH_S_PIOINTBUFAVAIL
, &dd
->ipath_sendctrl
);
716 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_sendctrl
,
721 * Handle receive interrupts for user ports; this means a user
722 * process was waiting for a packet to arrive, and didn't want
725 static void handle_urcv(struct ipath_devdata
*dd
, u32 istat
)
731 portr
= ((istat
>> INFINIPATH_I_RCVAVAIL_SHIFT
) &
732 infinipath_i_rcvavail_mask
)
733 | ((istat
>> INFINIPATH_I_RCVURG_SHIFT
) &
734 infinipath_i_rcvurg_mask
);
735 for (i
= 1; i
< dd
->ipath_cfgports
; i
++) {
736 struct ipath_portdata
*pd
= dd
->ipath_pd
[i
];
737 if (portr
& (1 << i
) && pd
&& pd
->port_cnt
&&
738 test_bit(IPATH_PORT_WAITING_RCV
, &pd
->port_flag
)) {
740 clear_bit(IPATH_PORT_WAITING_RCV
,
742 rcbit
= i
+ INFINIPATH_R_INTRAVAIL_SHIFT
;
743 clear_bit(1UL << rcbit
, &dd
->ipath_rcvctrl
);
744 wake_up_interruptible(&pd
->port_wait
);
749 /* only want to take one interrupt, so turn off the rcv
750 * interrupt for all the ports that we did the wakeup on
751 * (but never for kernel port)
753 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_rcvctrl
,
758 irqreturn_t
ipath_intr(int irq
, void *data
, struct pt_regs
*regs
)
760 struct ipath_devdata
*dd
= data
;
761 u32 istat
, chk0rcv
= 0;
762 ipath_err_t estat
= 0;
764 u32 oldhead
, curtail
;
765 static unsigned unexpected
= 0;
766 static const u32 port0rbits
= (1U<<INFINIPATH_I_RCVAVAIL_SHIFT
) |
767 (1U<<INFINIPATH_I_RCVURG_SHIFT
);
769 ipath_stats
.sps_ints
++;
771 if (!(dd
->ipath_flags
& IPATH_PRESENT
)) {
773 * This return value is not great, but we do not want the
774 * interrupt core code to remove our interrupt handler
775 * because we don't appear to be handling an interrupt
776 * during a chip reset.
782 * this needs to be flags&initted, not statusp, so we keep
783 * taking interrupts even after link goes down, etc.
784 * Also, we *must* clear the interrupt at some point, or we won't
785 * take it again, which can be real bad for errors, etc...
788 if (!(dd
->ipath_flags
& IPATH_INITTED
)) {
789 ipath_bad_intr(dd
, &unexpected
);
795 * We try to avoid reading the interrupt status register, since
796 * that's a PIO read, and stalls the processor for up to about
797 * ~0.25 usec. The idea is that if we processed a port0 packet,
798 * we blindly clear the port 0 receive interrupt bits, and nothing
799 * else, then return. If other interrupts are pending, the chip
800 * will re-interrupt us as soon as we write the intclear register.
801 * We then won't process any more kernel packets (if not the 2nd
802 * time, then the 3rd or 4th) and we'll then handle the other
803 * interrupts. We clear the interrupts first so that we don't
804 * lose intr for later packets that arrive while we are processing.
806 oldhead
= dd
->ipath_port0head
;
807 curtail
= (u32
)le64_to_cpu(*dd
->ipath_hdrqtailptr
);
808 if (oldhead
!= curtail
) {
809 if (dd
->ipath_flags
& IPATH_GPIO_INTR
) {
810 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_gpio_clear
,
812 istat
= port0rbits
| INFINIPATH_I_GPIO
;
816 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_intclear
, istat
);
818 if (oldhead
!= dd
->ipath_port0head
) {
819 ipath_stats
.sps_fastrcvint
++;
824 istat
= ipath_read_kreg32(dd
, dd
->ipath_kregs
->kr_intstatus
);
826 if (unlikely(!istat
)) {
827 ipath_stats
.sps_nullintr
++;
828 ret
= IRQ_NONE
; /* not our interrupt, or already handled */
831 if (unlikely(istat
== -1)) {
832 ipath_bad_regread(dd
);
833 /* don't know if it was our interrupt or not */
841 if (unlikely(istat
& ~infinipath_i_bitsextant
))
843 "interrupt with unknown interrupts %x set\n",
844 istat
& (u32
) ~ infinipath_i_bitsextant
);
846 ipath_cdbg(VERBOSE
, "intr stat=0x%x\n", istat
);
848 if (unlikely(istat
& INFINIPATH_I_ERROR
)) {
849 ipath_stats
.sps_errints
++;
850 estat
= ipath_read_kreg64(dd
,
851 dd
->ipath_kregs
->kr_errorstatus
);
853 dev_info(&dd
->pcidev
->dev
, "error interrupt (%x), "
854 "but no error bits set!\n", istat
);
855 else if (estat
== -1LL)
857 * should we try clearing all, or hope next read
860 ipath_dev_err(dd
, "Read of error status failed "
861 "(all bits set); ignoring\n");
863 if (handle_errors(dd
, estat
))
864 /* force calling ipath_kreceive() */
868 if (istat
& INFINIPATH_I_GPIO
) {
870 * Packets are available in the port 0 rcv queue.
871 * Eventually this needs to be generalized to check
872 * IPATH_GPIO_INTR, and the specific GPIO bit, if
873 * GPIO interrupts are used for anything else.
875 if (unlikely(!(dd
->ipath_flags
& IPATH_GPIO_INTR
))) {
877 gpiostatus
= ipath_read_kreg32(
878 dd
, dd
->ipath_kregs
->kr_gpio_status
);
879 ipath_dbg("Unexpected GPIO interrupt bits %x\n",
881 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_gpio_clear
,
885 /* Clear GPIO status bit 2 */
886 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_gpio_clear
,
891 chk0rcv
|= istat
& port0rbits
;
894 * Clear the interrupt bits we found set, unless they are receive
895 * related, in which case we already cleared them above, and don't
896 * want to clear them again, because we might lose an interrupt.
897 * Clear it early, so we "know" know the chip will have seen this by
898 * the time we process the queue, and will re-interrupt if necessary.
899 * The processor itself won't take the interrupt again until we return.
901 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_intclear
, istat
);
904 * handle port0 receive before checking for pio buffers available,
905 * since receives can overflow; piobuf waiters can afford a few
906 * extra cycles, since they were waiting anyway, and user's waiting
907 * for receive are at the bottom.
911 istat
&= ~port0rbits
;
914 if (istat
& ((infinipath_i_rcvavail_mask
<<
915 INFINIPATH_I_RCVAVAIL_SHIFT
)
916 | (infinipath_i_rcvurg_mask
<<
917 INFINIPATH_I_RCVURG_SHIFT
)))
918 handle_urcv(dd
, istat
);
920 if (istat
& INFINIPATH_I_SPIOBUFAVAIL
) {
921 clear_bit(IPATH_S_PIOINTBUFAVAIL
, &dd
->ipath_sendctrl
);
922 ipath_write_kreg(dd
, dd
->ipath_kregs
->kr_sendctrl
,
925 if (dd
->ipath_portpiowait
)
926 handle_port_pioavail(dd
);
928 handle_layer_pioavail(dd
);