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