1 /*
2 * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation.
3 * All rights reserved.
4 * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved.
5 *
6 * This software is available to you under a choice of one of two
7 * licenses. You may choose to be licensed under the terms of the GNU
8 * General Public License (GPL) Version 2, available from the file
9 * COPYING in the main directory of this source tree, or the
10 * OpenIB.org BSD license below:
11 *
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
14 * conditions are met:
15 *
16 * - Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
18 * disclaimer.
19 *
20 * - Redistributions in binary form must reproduce the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer in the documentation and/or other materials
23 * provided with the distribution.
24 *
25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32 * SOFTWARE.
33 */
34
35 #include <linux/pci.h>
36 #include <linux/delay.h>
37
38 #include "qib.h"
39 #include "qib_common.h"
40
41 /**
42 * qib_format_hwmsg - format a single hwerror message
43 * @msg message buffer
44 * @msgl length of message buffer
45 * @hwmsg message to add to message buffer
46 */
47 static void qib_format_hwmsg(char *msg, size_t msgl, const char *hwmsg)
48 {
49 strlcat(msg, "[", msgl);
50 strlcat(msg, hwmsg, msgl);
51 strlcat(msg, "]", msgl);
52 }
53
54 /**
55 * qib_format_hwerrors - format hardware error messages for display
56 * @hwerrs hardware errors bit vector
57 * @hwerrmsgs hardware error descriptions
58 * @nhwerrmsgs number of hwerrmsgs
59 * @msg message buffer
60 * @msgl message buffer length
61 */
62 void qib_format_hwerrors(u64 hwerrs, const struct qib_hwerror_msgs *hwerrmsgs,
63 size_t nhwerrmsgs, char *msg, size_t msgl)
64 {
65 int i;
66
67 for (i = 0; i < nhwerrmsgs; i++)
68 if (hwerrs & hwerrmsgs[i].mask)
69 qib_format_hwmsg(msg, msgl, hwerrmsgs[i].msg);
70 }
71
72 static void signal_ib_event(struct qib_pportdata *ppd, enum ib_event_type ev)
73 {
74 struct ib_event event;
75 struct qib_devdata *dd = ppd->dd;
76
77 event.device = &dd->verbs_dev.rdi.ibdev;
78 event.element.port_num = ppd->port;
79 event.event = ev;
80 ib_dispatch_event(&event);
81 }
82
83 void qib_handle_e_ibstatuschanged(struct qib_pportdata *ppd, u64 ibcs)
84 {
85 struct qib_devdata *dd = ppd->dd;
86 unsigned long flags;
87 u32 lstate;
88 u8 ltstate;
89 enum ib_event_type ev = 0;
90
91 lstate = dd->f_iblink_state(ibcs); /* linkstate */
92 ltstate = dd->f_ibphys_portstate(ibcs);
93
94 /*
95 * If linkstate transitions into INIT from any of the various down
96 * states, or if it transitions from any of the up (INIT or better)
97 * states into any of the down states (except link recovery), then
98 * call the chip-specific code to take appropriate actions.
99 *
100 * ppd->lflags could be 0 if this is the first time the interrupt
101 * handlers has been called but the link is already up.
102 */
103 if (lstate >= IB_PORT_INIT &&
104 (!ppd->lflags || (ppd->lflags & QIBL_LINKDOWN)) &&
105 ltstate == IB_PHYSPORTSTATE_LINKUP) {
106 /* transitioned to UP */
107 if (dd->f_ib_updown(ppd, 1, ibcs))
108 goto skip_ibchange; /* chip-code handled */
109 } else if (ppd->lflags & (QIBL_LINKINIT | QIBL_LINKARMED |
110 QIBL_LINKACTIVE | QIBL_IB_FORCE_NOTIFY)) {
111 if (ltstate != IB_PHYSPORTSTATE_LINKUP &&
112 ltstate <= IB_PHYSPORTSTATE_CFG_TRAIN &&
113 dd->f_ib_updown(ppd, 0, ibcs))
114 goto skip_ibchange; /* chip-code handled */
115 qib_set_uevent_bits(ppd, _QIB_EVENT_LINKDOWN_BIT);
116 }
117
118 if (lstate != IB_PORT_DOWN) {
119 /* lstate is INIT, ARMED, or ACTIVE */
120 if (lstate != IB_PORT_ACTIVE) {
121 *ppd->statusp &= ~QIB_STATUS_IB_READY;
122 if (ppd->lflags & QIBL_LINKACTIVE)
123 ev = IB_EVENT_PORT_ERR;
124 spin_lock_irqsave(&ppd->lflags_lock, flags);
125 if (lstate == IB_PORT_ARMED) {
126 ppd->lflags |= QIBL_LINKARMED | QIBL_LINKV;
127 ppd->lflags &= ~(QIBL_LINKINIT |
128 QIBL_LINKDOWN | QIBL_LINKACTIVE);
129 } else {
130 ppd->lflags |= QIBL_LINKINIT | QIBL_LINKV;
131 ppd->lflags &= ~(QIBL_LINKARMED |
132 QIBL_LINKDOWN | QIBL_LINKACTIVE);
133 }
134 spin_unlock_irqrestore(&ppd->lflags_lock, flags);
135 /* start a 75msec timer to clear symbol errors */
136 mod_timer(&ppd->symerr_clear_timer,
137 msecs_to_jiffies(75));
138 } else if (ltstate == IB_PHYSPORTSTATE_LINKUP &&
139 !(ppd->lflags & QIBL_LINKACTIVE)) {
140 /* active, but not active defered */
141 qib_hol_up(ppd); /* useful only for 6120 now */
142 *ppd->statusp |=
143 QIB_STATUS_IB_READY | QIB_STATUS_IB_CONF;
144 qib_clear_symerror_on_linkup(&ppd->symerr_clear_timer);
145 spin_lock_irqsave(&ppd->lflags_lock, flags);
146 ppd->lflags |= QIBL_LINKACTIVE | QIBL_LINKV;
147 ppd->lflags &= ~(QIBL_LINKINIT |
148 QIBL_LINKDOWN | QIBL_LINKARMED);
149 spin_unlock_irqrestore(&ppd->lflags_lock, flags);
150 if (dd->flags & QIB_HAS_SEND_DMA)
151 qib_sdma_process_event(ppd,
152 qib_sdma_event_e30_go_running);
153 ev = IB_EVENT_PORT_ACTIVE;
154 dd->f_setextled(ppd, 1);
155 }
156 } else { /* down */
157 if (ppd->lflags & QIBL_LINKACTIVE)
158 ev = IB_EVENT_PORT_ERR;
159 spin_lock_irqsave(&ppd->lflags_lock, flags);
160 ppd->lflags |= QIBL_LINKDOWN | QIBL_LINKV;
161 ppd->lflags &= ~(QIBL_LINKINIT |
162 QIBL_LINKACTIVE | QIBL_LINKARMED);
163 spin_unlock_irqrestore(&ppd->lflags_lock, flags);
164 *ppd->statusp &= ~QIB_STATUS_IB_READY;
165 }
166
167 skip_ibchange:
168 ppd->lastibcstat = ibcs;
169 if (ev)
170 signal_ib_event(ppd, ev);
171 }
172
173 void qib_clear_symerror_on_linkup(struct timer_list *t)
174 {
175 struct qib_pportdata *ppd = from_timer(ppd, t, symerr_clear_timer);
176
177 if (ppd->lflags & QIBL_LINKACTIVE)
178 return;
179
180 ppd->ibport_data.z_symbol_error_counter =
181 ppd->dd->f_portcntr(ppd, QIBPORTCNTR_IBSYMBOLERR);
182 }
183
184 /*
185 * Handle receive interrupts for user ctxts; this means a user
186 * process was waiting for a packet to arrive, and didn't want
187 * to poll.
188 */
189 void qib_handle_urcv(struct qib_devdata *dd, u64 ctxtr)
190 {
191 struct qib_ctxtdata *rcd;
192 unsigned long flags;
193 int i;
194
195 spin_lock_irqsave(&dd->uctxt_lock, flags);
196 for (i = dd->first_user_ctxt; dd->rcd && i < dd->cfgctxts; i++) {
197 if (!(ctxtr & (1ULL << i)))
198 continue;
199 rcd = dd->rcd[i];
200 if (!rcd || !rcd->cnt)
201 continue;
202
203 if (test_and_clear_bit(QIB_CTXT_WAITING_RCV, &rcd->flag)) {
204 wake_up_interruptible(&rcd->wait);
205 dd->f_rcvctrl(rcd->ppd, QIB_RCVCTRL_INTRAVAIL_DIS,
206 rcd->ctxt);
207 } else if (test_and_clear_bit(QIB_CTXT_WAITING_URG,
208 &rcd->flag)) {
209 rcd->urgent++;
210 wake_up_interruptible(&rcd->wait);
211 }
212 }
213 spin_unlock_irqrestore(&dd->uctxt_lock, flags);
214 }
215
216 void qib_bad_intrstatus(struct qib_devdata *dd)
217 {
218 static int allbits;
219
220 /* separate routine, for better optimization of qib_intr() */
221
222 /*
223 * We print the message and disable interrupts, in hope of
224 * having a better chance of debugging the problem.
225 */
226 qib_dev_err(dd,
227 "Read of chip interrupt status failed disabling interrupts\n");
228 if (allbits++) {
229 /* disable interrupt delivery, something is very wrong */
230 if (allbits == 2)
231 dd->f_set_intr_state(dd, 0);
232 if (allbits == 3) {
233 qib_dev_err(dd,
234 "2nd bad interrupt status, unregistering interrupts\n");
235 dd->flags |= QIB_BADINTR;
236 dd->flags &= ~QIB_INITTED;
237 dd->f_free_irq(dd);
238 }
239 }
240 }