]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/scsi/qla2xxx/qla_isr.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] qla2xxx: Correct use-after-free oops seen during EH-abort.
[mirror_ubuntu-bionic-kernel.git] / drivers / scsi / qla2xxx / qla_isr.c
CommitLineData
1da177e4 1/*
fa90c54f 2 * QLogic Fibre Channel HBA Driver
01e58d8e 3 * Copyright (c) 2003-2008 QLogic Corporation
1da177e4 4 *
fa90c54f 5 * See LICENSE.qla2xxx for copyright and licensing details.
1da177e4
LT		 6 */
7#include "qla_def.h"
8
05236a05 9#include <linux/delay.h>
5a0e3ad6 10#include <linux/slab.h>
df7baa50 11#include <scsi/scsi_tcq.h>
9a069e19 12#include <scsi/scsi_bsg_fc.h>
bad75002 13#include <scsi/scsi_eh.h>
df7baa50 14
1da177e4 15static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
73208dfd
AC		 16static void qla2x00_process_completed_request(struct scsi_qla_host *,
17 struct req_que *, uint32_t);
18static void qla2x00_status_entry(scsi_qla_host_t *, struct rsp_que *, void *);
2afa19a9 19static void qla2x00_status_cont_entry(struct rsp_que *, sts_cont_entry_t *);
73208dfd
AC		 20static void qla2x00_error_entry(scsi_qla_host_t *, struct rsp_que *,
21 sts_entry_t *);
9a853f71 22
1da177e4
LT		 23/**
24 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
25 * @irq:
26 * @dev_id: SCSI driver HA context
1da177e4
LT		 27 *
28 * Called by system whenever the host adapter generates an interrupt.
29 *
30 * Returns handled flag.
31 */
32irqreturn_t
7d12e780 33qla2100_intr_handler(int irq, void *dev_id)
1da177e4 34{
e315cd28
AC		 35 scsi_qla_host_t *vha;
36 struct qla_hw_data *ha;
3d71644c 37 struct device_reg_2xxx __iomem *reg;
1da177e4 38 int status;
1da177e4 39 unsigned long iter;
14e660e6 40 uint16_t hccr;
9a853f71 41 uint16_t mb[4];
e315cd28 42 struct rsp_que *rsp;
43fac4d9 43 unsigned long flags;
1da177e4 44
e315cd28
AC		 45 rsp = (struct rsp_que *) dev_id;
46 if (!rsp) {
1da177e4 47 printk(KERN_INFO
e315cd28 48 "%s(): NULL response queue pointer\n", __func__);
1da177e4
LT		 49 return (IRQ_NONE);
50 }
51
e315cd28 52 ha = rsp->hw;
3d71644c 53 reg = &ha->iobase->isp;
1da177e4
LT		 54 status = 0;
55
43fac4d9 56 spin_lock_irqsave(&ha->hardware_lock, flags);
2afa19a9 57 vha = pci_get_drvdata(ha->pdev);
1da177e4 58 for (iter = 50; iter--; ) {
14e660e6
SJ		 59 hccr = RD_REG_WORD(&reg->hccr);
60 if (hccr & HCCR_RISC_PAUSE) {
61 if (pci_channel_offline(ha->pdev))
62 break;
63
64 /*
65 * Issue a "HARD" reset in order for the RISC interrupt
66 * bit to be cleared. Schedule a big hammmer to get
67 * out of the RISC PAUSED state.
68 */
69 WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
70 RD_REG_WORD(&reg->hccr);
71
e315cd28
AC		 72 ha->isp_ops->fw_dump(vha, 1);
73 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
14e660e6
SJ		 74 break;
75 } else if ((RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) == 0)
1da177e4
LT		 76 break;
77
78 if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
79 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
80 RD_REG_WORD(&reg->hccr);
81
82 /* Get mailbox data. */
9a853f71
AV		 83 mb[0] = RD_MAILBOX_REG(ha, reg, 0);
84 if (mb[0] > 0x3fff && mb[0] < 0x8000) {
e315cd28 85 qla2x00_mbx_completion(vha, mb[0]);
1da177e4 86 status |= MBX_INTERRUPT;
9a853f71
AV		 87 } else if (mb[0] > 0x7fff && mb[0] < 0xc000) {
88 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
89 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
90 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
73208dfd 91 qla2x00_async_event(vha, rsp, mb);
1da177e4
LT		 92 } else {
93 /*EMPTY*/
94 DEBUG2(printk("scsi(%ld): Unrecognized "
9a853f71 95 "interrupt type (%d).\n",
e315cd28 96 vha->host_no, mb[0]));
1da177e4
LT		 97 }
98 /* Release mailbox registers. */
99 WRT_REG_WORD(&reg->semaphore, 0);
100 RD_REG_WORD(&reg->semaphore);
101 } else {
73208dfd 102 qla2x00_process_response_queue(rsp);
1da177e4
LT		 103
104 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
105 RD_REG_WORD(&reg->hccr);
106 }
107 }
43fac4d9 108 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1da177e4 109
1da177e4
LT		 110 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
111 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
1da177e4 112 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
0b05a1f0 113 complete(&ha->mbx_intr_comp);
1da177e4
LT		 114 }
115
1da177e4
LT		 116 return (IRQ_HANDLED);
117}
118
119/**
120 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
121 * @irq:
122 * @dev_id: SCSI driver HA context
1da177e4
LT		 123 *
124 * Called by system whenever the host adapter generates an interrupt.
125 *
126 * Returns handled flag.
127 */
128irqreturn_t
7d12e780 129qla2300_intr_handler(int irq, void *dev_id)
1da177e4 130{
e315cd28 131 scsi_qla_host_t *vha;
3d71644c 132 struct device_reg_2xxx __iomem *reg;
1da177e4 133 int status;
1da177e4
LT		 134 unsigned long iter;
135 uint32_t stat;
1da177e4 136 uint16_t hccr;
9a853f71 137 uint16_t mb[4];
e315cd28
AC		 138 struct rsp_que *rsp;
139 struct qla_hw_data *ha;
43fac4d9 140 unsigned long flags;
1da177e4 141
e315cd28
AC		 142 rsp = (struct rsp_que *) dev_id;
143 if (!rsp) {
1da177e4 144 printk(KERN_INFO
e315cd28 145 "%s(): NULL response queue pointer\n", __func__);
1da177e4
LT		 146 return (IRQ_NONE);
147 }
148
e315cd28 149 ha = rsp->hw;
3d71644c 150 reg = &ha->iobase->isp;
1da177e4
LT		 151 status = 0;
152
43fac4d9 153 spin_lock_irqsave(&ha->hardware_lock, flags);
2afa19a9 154 vha = pci_get_drvdata(ha->pdev);
1da177e4
LT		 155 for (iter = 50; iter--; ) {
156 stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
157 if (stat & HSR_RISC_PAUSED) {
85880801 158 if (unlikely(pci_channel_offline(ha->pdev)))
14e660e6
SJ		 159 break;
160
1da177e4
LT		 161 hccr = RD_REG_WORD(&reg->hccr);
162 if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
07f31805
AV		 163 qla_printk(KERN_INFO, ha, "Parity error -- "
164 "HCCR=%x, Dumping firmware!\n", hccr);
1da177e4 165 else
07f31805
AV		 166 qla_printk(KERN_INFO, ha, "RISC paused -- "
167 "HCCR=%x, Dumping firmware!\n", hccr);
1da177e4
LT		 168
169 /*
170 * Issue a "HARD" reset in order for the RISC
171 * interrupt bit to be cleared. Schedule a big
172 * hammmer to get out of the RISC PAUSED state.
173 */
174 WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
175 RD_REG_WORD(&reg->hccr);
07f31805 176
e315cd28
AC		 177 ha->isp_ops->fw_dump(vha, 1);
178 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 179 break;
180 } else if ((stat & HSR_RISC_INT) == 0)
181 break;
182
1da177e4 183 switch (stat & 0xff) {
1da177e4
LT		 184 case 0x1:
185 case 0x2:
186 case 0x10:
187 case 0x11:
e315cd28 188 qla2x00_mbx_completion(vha, MSW(stat));
1da177e4
LT		 189 status |= MBX_INTERRUPT;
190
191 /* Release mailbox registers. */
192 WRT_REG_WORD(&reg->semaphore, 0);
193 break;
194 case 0x12:
9a853f71
AV		 195 mb[0] = MSW(stat);
196 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
197 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
198 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
73208dfd 199 qla2x00_async_event(vha, rsp, mb);
9a853f71
AV		 200 break;
201 case 0x13:
73208dfd 202 qla2x00_process_response_queue(rsp);
1da177e4
LT		 203 break;
204 case 0x15:
9a853f71
AV		 205 mb[0] = MBA_CMPLT_1_16BIT;
206 mb[1] = MSW(stat);
73208dfd 207 qla2x00_async_event(vha, rsp, mb);
1da177e4
LT		 208 break;
209 case 0x16:
9a853f71
AV		 210 mb[0] = MBA_SCSI_COMPLETION;
211 mb[1] = MSW(stat);
212 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
73208dfd 213 qla2x00_async_event(vha, rsp, mb);
1da177e4
LT		 214 break;
215 default:
216 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
9a853f71 217 "(%d).\n",
e315cd28 218 vha->host_no, stat & 0xff));
1da177e4
LT		 219 break;
220 }
221 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
222 RD_REG_WORD_RELAXED(&reg->hccr);
223 }
43fac4d9 224 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1da177e4 225
1da177e4
LT		 226 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
227 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
1da177e4 228 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
0b05a1f0 229 complete(&ha->mbx_intr_comp);
1da177e4
LT		 230 }
231
1da177e4
LT		 232 return (IRQ_HANDLED);
233}
234
235/**
236 * qla2x00_mbx_completion() - Process mailbox command completions.
237 * @ha: SCSI driver HA context
238 * @mb0: Mailbox0 register
239 */
240static void
e315cd28 241qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
1da177e4
LT		 242{
243 uint16_t cnt;
244 uint16_t __iomem *wptr;
e315cd28 245 struct qla_hw_data *ha = vha->hw;
3d71644c 246 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1da177e4
LT		 247
248 /* Load return mailbox registers. */
249 ha->flags.mbox_int = 1;
250 ha->mailbox_out[0] = mb0;
251 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);
252
253 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
fa2a1ce5 254 if (IS_QLA2200(ha) && cnt == 8)
1da177e4
LT		 255 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
256 if (cnt == 4 || cnt == 5)
257 ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
258 else
259 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
fa2a1ce5 260
1da177e4
LT		 261 wptr++;
262 }
263
264 if (ha->mcp) {
265 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
e315cd28 266 __func__, vha->host_no, ha->mcp->mb[0]));
1da177e4
LT		 267 } else {
268 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
e315cd28 269 __func__, vha->host_no));
1da177e4
LT		 270 }
271}
272
8a659571
AV		 273static void
274qla81xx_idc_event(scsi_qla_host_t *vha, uint16_t aen, uint16_t descr)
275{
276 static char *event[] =
277 { "Complete", "Request Notification", "Time Extension" };
278 int rval;
279 struct device_reg_24xx __iomem *reg24 = &vha->hw->iobase->isp24;
280 uint16_t __iomem *wptr;
281 uint16_t cnt, timeout, mb[QLA_IDC_ACK_REGS];
282
283 /* Seed data -- mailbox1 -> mailbox7. */
284 wptr = (uint16_t __iomem *)&reg24->mailbox1;
285 for (cnt = 0; cnt < QLA_IDC_ACK_REGS; cnt++, wptr++)
286 mb[cnt] = RD_REG_WORD(wptr);
287
288 DEBUG2(printk("scsi(%ld): Inter-Driver Commucation %s -- "
289 "%04x %04x %04x %04x %04x %04x %04x.\n", vha->host_no,
290 event[aen & 0xff],
291 mb[0], mb[1], mb[2], mb[3], mb[4], mb[5], mb[6]));
292
293 /* Acknowledgement needed? [Notify && non-zero timeout]. */
294 timeout = (descr >> 8) & 0xf;
295 if (aen != MBA_IDC_NOTIFY || !timeout)
296 return;
297
298 DEBUG2(printk("scsi(%ld): Inter-Driver Commucation %s -- "
299 "ACK timeout=%d.\n", vha->host_no, event[aen & 0xff], timeout));
300
301 rval = qla2x00_post_idc_ack_work(vha, mb);
302 if (rval != QLA_SUCCESS)
303 qla_printk(KERN_WARNING, vha->hw,
304 "IDC failed to post ACK.\n");
305}
306
1da177e4
LT		 307/**
308 * qla2x00_async_event() - Process aynchronous events.
309 * @ha: SCSI driver HA context
9a853f71 310 * @mb: Mailbox registers (0 - 3)
1da177e4 311 */
2c3dfe3f 312void
73208dfd 313qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
1da177e4 314{
9a853f71 315#define LS_UNKNOWN 2
3a03eb79 316 static char *link_speeds[] = { "1", "2", "?", "4", "8", "10" };
1da177e4 317 char *link_speed;
1da177e4 318 uint16_t handle_cnt;
bdab23da 319 uint16_t cnt, mbx;
1da177e4 320 uint32_t handles[5];
e315cd28 321 struct qla_hw_data *ha = vha->hw;
3d71644c 322 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
bdab23da 323 struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
1da177e4
LT		 324 uint32_t rscn_entry, host_pid;
325 uint8_t rscn_queue_index;
4d4df193 326 unsigned long flags;
1da177e4
LT		 327
328 /* Setup to process RIO completion. */
329 handle_cnt = 0;
a9083016 330 if (IS_QLA8XXX_TYPE(ha))
3a03eb79 331 goto skip_rio;
1da177e4
LT		 332 switch (mb[0]) {
333 case MBA_SCSI_COMPLETION:
9a853f71 334 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
1da177e4
LT		 335 handle_cnt = 1;
336 break;
337 case MBA_CMPLT_1_16BIT:
9a853f71 338 handles[0] = mb[1];
1da177e4
LT		 339 handle_cnt = 1;
340 mb[0] = MBA_SCSI_COMPLETION;
341 break;
342 case MBA_CMPLT_2_16BIT:
9a853f71
AV		 343 handles[0] = mb[1];
344 handles[1] = mb[2];
1da177e4
LT		 345 handle_cnt = 2;
346 mb[0] = MBA_SCSI_COMPLETION;
347 break;
348 case MBA_CMPLT_3_16BIT:
9a853f71
AV		 349 handles[0] = mb[1];
350 handles[1] = mb[2];
351 handles[2] = mb[3];
1da177e4
LT		 352 handle_cnt = 3;
353 mb[0] = MBA_SCSI_COMPLETION;
354 break;
355 case MBA_CMPLT_4_16BIT:
9a853f71
AV		 356 handles[0] = mb[1];
357 handles[1] = mb[2];
358 handles[2] = mb[3];
1da177e4
LT		 359 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
360 handle_cnt = 4;
361 mb[0] = MBA_SCSI_COMPLETION;
362 break;
363 case MBA_CMPLT_5_16BIT:
9a853f71
AV		 364 handles[0] = mb[1];
365 handles[1] = mb[2];
366 handles[2] = mb[3];
1da177e4
LT		 367 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
368 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
369 handle_cnt = 5;
370 mb[0] = MBA_SCSI_COMPLETION;
371 break;
372 case MBA_CMPLT_2_32BIT:
9a853f71 373 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
1da177e4
LT		 374 handles[1] = le32_to_cpu(
375 ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) |
376 RD_MAILBOX_REG(ha, reg, 6));
377 handle_cnt = 2;
378 mb[0] = MBA_SCSI_COMPLETION;
379 break;
380 default:
381 break;
382 }
3a03eb79 383skip_rio:
1da177e4
LT		 384 switch (mb[0]) {
385 case MBA_SCSI_COMPLETION: /* Fast Post */
e315cd28 386 if (!vha->flags.online)
1da177e4
LT		 387 break;
388
389 for (cnt = 0; cnt < handle_cnt; cnt++)
73208dfd
AC		 390 qla2x00_process_completed_request(vha, rsp->req,
391 handles[cnt]);
1da177e4
LT		 392 break;
393
394 case MBA_RESET: /* Reset */
e315cd28
AC		 395 DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n",
396 vha->host_no));
1da177e4 397
e315cd28 398 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
1da177e4
LT		 399 break;
400
401 case MBA_SYSTEM_ERR: /* System Error */
bdab23da 402 mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox7) : 0;
1da177e4 403 qla_printk(KERN_INFO, ha,
bdab23da
AV		 404 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh "
405 "mbx7=%xh.\n", mb[1], mb[2], mb[3], mbx);
1da177e4 406
e315cd28 407 ha->isp_ops->fw_dump(vha, 1);
1da177e4 408
e428924c 409 if (IS_FWI2_CAPABLE(ha)) {
9a853f71
AV		 410 if (mb[1] == 0 && mb[2] == 0) {
411 qla_printk(KERN_ERR, ha,
412 "Unrecoverable Hardware Error: adapter "
413 "marked OFFLINE!\n");
e315cd28 414 vha->flags.online = 0;
9a853f71 415 } else
e315cd28 416 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
9a853f71 417 } else if (mb[1] == 0) {
1da177e4
LT		 418 qla_printk(KERN_INFO, ha,
419 "Unrecoverable Hardware Error: adapter marked "
420 "OFFLINE!\n");
e315cd28 421 vha->flags.online = 0;
1da177e4 422 } else
e315cd28 423 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 424 break;
425
426 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
bdab23da
AV		 427 DEBUG2(printk("scsi(%ld): ISP Request Transfer Error (%x).\n",
428 vha->host_no, mb[1]));
429 qla_printk(KERN_WARNING, ha,
430 "ISP Request Transfer Error (%x).\n", mb[1]);
1da177e4 431
e315cd28 432 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 433 break;
434
435 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
436 DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
e315cd28 437 vha->host_no));
1da177e4
LT		 438 qla_printk(KERN_WARNING, ha, "ISP Response Transfer Error.\n");
439
e315cd28 440 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 441 break;
442
443 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
444 DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
e315cd28 445 vha->host_no));
1da177e4
LT		 446 break;
447
448 case MBA_LIP_OCCURRED: /* Loop Initialization Procedure */
e315cd28 449 DEBUG2(printk("scsi(%ld): LIP occurred (%x).\n", vha->host_no,
1da177e4 450 mb[1]));
cc3ef7bc 451 qla_printk(KERN_INFO, ha, "LIP occurred (%x).\n", mb[1]);
1da177e4 452
e315cd28
AC		 453 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
454 atomic_set(&vha->loop_state, LOOP_DOWN);
455 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
456 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4
LT		 457 }
458
e315cd28
AC		 459 if (vha->vp_idx) {
460 atomic_set(&vha->vp_state, VP_FAILED);
461 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
2c3dfe3f
SJ		 462 }
463
e315cd28
AC		 464 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
465 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
1da177e4 466
e315cd28
AC		 467 vha->flags.management_server_logged_in = 0;
468 qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
1da177e4
LT		 469 break;
470
471 case MBA_LOOP_UP: /* Loop Up Event */
1da177e4
LT		 472 if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
473 link_speed = link_speeds[0];
d8b45213 474 ha->link_data_rate = PORT_SPEED_1GB;
1da177e4 475 } else {
9a853f71 476 link_speed = link_speeds[LS_UNKNOWN];
1da177e4
LT		 477 if (mb[1] < 5)
478 link_speed = link_speeds[mb[1]];
3a03eb79
AV		 479 else if (mb[1] == 0x13)
480 link_speed = link_speeds[5];
1da177e4
LT		 481 ha->link_data_rate = mb[1];
482 }
483
484 DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
e315cd28 485 vha->host_no, link_speed));
1da177e4
LT		 486 qla_printk(KERN_INFO, ha, "LOOP UP detected (%s Gbps).\n",
487 link_speed);
488
e315cd28
AC		 489 vha->flags.management_server_logged_in = 0;
490 qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
1da177e4
LT		 491 break;
492
493 case MBA_LOOP_DOWN: /* Loop Down Event */
bdab23da 494 mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox4) : 0;
4d4df193 495 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN "
bdab23da
AV		 496 "(%x %x %x %x).\n", vha->host_no, mb[1], mb[2], mb[3],
497 mbx));
498 qla_printk(KERN_INFO, ha,
499 "LOOP DOWN detected (%x %x %x %x).\n", mb[1], mb[2], mb[3],
500 mbx);
1da177e4 501
e315cd28
AC		 502 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
503 atomic_set(&vha->loop_state, LOOP_DOWN);
504 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
505 vha->device_flags |= DFLG_NO_CABLE;
506 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4
LT		 507 }
508
e315cd28
AC		 509 if (vha->vp_idx) {
510 atomic_set(&vha->vp_state, VP_FAILED);
511 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
2c3dfe3f
SJ		 512 }
513
e315cd28 514 vha->flags.management_server_logged_in = 0;
d8b45213 515 ha->link_data_rate = PORT_SPEED_UNKNOWN;
e315cd28 516 qla2x00_post_aen_work(vha, FCH_EVT_LINKDOWN, 0);
1da177e4
LT		 517 break;
518
519 case MBA_LIP_RESET: /* LIP reset occurred */
1da177e4 520 DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
e315cd28 521 vha->host_no, mb[1]));
1da177e4 522 qla_printk(KERN_INFO, ha,
cc3ef7bc 523 "LIP reset occurred (%x).\n", mb[1]);
1da177e4 524
e315cd28
AC		 525 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
526 atomic_set(&vha->loop_state, LOOP_DOWN);
527 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
528 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4
LT		 529 }
530
e315cd28
AC		 531 if (vha->vp_idx) {
532 atomic_set(&vha->vp_state, VP_FAILED);
533 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
2c3dfe3f
SJ		 534 }
535
e315cd28 536 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
1da177e4
LT		 537
538 ha->operating_mode = LOOP;
e315cd28
AC		 539 vha->flags.management_server_logged_in = 0;
540 qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
1da177e4
LT		 541 break;
542
3a03eb79 543 /* case MBA_DCBX_COMPLETE: */
1da177e4
LT		 544 case MBA_POINT_TO_POINT: /* Point-to-Point */
545 if (IS_QLA2100(ha))
546 break;
547
a9083016 548 if (IS_QLA8XXX_TYPE(ha))
3a03eb79
AV		 549 DEBUG2(printk("scsi(%ld): DCBX Completed -- %04x %04x "
550 "%04x\n", vha->host_no, mb[1], mb[2], mb[3]));
551 else
552 DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE "
553 "received.\n", vha->host_no));
1da177e4
LT		 554
555 /*
556 * Until there's a transition from loop down to loop up, treat
557 * this as loop down only.
558 */
e315cd28
AC		 559 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
560 atomic_set(&vha->loop_state, LOOP_DOWN);
561 if (!atomic_read(&vha->loop_down_timer))
562 atomic_set(&vha->loop_down_timer,
1da177e4 563 LOOP_DOWN_TIME);
e315cd28 564 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4
LT		 565 }
566
e315cd28
AC		 567 if (vha->vp_idx) {
568 atomic_set(&vha->vp_state, VP_FAILED);
569 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
2c3dfe3f
SJ		 570 }
571
e315cd28
AC		 572 if (!(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)))
573 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
574
575 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
576 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
4346b149
AV		 577
578 ha->flags.gpsc_supported = 1;
e315cd28 579 vha->flags.management_server_logged_in = 0;
1da177e4
LT		 580 break;
581
582 case MBA_CHG_IN_CONNECTION: /* Change in connection mode */
583 if (IS_QLA2100(ha))
584 break;
585
1da177e4
LT		 586 DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
587 "received.\n",
e315cd28 588 vha->host_no));
1da177e4
LT		 589 qla_printk(KERN_INFO, ha,
590 "Configuration change detected: value=%x.\n", mb[1]);
591
e315cd28
AC		 592 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
593 atomic_set(&vha->loop_state, LOOP_DOWN);
594 if (!atomic_read(&vha->loop_down_timer))
595 atomic_set(&vha->loop_down_timer,
1da177e4 596 LOOP_DOWN_TIME);
e315cd28 597 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4
LT		 598 }
599
e315cd28
AC		 600 if (vha->vp_idx) {
601 atomic_set(&vha->vp_state, VP_FAILED);
602 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
2c3dfe3f
SJ		 603 }
604
e315cd28
AC		 605 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
606 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
1da177e4
LT		 607 break;
608
609 case MBA_PORT_UPDATE: /* Port database update */
55903b9d
SV		 610 /*
611 * Handle only global and vn-port update events
612 *
613 * Relevant inputs:
614 * mb[1] = N_Port handle of changed port
615 * OR 0xffff for global event
616 * mb[2] = New login state
617 * 7 = Port logged out
618 * mb[3] = LSB is vp_idx, 0xff = all vps
619 *
620 * Skip processing if:
621 * Event is global, vp_idx is NOT all vps,
622 * vp_idx does not match
623 * Event is not global, vp_idx does not match
624 */
12cec63e
AV		 625 if (IS_QLA2XXX_MIDTYPE(ha) &&
626 ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff) ||
627 (mb[1] != 0xffff)) && vha->vp_idx != (mb[3] & 0xff))
628 break;
73208dfd 629
9764ff88
AV		 630 /* Global event -- port logout or port unavailable. */
631 if (mb[1] == 0xffff && mb[2] == 0x7) {
632 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
633 vha->host_no));
634 DEBUG(printk(KERN_INFO
635 "scsi(%ld): Port unavailable %04x %04x %04x.\n",
636 vha->host_no, mb[1], mb[2], mb[3]));
637
638 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
639 atomic_set(&vha->loop_state, LOOP_DOWN);
640 atomic_set(&vha->loop_down_timer,
641 LOOP_DOWN_TIME);
642 vha->device_flags |= DFLG_NO_CABLE;
643 qla2x00_mark_all_devices_lost(vha, 1);
644 }
645
646 if (vha->vp_idx) {
647 atomic_set(&vha->vp_state, VP_FAILED);
648 fc_vport_set_state(vha->fc_vport,
649 FC_VPORT_FAILED);
faadc5e7 650 qla2x00_mark_all_devices_lost(vha, 1);
9764ff88
AV		 651 }
652
653 vha->flags.management_server_logged_in = 0;
654 ha->link_data_rate = PORT_SPEED_UNKNOWN;
655 break;
656 }
657
1da177e4 658 /*
cc3ef7bc 659 * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
1da177e4
LT		 660 * event etc. earlier indicating loop is down) then process
661 * it. Otherwise ignore it and Wait for RSCN to come in.
662 */
e315cd28
AC		 663 atomic_set(&vha->loop_down_timer, 0);
664 if (atomic_read(&vha->loop_state) != LOOP_DOWN &&
665 atomic_read(&vha->loop_state) != LOOP_DEAD) {
1da177e4 666 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
e315cd28 667 "ignored %04x/%04x/%04x.\n", vha->host_no, mb[1],
9a853f71 668 mb[2], mb[3]));
1da177e4
LT		 669 break;
670 }
671
672 DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
e315cd28 673 vha->host_no));
1da177e4 674 DEBUG(printk(KERN_INFO
9a853f71 675 "scsi(%ld): Port database changed %04x %04x %04x.\n",
e315cd28 676 vha->host_no, mb[1], mb[2], mb[3]));
1da177e4
LT		 677
678 /*
679 * Mark all devices as missing so we will login again.
680 */
e315cd28 681 atomic_set(&vha->loop_state, LOOP_UP);
1da177e4 682
e315cd28 683 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4 684
e315cd28 685 vha->flags.rscn_queue_overflow = 1;
1da177e4 686
e315cd28
AC		 687 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
688 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
1da177e4
LT		 689 break;
690
691 case MBA_RSCN_UPDATE: /* State Change Registration */
3c397400 692 /* Check if the Vport has issued a SCR */
e315cd28 693 if (vha->vp_idx && test_bit(VP_SCR_NEEDED, &vha->vp_flags))
3c397400
SJ		 694 break;
695 /* Only handle SCNs for our Vport index. */
0d6e61bc 696 if (ha->flags.npiv_supported && vha->vp_idx != (mb[3] & 0xff))
3c397400 697 break;
0d6e61bc 698
1da177e4 699 DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
e315cd28 700 vha->host_no));
1da177e4 701 DEBUG(printk(KERN_INFO
f4a8dbc7 702 "scsi(%ld): RSCN database changed -- %04x %04x %04x.\n",
e315cd28 703 vha->host_no, mb[1], mb[2], mb[3]));
1da177e4 704
59d72d87 705 rscn_entry = ((mb[1] & 0xff) << 16) | mb[2];
e315cd28
AC		 706 host_pid = (vha->d_id.b.domain << 16) | (vha->d_id.b.area << 8)
707 | vha->d_id.b.al_pa;
1da177e4
LT		 708 if (rscn_entry == host_pid) {
709 DEBUG(printk(KERN_INFO
710 "scsi(%ld): Ignoring RSCN update to local host "
711 "port ID (%06x)\n",
e315cd28 712 vha->host_no, host_pid));
1da177e4
LT		 713 break;
714 }
715
59d72d87
RA		 716 /* Ignore reserved bits from RSCN-payload. */
717 rscn_entry = ((mb[1] & 0x3ff) << 16) | mb[2];
e315cd28 718 rscn_queue_index = vha->rscn_in_ptr + 1;
1da177e4
LT		 719 if (rscn_queue_index == MAX_RSCN_COUNT)
720 rscn_queue_index = 0;
e315cd28
AC		 721 if (rscn_queue_index != vha->rscn_out_ptr) {
722 vha->rscn_queue[vha->rscn_in_ptr] = rscn_entry;
723 vha->rscn_in_ptr = rscn_queue_index;
1da177e4 724 } else {
e315cd28 725 vha->flags.rscn_queue_overflow = 1;
1da177e4
LT		 726 }
727
e315cd28
AC		 728 atomic_set(&vha->loop_state, LOOP_UPDATE);
729 atomic_set(&vha->loop_down_timer, 0);
730 vha->flags.management_server_logged_in = 0;
1da177e4 731
e315cd28
AC		 732 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
733 set_bit(RSCN_UPDATE, &vha->dpc_flags);
734 qla2x00_post_aen_work(vha, FCH_EVT_RSCN, rscn_entry);
1da177e4
LT		 735 break;
736
737 /* case MBA_RIO_RESPONSE: */
738 case MBA_ZIO_RESPONSE:
3fd67cdf 739 DEBUG3(printk("scsi(%ld): [R|Z]IO update completion.\n",
e315cd28 740 vha->host_no));
1da177e4 741
e428924c 742 if (IS_FWI2_CAPABLE(ha))
2afa19a9 743 qla24xx_process_response_queue(vha, rsp);
4fdfefe5 744 else
73208dfd 745 qla2x00_process_response_queue(rsp);
1da177e4 746 break;
9a853f71
AV		 747
748 case MBA_DISCARD_RND_FRAME:
749 DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x "
e315cd28 750 "%04x.\n", vha->host_no, mb[1], mb[2], mb[3]));
9a853f71 751 break;
45ebeb56
AV		 752
753 case MBA_TRACE_NOTIFICATION:
754 DEBUG2(printk("scsi(%ld): Trace Notification -- %04x %04x.\n",
e315cd28 755 vha->host_no, mb[1], mb[2]));
45ebeb56 756 break;
4d4df193
HK		 757
758 case MBA_ISP84XX_ALERT:
759 DEBUG2(printk("scsi(%ld): ISP84XX Alert Notification -- "
e315cd28 760 "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
4d4df193
HK		 761
762 spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
763 switch (mb[1]) {
764 case A84_PANIC_RECOVERY:
765 qla_printk(KERN_INFO, ha, "Alert 84XX: panic recovery "
766 "%04x %04x\n", mb[2], mb[3]);
767 break;
768 case A84_OP_LOGIN_COMPLETE:
769 ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
770 DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX:"
771 "firmware version %x\n", ha->cs84xx->op_fw_version));
772 break;
773 case A84_DIAG_LOGIN_COMPLETE:
774 ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
775 DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX:"
776 "diagnostic firmware version %x\n",
777 ha->cs84xx->diag_fw_version));
778 break;
779 case A84_GOLD_LOGIN_COMPLETE:
780 ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
781 ha->cs84xx->fw_update = 1;
782 DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX: gold "
783 "firmware version %x\n",
784 ha->cs84xx->gold_fw_version));
785 break;
786 default:
787 qla_printk(KERN_ERR, ha,
788 "Alert 84xx: Invalid Alert %04x %04x %04x\n",
789 mb[1], mb[2], mb[3]);
790 }
791 spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
792 break;
3a03eb79
AV		 793 case MBA_DCBX_START:
794 DEBUG2(printk("scsi(%ld): DCBX Started -- %04x %04x %04x\n",
795 vha->host_no, mb[1], mb[2], mb[3]));
796 break;
797 case MBA_DCBX_PARAM_UPDATE:
798 DEBUG2(printk("scsi(%ld): DCBX Parameters Updated -- "
799 "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
800 break;
801 case MBA_FCF_CONF_ERR:
802 DEBUG2(printk("scsi(%ld): FCF Configuration Error -- "
803 "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
804 break;
805 case MBA_IDC_COMPLETE:
3a03eb79 806 case MBA_IDC_NOTIFY:
3a03eb79 807 case MBA_IDC_TIME_EXT:
8a659571 808 qla81xx_idc_event(vha, mb[0], mb[1]);
3a03eb79 809 break;
1da177e4 810 }
2c3dfe3f 811
e315cd28 812 if (!vha->vp_idx && ha->num_vhosts)
73208dfd 813 qla2x00_alert_all_vps(rsp, mb);
1da177e4
LT		 814}
815
816/**
817 * qla2x00_process_completed_request() - Process a Fast Post response.
818 * @ha: SCSI driver HA context
819 * @index: SRB index
820 */
821static void
73208dfd
AC		 822qla2x00_process_completed_request(struct scsi_qla_host *vha,
823 struct req_que *req, uint32_t index)
1da177e4
LT		 824{
825 srb_t *sp;
e315cd28 826 struct qla_hw_data *ha = vha->hw;
1da177e4
LT		 827
828 /* Validate handle. */
829 if (index >= MAX_OUTSTANDING_COMMANDS) {
830 DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
e315cd28 831 vha->host_no, index));
1da177e4
LT		 832 qla_printk(KERN_WARNING, ha,
833 "Invalid SCSI completion handle %d.\n", index);
834
e315cd28 835 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 836 return;
837 }
838
e315cd28 839 sp = req->outstanding_cmds[index];
1da177e4
LT		 840 if (sp) {
841 /* Free outstanding command slot. */
e315cd28 842 req->outstanding_cmds[index] = NULL;
1da177e4 843
1da177e4
LT		 844 /* Save ISP completion status */
845 sp->cmd->result = DID_OK << 16;
73208dfd 846 qla2x00_sp_compl(ha, sp);
1da177e4 847 } else {
2afa19a9 848 DEBUG2(printk("scsi(%ld) Req:%d: Invalid ISP SCSI completion"
a9083016 849 " handle(0x%x)\n", vha->host_no, req->id, index));
1da177e4
LT		 850 qla_printk(KERN_WARNING, ha,
851 "Invalid ISP SCSI completion handle\n");
852
e315cd28 853 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 854 }
855}
856
ac280b67
AV		 857static srb_t *
858qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
859 struct req_que *req, void *iocb)
860{
861 struct qla_hw_data *ha = vha->hw;
862 sts_entry_t *pkt = iocb;
863 srb_t *sp = NULL;
864 uint16_t index;
865
866 index = LSW(pkt->handle);
867 if (index >= MAX_OUTSTANDING_COMMANDS) {
868 qla_printk(KERN_WARNING, ha,
869 "%s: Invalid completion handle (%x).\n", func, index);
870 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
871 goto done;
872 }
873 sp = req->outstanding_cmds[index];
874 if (!sp) {
875 qla_printk(KERN_WARNING, ha,
876 "%s: Invalid completion handle (%x) -- timed-out.\n", func,
877 index);
878 return sp;
879 }
880 if (sp->handle != index) {
881 qla_printk(KERN_WARNING, ha,
882 "%s: SRB handle (%x) mismatch %x.\n", func, sp->handle,
883 index);
884 return NULL;
885 }
9a069e19 886
ac280b67 887 req->outstanding_cmds[index] = NULL;
9a069e19 888
ac280b67
AV		 889done:
890 return sp;
891}
892
893static void
894qla2x00_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
895 struct mbx_entry *mbx)
896{
897 const char func[] = "MBX-IOCB";
898 const char *type;
ac280b67
AV		 899 fc_port_t *fcport;
900 srb_t *sp;
4916392b
MI		 901 struct srb_iocb *lio;
902 struct srb_ctx *ctx;
99b0bec7 903 uint16_t *data;
5ff1d584 904 uint16_t status;
ac280b67
AV		 905
906 sp = qla2x00_get_sp_from_handle(vha, func, req, mbx);
907 if (!sp)
908 return;
909
4916392b
MI		 910 ctx = sp->ctx;
911 lio = ctx->u.iocb_cmd;
912 type = ctx->name;
ac280b67 913 fcport = sp->fcport;
4916392b 914 data = lio->u.logio.data;
ac280b67 915
5ff1d584 916 data[0] = MBS_COMMAND_ERROR;
4916392b 917 data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
5ff1d584 918 QLA_LOGIO_LOGIN_RETRIED : 0;
ac280b67
AV		 919 if (mbx->entry_status) {
920 DEBUG2(printk(KERN_WARNING
d3fa9e7d
AV		 921 "scsi(%ld:%x): Async-%s error entry - portid=%02x%02x%02x "
922 "entry-status=%x status=%x state-flag=%x "
923 "status-flags=%x.\n",
ac280b67 924 fcport->vha->host_no, sp->handle, type,
d3fa9e7d
AV		 925 fcport->d_id.b.domain, fcport->d_id.b.area,
926 fcport->d_id.b.al_pa, mbx->entry_status,
927 le16_to_cpu(mbx->status), le16_to_cpu(mbx->state_flags),
ac280b67 928 le16_to_cpu(mbx->status_flags)));
d3fa9e7d 929
ac280b67
AV		 930 DEBUG2(qla2x00_dump_buffer((uint8_t *)mbx, sizeof(*mbx)));
931
99b0bec7 932 goto logio_done;
ac280b67
AV		 933 }
934
5ff1d584 935 status = le16_to_cpu(mbx->status);
4916392b 936 if (status == 0x30 && ctx->type == SRB_LOGIN_CMD &&
5ff1d584
AV		 937 le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
938 status = 0;
939 if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
ac280b67 940 DEBUG2(printk(KERN_DEBUG
d3fa9e7d
AV		 941 "scsi(%ld:%x): Async-%s complete - portid=%02x%02x%02x "
942 "mbx1=%x.\n",
ac280b67 943 fcport->vha->host_no, sp->handle, type,
d3fa9e7d
AV		 944 fcport->d_id.b.domain, fcport->d_id.b.area,
945 fcport->d_id.b.al_pa, le16_to_cpu(mbx->mb1)));
ac280b67
AV		 946
947 data[0] = MBS_COMMAND_COMPLETE;
4916392b 948 if (ctx->type == SRB_LOGIN_CMD) {
99b0bec7
AV		 949 fcport->port_type = FCT_TARGET;
950 if (le16_to_cpu(mbx->mb1) & BIT_0)
951 fcport->port_type = FCT_INITIATOR;
952 if (le16_to_cpu(mbx->mb1) & BIT_1)
953 fcport->flags |= FCF_FCP2_DEVICE;
5ff1d584 954 }
99b0bec7 955 goto logio_done;
ac280b67
AV		 956 }
957
958 data[0] = le16_to_cpu(mbx->mb0);
959 switch (data[0]) {
960 case MBS_PORT_ID_USED:
961 data[1] = le16_to_cpu(mbx->mb1);
962 break;
963 case MBS_LOOP_ID_USED:
964 break;
965 default:
966 data[0] = MBS_COMMAND_ERROR;
ac280b67
AV		 967 break;
968 }
969
970 DEBUG2(printk(KERN_WARNING
d3fa9e7d
AV		 971 "scsi(%ld:%x): Async-%s failed - portid=%02x%02x%02x status=%x "
972 "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n",
973 fcport->vha->host_no, sp->handle, type, fcport->d_id.b.domain,
974 fcport->d_id.b.area, fcport->d_id.b.al_pa, status,
ac280b67
AV		 975 le16_to_cpu(mbx->mb0), le16_to_cpu(mbx->mb1),
976 le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
977 le16_to_cpu(mbx->mb7)));
978
99b0bec7 979logio_done:
4916392b 980 lio->done(sp);
ac280b67
AV		 981}
982
9a069e19
GM		 983static void
984qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
985 struct sts_entry_24xx *pkt, int iocb_type)
986{
987 const char func[] = "ELS_CT_IOCB";
988 const char *type;
989 struct qla_hw_data *ha = vha->hw;
990 srb_t *sp;
4916392b 991 struct srb_ctx *sp_bsg;
9a069e19
GM		 992 struct fc_bsg_job *bsg_job;
993 uint16_t comp_status;
994 uint32_t fw_status[3];
995 uint8_t* fw_sts_ptr;
996
997 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
998 if (!sp)
999 return;
4916392b
MI		 1000 sp_bsg = sp->ctx;
1001 bsg_job = sp_bsg->u.bsg_job;
9a069e19
GM		 1002
1003 type = NULL;
4916392b 1004 switch (sp_bsg->type) {
9a069e19
GM		 1005 case SRB_ELS_CMD_RPT:
1006 case SRB_ELS_CMD_HST:
1007 type = "els";
1008 break;
1009 case SRB_CT_CMD:
1010 type = "ct pass-through";
1011 break;
1012 default:
1013 qla_printk(KERN_WARNING, ha,
1014 "%s: Unrecognized SRB: (%p) type=%d.\n", func, sp,
4916392b 1015 sp_bsg->type);
9a069e19
GM		 1016 return;
1017 }
1018
1019 comp_status = fw_status[0] = le16_to_cpu(pkt->comp_status);
1020 fw_status[1] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1);
1021 fw_status[2] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2);
1022
1023 /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
1024 * fc payload to the caller
1025 */
1026 bsg_job->reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
1027 bsg_job->reply_len = sizeof(struct fc_bsg_reply) + sizeof(fw_status);
1028
1029 if (comp_status != CS_COMPLETE) {
1030 if (comp_status == CS_DATA_UNDERRUN) {
1031 bsg_job->reply->result = DID_OK << 16;
1032 bsg_job->reply->reply_payload_rcv_len =
1033 le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count);
1034
1035 DEBUG2(qla_printk(KERN_WARNING, ha,
1036 "scsi(%ld:0x%x): ELS-CT pass-through-%s error comp_status-status=0x%x "
1037 "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
1038 vha->host_no, sp->handle, type, comp_status, fw_status[1], fw_status[2],
1039 le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count)));
1040 fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
1041 memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
1042 }
1043 else {
1044 DEBUG2(qla_printk(KERN_WARNING, ha,
1045 "scsi(%ld:0x%x): ELS-CT pass-through-%s error comp_status-status=0x%x "
1046 "error subcode 1=0x%x error subcode 2=0x%x.\n",
1047 vha->host_no, sp->handle, type, comp_status,
1048 le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1),
1049 le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2)));
1050 bsg_job->reply->result = DID_ERROR << 16;
1051 bsg_job->reply->reply_payload_rcv_len = 0;
1052 fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
1053 memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
1054 }
1055 DEBUG2(qla2x00_dump_buffer((uint8_t *)pkt, sizeof(*pkt)));
1056 }
1057 else {
1058 bsg_job->reply->result = DID_OK << 16;;
1059 bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
1060 bsg_job->reply_len = 0;
1061 }
1062
1063 dma_unmap_sg(&ha->pdev->dev,
1064 bsg_job->request_payload.sg_list,
1065 bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
1066 dma_unmap_sg(&ha->pdev->dev,
1067 bsg_job->reply_payload.sg_list,
1068 bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
4916392b
MI		 1069 if ((sp_bsg->type == SRB_ELS_CMD_HST) ||
1070 (sp_bsg->type == SRB_CT_CMD))
9a069e19
GM		 1071 kfree(sp->fcport);
1072 kfree(sp->ctx);
1073 mempool_free(sp, ha->srb_mempool);
1074 bsg_job->job_done(bsg_job);
1075}
1076
ac280b67
AV		 1077static void
1078qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
1079 struct logio_entry_24xx *logio)
1080{
1081 const char func[] = "LOGIO-IOCB";
1082 const char *type;
ac280b67
AV		 1083 fc_port_t *fcport;
1084 srb_t *sp;
4916392b
MI		 1085 struct srb_iocb *lio;
1086 struct srb_ctx *ctx;
99b0bec7 1087 uint16_t *data;
ac280b67
AV		 1088 uint32_t iop[2];
1089
1090 sp = qla2x00_get_sp_from_handle(vha, func, req, logio);
1091 if (!sp)
1092 return;
1093
4916392b
MI		 1094 ctx = sp->ctx;
1095 lio = ctx->u.iocb_cmd;
1096 type = ctx->name;
ac280b67 1097 fcport = sp->fcport;
4916392b 1098 data = lio->u.logio.data;
ac280b67 1099
5ff1d584 1100 data[0] = MBS_COMMAND_ERROR;
4916392b 1101 data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
5ff1d584 1102 QLA_LOGIO_LOGIN_RETRIED : 0;
ac280b67
AV		 1103 if (logio->entry_status) {
1104 DEBUG2(printk(KERN_WARNING
d3fa9e7d
AV		 1105 "scsi(%ld:%x): Async-%s error entry - "
1106 "portid=%02x%02x%02x entry-status=%x.\n",
ac280b67 1107 fcport->vha->host_no, sp->handle, type,
d3fa9e7d
AV		 1108 fcport->d_id.b.domain, fcport->d_id.b.area,
1109 fcport->d_id.b.al_pa, logio->entry_status));
ac280b67
AV		 1110 DEBUG2(qla2x00_dump_buffer((uint8_t *)logio, sizeof(*logio)));
1111
99b0bec7 1112 goto logio_done;
ac280b67
AV		 1113 }
1114
1115 if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
1116 DEBUG2(printk(KERN_DEBUG
d3fa9e7d
AV		 1117 "scsi(%ld:%x): Async-%s complete - portid=%02x%02x%02x "
1118 "iop0=%x.\n",
ac280b67 1119 fcport->vha->host_no, sp->handle, type,
d3fa9e7d
AV		 1120 fcport->d_id.b.domain, fcport->d_id.b.area,
1121 fcport->d_id.b.al_pa,
ac280b67
AV		 1122 le32_to_cpu(logio->io_parameter[0])));
1123
1124 data[0] = MBS_COMMAND_COMPLETE;
4916392b 1125 if (ctx->type != SRB_LOGIN_CMD)
99b0bec7 1126 goto logio_done;
ac280b67
AV		 1127
1128 iop[0] = le32_to_cpu(logio->io_parameter[0]);
1129 if (iop[0] & BIT_4) {
1130 fcport->port_type = FCT_TARGET;
1131 if (iop[0] & BIT_8)
8474f3a0 1132 fcport->flags |= FCF_FCP2_DEVICE;
ac280b67
AV		 1133 }
1134 if (iop[0] & BIT_5)
1135 fcport->port_type = FCT_INITIATOR;
1136 if (logio->io_parameter[7] || logio->io_parameter[8])
1137 fcport->supported_classes |= FC_COS_CLASS2;
1138 if (logio->io_parameter[9] || logio->io_parameter[10])
1139 fcport->supported_classes |= FC_COS_CLASS3;
1140
99b0bec7 1141 goto logio_done;
ac280b67
AV		 1142 }
1143
1144 iop[0] = le32_to_cpu(logio->io_parameter[0]);
1145 iop[1] = le32_to_cpu(logio->io_parameter[1]);
1146 switch (iop[0]) {
1147 case LSC_SCODE_PORTID_USED:
1148 data[0] = MBS_PORT_ID_USED;
1149 data[1] = LSW(iop[1]);
1150 break;
1151 case LSC_SCODE_NPORT_USED:
1152 data[0] = MBS_LOOP_ID_USED;
1153 break;
1154 case LSC_SCODE_CMD_FAILED:
1155 if ((iop[1] & 0xff) == 0x05) {
1156 data[0] = MBS_NOT_LOGGED_IN;
1157 break;
1158 }
1159 /* Fall through. */
1160 default:
1161 data[0] = MBS_COMMAND_ERROR;
ac280b67
AV		 1162 break;
1163 }
1164
1165 DEBUG2(printk(KERN_WARNING
d3fa9e7d
AV		 1166 "scsi(%ld:%x): Async-%s failed - portid=%02x%02x%02x comp=%x "
1167 "iop0=%x iop1=%x.\n",
1168 fcport->vha->host_no, sp->handle, type, fcport->d_id.b.domain,
1169 fcport->d_id.b.area, fcport->d_id.b.al_pa,
ac280b67
AV		 1170 le16_to_cpu(logio->comp_status),
1171 le32_to_cpu(logio->io_parameter[0]),
1172 le32_to_cpu(logio->io_parameter[1])));
1173
99b0bec7 1174logio_done:
4916392b 1175 lio->done(sp);
ac280b67
AV		 1176}
1177
3822263e
MI		 1178static void
1179qla24xx_tm_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
1180 struct tsk_mgmt_entry *tsk)
1181{
1182 const char func[] = "TMF-IOCB";
1183 const char *type;
1184 fc_port_t *fcport;
1185 srb_t *sp;
1186 struct srb_iocb *iocb;
1187 struct srb_ctx *ctx;
1188 struct sts_entry_24xx *sts = (struct sts_entry_24xx *)tsk;
1189 int error = 1;
1190
1191 sp = qla2x00_get_sp_from_handle(vha, func, req, tsk);
1192 if (!sp)
1193 return;
1194
1195 ctx = sp->ctx;
1196 iocb = ctx->u.iocb_cmd;
1197 type = ctx->name;
1198 fcport = sp->fcport;
1199
1200 if (sts->entry_status) {
1201 DEBUG2(printk(KERN_WARNING
1202 "scsi(%ld:%x): Async-%s error - entry-status(%x).\n",
1203 fcport->vha->host_no, sp->handle, type,
1204 sts->entry_status));
1205 } else if (sts->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1206 DEBUG2(printk(KERN_WARNING
1207 "scsi(%ld:%x): Async-%s error - completion status(%x).\n",
1208 fcport->vha->host_no, sp->handle, type,
1209 sts->comp_status));
1210 } else if (!(le16_to_cpu(sts->scsi_status) &
1211 SS_RESPONSE_INFO_LEN_VALID)) {
1212 DEBUG2(printk(KERN_WARNING
1213 "scsi(%ld:%x): Async-%s error - no response info(%x).\n",
1214 fcport->vha->host_no, sp->handle, type,
1215 sts->scsi_status));
1216 } else if (le32_to_cpu(sts->rsp_data_len) < 4) {
1217 DEBUG2(printk(KERN_WARNING
1218 "scsi(%ld:%x): Async-%s error - not enough response(%d).\n",
1219 fcport->vha->host_no, sp->handle, type,
1220 sts->rsp_data_len));
1221 } else if (sts->data[3]) {
1222 DEBUG2(printk(KERN_WARNING
1223 "scsi(%ld:%x): Async-%s error - response(%x).\n",
1224 fcport->vha->host_no, sp->handle, type,
1225 sts->data[3]));
1226 } else {
1227 error = 0;
1228 }
1229
1230 if (error) {
1231 iocb->u.tmf.data = error;
1232 DEBUG2(qla2x00_dump_buffer((uint8_t *)sts, sizeof(*sts)));
1233 }
1234
1235 iocb->done(sp);
1236}
1237
1238static void
1239qla24xx_marker_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
1240 struct mrk_entry_24xx *mrk)
1241{
1242 const char func[] = "MRK-IOCB";
1243 const char *type;
1244 fc_port_t *fcport;
1245 srb_t *sp;
1246 struct srb_iocb *iocb;
1247 struct srb_ctx *ctx;
1248 struct sts_entry_24xx *sts = (struct sts_entry_24xx *)mrk;
1249
1250 sp = qla2x00_get_sp_from_handle(vha, func, req, mrk);
1251 if (!sp)
1252 return;
1253
1254 ctx = sp->ctx;
1255 iocb = ctx->u.iocb_cmd;
1256 type = ctx->name;
1257 fcport = sp->fcport;
1258
1259 if (sts->entry_status) {
1260 iocb->u.marker.data = 1;
1261 DEBUG2(printk(KERN_WARNING
1262 "scsi(%ld:%x): Async-%s error entry - entry-status=%x.\n",
1263 fcport->vha->host_no, sp->handle, type,
1264 sts->entry_status));
1265 DEBUG2(qla2x00_dump_buffer((uint8_t *)mrk, sizeof(*sts)));
1266 }
1267
1268 iocb->done(sp);
1269}
1270
1da177e4
LT		 1271/**
1272 * qla2x00_process_response_queue() - Process response queue entries.
1273 * @ha: SCSI driver HA context
1274 */
1275void
73208dfd 1276qla2x00_process_response_queue(struct rsp_que *rsp)
1da177e4 1277{
73208dfd
AC		 1278 struct scsi_qla_host *vha;
1279 struct qla_hw_data *ha = rsp->hw;
3d71644c 1280 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1da177e4
LT		 1281 sts_entry_t *pkt;
1282 uint16_t handle_cnt;
1283 uint16_t cnt;
73208dfd 1284
2afa19a9 1285 vha = pci_get_drvdata(ha->pdev);
1da177e4 1286
e315cd28 1287 if (!vha->flags.online)
1da177e4
LT		 1288 return;
1289
e315cd28
AC		 1290 while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
1291 pkt = (sts_entry_t *)rsp->ring_ptr;
1da177e4 1292
e315cd28
AC		 1293 rsp->ring_index++;
1294 if (rsp->ring_index == rsp->length) {
1295 rsp->ring_index = 0;
1296 rsp->ring_ptr = rsp->ring;
1da177e4 1297 } else {
e315cd28 1298 rsp->ring_ptr++;
1da177e4
LT		 1299 }
1300
1301 if (pkt->entry_status != 0) {
1302 DEBUG3(printk(KERN_INFO
e315cd28 1303 "scsi(%ld): Process error entry.\n", vha->host_no));
1da177e4 1304
73208dfd 1305 qla2x00_error_entry(vha, rsp, pkt);
1da177e4
LT		 1306 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1307 wmb();
1308 continue;
1309 }
1310
1311 switch (pkt->entry_type) {
1312 case STATUS_TYPE:
73208dfd 1313 qla2x00_status_entry(vha, rsp, pkt);
1da177e4
LT		 1314 break;
1315 case STATUS_TYPE_21:
1316 handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
1317 for (cnt = 0; cnt < handle_cnt; cnt++) {
73208dfd 1318 qla2x00_process_completed_request(vha, rsp->req,
1da177e4
LT		 1319 ((sts21_entry_t *)pkt)->handle[cnt]);
1320 }
1321 break;
1322 case STATUS_TYPE_22:
1323 handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
1324 for (cnt = 0; cnt < handle_cnt; cnt++) {
73208dfd 1325 qla2x00_process_completed_request(vha, rsp->req,
1da177e4
LT		 1326 ((sts22_entry_t *)pkt)->handle[cnt]);
1327 }
1328 break;
1329 case STATUS_CONT_TYPE:
2afa19a9 1330 qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
1da177e4 1331 break;
ac280b67
AV		 1332 case MBX_IOCB_TYPE:
1333 qla2x00_mbx_iocb_entry(vha, rsp->req,
1334 (struct mbx_entry *)pkt);
3822263e 1335 break;
1da177e4
LT		 1336 default:
1337 /* Type Not Supported. */
1338 DEBUG4(printk(KERN_WARNING
1339 "scsi(%ld): Received unknown response pkt type %x "
1340 "entry status=%x.\n",
e315cd28 1341 vha->host_no, pkt->entry_type, pkt->entry_status));
1da177e4
LT		 1342 break;
1343 }
1344 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1345 wmb();
1346 }
1347
1348 /* Adjust ring index */
e315cd28 1349 WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), rsp->ring_index);
1da177e4
LT		 1350}
1351
4733fcb1 1352static inline void
2afa19a9
AC		 1353qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t sense_len,
1354 struct rsp_que *rsp)
4733fcb1
AV		 1355{
1356 struct scsi_cmnd *cp = sp->cmd;
1357
1358 if (sense_len >= SCSI_SENSE_BUFFERSIZE)
1359 sense_len = SCSI_SENSE_BUFFERSIZE;
1360
4733fcb1
AV		 1361 sp->request_sense_length = sense_len;
1362 sp->request_sense_ptr = cp->sense_buffer;
1363 if (sp->request_sense_length > 32)
1364 sense_len = 32;
1365
1366 memcpy(cp->sense_buffer, sense_data, sense_len);
1367
1368 sp->request_sense_ptr += sense_len;
1369 sp->request_sense_length -= sense_len;
1370 if (sp->request_sense_length != 0)
2afa19a9 1371 rsp->status_srb = sp;
4733fcb1
AV		 1372
1373 DEBUG5(printk("%s(): Check condition Sense data, scsi(%ld:%d:%d:%d) "
e315cd28 1374 "cmd=%p pid=%ld\n", __func__, sp->fcport->vha->host_no,
19851f13
AV		 1375 cp->device->channel, cp->device->id, cp->device->lun, cp,
1376 cp->serial_number));
4733fcb1 1377 if (sense_len)
ddb9b126 1378 DEBUG5(qla2x00_dump_buffer(cp->sense_buffer, sense_len));
4733fcb1
AV		 1379}
1380
bad75002
AE		 1381struct scsi_dif_tuple {
1382 __be16 guard; /* Checksum */
1383 __be16 app_tag; /* APPL identifer */
1384 __be32 ref_tag; /* Target LBA or indirect LBA */
1385};
1386
1387/*
1388 * Checks the guard or meta-data for the type of error
1389 * detected by the HBA. In case of errors, we set the
1390 * ASC/ASCQ fields in the sense buffer with ILLEGAL_REQUEST
1391 * to indicate to the kernel that the HBA detected error.
1392 */
1393static inline void
1394qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
1395{
1396 struct scsi_cmnd *cmd = sp->cmd;
1397 struct scsi_dif_tuple *ep =
1398 (struct scsi_dif_tuple *)&sts24->data[20];
1399 struct scsi_dif_tuple *ap =
1400 (struct scsi_dif_tuple *)&sts24->data[12];
1401 uint32_t e_ref_tag, a_ref_tag;
1402 uint16_t e_app_tag, a_app_tag;
1403 uint16_t e_guard, a_guard;
1404
1405 e_ref_tag = be32_to_cpu(ep->ref_tag);
1406 a_ref_tag = be32_to_cpu(ap->ref_tag);
1407 e_app_tag = be16_to_cpu(ep->app_tag);
1408 a_app_tag = be16_to_cpu(ap->app_tag);
1409 e_guard = be16_to_cpu(ep->guard);
1410 a_guard = be16_to_cpu(ap->guard);
1411
1412 DEBUG18(printk(KERN_DEBUG
1413 "%s(): iocb(s) %p Returned STATUS\n", __func__, sts24));
1414
1415 DEBUG18(printk(KERN_ERR "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
1416 " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
1417 " tag=0x%x, act guard=0x%x, exp guard=0x%x\n",
1418 cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
1419 a_app_tag, e_app_tag, a_guard, e_guard));
1420
1421
1422 /* check guard */
1423 if (e_guard != a_guard) {
1424 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1425 0x10, 0x1);
1426 set_driver_byte(cmd, DRIVER_SENSE);
1427 set_host_byte(cmd, DID_ABORT);
1428 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1429 return;
1430 }
1431
1432 /* check appl tag */
1433 if (e_app_tag != a_app_tag) {
1434 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1435 0x10, 0x2);
1436 set_driver_byte(cmd, DRIVER_SENSE);
1437 set_host_byte(cmd, DID_ABORT);
1438 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1439 return;
1440 }
1441
1442 /* check ref tag */
1443 if (e_ref_tag != a_ref_tag) {
1444 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1445 0x10, 0x3);
1446 set_driver_byte(cmd, DRIVER_SENSE);
1447 set_host_byte(cmd, DID_ABORT);
1448 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1449 return;
1450 }
1451}
1452
1da177e4
LT		 1453/**
1454 * qla2x00_status_entry() - Process a Status IOCB entry.
1455 * @ha: SCSI driver HA context
1456 * @pkt: Entry pointer
1457 */
1458static void
73208dfd 1459qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
1da177e4 1460{
1da177e4 1461 srb_t *sp;
1da177e4
LT		 1462 fc_port_t *fcport;
1463 struct scsi_cmnd *cp;
9a853f71
AV		 1464 sts_entry_t *sts;
1465 struct sts_entry_24xx *sts24;
1da177e4
LT		 1466 uint16_t comp_status;
1467 uint16_t scsi_status;
b7d2280c 1468 uint16_t ox_id;
1da177e4
LT		 1469 uint8_t lscsi_status;
1470 int32_t resid;
ed17c71b 1471 uint32_t sense_len, rsp_info_len, resid_len, fw_resid_len;
9a853f71 1472 uint8_t *rsp_info, *sense_data;
e315cd28 1473 struct qla_hw_data *ha = vha->hw;
2afa19a9
AC		 1474 uint32_t handle;
1475 uint16_t que;
1476 struct req_que *req;
b7d2280c 1477 int logit = 1;
9a853f71
AV		 1478
1479 sts = (sts_entry_t *) pkt;
1480 sts24 = (struct sts_entry_24xx *) pkt;
e428924c 1481 if (IS_FWI2_CAPABLE(ha)) {
9a853f71
AV		 1482 comp_status = le16_to_cpu(sts24->comp_status);
1483 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
1484 } else {
1485 comp_status = le16_to_cpu(sts->comp_status);
1486 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
1487 }
2afa19a9
AC		 1488 handle = (uint32_t) LSW(sts->handle);
1489 que = MSW(sts->handle);
1490 req = ha->req_q_map[que];
a9083016 1491
1da177e4 1492 /* Fast path completion. */
9a853f71 1493 if (comp_status == CS_COMPLETE && scsi_status == 0) {
2afa19a9 1494 qla2x00_process_completed_request(vha, req, handle);
1da177e4
LT		 1495
1496 return;
1497 }
1498
1499 /* Validate handle. */
2afa19a9
AC		 1500 if (handle < MAX_OUTSTANDING_COMMANDS) {
1501 sp = req->outstanding_cmds[handle];
1502 req->outstanding_cmds[handle] = NULL;
1da177e4
LT		 1503 } else
1504 sp = NULL;
1505
1506 if (sp == NULL) {
b7d2280c
AV		 1507 qla_printk(KERN_WARNING, ha,
1508 "scsi(%ld): Invalid status handle (0x%x).\n", vha->host_no,
1509 sts->handle);
1da177e4 1510
e315cd28
AC		 1511 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1512 qla2xxx_wake_dpc(vha);
1da177e4
LT		 1513 return;
1514 }
1515 cp = sp->cmd;
1516 if (cp == NULL) {
1da177e4 1517 qla_printk(KERN_WARNING, ha,
b7d2280c
AV		 1518 "scsi(%ld): Command already returned (0x%x/%p).\n",
1519 vha->host_no, sts->handle, sp);
1da177e4
LT		 1520
1521 return;
1522 }
1523
9a853f71 1524 lscsi_status = scsi_status & STATUS_MASK;
1da177e4 1525
bdf79621 1526 fcport = sp->fcport;
1da177e4 1527
b7d2280c 1528 ox_id = 0;
ed17c71b 1529 sense_len = rsp_info_len = resid_len = fw_resid_len = 0;
e428924c 1530 if (IS_FWI2_CAPABLE(ha)) {
0f00a206
LC		 1531 if (scsi_status & SS_SENSE_LEN_VALID)
1532 sense_len = le32_to_cpu(sts24->sense_len);
1533 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
1534 rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
1535 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER))
1536 resid_len = le32_to_cpu(sts24->rsp_residual_count);
1537 if (comp_status == CS_DATA_UNDERRUN)
1538 fw_resid_len = le32_to_cpu(sts24->residual_len);
9a853f71
AV		 1539 rsp_info = sts24->data;
1540 sense_data = sts24->data;
1541 host_to_fcp_swap(sts24->data, sizeof(sts24->data));
b7d2280c 1542 ox_id = le16_to_cpu(sts24->ox_id);
9a853f71 1543 } else {
0f00a206
LC		 1544 if (scsi_status & SS_SENSE_LEN_VALID)
1545 sense_len = le16_to_cpu(sts->req_sense_length);
1546 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
1547 rsp_info_len = le16_to_cpu(sts->rsp_info_len);
9a853f71
AV		 1548 resid_len = le32_to_cpu(sts->residual_length);
1549 rsp_info = sts->rsp_info;
1550 sense_data = sts->req_sense_data;
1551 }
1552
1da177e4
LT		 1553 /* Check for any FCP transport errors. */
1554 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
9a853f71 1555 /* Sense data lies beyond any FCP RESPONSE data. */
e428924c 1556 if (IS_FWI2_CAPABLE(ha))
9a853f71
AV		 1557 sense_data += rsp_info_len;
1558 if (rsp_info_len > 3 && rsp_info[3]) {
b7d2280c
AV		 1559 DEBUG2(qla_printk(KERN_INFO, ha,
1560 "scsi(%ld:%d:%d): FCP I/O protocol failure "
1561 "(0x%x/0x%x).\n", vha->host_no, cp->device->id,
1562 cp->device->lun, rsp_info_len, rsp_info[3]));
1da177e4
LT		 1563
1564 cp->result = DID_BUS_BUSY << 16;
b7d2280c 1565 goto out;
1da177e4
LT		 1566 }
1567 }
1568
3e8ce320
AV		 1569 /* Check for overrun. */
1570 if (IS_FWI2_CAPABLE(ha) && comp_status == CS_COMPLETE &&
1571 scsi_status & SS_RESIDUAL_OVER)
1572 comp_status = CS_DATA_OVERRUN;
1573
1da177e4
LT		 1574 /*
1575 * Based on Host and scsi status generate status code for Linux
1576 */
1577 switch (comp_status) {
1578 case CS_COMPLETE:
df7baa50 1579 case CS_QUEUE_FULL:
1da177e4
LT		 1580 if (scsi_status == 0) {
1581 cp->result = DID_OK << 16;
1582 break;
1583 }
1584 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
9a853f71 1585 resid = resid_len;
385d70b4 1586 scsi_set_resid(cp, resid);
0da69df1
AV		 1587
1588 if (!lscsi_status &&
385d70b4 1589 ((unsigned)(scsi_bufflen(cp) - resid) <
0da69df1
AV		 1590 cp->underflow)) {
1591 qla_printk(KERN_INFO, ha,
b7d2280c
AV		 1592 "scsi(%ld:%d:%d): Mid-layer underflow "
1593 "detected (0x%x of 0x%x bytes).\n",
1594 vha->host_no, cp->device->id,
1595 cp->device->lun, resid, scsi_bufflen(cp));
0da69df1
AV		 1596
1597 cp->result = DID_ERROR << 16;
1598 break;
1599 }
1da177e4 1600 }
1da177e4
LT		 1601 cp->result = DID_OK << 16 | lscsi_status;
1602
df7baa50 1603 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
b7d2280c
AV		 1604 DEBUG2(qla_printk(KERN_INFO, ha,
1605 "scsi(%ld:%d:%d) QUEUE FULL detected.\n",
1606 vha->host_no, cp->device->id, cp->device->lun));
df7baa50
AV		 1607 break;
1608 }
b7d2280c 1609 logit = 0;
1da177e4
LT		 1610 if (lscsi_status != SS_CHECK_CONDITION)
1611 break;
1612
b80ca4f7 1613 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 1614 if (!(scsi_status & SS_SENSE_LEN_VALID))
1615 break;
1616
2afa19a9 1617 qla2x00_handle_sense(sp, sense_data, sense_len, rsp);
1da177e4
LT		 1618 break;
1619
1620 case CS_DATA_UNDERRUN:
ed17c71b 1621 /* Use F/W calculated residual length. */
0f00a206
LC		 1622 resid = IS_FWI2_CAPABLE(ha) ? fw_resid_len : resid_len;
1623 scsi_set_resid(cp, resid);
1624 if (scsi_status & SS_RESIDUAL_UNDER) {
1625 if (IS_FWI2_CAPABLE(ha) && fw_resid_len != resid_len) {
b7d2280c
AV		 1626 DEBUG2(qla_printk(KERN_INFO, ha,
1627 "scsi(%ld:%d:%d) Dropped frame(s) detected "
1628 "(0x%x of 0x%x bytes).\n", vha->host_no,
0f00a206
LC		 1629 cp->device->id, cp->device->lun, resid,
1630 scsi_bufflen(cp)));
1631
1632 cp->result = DID_ERROR << 16 | lscsi_status;
1633 break;
6acf8190 1634 }
ed17c71b 1635
0f00a206
LC		 1636 if (!lscsi_status &&
1637 ((unsigned)(scsi_bufflen(cp) - resid) <
1638 cp->underflow)) {
1639 qla_printk(KERN_INFO, ha,
b7d2280c
AV		 1640 "scsi(%ld:%d:%d): Mid-layer underflow "
1641 "detected (0x%x of 0x%x bytes).\n",
1642 vha->host_no, cp->device->id,
0f00a206 1643 cp->device->lun, resid, scsi_bufflen(cp));
e038a1be 1644
0f00a206
LC		 1645 cp->result = DID_ERROR << 16;
1646 break;
1647 }
1648 } else if (!lscsi_status) {
b7d2280c
AV		 1649 DEBUG2(qla_printk(KERN_INFO, ha,
1650 "scsi(%ld:%d:%d) Dropped frame(s) detected (0x%x "
1651 "of 0x%x bytes).\n", vha->host_no, cp->device->id,
0f00a206
LC		 1652 cp->device->lun, resid, scsi_bufflen(cp)));
1653
1654 cp->result = DID_ERROR << 16;
1655 break;
1da177e4
LT		 1656 }
1657
0f00a206 1658 cp->result = DID_OK << 16 | lscsi_status;
b7d2280c 1659 logit = 0;
0f00a206 1660
1da177e4 1661 /*
fa2a1ce5 1662 * Check to see if SCSI Status is non zero. If so report SCSI
1da177e4
LT		 1663 * Status.
1664 */
1665 if (lscsi_status != 0) {
ffec28a3 1666 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
b7d2280c
AV		 1667 DEBUG2(qla_printk(KERN_INFO, ha,
1668 "scsi(%ld:%d:%d) QUEUE FULL detected.\n",
1669 vha->host_no, cp->device->id,
1670 cp->device->lun));
1671 logit = 1;
ffec28a3
AV		 1672 break;
1673 }
1da177e4
LT		 1674 if (lscsi_status != SS_CHECK_CONDITION)
1675 break;
1676
b80ca4f7 1677 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 1678 if (!(scsi_status & SS_SENSE_LEN_VALID))
1679 break;
1680
2afa19a9 1681 qla2x00_handle_sense(sp, sense_data, sense_len, rsp);
1da177e4
LT		 1682 }
1683 break;
1684
1da177e4
LT		 1685 case CS_PORT_LOGGED_OUT:
1686 case CS_PORT_CONFIG_CHG:
1687 case CS_PORT_BUSY:
1688 case CS_INCOMPLETE:
1689 case CS_PORT_UNAVAILABLE:
b7d2280c 1690 case CS_TIMEOUT:
056a4483
MC		 1691 /*
1692 * We are going to have the fc class block the rport
1693 * while we try to recover so instruct the mid layer
1694 * to requeue until the class decides how to handle this.
1695 */
1696 cp->result = DID_TRANSPORT_DISRUPTED << 16;
b7d2280c
AV		 1697
1698 if (comp_status == CS_TIMEOUT) {
1699 if (IS_FWI2_CAPABLE(ha))
1700 break;
1701 else if ((le16_to_cpu(sts->status_flags) &
1702 SF_LOGOUT_SENT) == 0)
1703 break;
1704 }
1705
1706 DEBUG2(qla_printk(KERN_INFO, ha,
1707 "scsi(%ld:%d:%d) Port down status: port-state=0x%x\n",
1708 vha->host_no, cp->device->id, cp->device->lun,
1709 atomic_read(&fcport->state)));
1710
a7a28504 1711 if (atomic_read(&fcport->state) == FCS_ONLINE)
e315cd28 1712 qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
1da177e4
LT		 1713 break;
1714
1715 case CS_RESET:
1da177e4 1716 case CS_ABORTED:
1da177e4
LT		 1717 cp->result = DID_RESET << 16;
1718 break;
bad75002
AE		 1719
1720 case CS_DIF_ERROR:
1721 qla2x00_handle_dif_error(sp, sts24);
1722 break;
1da177e4 1723 default:
1da177e4
LT		 1724 cp->result = DID_ERROR << 16;
1725 break;
1726 }
1727
b7d2280c
AV		 1728out:
1729 if (logit)
1730 DEBUG2(qla_printk(KERN_INFO, ha,
1731 "scsi(%ld:%d:%d) FCP command status: 0x%x-0x%x (0x%x) "
1732 "oxid=0x%x ser=0x%lx cdb=%02x%02x%02x len=0x%x "
1733 "rsp_info=0x%x resid=0x%x fw_resid=0x%x\n", vha->host_no,
1734 cp->device->id, cp->device->lun, comp_status, scsi_status,
1735 cp->result, ox_id, cp->serial_number, cp->cmnd[0],
1736 cp->cmnd[1], cp->cmnd[2], scsi_bufflen(cp), rsp_info_len,
1737 resid_len, fw_resid_len));
1738
2afa19a9 1739 if (rsp->status_srb == NULL)
73208dfd 1740 qla2x00_sp_compl(ha, sp);
1da177e4
LT		 1741}
1742
1743/**
1744 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
1745 * @ha: SCSI driver HA context
1746 * @pkt: Entry pointer
1747 *
1748 * Extended sense data.
1749 */
1750static void
2afa19a9 1751qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
1da177e4
LT		 1752{
1753 uint8_t sense_sz = 0;
2afa19a9
AC		 1754 struct qla_hw_data *ha = rsp->hw;
1755 srb_t *sp = rsp->status_srb;
1da177e4
LT		 1756 struct scsi_cmnd *cp;
1757
1758 if (sp != NULL && sp->request_sense_length != 0) {
1759 cp = sp->cmd;
1760 if (cp == NULL) {
1761 DEBUG2(printk("%s(): Cmd already returned back to OS "
75bc4190 1762 "sp=%p.\n", __func__, sp));
1da177e4
LT		 1763 qla_printk(KERN_INFO, ha,
1764 "cmd is NULL: already returned to OS (sp=%p)\n",
fa2a1ce5 1765 sp);
1da177e4 1766
2afa19a9 1767 rsp->status_srb = NULL;
1da177e4
LT		 1768 return;
1769 }
1770
1771 if (sp->request_sense_length > sizeof(pkt->data)) {
1772 sense_sz = sizeof(pkt->data);
1773 } else {
1774 sense_sz = sp->request_sense_length;
1775 }
1776
1777 /* Move sense data. */
e428924c 1778 if (IS_FWI2_CAPABLE(ha))
9a853f71 1779 host_to_fcp_swap(pkt->data, sizeof(pkt->data));
1da177e4
LT		 1780 memcpy(sp->request_sense_ptr, pkt->data, sense_sz);
1781 DEBUG5(qla2x00_dump_buffer(sp->request_sense_ptr, sense_sz));
1782
1783 sp->request_sense_ptr += sense_sz;
1784 sp->request_sense_length -= sense_sz;
1785
1786 /* Place command on done queue. */
1787 if (sp->request_sense_length == 0) {
2afa19a9 1788 rsp->status_srb = NULL;
73208dfd 1789 qla2x00_sp_compl(ha, sp);
1da177e4
LT		 1790 }
1791 }
1792}
1793
1794/**
1795 * qla2x00_error_entry() - Process an error entry.
1796 * @ha: SCSI driver HA context
1797 * @pkt: Entry pointer
1798 */
1799static void
73208dfd 1800qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
1da177e4
LT		 1801{
1802 srb_t *sp;
e315cd28 1803 struct qla_hw_data *ha = vha->hw;
2afa19a9
AC		 1804 uint32_t handle = LSW(pkt->handle);
1805 uint16_t que = MSW(pkt->handle);
1806 struct req_que *req = ha->req_q_map[que];
1da177e4
LT		 1807#if defined(QL_DEBUG_LEVEL_2)
1808 if (pkt->entry_status & RF_INV_E_ORDER)
1809 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Order\n", __func__);
1810 else if (pkt->entry_status & RF_INV_E_COUNT)
1811 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Count\n", __func__);
1812 else if (pkt->entry_status & RF_INV_E_PARAM)
fa2a1ce5 1813 qla_printk(KERN_ERR, ha,
1da177e4
LT		 1814 "%s: Invalid Entry Parameter\n", __func__);
1815 else if (pkt->entry_status & RF_INV_E_TYPE)
1816 qla_printk(KERN_ERR, ha, "%s: Invalid Entry Type\n", __func__);
1817 else if (pkt->entry_status & RF_BUSY)
1818 qla_printk(KERN_ERR, ha, "%s: Busy\n", __func__);
1819 else
1820 qla_printk(KERN_ERR, ha, "%s: UNKNOWN flag error\n", __func__);
1821#endif
1822
1823 /* Validate handle. */
2afa19a9
AC		 1824 if (handle < MAX_OUTSTANDING_COMMANDS)
1825 sp = req->outstanding_cmds[handle];
1da177e4
LT		 1826 else
1827 sp = NULL;
1828
1829 if (sp) {
1830 /* Free outstanding command slot. */
2afa19a9 1831 req->outstanding_cmds[handle] = NULL;
354d6b21 1832
1da177e4
LT		 1833 /* Bad payload or header */
1834 if (pkt->entry_status &
1835 (RF_INV_E_ORDER | RF_INV_E_COUNT |
1836 RF_INV_E_PARAM | RF_INV_E_TYPE)) {
1837 sp->cmd->result = DID_ERROR << 16;
1838 } else if (pkt->entry_status & RF_BUSY) {
1839 sp->cmd->result = DID_BUS_BUSY << 16;
1840 } else {
1841 sp->cmd->result = DID_ERROR << 16;
1842 }
73208dfd 1843 qla2x00_sp_compl(ha, sp);
1da177e4 1844
9a853f71
AV		 1845 } else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type ==
1846 COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7) {
1da177e4 1847 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
e315cd28 1848 vha->host_no));
1da177e4
LT		 1849 qla_printk(KERN_WARNING, ha,
1850 "Error entry - invalid handle\n");
1851
e315cd28
AC		 1852 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1853 qla2xxx_wake_dpc(vha);
1da177e4
LT		 1854 }
1855}
1856
9a853f71
AV		 1857/**
1858 * qla24xx_mbx_completion() - Process mailbox command completions.
1859 * @ha: SCSI driver HA context
1860 * @mb0: Mailbox0 register
1861 */
1862static void
e315cd28 1863qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
9a853f71
AV		 1864{
1865 uint16_t cnt;
1866 uint16_t __iomem *wptr;
e315cd28 1867 struct qla_hw_data *ha = vha->hw;
9a853f71
AV		 1868 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1869
1870 /* Load return mailbox registers. */
1871 ha->flags.mbox_int = 1;
1872 ha->mailbox_out[0] = mb0;
1873 wptr = (uint16_t __iomem *)&reg->mailbox1;
1874
1875 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
1876 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
1877 wptr++;
1878 }
1879
1880 if (ha->mcp) {
1881 DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
e315cd28 1882 __func__, vha->host_no, ha->mcp->mb[0]));
9a853f71
AV		 1883 } else {
1884 DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
e315cd28 1885 __func__, vha->host_no));
9a853f71
AV		 1886 }
1887}
1888
1889/**
1890 * qla24xx_process_response_queue() - Process response queue entries.
1891 * @ha: SCSI driver HA context
1892 */
2afa19a9
AC		 1893void qla24xx_process_response_queue(struct scsi_qla_host *vha,
1894 struct rsp_que *rsp)
9a853f71 1895{
9a853f71 1896 struct sts_entry_24xx *pkt;
a9083016 1897 struct qla_hw_data *ha = vha->hw;
9a853f71 1898
e315cd28 1899 if (!vha->flags.online)
9a853f71
AV		 1900 return;
1901
e315cd28
AC		 1902 while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
1903 pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
9a853f71 1904
e315cd28
AC		 1905 rsp->ring_index++;
1906 if (rsp->ring_index == rsp->length) {
1907 rsp->ring_index = 0;
1908 rsp->ring_ptr = rsp->ring;
9a853f71 1909 } else {
e315cd28 1910 rsp->ring_ptr++;
9a853f71
AV		 1911 }
1912
1913 if (pkt->entry_status != 0) {
1914 DEBUG3(printk(KERN_INFO
e315cd28 1915 "scsi(%ld): Process error entry.\n", vha->host_no));
9a853f71 1916
73208dfd 1917 qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
9a853f71
AV		 1918 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1919 wmb();
1920 continue;
1921 }
1922
1923 switch (pkt->entry_type) {
1924 case STATUS_TYPE:
73208dfd 1925 qla2x00_status_entry(vha, rsp, pkt);
9a853f71
AV		 1926 break;
1927 case STATUS_CONT_TYPE:
2afa19a9 1928 qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
9a853f71 1929 break;
2c3dfe3f 1930 case VP_RPT_ID_IOCB_TYPE:
e315cd28 1931 qla24xx_report_id_acquisition(vha,
2c3dfe3f
SJ		 1932 (struct vp_rpt_id_entry_24xx *)pkt);
1933 break;
ac280b67
AV		 1934 case LOGINOUT_PORT_IOCB_TYPE:
1935 qla24xx_logio_entry(vha, rsp->req,
1936 (struct logio_entry_24xx *)pkt);
1937 break;
3822263e
MI		 1938 case TSK_MGMT_IOCB_TYPE:
1939 qla24xx_tm_iocb_entry(vha, rsp->req,
1940 (struct tsk_mgmt_entry *)pkt);
1941 break;
1942 case MARKER_TYPE:
1943 qla24xx_marker_iocb_entry(vha, rsp->req,
1944 (struct mrk_entry_24xx *)pkt);
1945 break;
9a069e19
GM		 1946 case CT_IOCB_TYPE:
1947 qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
1948 clear_bit(MBX_INTERRUPT, &vha->hw->mbx_cmd_flags);
1949 break;
1950 case ELS_IOCB_TYPE:
1951 qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
1952 break;
9a853f71
AV		 1953 default:
1954 /* Type Not Supported. */
1955 DEBUG4(printk(KERN_WARNING
1956 "scsi(%ld): Received unknown response pkt type %x "
1957 "entry status=%x.\n",
e315cd28 1958 vha->host_no, pkt->entry_type, pkt->entry_status));
9a853f71
AV		 1959 break;
1960 }
1961 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1962 wmb();
1963 }
1964
1965 /* Adjust ring index */
a9083016
GM		 1966 if (IS_QLA82XX(ha)) {
1967 struct device_reg_82xx __iomem *reg = &ha->iobase->isp82;
1968 WRT_REG_DWORD(&reg->rsp_q_out[0], rsp->ring_index);
1969 } else
1970 WRT_REG_DWORD(rsp->rsp_q_out, rsp->ring_index);
9a853f71
AV		 1971}
1972
05236a05 1973static void
e315cd28 1974qla2xxx_check_risc_status(scsi_qla_host_t *vha)
05236a05
AV		 1975{
1976 int rval;
1977 uint32_t cnt;
e315cd28 1978 struct qla_hw_data *ha = vha->hw;
05236a05
AV		 1979 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
1980
3a03eb79 1981 if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha))
05236a05
AV		 1982 return;
1983
1984 rval = QLA_SUCCESS;
1985 WRT_REG_DWORD(&reg->iobase_addr, 0x7C00);
1986 RD_REG_DWORD(&reg->iobase_addr);
1987 WRT_REG_DWORD(&reg->iobase_window, 0x0001);
1988 for (cnt = 10000; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
1989 rval == QLA_SUCCESS; cnt--) {
1990 if (cnt) {
1991 WRT_REG_DWORD(&reg->iobase_window, 0x0001);
1992 udelay(10);
1993 } else
1994 rval = QLA_FUNCTION_TIMEOUT;
1995 }
1996 if (rval == QLA_SUCCESS)
1997 goto next_test;
1998
1999 WRT_REG_DWORD(&reg->iobase_window, 0x0003);
2000 for (cnt = 100; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
2001 rval == QLA_SUCCESS; cnt--) {
2002 if (cnt) {
2003 WRT_REG_DWORD(&reg->iobase_window, 0x0003);
2004 udelay(10);
2005 } else
2006 rval = QLA_FUNCTION_TIMEOUT;
2007 }
2008 if (rval != QLA_SUCCESS)
2009 goto done;
2010
2011next_test:
2012 if (RD_REG_DWORD(&reg->iobase_c8) & BIT_3)
2013 qla_printk(KERN_INFO, ha, "Additional code -- 0x55AA.\n");
2014
2015done:
2016 WRT_REG_DWORD(&reg->iobase_window, 0x0000);
2017 RD_REG_DWORD(&reg->iobase_window);
2018}
2019
9a853f71
AV		 2020/**
2021 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
2022 * @irq:
2023 * @dev_id: SCSI driver HA context
9a853f71
AV		 2024 *
2025 * Called by system whenever the host adapter generates an interrupt.
2026 *
2027 * Returns handled flag.
2028 */
2029irqreturn_t
7d12e780 2030qla24xx_intr_handler(int irq, void *dev_id)
9a853f71 2031{
e315cd28
AC		 2032 scsi_qla_host_t *vha;
2033 struct qla_hw_data *ha;
9a853f71
AV		 2034 struct device_reg_24xx __iomem *reg;
2035 int status;
9a853f71
AV		 2036 unsigned long iter;
2037 uint32_t stat;
2038 uint32_t hccr;
2039 uint16_t mb[4];
e315cd28 2040 struct rsp_que *rsp;
43fac4d9 2041 unsigned long flags;
9a853f71 2042
e315cd28
AC		 2043 rsp = (struct rsp_que *) dev_id;
2044 if (!rsp) {
9a853f71 2045 printk(KERN_INFO
e315cd28 2046 "%s(): NULL response queue pointer\n", __func__);
9a853f71
AV		 2047 return IRQ_NONE;
2048 }
2049
e315cd28 2050 ha = rsp->hw;
9a853f71
AV		 2051 reg = &ha->iobase->isp24;
2052 status = 0;
2053
85880801
AV		 2054 if (unlikely(pci_channel_offline(ha->pdev)))
2055 return IRQ_HANDLED;
2056
43fac4d9 2057 spin_lock_irqsave(&ha->hardware_lock, flags);
2afa19a9 2058 vha = pci_get_drvdata(ha->pdev);
9a853f71
AV		 2059 for (iter = 50; iter--; ) {
2060 stat = RD_REG_DWORD(&reg->host_status);
2061 if (stat & HSRX_RISC_PAUSED) {
85880801 2062 if (unlikely(pci_channel_offline(ha->pdev)))
14e660e6
SJ		 2063 break;
2064
9a853f71
AV		 2065 hccr = RD_REG_DWORD(&reg->hccr);
2066
2067 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
2068 "Dumping firmware!\n", hccr);
05236a05 2069
e315cd28 2070 qla2xxx_check_risc_status(vha);
05236a05 2071
e315cd28
AC		 2072 ha->isp_ops->fw_dump(vha, 1);
2073 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
9a853f71
AV		 2074 break;
2075 } else if ((stat & HSRX_RISC_INT) == 0)
2076 break;
2077
2078 switch (stat & 0xff) {
2079 case 0x1:
2080 case 0x2:
2081 case 0x10:
2082 case 0x11:
e315cd28 2083 qla24xx_mbx_completion(vha, MSW(stat));
9a853f71
AV		 2084 status |= MBX_INTERRUPT;
2085
2086 break;
2087 case 0x12:
2088 mb[0] = MSW(stat);
2089 mb[1] = RD_REG_WORD(&reg->mailbox1);
2090 mb[2] = RD_REG_WORD(&reg->mailbox2);
2091 mb[3] = RD_REG_WORD(&reg->mailbox3);
73208dfd 2092 qla2x00_async_event(vha, rsp, mb);
9a853f71
AV		 2093 break;
2094 case 0x13:
73208dfd 2095 case 0x14:
2afa19a9 2096 qla24xx_process_response_queue(vha, rsp);
9a853f71
AV		 2097 break;
2098 default:
2099 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
2100 "(%d).\n",
e315cd28 2101 vha->host_no, stat & 0xff));
9a853f71
AV		 2102 break;
2103 }
2104 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2105 RD_REG_DWORD_RELAXED(&reg->hccr);
2106 }
43fac4d9 2107 spin_unlock_irqrestore(&ha->hardware_lock, flags);
9a853f71
AV		 2108
2109 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
2110 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
9a853f71 2111 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
0b05a1f0 2112 complete(&ha->mbx_intr_comp);
9a853f71
AV		 2113 }
2114
2115 return IRQ_HANDLED;
2116}
2117
a8488abe
AV		 2118static irqreturn_t
2119qla24xx_msix_rsp_q(int irq, void *dev_id)
2120{
e315cd28
AC		 2121 struct qla_hw_data *ha;
2122 struct rsp_que *rsp;
a8488abe 2123 struct device_reg_24xx __iomem *reg;
2afa19a9 2124 struct scsi_qla_host *vha;
0f19bc68 2125 unsigned long flags;
a8488abe 2126
e315cd28
AC		 2127 rsp = (struct rsp_que *) dev_id;
2128 if (!rsp) {
2129 printk(KERN_INFO
2130 "%s(): NULL response queue pointer\n", __func__);
2131 return IRQ_NONE;
2132 }
2133 ha = rsp->hw;
a8488abe
AV		 2134 reg = &ha->iobase->isp24;
2135
0f19bc68 2136 spin_lock_irqsave(&ha->hardware_lock, flags);
a8488abe 2137
a67093d4 2138 vha = pci_get_drvdata(ha->pdev);
2afa19a9 2139 qla24xx_process_response_queue(vha, rsp);
3155754a 2140 if (!ha->flags.disable_msix_handshake) {
eb94114b
AC		 2141 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2142 RD_REG_DWORD_RELAXED(&reg->hccr);
2143 }
0f19bc68 2144 spin_unlock_irqrestore(&ha->hardware_lock, flags);
a8488abe
AV		 2145
2146 return IRQ_HANDLED;
2147}
2148
68ca949c
AC		 2149static irqreturn_t
2150qla25xx_msix_rsp_q(int irq, void *dev_id)
2151{
2152 struct qla_hw_data *ha;
2153 struct rsp_que *rsp;
3155754a 2154 struct device_reg_24xx __iomem *reg;
0f19bc68 2155 unsigned long flags;
68ca949c
AC		 2156
2157 rsp = (struct rsp_que *) dev_id;
2158 if (!rsp) {
2159 printk(KERN_INFO
2160 "%s(): NULL response queue pointer\n", __func__);
2161 return IRQ_NONE;
2162 }
2163 ha = rsp->hw;
2164
3155754a
AC		 2165 /* Clear the interrupt, if enabled, for this response queue */
2166 if (rsp->options & ~BIT_6) {
2167 reg = &ha->iobase->isp24;
0f19bc68 2168 spin_lock_irqsave(&ha->hardware_lock, flags);
3155754a
AC		 2169 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2170 RD_REG_DWORD_RELAXED(&reg->hccr);
0f19bc68 2171 spin_unlock_irqrestore(&ha->hardware_lock, flags);
3155754a 2172 }
68ca949c
AC		 2173 queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);
2174
2175 return IRQ_HANDLED;
2176}
2177
a8488abe
AV		 2178static irqreturn_t
2179qla24xx_msix_default(int irq, void *dev_id)
2180{
e315cd28
AC		 2181 scsi_qla_host_t *vha;
2182 struct qla_hw_data *ha;
2183 struct rsp_que *rsp;
a8488abe
AV		 2184 struct device_reg_24xx __iomem *reg;
2185 int status;
a8488abe
AV		 2186 uint32_t stat;
2187 uint32_t hccr;
2188 uint16_t mb[4];
0f19bc68 2189 unsigned long flags;
a8488abe 2190
e315cd28
AC		 2191 rsp = (struct rsp_que *) dev_id;
2192 if (!rsp) {
2193 DEBUG(printk(
2194 "%s(): NULL response queue pointer\n", __func__));
2195 return IRQ_NONE;
2196 }
2197 ha = rsp->hw;
a8488abe
AV		 2198 reg = &ha->iobase->isp24;
2199 status = 0;
2200
0f19bc68 2201 spin_lock_irqsave(&ha->hardware_lock, flags);
2afa19a9 2202 vha = pci_get_drvdata(ha->pdev);
87f27015 2203 do {
a8488abe
AV		 2204 stat = RD_REG_DWORD(&reg->host_status);
2205 if (stat & HSRX_RISC_PAUSED) {
85880801 2206 if (unlikely(pci_channel_offline(ha->pdev)))
14e660e6
SJ		 2207 break;
2208
a8488abe
AV		 2209 hccr = RD_REG_DWORD(&reg->hccr);
2210
2211 qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
2212 "Dumping firmware!\n", hccr);
05236a05 2213
e315cd28 2214 qla2xxx_check_risc_status(vha);
05236a05 2215
e315cd28
AC		 2216 ha->isp_ops->fw_dump(vha, 1);
2217 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
a8488abe
AV		 2218 break;
2219 } else if ((stat & HSRX_RISC_INT) == 0)
2220 break;
2221
2222 switch (stat & 0xff) {
2223 case 0x1:
2224 case 0x2:
2225 case 0x10:
2226 case 0x11:
e315cd28 2227 qla24xx_mbx_completion(vha, MSW(stat));
a8488abe
AV		 2228 status |= MBX_INTERRUPT;
2229
2230 break;
2231 case 0x12:
2232 mb[0] = MSW(stat);
2233 mb[1] = RD_REG_WORD(&reg->mailbox1);
2234 mb[2] = RD_REG_WORD(&reg->mailbox2);
2235 mb[3] = RD_REG_WORD(&reg->mailbox3);
73208dfd 2236 qla2x00_async_event(vha, rsp, mb);
a8488abe
AV		 2237 break;
2238 case 0x13:
73208dfd 2239 case 0x14:
2afa19a9 2240 qla24xx_process_response_queue(vha, rsp);
a8488abe
AV		 2241 break;
2242 default:
2243 DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
2244 "(%d).\n",
e315cd28 2245 vha->host_no, stat & 0xff));
a8488abe
AV		 2246 break;
2247 }
2248 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
87f27015 2249 } while (0);
0f19bc68 2250 spin_unlock_irqrestore(&ha->hardware_lock, flags);
a8488abe
AV		 2251
2252 if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
2253 (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
a8488abe 2254 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
0b05a1f0 2255 complete(&ha->mbx_intr_comp);
a8488abe 2256 }
a8488abe
AV		 2257 return IRQ_HANDLED;
2258}
2259
2260/* Interrupt handling helpers. */
2261
2262struct qla_init_msix_entry {
a8488abe 2263 const char *name;
476834c2 2264 irq_handler_t handler;
a8488abe
AV		 2265};
2266
68ca949c 2267static struct qla_init_msix_entry msix_entries[3] = {
2afa19a9
AC		 2268 { "qla2xxx (default)", qla24xx_msix_default },
2269 { "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
68ca949c 2270 { "qla2xxx (multiq)", qla25xx_msix_rsp_q },
a8488abe
AV		 2271};
2272
a9083016
GM		 2273static struct qla_init_msix_entry qla82xx_msix_entries[2] = {
2274 { "qla2xxx (default)", qla82xx_msix_default },
2275 { "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
2276};
2277
a8488abe 2278static void
e315cd28 2279qla24xx_disable_msix(struct qla_hw_data *ha)
a8488abe
AV		 2280{
2281 int i;
2282 struct qla_msix_entry *qentry;
2283
73208dfd
AC		 2284 for (i = 0; i < ha->msix_count; i++) {
2285 qentry = &ha->msix_entries[i];
a8488abe 2286 if (qentry->have_irq)
73208dfd 2287 free_irq(qentry->vector, qentry->rsp);
a8488abe
AV		 2288 }
2289 pci_disable_msix(ha->pdev);
73208dfd
AC		 2290 kfree(ha->msix_entries);
2291 ha->msix_entries = NULL;
2292 ha->flags.msix_enabled = 0;
a8488abe
AV		 2293}
2294
2295static int
73208dfd 2296qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
a8488abe 2297{
ad038fa8 2298#define MIN_MSIX_COUNT 2
a8488abe 2299 int i, ret;
73208dfd 2300 struct msix_entry *entries;
a8488abe 2301 struct qla_msix_entry *qentry;
73208dfd
AC		 2302
2303 entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
a9083016 2304 GFP_KERNEL);
73208dfd
AC		 2305 if (!entries)
2306 return -ENOMEM;
a8488abe 2307
73208dfd
AC		 2308 for (i = 0; i < ha->msix_count; i++)
2309 entries[i].entry = i;
a8488abe 2310
73208dfd 2311 ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
a8488abe 2312 if (ret) {
ad038fa8
LC		 2313 if (ret < MIN_MSIX_COUNT)
2314 goto msix_failed;
2315
a8488abe 2316 qla_printk(KERN_WARNING, ha,
73208dfd
AC		 2317 "MSI-X: Failed to enable support -- %d/%d\n"
2318 " Retry with %d vectors\n", ha->msix_count, ret, ret);
2319 ha->msix_count = ret;
2320 ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
2321 if (ret) {
ad038fa8 2322msix_failed:
73208dfd
AC		 2323 qla_printk(KERN_WARNING, ha, "MSI-X: Failed to enable"
2324 " support, giving up -- %d/%d\n",
2325 ha->msix_count, ret);
2326 goto msix_out;
2327 }
2afa19a9 2328 ha->max_rsp_queues = ha->msix_count - 1;
73208dfd
AC		 2329 }
2330 ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
2331 ha->msix_count, GFP_KERNEL);
2332 if (!ha->msix_entries) {
2333 ret = -ENOMEM;
a8488abe
AV		 2334 goto msix_out;
2335 }
2336 ha->flags.msix_enabled = 1;
2337
73208dfd
AC		 2338 for (i = 0; i < ha->msix_count; i++) {
2339 qentry = &ha->msix_entries[i];
2340 qentry->vector = entries[i].vector;
2341 qentry->entry = entries[i].entry;
a8488abe 2342 qentry->have_irq = 0;
73208dfd 2343 qentry->rsp = NULL;
a8488abe
AV		 2344 }
2345
2afa19a9
AC		 2346 /* Enable MSI-X vectors for the base queue */
2347 for (i = 0; i < 2; i++) {
2348 qentry = &ha->msix_entries[i];
a9083016
GM		 2349 if (IS_QLA82XX(ha)) {
2350 ret = request_irq(qentry->vector,
2351 qla82xx_msix_entries[i].handler,
2352 0, qla82xx_msix_entries[i].name, rsp);
2353 } else {
2354 ret = request_irq(qentry->vector,
2355 msix_entries[i].handler,
2356 0, msix_entries[i].name, rsp);
2357 }
2afa19a9
AC		 2358 if (ret) {
2359 qla_printk(KERN_WARNING, ha,
73208dfd
AC		 2360 "MSI-X: Unable to register handler -- %x/%d.\n",
2361 qentry->vector, ret);
2afa19a9
AC		 2362 qla24xx_disable_msix(ha);
2363 ha->mqenable = 0;
2364 goto msix_out;
2365 }
2366 qentry->have_irq = 1;
2367 qentry->rsp = rsp;
2368 rsp->msix = qentry;
73208dfd 2369 }
73208dfd
AC		 2370
2371 /* Enable MSI-X vector for response queue update for queue 0 */
2afa19a9 2372 if (ha->mqiobase && (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
73208dfd 2373 ha->mqenable = 1;
73208dfd 2374
a8488abe 2375msix_out:
73208dfd 2376 kfree(entries);
a8488abe
AV		 2377 return ret;
2378}
2379
2380int
73208dfd 2381qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
a8488abe
AV		 2382{
2383 int ret;
963b0fdd 2384 device_reg_t __iomem *reg = ha->iobase;
a8488abe
AV		 2385
2386 /* If possible, enable MSI-X. */
3a03eb79 2387 if (!IS_QLA2432(ha) && !IS_QLA2532(ha) &&
a9083016 2388 !IS_QLA8432(ha) && !IS_QLA8XXX_TYPE(ha))
6377a7ae
BH		 2389 goto skip_msi;
2390
2391 if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
2392 (ha->pdev->subsystem_device == 0x7040 ||
2393 ha->pdev->subsystem_device == 0x7041 ||
2394 ha->pdev->subsystem_device == 0x1705)) {
2395 DEBUG2(qla_printk(KERN_WARNING, ha,
2396 "MSI-X: Unsupported ISP2432 SSVID/SSDID (0x%X,0x%X).\n",
2397 ha->pdev->subsystem_vendor,
2398 ha->pdev->subsystem_device));
2399 goto skip_msi;
2400 }
a8488abe 2401
e315cd28
AC		 2402 if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX ||
2403 !QLA_MSIX_FW_MODE_1(ha->fw_attributes))) {
a8488abe 2404 DEBUG2(qla_printk(KERN_WARNING, ha,
e315cd28
AC		 2405 "MSI-X: Unsupported ISP2432 (0x%X, 0x%X).\n",
2406 ha->pdev->revision, ha->fw_attributes));
a8488abe
AV		 2407 goto skip_msix;
2408 }
2409
73208dfd 2410 ret = qla24xx_enable_msix(ha, rsp);
a8488abe
AV		 2411 if (!ret) {
2412 DEBUG2(qla_printk(KERN_INFO, ha,
2413 "MSI-X: Enabled (0x%X, 0x%X).\n", ha->chip_revision,
2414 ha->fw_attributes));
963b0fdd 2415 goto clear_risc_ints;
a8488abe
AV		 2416 }
2417 qla_printk(KERN_WARNING, ha,
a9083016 2418 "MSI-X: Falling back-to MSI mode -- %d.\n", ret);
a8488abe 2419skip_msix:
cbedb601 2420
3a03eb79
AV		 2421 if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
2422 !IS_QLA8001(ha))
cbedb601
AV		 2423 goto skip_msi;
2424
2425 ret = pci_enable_msi(ha->pdev);
2426 if (!ret) {
2427 DEBUG2(qla_printk(KERN_INFO, ha, "MSI: Enabled.\n"));
2428 ha->flags.msi_enabled = 1;
a9083016
GM		 2429 } else
2430 qla_printk(KERN_WARNING, ha,
2431 "MSI-X: Falling back-to INTa mode -- %d.\n", ret);
cbedb601
AV		 2432skip_msi:
2433
fd34f556 2434 ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
d1b1bef4 2435 IRQF_SHARED, QLA2XXX_DRIVER_NAME, rsp);
963b0fdd 2436 if (ret) {
a8488abe
AV		 2437 qla_printk(KERN_WARNING, ha,
2438 "Failed to reserve interrupt %d already in use.\n",
2439 ha->pdev->irq);
963b0fdd
AV		 2440 goto fail;
2441 }
2442 ha->flags.inta_enabled = 1;
963b0fdd
AV		 2443clear_risc_ints:
2444
3a03eb79
AV		 2445 /*
2446 * FIXME: Noted that 8014s were being dropped during NK testing.
2447 * Timing deltas during MSI-X/INTa transitions?
2448 */
a9083016 2449 if (IS_QLA81XX(ha) || IS_QLA82XX(ha))
3a03eb79 2450 goto fail;
c6952483 2451 spin_lock_irq(&ha->hardware_lock);
963b0fdd
AV		 2452 if (IS_FWI2_CAPABLE(ha)) {
2453 WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_HOST_INT);
2454 WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_RISC_INT);
2455 } else {
2456 WRT_REG_WORD(&reg->isp.semaphore, 0);
2457 WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_RISC_INT);
2458 WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_HOST_INT);
a8488abe 2459 }
c6952483 2460 spin_unlock_irq(&ha->hardware_lock);
a8488abe 2461
963b0fdd 2462fail:
a8488abe
AV		 2463 return ret;
2464}
2465
2466void
e315cd28 2467qla2x00_free_irqs(scsi_qla_host_t *vha)
a8488abe 2468{
e315cd28 2469 struct qla_hw_data *ha = vha->hw;
73208dfd 2470 struct rsp_que *rsp = ha->rsp_q_map[0];
a8488abe
AV		 2471
2472 if (ha->flags.msix_enabled)
2473 qla24xx_disable_msix(ha);
90a86fc0 2474 else if (ha->flags.msi_enabled) {
e315cd28 2475 free_irq(ha->pdev->irq, rsp);
cbedb601 2476 pci_disable_msi(ha->pdev);
90a86fc0
JC		 2477 } else
2478 free_irq(ha->pdev->irq, rsp);
a8488abe 2479}
e315cd28 2480
73208dfd
AC		 2481
2482int qla25xx_request_irq(struct rsp_que *rsp)
2483{
2484 struct qla_hw_data *ha = rsp->hw;
2afa19a9 2485 struct qla_init_msix_entry *intr = &msix_entries[2];
73208dfd
AC		 2486 struct qla_msix_entry *msix = rsp->msix;
2487 int ret;
2488
2489 ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
2490 if (ret) {
2491 qla_printk(KERN_WARNING, ha,
2492 "MSI-X: Unable to register handler -- %x/%d.\n",
2493 msix->vector, ret);
2494 return ret;
2495 }
2496 msix->have_irq = 1;
2497 msix->rsp = rsp;
2498 return ret;
2499}
ubuntu-bionic-kernel mirror