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 } 241