projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
qla2xxx: Prevent removal and board_disable race
[linux-2.6-block.git] / drivers / scsi / qla2xxx / qla_isr.c
CommitLineData
1da177e4 1/*
fa90c54f 2 * QLogic Fibre Channel HBA Driver
bd21eaf9 3 * Copyright (c) 2003-2014 QLogic Corporation
1da177e4 4 *
fa90c54f 5 * See LICENSE.qla2xxx for copyright and licensing details.
1da177e4
LT		 6 */
7#include "qla_def.h"
2d70c103 8#include "qla_target.h"
1da177e4 9
05236a05 10#include <linux/delay.h>
5a0e3ad6 11#include <linux/slab.h>
df7baa50 12#include <scsi/scsi_tcq.h>
9a069e19 13#include <scsi/scsi_bsg_fc.h>
bad75002 14#include <scsi/scsi_eh.h>
df7baa50 15
1da177e4 16static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
73208dfd 17static void qla2x00_status_entry(scsi_qla_host_t *, struct rsp_que *, void *);
2afa19a9 18static void qla2x00_status_cont_entry(struct rsp_que *, sts_cont_entry_t *);
73208dfd
AC		 19static void qla2x00_error_entry(scsi_qla_host_t *, struct rsp_que *,
20 sts_entry_t *);
9a853f71 21
1da177e4
LT		 22/**
23 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
24 * @irq:
25 * @dev_id: SCSI driver HA context
1da177e4
LT		 26 *
27 * Called by system whenever the host adapter generates an interrupt.
28 *
29 * Returns handled flag.
30 */
31irqreturn_t
7d12e780 32qla2100_intr_handler(int irq, void *dev_id)
1da177e4 33{
e315cd28
AC		 34 scsi_qla_host_t *vha;
35 struct qla_hw_data *ha;
3d71644c 36 struct device_reg_2xxx __iomem *reg;
1da177e4 37 int status;
1da177e4 38 unsigned long iter;
14e660e6 39 uint16_t hccr;
9a853f71 40 uint16_t mb[4];
e315cd28 41 struct rsp_que *rsp;
43fac4d9 42 unsigned long flags;
1da177e4 43
e315cd28
AC		 44 rsp = (struct rsp_que *) dev_id;
45 if (!rsp) {
3256b435
CD		 46 ql_log(ql_log_info, NULL, 0x505d,
47 "%s: NULL response queue pointer.\n", __func__);
1da177e4
LT		 48 return (IRQ_NONE);
49 }
50
e315cd28 51 ha = rsp->hw;
3d71644c 52 reg = &ha->iobase->isp;
1da177e4
LT		 53 status = 0;
54
43fac4d9 55 spin_lock_irqsave(&ha->hardware_lock, flags);
2afa19a9 56 vha = pci_get_drvdata(ha->pdev);
1da177e4 57 for (iter = 50; iter--; ) {
14e660e6 58 hccr = RD_REG_WORD(&reg->hccr);
c821e0d5 59 if (qla2x00_check_reg16_for_disconnect(vha, hccr))
f3ddac19 60 break;
14e660e6
SJ		 61 if (hccr & HCCR_RISC_PAUSE) {
62 if (pci_channel_offline(ha->pdev))
63 break;
64
65 /*
66 * Issue a "HARD" reset in order for the RISC interrupt
a06a0f8e 67 * bit to be cleared. Schedule a big hammer to get
14e660e6
SJ		 68 * out of the RISC PAUSED state.
69 */
70 WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
71 RD_REG_WORD(&reg->hccr);
72
e315cd28
AC		 73 ha->isp_ops->fw_dump(vha, 1);
74 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
14e660e6
SJ		 75 break;
76 } else if ((RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) == 0)
1da177e4
LT		 77 break;
78
79 if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
80 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
81 RD_REG_WORD(&reg->hccr);
82
83 /* Get mailbox data. */
9a853f71
AV		 84 mb[0] = RD_MAILBOX_REG(ha, reg, 0);
85 if (mb[0] > 0x3fff && mb[0] < 0x8000) {
e315cd28 86 qla2x00_mbx_completion(vha, mb[0]);
1da177e4 87 status |= MBX_INTERRUPT;
9a853f71
AV		 88 } else if (mb[0] > 0x7fff && mb[0] < 0xc000) {
89 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
90 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
91 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
73208dfd 92 qla2x00_async_event(vha, rsp, mb);
1da177e4
LT		 93 } else {
94 /*EMPTY*/
7c3df132
SK		 95 ql_dbg(ql_dbg_async, vha, 0x5025,
96 "Unrecognized interrupt type (%d).\n",
97 mb[0]);
1da177e4
LT		 98 }
99 /* Release mailbox registers. */
100 WRT_REG_WORD(&reg->semaphore, 0);
101 RD_REG_WORD(&reg->semaphore);
102 } else {
73208dfd 103 qla2x00_process_response_queue(rsp);
1da177e4
LT		 104
105 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
106 RD_REG_WORD(&reg->hccr);
107 }
108 }
36439832 109 qla2x00_handle_mbx_completion(ha, status);
43fac4d9 110 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1da177e4 111
1da177e4
LT		 112 return (IRQ_HANDLED);
113}
114
f3ddac19 115bool
c821e0d5 116qla2x00_check_reg32_for_disconnect(scsi_qla_host_t *vha, uint32_t reg)
f3ddac19
CD		 117{
118 /* Check for PCI disconnection */
119 if (reg == 0xffffffff) {
beb9e315
JL		 120 if (!test_and_set_bit(PFLG_DISCONNECTED, &vha->pci_flags) &&
121 !test_bit(PFLG_DRIVER_REMOVING, &vha->pci_flags)) {
232792b6
JL		 122 /*
123 * Schedule this (only once) on the default system
124 * workqueue so that all the adapter workqueues and the
125 * DPC thread can be shutdown cleanly.
126 */
127 schedule_work(&vha->hw->board_disable);
128 }
f3ddac19
CD		 129 return true;
130 } else
131 return false;
132}
133
c821e0d5
JL		 134bool
135qla2x00_check_reg16_for_disconnect(scsi_qla_host_t *vha, uint16_t reg)
136{
137 return qla2x00_check_reg32_for_disconnect(vha, 0xffff0000 | reg);
138}
139
1da177e4
LT		 140/**
141 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
142 * @irq:
143 * @dev_id: SCSI driver HA context
1da177e4
LT		 144 *
145 * Called by system whenever the host adapter generates an interrupt.
146 *
147 * Returns handled flag.
148 */
149irqreturn_t
7d12e780 150qla2300_intr_handler(int irq, void *dev_id)
1da177e4 151{
e315cd28 152 scsi_qla_host_t *vha;
3d71644c 153 struct device_reg_2xxx __iomem *reg;
1da177e4 154 int status;
1da177e4
LT		 155 unsigned long iter;
156 uint32_t stat;
1da177e4 157 uint16_t hccr;
9a853f71 158 uint16_t mb[4];
e315cd28
AC		 159 struct rsp_que *rsp;
160 struct qla_hw_data *ha;
43fac4d9 161 unsigned long flags;
1da177e4 162
e315cd28
AC		 163 rsp = (struct rsp_que *) dev_id;
164 if (!rsp) {
3256b435
CD		 165 ql_log(ql_log_info, NULL, 0x5058,
166 "%s: NULL response queue pointer.\n", __func__);
1da177e4
LT		 167 return (IRQ_NONE);
168 }
169
e315cd28 170 ha = rsp->hw;
3d71644c 171 reg = &ha->iobase->isp;
1da177e4
LT		 172 status = 0;
173
43fac4d9 174 spin_lock_irqsave(&ha->hardware_lock, flags);
2afa19a9 175 vha = pci_get_drvdata(ha->pdev);
1da177e4
LT		 176 for (iter = 50; iter--; ) {
177 stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
c821e0d5 178 if (qla2x00_check_reg32_for_disconnect(vha, stat))
f3ddac19 179 break;
1da177e4 180 if (stat & HSR_RISC_PAUSED) {
85880801 181 if (unlikely(pci_channel_offline(ha->pdev)))
14e660e6
SJ		 182 break;
183
1da177e4 184 hccr = RD_REG_WORD(&reg->hccr);
f3ddac19 185
1da177e4 186 if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
7c3df132
SK		 187 ql_log(ql_log_warn, vha, 0x5026,
188 "Parity error -- HCCR=%x, Dumping "
189 "firmware.\n", hccr);
1da177e4 190 else
7c3df132
SK		 191 ql_log(ql_log_warn, vha, 0x5027,
192 "RISC paused -- HCCR=%x, Dumping "
193 "firmware.\n", hccr);
1da177e4
LT		 194
195 /*
196 * Issue a "HARD" reset in order for the RISC
197 * interrupt bit to be cleared. Schedule a big
a06a0f8e 198 * hammer to get out of the RISC PAUSED state.
1da177e4
LT		 199 */
200 WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
201 RD_REG_WORD(&reg->hccr);
07f31805 202
e315cd28
AC		 203 ha->isp_ops->fw_dump(vha, 1);
204 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 205 break;
206 } else if ((stat & HSR_RISC_INT) == 0)
207 break;
208
1da177e4 209 switch (stat & 0xff) {
1da177e4
LT		 210 case 0x1:
211 case 0x2:
212 case 0x10:
213 case 0x11:
e315cd28 214 qla2x00_mbx_completion(vha, MSW(stat));
1da177e4
LT		 215 status |= MBX_INTERRUPT;
216
217 /* Release mailbox registers. */
218 WRT_REG_WORD(&reg->semaphore, 0);
219 break;
220 case 0x12:
9a853f71
AV		 221 mb[0] = MSW(stat);
222 mb[1] = RD_MAILBOX_REG(ha, reg, 1);
223 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
224 mb[3] = RD_MAILBOX_REG(ha, reg, 3);
73208dfd 225 qla2x00_async_event(vha, rsp, mb);
9a853f71
AV		 226 break;
227 case 0x13:
73208dfd 228 qla2x00_process_response_queue(rsp);
1da177e4
LT		 229 break;
230 case 0x15:
9a853f71
AV		 231 mb[0] = MBA_CMPLT_1_16BIT;
232 mb[1] = MSW(stat);
73208dfd 233 qla2x00_async_event(vha, rsp, mb);
1da177e4
LT		 234 break;
235 case 0x16:
9a853f71
AV		 236 mb[0] = MBA_SCSI_COMPLETION;
237 mb[1] = MSW(stat);
238 mb[2] = RD_MAILBOX_REG(ha, reg, 2);
73208dfd 239 qla2x00_async_event(vha, rsp, mb);
1da177e4
LT		 240 break;
241 default:
7c3df132
SK		 242 ql_dbg(ql_dbg_async, vha, 0x5028,
243 "Unrecognized interrupt type (%d).\n", stat & 0xff);
1da177e4
LT		 244 break;
245 }
246 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
247 RD_REG_WORD_RELAXED(&reg->hccr);
248 }
36439832 249 qla2x00_handle_mbx_completion(ha, status);
43fac4d9 250 spin_unlock_irqrestore(&ha->hardware_lock, flags);
1da177e4 251
1da177e4
LT		 252 return (IRQ_HANDLED);
253}
254
255/**
256 * qla2x00_mbx_completion() - Process mailbox command completions.
257 * @ha: SCSI driver HA context
258 * @mb0: Mailbox0 register
259 */
260static void
e315cd28 261qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
1da177e4
LT		 262{
263 uint16_t cnt;
4fa94f83 264 uint32_t mboxes;
1da177e4 265 uint16_t __iomem *wptr;
e315cd28 266 struct qla_hw_data *ha = vha->hw;
3d71644c 267 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1da177e4 268
4fa94f83
AV		 269 /* Read all mbox registers? */
270 mboxes = (1 << ha->mbx_count) - 1;
271 if (!ha->mcp)
a720101d 272 ql_dbg(ql_dbg_async, vha, 0x5001, "MBX pointer ERROR.\n");
4fa94f83
AV		 273 else
274 mboxes = ha->mcp->in_mb;
275
1da177e4
LT		 276 /* Load return mailbox registers. */
277 ha->flags.mbox_int = 1;
278 ha->mailbox_out[0] = mb0;
4fa94f83 279 mboxes >>= 1;
1da177e4
LT		 280 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);
281
282 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
fa2a1ce5 283 if (IS_QLA2200(ha) && cnt == 8)
1da177e4 284 wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
4fa94f83 285 if ((cnt == 4 || cnt == 5) && (mboxes & BIT_0))
1da177e4 286 ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
4fa94f83 287 else if (mboxes & BIT_0)
1da177e4 288 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
fa2a1ce5 289
1da177e4 290 wptr++;
4fa94f83 291 mboxes >>= 1;
1da177e4 292 }
1da177e4
LT		 293}
294
8a659571
AV		 295static void
296qla81xx_idc_event(scsi_qla_host_t *vha, uint16_t aen, uint16_t descr)
297{
298 static char *event[] =
299 { "Complete", "Request Notification", "Time Extension" };
300 int rval;
301 struct device_reg_24xx __iomem *reg24 = &vha->hw->iobase->isp24;
9e5054ec 302 struct device_reg_82xx __iomem *reg82 = &vha->hw->iobase->isp82;
8a659571
AV		 303 uint16_t __iomem *wptr;
304 uint16_t cnt, timeout, mb[QLA_IDC_ACK_REGS];
305
306 /* Seed data -- mailbox1 -> mailbox7. */
9e5054ec
CD		 307 if (IS_QLA81XX(vha->hw) || IS_QLA83XX(vha->hw))
308 wptr = (uint16_t __iomem *)&reg24->mailbox1;
309 else if (IS_QLA8044(vha->hw))
310 wptr = (uint16_t __iomem *)&reg82->mailbox_out[1];
311 else
312 return;
313
8a659571
AV		 314 for (cnt = 0; cnt < QLA_IDC_ACK_REGS; cnt++, wptr++)
315 mb[cnt] = RD_REG_WORD(wptr);
316
7c3df132 317 ql_dbg(ql_dbg_async, vha, 0x5021,
6246b8a1 318 "Inter-Driver Communication %s -- "
7c3df132
SK		 319 "%04x %04x %04x %04x %04x %04x %04x.\n",
320 event[aen & 0xff], mb[0], mb[1], mb[2], mb[3],
321 mb[4], mb[5], mb[6]);
454073c9
SV		 322 switch (aen) {
323 /* Handle IDC Error completion case. */
324 case MBA_IDC_COMPLETE:
325 if (mb[1] >> 15) {
326 vha->hw->flags.idc_compl_status = 1;
9aaf2cea 327 if (vha->hw->notify_dcbx_comp && !vha->vp_idx)
454073c9
SV		 328 complete(&vha->hw->dcbx_comp);
329 }
330 break;
331
332 case MBA_IDC_NOTIFY:
333 /* Acknowledgement needed? [Notify && non-zero timeout]. */
334 timeout = (descr >> 8) & 0xf;
335 ql_dbg(ql_dbg_async, vha, 0x5022,
336 "%lu Inter-Driver Communication %s -- ACK timeout=%d.\n",
337 vha->host_no, event[aen & 0xff], timeout);
338
339 if (!timeout)
340 return;
341 rval = qla2x00_post_idc_ack_work(vha, mb);
342 if (rval != QLA_SUCCESS)
343 ql_log(ql_log_warn, vha, 0x5023,
344 "IDC failed to post ACK.\n");
345 break;
346 case MBA_IDC_TIME_EXT:
347 vha->hw->idc_extend_tmo = descr;
348 ql_dbg(ql_dbg_async, vha, 0x5087,
349 "%lu Inter-Driver Communication %s -- "
350 "Extend timeout by=%d.\n",
351 vha->host_no, event[aen & 0xff], vha->hw->idc_extend_tmo);
352 break;
bf5b8ad7 353 }
8a659571
AV		 354}
355
daae62a3 356#define LS_UNKNOWN 2
d0297c9a
JC		 357const char *
358qla2x00_get_link_speed_str(struct qla_hw_data *ha, uint16_t speed)
daae62a3 359{
f73cb695
CD		 360 static const char *const link_speeds[] = {
361 "1", "2", "?", "4", "8", "16", "32", "10"
d0297c9a 362 };
f73cb695 363#define QLA_LAST_SPEED 7
daae62a3
CD		 364
365 if (IS_QLA2100(ha) || IS_QLA2200(ha))
d0297c9a
JC		 366 return link_speeds[0];
367 else if (speed == 0x13)
f73cb695
CD		 368 return link_speeds[QLA_LAST_SPEED];
369 else if (speed < QLA_LAST_SPEED)
d0297c9a
JC		 370 return link_speeds[speed];
371 else
372 return link_speeds[LS_UNKNOWN];
daae62a3
CD		 373}
374
fa492630 375static void
7d613ac6
SV		 376qla83xx_handle_8200_aen(scsi_qla_host_t *vha, uint16_t *mb)
377{
378 struct qla_hw_data *ha = vha->hw;
379
380 /*
381 * 8200 AEN Interpretation:
382 * mb[0] = AEN code
383 * mb[1] = AEN Reason code
384 * mb[2] = LSW of Peg-Halt Status-1 Register
385 * mb[6] = MSW of Peg-Halt Status-1 Register
386 * mb[3] = LSW of Peg-Halt Status-2 register
387 * mb[7] = MSW of Peg-Halt Status-2 register
388 * mb[4] = IDC Device-State Register value
389 * mb[5] = IDC Driver-Presence Register value
390 */
391 ql_dbg(ql_dbg_async, vha, 0x506b, "AEN Code: mb[0] = 0x%x AEN reason: "
392 "mb[1] = 0x%x PH-status1: mb[2] = 0x%x PH-status1: mb[6] = 0x%x.\n",
393 mb[0], mb[1], mb[2], mb[6]);
394 ql_dbg(ql_dbg_async, vha, 0x506c, "PH-status2: mb[3] = 0x%x "
395 "PH-status2: mb[7] = 0x%x Device-State: mb[4] = 0x%x "
396 "Drv-Presence: mb[5] = 0x%x.\n", mb[3], mb[7], mb[4], mb[5]);
397
398 if (mb[1] & (IDC_PEG_HALT_STATUS_CHANGE | IDC_NIC_FW_REPORTED_FAILURE |
399 IDC_HEARTBEAT_FAILURE)) {
400 ha->flags.nic_core_hung = 1;
401 ql_log(ql_log_warn, vha, 0x5060,
402 "83XX: F/W Error Reported: Check if reset required.\n");
403
404 if (mb[1] & IDC_PEG_HALT_STATUS_CHANGE) {
405 uint32_t protocol_engine_id, fw_err_code, err_level;
406
407 /*
408 * IDC_PEG_HALT_STATUS_CHANGE interpretation:
409 * - PEG-Halt Status-1 Register:
410 * (LSW = mb[2], MSW = mb[6])
411 * Bits 0-7 = protocol-engine ID
412 * Bits 8-28 = f/w error code
413 * Bits 29-31 = Error-level
414 * Error-level 0x1 = Non-Fatal error
415 * Error-level 0x2 = Recoverable Fatal error
416 * Error-level 0x4 = UnRecoverable Fatal error
417 * - PEG-Halt Status-2 Register:
418 * (LSW = mb[3], MSW = mb[7])
419 */
420 protocol_engine_id = (mb[2] & 0xff);
421 fw_err_code = (((mb[2] & 0xff00) >> 8) |
422 ((mb[6] & 0x1fff) << 8));
423 err_level = ((mb[6] & 0xe000) >> 13);
424 ql_log(ql_log_warn, vha, 0x5061, "PegHalt Status-1 "
425 "Register: protocol_engine_id=0x%x "
426 "fw_err_code=0x%x err_level=0x%x.\n",
427 protocol_engine_id, fw_err_code, err_level);
428 ql_log(ql_log_warn, vha, 0x5062, "PegHalt Status-2 "
429 "Register: 0x%x%x.\n", mb[7], mb[3]);
430 if (err_level == ERR_LEVEL_NON_FATAL) {
431 ql_log(ql_log_warn, vha, 0x5063,
432 "Not a fatal error, f/w has recovered "
433 "iteself.\n");
434 } else if (err_level == ERR_LEVEL_RECOVERABLE_FATAL) {
435 ql_log(ql_log_fatal, vha, 0x5064,
436 "Recoverable Fatal error: Chip reset "
437 "required.\n");
438 qla83xx_schedule_work(vha,
439 QLA83XX_NIC_CORE_RESET);
440 } else if (err_level == ERR_LEVEL_UNRECOVERABLE_FATAL) {
441 ql_log(ql_log_fatal, vha, 0x5065,
442 "Unrecoverable Fatal error: Set FAILED "
443 "state, reboot required.\n");
444 qla83xx_schedule_work(vha,
445 QLA83XX_NIC_CORE_UNRECOVERABLE);
446 }
447 }
448
449 if (mb[1] & IDC_NIC_FW_REPORTED_FAILURE) {
450 uint16_t peg_fw_state, nw_interface_link_up;
451 uint16_t nw_interface_signal_detect, sfp_status;
452 uint16_t htbt_counter, htbt_monitor_enable;
453 uint16_t sfp_additonal_info, sfp_multirate;
454 uint16_t sfp_tx_fault, link_speed, dcbx_status;
455
456 /*
457 * IDC_NIC_FW_REPORTED_FAILURE interpretation:
458 * - PEG-to-FC Status Register:
459 * (LSW = mb[2], MSW = mb[6])
460 * Bits 0-7 = Peg-Firmware state
461 * Bit 8 = N/W Interface Link-up
462 * Bit 9 = N/W Interface signal detected
463 * Bits 10-11 = SFP Status
464 * SFP Status 0x0 = SFP+ transceiver not expected
465 * SFP Status 0x1 = SFP+ transceiver not present
466 * SFP Status 0x2 = SFP+ transceiver invalid
467 * SFP Status 0x3 = SFP+ transceiver present and
468 * valid
469 * Bits 12-14 = Heartbeat Counter
470 * Bit 15 = Heartbeat Monitor Enable
471 * Bits 16-17 = SFP Additional Info
472 * SFP info 0x0 = Unregocnized transceiver for
473 * Ethernet
474 * SFP info 0x1 = SFP+ brand validation failed
475 * SFP info 0x2 = SFP+ speed validation failed
476 * SFP info 0x3 = SFP+ access error
477 * Bit 18 = SFP Multirate
478 * Bit 19 = SFP Tx Fault
479 * Bits 20-22 = Link Speed
480 * Bits 23-27 = Reserved
481 * Bits 28-30 = DCBX Status
482 * DCBX Status 0x0 = DCBX Disabled
483 * DCBX Status 0x1 = DCBX Enabled
484 * DCBX Status 0x2 = DCBX Exchange error
485 * Bit 31 = Reserved
486 */
487 peg_fw_state = (mb[2] & 0x00ff);
488 nw_interface_link_up = ((mb[2] & 0x0100) >> 8);
489 nw_interface_signal_detect = ((mb[2] & 0x0200) >> 9);
490 sfp_status = ((mb[2] & 0x0c00) >> 10);
491 htbt_counter = ((mb[2] & 0x7000) >> 12);
492 htbt_monitor_enable = ((mb[2] & 0x8000) >> 15);
493 sfp_additonal_info = (mb[6] & 0x0003);
494 sfp_multirate = ((mb[6] & 0x0004) >> 2);
495 sfp_tx_fault = ((mb[6] & 0x0008) >> 3);
496 link_speed = ((mb[6] & 0x0070) >> 4);
497 dcbx_status = ((mb[6] & 0x7000) >> 12);
498
499 ql_log(ql_log_warn, vha, 0x5066,
500 "Peg-to-Fc Status Register:\n"
501 "peg_fw_state=0x%x, nw_interface_link_up=0x%x, "
502 "nw_interface_signal_detect=0x%x"
503 "\nsfp_statis=0x%x.\n ", peg_fw_state,
504 nw_interface_link_up, nw_interface_signal_detect,
505 sfp_status);
506 ql_log(ql_log_warn, vha, 0x5067,
507 "htbt_counter=0x%x, htbt_monitor_enable=0x%x, "
508 "sfp_additonal_info=0x%x, sfp_multirate=0x%x.\n ",
509 htbt_counter, htbt_monitor_enable,
510 sfp_additonal_info, sfp_multirate);
511 ql_log(ql_log_warn, vha, 0x5068,
512 "sfp_tx_fault=0x%x, link_state=0x%x, "
513 "dcbx_status=0x%x.\n", sfp_tx_fault, link_speed,
514 dcbx_status);
515
516 qla83xx_schedule_work(vha, QLA83XX_NIC_CORE_RESET);
517 }
518
519 if (mb[1] & IDC_HEARTBEAT_FAILURE) {
520 ql_log(ql_log_warn, vha, 0x5069,
521 "Heartbeat Failure encountered, chip reset "
522 "required.\n");
523
524 qla83xx_schedule_work(vha, QLA83XX_NIC_CORE_RESET);
525 }
526 }
527
528 if (mb[1] & IDC_DEVICE_STATE_CHANGE) {
529 ql_log(ql_log_info, vha, 0x506a,
530 "IDC Device-State changed = 0x%x.\n", mb[4]);
6c3943cd
SK		 531 if (ha->flags.nic_core_reset_owner)
532 return;
7d613ac6
SV		 533 qla83xx_schedule_work(vha, MBA_IDC_AEN);
534 }
535}
536
bb4cf5b7
CD		 537int
538qla2x00_is_a_vp_did(scsi_qla_host_t *vha, uint32_t rscn_entry)
539{
540 struct qla_hw_data *ha = vha->hw;
541 scsi_qla_host_t *vp;
542 uint32_t vp_did;
543 unsigned long flags;
544 int ret = 0;
545
546 if (!ha->num_vhosts)
547 return ret;
548
549 spin_lock_irqsave(&ha->vport_slock, flags);
550 list_for_each_entry(vp, &ha->vp_list, list) {
551 vp_did = vp->d_id.b24;
552 if (vp_did == rscn_entry) {
553 ret = 1;
554 break;
555 }
556 }
557 spin_unlock_irqrestore(&ha->vport_slock, flags);
558
559 return ret;
560}
561
1da177e4
LT		 562/**
563 * qla2x00_async_event() - Process aynchronous events.
564 * @ha: SCSI driver HA context
9a853f71 565 * @mb: Mailbox registers (0 - 3)
1da177e4 566 */
2c3dfe3f 567void
73208dfd 568qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
1da177e4 569{
1da177e4 570 uint16_t handle_cnt;
bdab23da 571 uint16_t cnt, mbx;
1da177e4 572 uint32_t handles[5];
e315cd28 573 struct qla_hw_data *ha = vha->hw;
3d71644c 574 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
bdab23da 575 struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
bc5c2aad 576 struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
1da177e4 577 uint32_t rscn_entry, host_pid;
4d4df193 578 unsigned long flags;
1da177e4
LT		 579
580 /* Setup to process RIO completion. */
581 handle_cnt = 0;
6246b8a1 582 if (IS_CNA_CAPABLE(ha))
3a03eb79 583 goto skip_rio;
1da177e4
LT		 584 switch (mb[0]) {
585 case MBA_SCSI_COMPLETION:
9a853f71 586 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
1da177e4
LT		 587 handle_cnt = 1;
588 break;
589 case MBA_CMPLT_1_16BIT:
9a853f71 590 handles[0] = mb[1];
1da177e4
LT		 591 handle_cnt = 1;
592 mb[0] = MBA_SCSI_COMPLETION;
593 break;
594 case MBA_CMPLT_2_16BIT:
9a853f71
AV		 595 handles[0] = mb[1];
596 handles[1] = mb[2];
1da177e4
LT		 597 handle_cnt = 2;
598 mb[0] = MBA_SCSI_COMPLETION;
599 break;
600 case MBA_CMPLT_3_16BIT:
9a853f71
AV		 601 handles[0] = mb[1];
602 handles[1] = mb[2];
603 handles[2] = mb[3];
1da177e4
LT		 604 handle_cnt = 3;
605 mb[0] = MBA_SCSI_COMPLETION;
606 break;
607 case MBA_CMPLT_4_16BIT:
9a853f71
AV		 608 handles[0] = mb[1];
609 handles[1] = mb[2];
610 handles[2] = mb[3];
1da177e4
LT		 611 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
612 handle_cnt = 4;
613 mb[0] = MBA_SCSI_COMPLETION;
614 break;
615 case MBA_CMPLT_5_16BIT:
9a853f71
AV		 616 handles[0] = mb[1];
617 handles[1] = mb[2];
618 handles[2] = mb[3];
1da177e4
LT		 619 handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
620 handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
621 handle_cnt = 5;
622 mb[0] = MBA_SCSI_COMPLETION;
623 break;
624 case MBA_CMPLT_2_32BIT:
9a853f71 625 handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
1da177e4
LT		 626 handles[1] = le32_to_cpu(
627 ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) |
628 RD_MAILBOX_REG(ha, reg, 6));
629 handle_cnt = 2;
630 mb[0] = MBA_SCSI_COMPLETION;
631 break;
632 default:
633 break;
634 }
3a03eb79 635skip_rio:
1da177e4
LT		 636 switch (mb[0]) {
637 case MBA_SCSI_COMPLETION: /* Fast Post */
e315cd28 638 if (!vha->flags.online)
1da177e4
LT		 639 break;
640
641 for (cnt = 0; cnt < handle_cnt; cnt++)
73208dfd
AC		 642 qla2x00_process_completed_request(vha, rsp->req,
643 handles[cnt]);
1da177e4
LT		 644 break;
645
646 case MBA_RESET: /* Reset */
7c3df132
SK		 647 ql_dbg(ql_dbg_async, vha, 0x5002,
648 "Asynchronous RESET.\n");
1da177e4 649
e315cd28 650 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
1da177e4
LT		 651 break;
652
653 case MBA_SYSTEM_ERR: /* System Error */
f73cb695 654 mbx = (IS_QLA81XX(ha) || IS_QLA83XX(ha) || IS_QLA27XX(ha)) ?
6246b8a1 655 RD_REG_WORD(&reg24->mailbox7) : 0;
7c3df132 656 ql_log(ql_log_warn, vha, 0x5003,
bdab23da
AV		 657 "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh "
658 "mbx7=%xh.\n", mb[1], mb[2], mb[3], mbx);
1da177e4 659
e315cd28 660 ha->isp_ops->fw_dump(vha, 1);
1da177e4 661
e428924c 662 if (IS_FWI2_CAPABLE(ha)) {
9a853f71 663 if (mb[1] == 0 && mb[2] == 0) {
7c3df132 664 ql_log(ql_log_fatal, vha, 0x5004,
9a853f71
AV		 665 "Unrecoverable Hardware Error: adapter "
666 "marked OFFLINE!\n");
e315cd28 667 vha->flags.online = 0;
6246b8a1 668 vha->device_flags |= DFLG_DEV_FAILED;
b1d46989 669 } else {
25985edc 670 /* Check to see if MPI timeout occurred */
f73cb695 671 if ((mbx & MBX_3) && (ha->port_no == 0))
b1d46989
MI		 672 set_bit(MPI_RESET_NEEDED,
673 &vha->dpc_flags);
674
e315cd28 675 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
b1d46989 676 }
9a853f71 677 } else if (mb[1] == 0) {
7c3df132 678 ql_log(ql_log_fatal, vha, 0x5005,
1da177e4
LT		 679 "Unrecoverable Hardware Error: adapter marked "
680 "OFFLINE!\n");
e315cd28 681 vha->flags.online = 0;
6246b8a1 682 vha->device_flags |= DFLG_DEV_FAILED;
1da177e4 683 } else
e315cd28 684 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 685 break;
686
687 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
7c3df132
SK		 688 ql_log(ql_log_warn, vha, 0x5006,
689 "ISP Request Transfer Error (%x).\n", mb[1]);
1da177e4 690
e315cd28 691 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 692 break;
693
694 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
7c3df132
SK		 695 ql_log(ql_log_warn, vha, 0x5007,
696 "ISP Response Transfer Error.\n");
1da177e4 697
e315cd28 698 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 699 break;
700
701 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
7c3df132
SK		 702 ql_dbg(ql_dbg_async, vha, 0x5008,
703 "Asynchronous WAKEUP_THRES.\n");
1da177e4 704
2d70c103 705 break;
1da177e4 706 case MBA_LIP_OCCURRED: /* Loop Initialization Procedure */
cfb0919c 707 ql_dbg(ql_dbg_async, vha, 0x5009,
7c3df132 708 "LIP occurred (%x).\n", mb[1]);
1da177e4 709
e315cd28
AC		 710 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
711 atomic_set(&vha->loop_state, LOOP_DOWN);
712 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
713 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4
LT		 714 }
715
e315cd28
AC		 716 if (vha->vp_idx) {
717 atomic_set(&vha->vp_state, VP_FAILED);
718 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
2c3dfe3f
SJ		 719 }
720
e315cd28
AC		 721 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
722 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
1da177e4 723
e315cd28
AC		 724 vha->flags.management_server_logged_in = 0;
725 qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
1da177e4
LT		 726 break;
727
728 case MBA_LOOP_UP: /* Loop Up Event */
daae62a3 729 if (IS_QLA2100(ha) || IS_QLA2200(ha))
d8b45213 730 ha->link_data_rate = PORT_SPEED_1GB;
daae62a3 731 else
1da177e4 732 ha->link_data_rate = mb[1];
1da177e4 733
8e5a9484 734 ql_log(ql_log_info, vha, 0x500a,
daae62a3 735 "LOOP UP detected (%s Gbps).\n",
d0297c9a 736 qla2x00_get_link_speed_str(ha, ha->link_data_rate));
1da177e4 737
e315cd28
AC		 738 vha->flags.management_server_logged_in = 0;
739 qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
1da177e4
LT		 740 break;
741
742 case MBA_LOOP_DOWN: /* Loop Down Event */
6246b8a1
GM		 743 mbx = (IS_QLA81XX(ha) || IS_QLA8031(ha))
744 ? RD_REG_WORD(&reg24->mailbox4) : 0;
7ec0effd
AD		 745 mbx = (IS_P3P_TYPE(ha)) ? RD_REG_WORD(&reg82->mailbox_out[4])
746 : mbx;
8e5a9484 747 ql_log(ql_log_info, vha, 0x500b,
7c3df132
SK		 748 "LOOP DOWN detected (%x %x %x %x).\n",
749 mb[1], mb[2], mb[3], mbx);
1da177e4 750
e315cd28
AC		 751 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
752 atomic_set(&vha->loop_state, LOOP_DOWN);
753 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
754 vha->device_flags |= DFLG_NO_CABLE;
755 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4
LT		 756 }
757
e315cd28
AC		 758 if (vha->vp_idx) {
759 atomic_set(&vha->vp_state, VP_FAILED);
760 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
2c3dfe3f
SJ		 761 }
762
e315cd28 763 vha->flags.management_server_logged_in = 0;
d8b45213 764 ha->link_data_rate = PORT_SPEED_UNKNOWN;
e315cd28 765 qla2x00_post_aen_work(vha, FCH_EVT_LINKDOWN, 0);
1da177e4
LT		 766 break;
767
768 case MBA_LIP_RESET: /* LIP reset occurred */
cfb0919c 769 ql_dbg(ql_dbg_async, vha, 0x500c,
cc3ef7bc 770 "LIP reset occurred (%x).\n", mb[1]);
1da177e4 771
e315cd28
AC		 772 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
773 atomic_set(&vha->loop_state, LOOP_DOWN);
774 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
775 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4
LT		 776 }
777
e315cd28
AC		 778 if (vha->vp_idx) {
779 atomic_set(&vha->vp_state, VP_FAILED);
780 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
2c3dfe3f
SJ		 781 }
782
e315cd28 783 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
1da177e4
LT		 784
785 ha->operating_mode = LOOP;
e315cd28
AC		 786 vha->flags.management_server_logged_in = 0;
787 qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
1da177e4
LT		 788 break;
789
3a03eb79 790 /* case MBA_DCBX_COMPLETE: */
1da177e4
LT		 791 case MBA_POINT_TO_POINT: /* Point-to-Point */
792 if (IS_QLA2100(ha))
793 break;
794
7ec0effd 795 if (IS_CNA_CAPABLE(ha)) {
7c3df132
SK		 796 ql_dbg(ql_dbg_async, vha, 0x500d,
797 "DCBX Completed -- %04x %04x %04x.\n",
798 mb[1], mb[2], mb[3]);
9aaf2cea 799 if (ha->notify_dcbx_comp && !vha->vp_idx)
23f2ebd1
SR		 800 complete(&ha->dcbx_comp);
801
802 } else
7c3df132
SK		 803 ql_dbg(ql_dbg_async, vha, 0x500e,
804 "Asynchronous P2P MODE received.\n");
1da177e4
LT		 805
806 /*
807 * Until there's a transition from loop down to loop up, treat
808 * this as loop down only.
809 */
e315cd28
AC		 810 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
811 atomic_set(&vha->loop_state, LOOP_DOWN);
812 if (!atomic_read(&vha->loop_down_timer))
813 atomic_set(&vha->loop_down_timer,
1da177e4 814 LOOP_DOWN_TIME);
e315cd28 815 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4
LT		 816 }
817
e315cd28
AC		 818 if (vha->vp_idx) {
819 atomic_set(&vha->vp_state, VP_FAILED);
820 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
2c3dfe3f
SJ		 821 }
822
e315cd28
AC		 823 if (!(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)))
824 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
825
826 set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
827 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
4346b149
AV		 828
829 ha->flags.gpsc_supported = 1;
e315cd28 830 vha->flags.management_server_logged_in = 0;
1da177e4
LT		 831 break;
832
833 case MBA_CHG_IN_CONNECTION: /* Change in connection mode */
834 if (IS_QLA2100(ha))
835 break;
836
cfb0919c 837 ql_dbg(ql_dbg_async, vha, 0x500f,
1da177e4
LT		 838 "Configuration change detected: value=%x.\n", mb[1]);
839
e315cd28
AC		 840 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
841 atomic_set(&vha->loop_state, LOOP_DOWN);
842 if (!atomic_read(&vha->loop_down_timer))
843 atomic_set(&vha->loop_down_timer,
1da177e4 844 LOOP_DOWN_TIME);
e315cd28 845 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4
LT		 846 }
847
e315cd28
AC		 848 if (vha->vp_idx) {
849 atomic_set(&vha->vp_state, VP_FAILED);
850 fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
2c3dfe3f
SJ		 851 }
852
e315cd28
AC		 853 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
854 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
1da177e4
LT		 855 break;
856
857 case MBA_PORT_UPDATE: /* Port database update */
55903b9d
SV		 858 /*
859 * Handle only global and vn-port update events
860 *
861 * Relevant inputs:
862 * mb[1] = N_Port handle of changed port
863 * OR 0xffff for global event
864 * mb[2] = New login state
865 * 7 = Port logged out
866 * mb[3] = LSB is vp_idx, 0xff = all vps
867 *
868 * Skip processing if:
869 * Event is global, vp_idx is NOT all vps,
870 * vp_idx does not match
871 * Event is not global, vp_idx does not match
872 */
12cec63e
AV		 873 if (IS_QLA2XXX_MIDTYPE(ha) &&
874 ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff) ||
875 (mb[1] != 0xffff)) && vha->vp_idx != (mb[3] & 0xff))
876 break;
73208dfd 877
9764ff88
AV		 878 /* Global event -- port logout or port unavailable. */
879 if (mb[1] == 0xffff && mb[2] == 0x7) {
7c3df132
SK		 880 ql_dbg(ql_dbg_async, vha, 0x5010,
881 "Port unavailable %04x %04x %04x.\n",
882 mb[1], mb[2], mb[3]);
daae62a3
CD		 883 ql_log(ql_log_warn, vha, 0x505e,
884 "Link is offline.\n");
9764ff88
AV		 885
886 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
887 atomic_set(&vha->loop_state, LOOP_DOWN);
888 atomic_set(&vha->loop_down_timer,
889 LOOP_DOWN_TIME);
890 vha->device_flags |= DFLG_NO_CABLE;
891 qla2x00_mark_all_devices_lost(vha, 1);
892 }
893
894 if (vha->vp_idx) {
895 atomic_set(&vha->vp_state, VP_FAILED);
896 fc_vport_set_state(vha->fc_vport,
897 FC_VPORT_FAILED);
faadc5e7 898 qla2x00_mark_all_devices_lost(vha, 1);
9764ff88
AV		 899 }
900
901 vha->flags.management_server_logged_in = 0;
902 ha->link_data_rate = PORT_SPEED_UNKNOWN;
903 break;
904 }
905
1da177e4 906 /*
cc3ef7bc 907 * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
1da177e4
LT		 908 * event etc. earlier indicating loop is down) then process
909 * it. Otherwise ignore it and Wait for RSCN to come in.
910 */
e315cd28 911 atomic_set(&vha->loop_down_timer, 0);
8e5a9484
CD		 912 if (atomic_read(&vha->loop_state) != LOOP_DOWN &&
913 atomic_read(&vha->loop_state) != LOOP_DEAD) {
7c3df132
SK		 914 ql_dbg(ql_dbg_async, vha, 0x5011,
915 "Asynchronous PORT UPDATE ignored %04x/%04x/%04x.\n",
916 mb[1], mb[2], mb[3]);
2d70c103
NB		 917
918 qlt_async_event(mb[0], vha, mb);
1da177e4
LT		 919 break;
920 }
921
7c3df132
SK		 922 ql_dbg(ql_dbg_async, vha, 0x5012,
923 "Port database changed %04x %04x %04x.\n",
924 mb[1], mb[2], mb[3]);
1da177e4
LT		 925
926 /*
927 * Mark all devices as missing so we will login again.
928 */
e315cd28 929 atomic_set(&vha->loop_state, LOOP_UP);
1da177e4 930
e315cd28 931 qla2x00_mark_all_devices_lost(vha, 1);
1da177e4 932
2d70c103
NB		 933 if (vha->vp_idx == 0 && !qla_ini_mode_enabled(vha))
934 set_bit(SCR_PENDING, &vha->dpc_flags);
935
e315cd28
AC		 936 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
937 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
2d70c103
NB		 938
939 qlt_async_event(mb[0], vha, mb);
1da177e4
LT		 940 break;
941
942 case MBA_RSCN_UPDATE: /* State Change Registration */
3c397400 943 /* Check if the Vport has issued a SCR */
e315cd28 944 if (vha->vp_idx && test_bit(VP_SCR_NEEDED, &vha->vp_flags))
3c397400
SJ		 945 break;
946 /* Only handle SCNs for our Vport index. */
0d6e61bc 947 if (ha->flags.npiv_supported && vha->vp_idx != (mb[3] & 0xff))
3c397400 948 break;
0d6e61bc 949
7c3df132
SK		 950 ql_dbg(ql_dbg_async, vha, 0x5013,
951 "RSCN database changed -- %04x %04x %04x.\n",
952 mb[1], mb[2], mb[3]);
1da177e4 953
59d72d87 954 rscn_entry = ((mb[1] & 0xff) << 16) | mb[2];
e315cd28
AC		 955 host_pid = (vha->d_id.b.domain << 16) | (vha->d_id.b.area << 8)
956 | vha->d_id.b.al_pa;
1da177e4 957 if (rscn_entry == host_pid) {
7c3df132
SK		 958 ql_dbg(ql_dbg_async, vha, 0x5014,
959 "Ignoring RSCN update to local host "
960 "port ID (%06x).\n", host_pid);
1da177e4
LT		 961 break;
962 }
963
59d72d87
RA		 964 /* Ignore reserved bits from RSCN-payload. */
965 rscn_entry = ((mb[1] & 0x3ff) << 16) | mb[2];
1da177e4 966
bb4cf5b7
CD		 967 /* Skip RSCNs for virtual ports on the same physical port */
968 if (qla2x00_is_a_vp_did(vha, rscn_entry))
969 break;
970
e315cd28
AC		 971 atomic_set(&vha->loop_down_timer, 0);
972 vha->flags.management_server_logged_in = 0;
1da177e4 973
e315cd28
AC		 974 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
975 set_bit(RSCN_UPDATE, &vha->dpc_flags);
976 qla2x00_post_aen_work(vha, FCH_EVT_RSCN, rscn_entry);
1da177e4
LT		 977 break;
978
979 /* case MBA_RIO_RESPONSE: */
980 case MBA_ZIO_RESPONSE:
7c3df132
SK		 981 ql_dbg(ql_dbg_async, vha, 0x5015,
982 "[R|Z]IO update completion.\n");
1da177e4 983
e428924c 984 if (IS_FWI2_CAPABLE(ha))
2afa19a9 985 qla24xx_process_response_queue(vha, rsp);
4fdfefe5 986 else
73208dfd 987 qla2x00_process_response_queue(rsp);
1da177e4 988 break;
9a853f71
AV		 989
990 case MBA_DISCARD_RND_FRAME:
7c3df132
SK		 991 ql_dbg(ql_dbg_async, vha, 0x5016,
992 "Discard RND Frame -- %04x %04x %04x.\n",
993 mb[1], mb[2], mb[3]);
9a853f71 994 break;
45ebeb56
AV		 995
996 case MBA_TRACE_NOTIFICATION:
7c3df132
SK		 997 ql_dbg(ql_dbg_async, vha, 0x5017,
998 "Trace Notification -- %04x %04x.\n", mb[1], mb[2]);
45ebeb56 999 break;
4d4df193
HK		 1000
1001 case MBA_ISP84XX_ALERT:
7c3df132
SK		 1002 ql_dbg(ql_dbg_async, vha, 0x5018,
1003 "ISP84XX Alert Notification -- %04x %04x %04x.\n",
1004 mb[1], mb[2], mb[3]);
4d4df193
HK		 1005
1006 spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
1007 switch (mb[1]) {
1008 case A84_PANIC_RECOVERY:
7c3df132
SK		 1009 ql_log(ql_log_info, vha, 0x5019,
1010 "Alert 84XX: panic recovery %04x %04x.\n",
1011 mb[2], mb[3]);
4d4df193
HK		 1012 break;
1013 case A84_OP_LOGIN_COMPLETE:
1014 ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
7c3df132
SK		 1015 ql_log(ql_log_info, vha, 0x501a,
1016 "Alert 84XX: firmware version %x.\n",
1017 ha->cs84xx->op_fw_version);
4d4df193
HK		 1018 break;
1019 case A84_DIAG_LOGIN_COMPLETE:
1020 ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
7c3df132
SK		 1021 ql_log(ql_log_info, vha, 0x501b,
1022 "Alert 84XX: diagnostic firmware version %x.\n",
1023 ha->cs84xx->diag_fw_version);
4d4df193
HK		 1024 break;
1025 case A84_GOLD_LOGIN_COMPLETE:
1026 ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
1027 ha->cs84xx->fw_update = 1;
7c3df132
SK		 1028 ql_log(ql_log_info, vha, 0x501c,
1029 "Alert 84XX: gold firmware version %x.\n",
1030 ha->cs84xx->gold_fw_version);
4d4df193
HK		 1031 break;
1032 default:
7c3df132
SK		 1033 ql_log(ql_log_warn, vha, 0x501d,
1034 "Alert 84xx: Invalid Alert %04x %04x %04x.\n",
4d4df193
HK		 1035 mb[1], mb[2], mb[3]);
1036 }
1037 spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
1038 break;
3a03eb79 1039 case MBA_DCBX_START:
7c3df132
SK		 1040 ql_dbg(ql_dbg_async, vha, 0x501e,
1041 "DCBX Started -- %04x %04x %04x.\n",
1042 mb[1], mb[2], mb[3]);
3a03eb79
AV		 1043 break;
1044 case MBA_DCBX_PARAM_UPDATE:
7c3df132
SK		 1045 ql_dbg(ql_dbg_async, vha, 0x501f,
1046 "DCBX Parameters Updated -- %04x %04x %04x.\n",
1047 mb[1], mb[2], mb[3]);
3a03eb79
AV		 1048 break;
1049 case MBA_FCF_CONF_ERR:
7c3df132
SK		 1050 ql_dbg(ql_dbg_async, vha, 0x5020,
1051 "FCF Configuration Error -- %04x %04x %04x.\n",
1052 mb[1], mb[2], mb[3]);
3a03eb79 1053 break;
3a03eb79 1054 case MBA_IDC_NOTIFY:
7ec0effd 1055 if (IS_QLA8031(vha->hw) || IS_QLA8044(ha)) {
67b2a31f
CD		 1056 mb[4] = RD_REG_WORD(&reg24->mailbox4);
1057 if (((mb[2] & 0x7fff) == MBC_PORT_RESET ||
1058 (mb[2] & 0x7fff) == MBC_SET_PORT_CONFIG) &&
1059 (mb[4] & INTERNAL_LOOPBACK_MASK) != 0) {
8fcd6b8b 1060 set_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags);
67b2a31f
CD		 1061 /*
1062 * Extend loop down timer since port is active.
1063 */
1064 if (atomic_read(&vha->loop_state) == LOOP_DOWN)
1065 atomic_set(&vha->loop_down_timer,
1066 LOOP_DOWN_TIME);
8fcd6b8b
CD		 1067 qla2xxx_wake_dpc(vha);
1068 }
67b2a31f 1069 }
8fcd6b8b 1070 case MBA_IDC_COMPLETE:
9aaf2cea 1071 if (ha->notify_lb_portup_comp && !vha->vp_idx)
f356bef1
CD		 1072 complete(&ha->lb_portup_comp);
1073 /* Fallthru */
3a03eb79 1074 case MBA_IDC_TIME_EXT:
7ec0effd
AD		 1075 if (IS_QLA81XX(vha->hw) || IS_QLA8031(vha->hw) ||
1076 IS_QLA8044(ha))
7d613ac6
SV		 1077 qla81xx_idc_event(vha, mb[0], mb[1]);
1078 break;
1079
1080 case MBA_IDC_AEN:
1081 mb[4] = RD_REG_WORD(&reg24->mailbox4);
1082 mb[5] = RD_REG_WORD(&reg24->mailbox5);
1083 mb[6] = RD_REG_WORD(&reg24->mailbox6);
1084 mb[7] = RD_REG_WORD(&reg24->mailbox7);
1085 qla83xx_handle_8200_aen(vha, mb);
3a03eb79 1086 break;
7d613ac6 1087
6246b8a1
GM		 1088 default:
1089 ql_dbg(ql_dbg_async, vha, 0x5057,
1090 "Unknown AEN:%04x %04x %04x %04x\n",
1091 mb[0], mb[1], mb[2], mb[3]);
1da177e4 1092 }
2c3dfe3f 1093
2d70c103
NB		 1094 qlt_async_event(mb[0], vha, mb);
1095
e315cd28 1096 if (!vha->vp_idx && ha->num_vhosts)
73208dfd 1097 qla2x00_alert_all_vps(rsp, mb);
1da177e4
LT		 1098}
1099
1100/**
1101 * qla2x00_process_completed_request() - Process a Fast Post response.
1102 * @ha: SCSI driver HA context
1103 * @index: SRB index
1104 */
8ae6d9c7 1105void
73208dfd 1106qla2x00_process_completed_request(struct scsi_qla_host *vha,
8ae6d9c7 1107 struct req_que *req, uint32_t index)
1da177e4
LT		 1108{
1109 srb_t *sp;
e315cd28 1110 struct qla_hw_data *ha = vha->hw;
1da177e4
LT		 1111
1112 /* Validate handle. */
8d93f550 1113 if (index >= req->num_outstanding_cmds) {
7c3df132
SK		 1114 ql_log(ql_log_warn, vha, 0x3014,
1115 "Invalid SCSI command index (%x).\n", index);
1da177e4 1116
7ec0effd 1117 if (IS_P3P_TYPE(ha))
8f7daead
GM		 1118 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
1119 else
1120 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 1121 return;
1122 }
1123
e315cd28 1124 sp = req->outstanding_cmds[index];
1da177e4
LT		 1125 if (sp) {
1126 /* Free outstanding command slot. */
e315cd28 1127 req->outstanding_cmds[index] = NULL;
1da177e4 1128
1da177e4 1129 /* Save ISP completion status */
9ba56b95 1130 sp->done(ha, sp, DID_OK << 16);
1da177e4 1131 } else {
7c3df132 1132 ql_log(ql_log_warn, vha, 0x3016, "Invalid SCSI SRB.\n");
1da177e4 1133
7ec0effd 1134 if (IS_P3P_TYPE(ha))
8f7daead
GM		 1135 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
1136 else
1137 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1da177e4
LT		 1138 }
1139}
1140
8ae6d9c7 1141srb_t *
ac280b67
AV		 1142qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
1143 struct req_que *req, void *iocb)
1144{
1145 struct qla_hw_data *ha = vha->hw;
1146 sts_entry_t *pkt = iocb;
1147 srb_t *sp = NULL;
1148 uint16_t index;
1149
1150 index = LSW(pkt->handle);
8d93f550 1151 if (index >= req->num_outstanding_cmds) {
7c3df132
SK		 1152 ql_log(ql_log_warn, vha, 0x5031,
1153 "Invalid command index (%x).\n", index);
7ec0effd 1154 if (IS_P3P_TYPE(ha))
8f7daead
GM		 1155 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
1156 else
1157 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
ac280b67
AV		 1158 goto done;
1159 }
1160 sp = req->outstanding_cmds[index];
1161 if (!sp) {
7c3df132
SK		 1162 ql_log(ql_log_warn, vha, 0x5032,
1163 "Invalid completion handle (%x) -- timed-out.\n", index);
ac280b67
AV		 1164 return sp;
1165 }
1166 if (sp->handle != index) {
7c3df132
SK		 1167 ql_log(ql_log_warn, vha, 0x5033,
1168 "SRB handle (%x) mismatch %x.\n", sp->handle, index);
ac280b67
AV		 1169 return NULL;
1170 }
9a069e19 1171
ac280b67 1172 req->outstanding_cmds[index] = NULL;
9a069e19 1173
ac280b67
AV		 1174done:
1175 return sp;
1176}
1177
1178static void
1179qla2x00_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
1180 struct mbx_entry *mbx)
1181{
1182 const char func[] = "MBX-IOCB";
1183 const char *type;
ac280b67
AV		 1184 fc_port_t *fcport;
1185 srb_t *sp;
4916392b 1186 struct srb_iocb *lio;
99b0bec7 1187 uint16_t *data;
5ff1d584 1188 uint16_t status;
ac280b67
AV		 1189
1190 sp = qla2x00_get_sp_from_handle(vha, func, req, mbx);
1191 if (!sp)
1192 return;
1193
9ba56b95
GM		 1194 lio = &sp->u.iocb_cmd;
1195 type = sp->name;
ac280b67 1196 fcport = sp->fcport;
4916392b 1197 data = lio->u.logio.data;
ac280b67 1198
5ff1d584 1199 data[0] = MBS_COMMAND_ERROR;
4916392b 1200 data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
5ff1d584 1201 QLA_LOGIO_LOGIN_RETRIED : 0;
ac280b67 1202 if (mbx->entry_status) {
7c3df132 1203 ql_dbg(ql_dbg_async, vha, 0x5043,
cfb0919c 1204 "Async-%s error entry - hdl=%x portid=%02x%02x%02x "
d3fa9e7d 1205 "entry-status=%x status=%x state-flag=%x "
cfb0919c
CD		 1206 "status-flags=%x.\n", type, sp->handle,
1207 fcport->d_id.b.domain, fcport->d_id.b.area,
d3fa9e7d
AV		 1208 fcport->d_id.b.al_pa, mbx->entry_status,
1209 le16_to_cpu(mbx->status), le16_to_cpu(mbx->state_flags),
7c3df132 1210 le16_to_cpu(mbx->status_flags));
d3fa9e7d 1211
cfb0919c 1212 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5029,
7c3df132 1213 (uint8_t *)mbx, sizeof(*mbx));
ac280b67 1214
99b0bec7 1215 goto logio_done;
ac280b67
AV		 1216 }
1217
5ff1d584 1218 status = le16_to_cpu(mbx->status);
9ba56b95 1219 if (status == 0x30 && sp->type == SRB_LOGIN_CMD &&
5ff1d584
AV		 1220 le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
1221 status = 0;
1222 if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
7c3df132 1223 ql_dbg(ql_dbg_async, vha, 0x5045,
cfb0919c
CD		 1224 "Async-%s complete - hdl=%x portid=%02x%02x%02x mbx1=%x.\n",
1225 type, sp->handle, fcport->d_id.b.domain,
1226 fcport->d_id.b.area, fcport->d_id.b.al_pa,
1227 le16_to_cpu(mbx->mb1));
ac280b67
AV		 1228
1229 data[0] = MBS_COMMAND_COMPLETE;
9ba56b95 1230 if (sp->type == SRB_LOGIN_CMD) {
99b0bec7
AV		 1231 fcport->port_type = FCT_TARGET;
1232 if (le16_to_cpu(mbx->mb1) & BIT_0)
1233 fcport->port_type = FCT_INITIATOR;
6ac52608 1234 else if (le16_to_cpu(mbx->mb1) & BIT_1)
99b0bec7 1235 fcport->flags |= FCF_FCP2_DEVICE;
5ff1d584 1236 }
99b0bec7 1237 goto logio_done;
ac280b67
AV		 1238 }
1239
1240 data[0] = le16_to_cpu(mbx->mb0);
1241 switch (data[0]) {
1242 case MBS_PORT_ID_USED:
1243 data[1] = le16_to_cpu(mbx->mb1);
1244 break;
1245 case MBS_LOOP_ID_USED:
1246 break;
1247 default:
1248 data[0] = MBS_COMMAND_ERROR;
ac280b67
AV		 1249 break;
1250 }
1251
7c3df132 1252 ql_log(ql_log_warn, vha, 0x5046,
cfb0919c
CD		 1253 "Async-%s failed - hdl=%x portid=%02x%02x%02x status=%x "
1254 "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n", type, sp->handle,
1255 fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa,
1256 status, le16_to_cpu(mbx->mb0), le16_to_cpu(mbx->mb1),
ac280b67 1257 le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
7c3df132 1258 le16_to_cpu(mbx->mb7));
ac280b67 1259
99b0bec7 1260logio_done:
9ba56b95 1261 sp->done(vha, sp, 0);
ac280b67
AV		 1262}
1263
9bc4f4fb
HZ		 1264static void
1265qla2x00_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
1266 sts_entry_t *pkt, int iocb_type)
1267{
1268 const char func[] = "CT_IOCB";
1269 const char *type;
9bc4f4fb 1270 srb_t *sp;
9bc4f4fb
HZ		 1271 struct fc_bsg_job *bsg_job;
1272 uint16_t comp_status;
9ba56b95 1273 int res;
9bc4f4fb
HZ		 1274
1275 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
1276 if (!sp)
1277 return;
1278
9ba56b95 1279 bsg_job = sp->u.bsg_job;
9bc4f4fb 1280
9ba56b95 1281 type = "ct pass-through";
9bc4f4fb
HZ		 1282
1283 comp_status = le16_to_cpu(pkt->comp_status);
1284
1285 /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
1286 * fc payload to the caller
1287 */
1288 bsg_job->reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
1289 bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1290
1291 if (comp_status != CS_COMPLETE) {
1292 if (comp_status == CS_DATA_UNDERRUN) {
9ba56b95 1293 res = DID_OK << 16;
9bc4f4fb
HZ		 1294 bsg_job->reply->reply_payload_rcv_len =
1295 le16_to_cpu(((sts_entry_t *)pkt)->rsp_info_len);
1296
7c3df132
SK		 1297 ql_log(ql_log_warn, vha, 0x5048,
1298 "CT pass-through-%s error "
9bc4f4fb 1299 "comp_status-status=0x%x total_byte = 0x%x.\n",
7c3df132
SK		 1300 type, comp_status,
1301 bsg_job->reply->reply_payload_rcv_len);
9bc4f4fb 1302 } else {
7c3df132
SK		 1303 ql_log(ql_log_warn, vha, 0x5049,
1304 "CT pass-through-%s error "
1305 "comp_status-status=0x%x.\n", type, comp_status);
9ba56b95 1306 res = DID_ERROR << 16;
9bc4f4fb
HZ		 1307 bsg_job->reply->reply_payload_rcv_len = 0;
1308 }
cfb0919c 1309 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5035,
7c3df132 1310 (uint8_t *)pkt, sizeof(*pkt));
9bc4f4fb 1311 } else {
9ba56b95 1312 res = DID_OK << 16;
9bc4f4fb
HZ		 1313 bsg_job->reply->reply_payload_rcv_len =
1314 bsg_job->reply_payload.payload_len;
1315 bsg_job->reply_len = 0;
1316 }
1317
9ba56b95 1318 sp->done(vha, sp, res);
9bc4f4fb
HZ		 1319}
1320
9a069e19
GM		 1321static void
1322qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
1323 struct sts_entry_24xx *pkt, int iocb_type)
1324{
1325 const char func[] = "ELS_CT_IOCB";
1326 const char *type;
9a069e19 1327 srb_t *sp;
9a069e19
GM		 1328 struct fc_bsg_job *bsg_job;
1329 uint16_t comp_status;
1330 uint32_t fw_status[3];
1331 uint8_t* fw_sts_ptr;
9ba56b95 1332 int res;
9a069e19
GM		 1333
1334 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
1335 if (!sp)
1336 return;
9ba56b95 1337 bsg_job = sp->u.bsg_job;
9a069e19
GM		 1338
1339 type = NULL;
9ba56b95 1340 switch (sp->type) {
9a069e19
GM		 1341 case SRB_ELS_CMD_RPT:
1342 case SRB_ELS_CMD_HST:
1343 type = "els";
1344 break;
1345 case SRB_CT_CMD:
1346 type = "ct pass-through";
1347 break;
1348 default:
37fed3ee 1349 ql_dbg(ql_dbg_user, vha, 0x503e,
9ba56b95 1350 "Unrecognized SRB: (%p) type=%d.\n", sp, sp->type);
9a069e19
GM		 1351 return;
1352 }
1353
1354 comp_status = fw_status[0] = le16_to_cpu(pkt->comp_status);
1355 fw_status[1] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1);
1356 fw_status[2] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2);
1357
1358 /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
1359 * fc payload to the caller
1360 */
1361 bsg_job->reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
1362 bsg_job->reply_len = sizeof(struct fc_bsg_reply) + sizeof(fw_status);
1363
1364 if (comp_status != CS_COMPLETE) {
1365 if (comp_status == CS_DATA_UNDERRUN) {
9ba56b95 1366 res = DID_OK << 16;
9a069e19 1367 bsg_job->reply->reply_payload_rcv_len =
9ba56b95 1368 le16_to_cpu(((struct els_sts_entry_24xx *)pkt)->total_byte_count);
9a069e19 1369
37fed3ee 1370 ql_dbg(ql_dbg_user, vha, 0x503f,
cfb0919c 1371 "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
9a069e19 1372 "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
cfb0919c 1373 type, sp->handle, comp_status, fw_status[1], fw_status[2],
7c3df132
SK		 1374 le16_to_cpu(((struct els_sts_entry_24xx *)
1375 pkt)->total_byte_count));
9a069e19
GM		 1376 fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
1377 memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
1378 }
1379 else {
37fed3ee 1380 ql_dbg(ql_dbg_user, vha, 0x5040,
cfb0919c 1381 "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
9a069e19 1382 "error subcode 1=0x%x error subcode 2=0x%x.\n",
cfb0919c 1383 type, sp->handle, comp_status,
7c3df132
SK		 1384 le16_to_cpu(((struct els_sts_entry_24xx *)
1385 pkt)->error_subcode_1),
1386 le16_to_cpu(((struct els_sts_entry_24xx *)
1387 pkt)->error_subcode_2));
9ba56b95 1388 res = DID_ERROR << 16;
9a069e19
GM		 1389 bsg_job->reply->reply_payload_rcv_len = 0;
1390 fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
1391 memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
1392 }
37fed3ee 1393 ql_dump_buffer(ql_dbg_user + ql_dbg_buffer, vha, 0x5056,
7c3df132 1394 (uint8_t *)pkt, sizeof(*pkt));
9a069e19
GM		 1395 }
1396 else {
9ba56b95 1397 res = DID_OK << 16;
9a069e19
GM		 1398 bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
1399 bsg_job->reply_len = 0;
1400 }
1401
9ba56b95 1402 sp->done(vha, sp, res);
9a069e19
GM		 1403}
1404
ac280b67
AV		 1405static void
1406qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
1407 struct logio_entry_24xx *logio)
1408{
1409 const char func[] = "LOGIO-IOCB";
1410 const char *type;
ac280b67
AV		 1411 fc_port_t *fcport;
1412 srb_t *sp;
4916392b 1413 struct srb_iocb *lio;
99b0bec7 1414 uint16_t *data;
ac280b67
AV		 1415 uint32_t iop[2];
1416
1417 sp = qla2x00_get_sp_from_handle(vha, func, req, logio);
1418 if (!sp)
1419 return;
1420
9ba56b95
GM		 1421 lio = &sp->u.iocb_cmd;
1422 type = sp->name;
ac280b67 1423 fcport = sp->fcport;
4916392b 1424 data = lio->u.logio.data;
ac280b67 1425
5ff1d584 1426 data[0] = MBS_COMMAND_ERROR;
4916392b 1427 data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
5ff1d584 1428 QLA_LOGIO_LOGIN_RETRIED : 0;
ac280b67 1429 if (logio->entry_status) {
5e19ed90 1430 ql_log(ql_log_warn, fcport->vha, 0x5034,
cfb0919c 1431 "Async-%s error entry - hdl=%x"
d3fa9e7d 1432 "portid=%02x%02x%02x entry-status=%x.\n",
cfb0919c
CD		 1433 type, sp->handle, fcport->d_id.b.domain,
1434 fcport->d_id.b.area, fcport->d_id.b.al_pa,
1435 logio->entry_status);
1436 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x504d,
7c3df132 1437 (uint8_t *)logio, sizeof(*logio));
ac280b67 1438
99b0bec7 1439 goto logio_done;
ac280b67
AV		 1440 }
1441
1442 if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
5e19ed90 1443 ql_dbg(ql_dbg_async, fcport->vha, 0x5036,
cfb0919c
CD		 1444 "Async-%s complete - hdl=%x portid=%02x%02x%02x "
1445 "iop0=%x.\n", type, sp->handle, fcport->d_id.b.domain,
1446 fcport->d_id.b.area, fcport->d_id.b.al_pa,
7c3df132 1447 le32_to_cpu(logio->io_parameter[0]));
ac280b67
AV		 1448
1449 data[0] = MBS_COMMAND_COMPLETE;
9ba56b95 1450 if (sp->type != SRB_LOGIN_CMD)
99b0bec7 1451 goto logio_done;
ac280b67
AV		 1452
1453 iop[0] = le32_to_cpu(logio->io_parameter[0]);
1454 if (iop[0] & BIT_4) {
1455 fcport->port_type = FCT_TARGET;
1456 if (iop[0] & BIT_8)
8474f3a0 1457 fcport->flags |= FCF_FCP2_DEVICE;
b0cd579c 1458 } else if (iop[0] & BIT_5)
ac280b67 1459 fcport->port_type = FCT_INITIATOR;
b0cd579c 1460
2d70c103
NB		 1461 if (iop[0] & BIT_7)
1462 fcport->flags |= FCF_CONF_COMP_SUPPORTED;
1463
ac280b67
AV		 1464 if (logio->io_parameter[7] || logio->io_parameter[8])
1465 fcport->supported_classes |= FC_COS_CLASS2;
1466 if (logio->io_parameter[9] || logio->io_parameter[10])
1467 fcport->supported_classes |= FC_COS_CLASS3;
1468
99b0bec7 1469 goto logio_done;
ac280b67
AV		 1470 }
1471
1472 iop[0] = le32_to_cpu(logio->io_parameter[0]);
1473 iop[1] = le32_to_cpu(logio->io_parameter[1]);
1474 switch (iop[0]) {
1475 case LSC_SCODE_PORTID_USED:
1476 data[0] = MBS_PORT_ID_USED;
1477 data[1] = LSW(iop[1]);
1478 break;
1479 case LSC_SCODE_NPORT_USED:
1480 data[0] = MBS_LOOP_ID_USED;
1481 break;
ac280b67
AV		 1482 default:
1483 data[0] = MBS_COMMAND_ERROR;
ac280b67
AV		 1484 break;
1485 }
1486
5e19ed90 1487 ql_dbg(ql_dbg_async, fcport->vha, 0x5037,
cfb0919c
CD		 1488 "Async-%s failed - hdl=%x portid=%02x%02x%02x comp=%x "
1489 "iop0=%x iop1=%x.\n", type, sp->handle, fcport->d_id.b.domain,
d3fa9e7d 1490 fcport->d_id.b.area, fcport->d_id.b.al_pa,
ac280b67
AV		 1491 le16_to_cpu(logio->comp_status),
1492 le32_to_cpu(logio->io_parameter[0]),
7c3df132 1493 le32_to_cpu(logio->io_parameter[1]));
ac280b67 1494
99b0bec7 1495logio_done:
9ba56b95 1496 sp->done(vha, sp, 0);
ac280b67
AV		 1497}
1498
3822263e 1499static void
faef62d1 1500qla24xx_tm_iocb_entry(scsi_qla_host_t *vha, struct req_que *req, void *tsk)
3822263e
MI		 1501{
1502 const char func[] = "TMF-IOCB";
1503 const char *type;
1504 fc_port_t *fcport;
1505 srb_t *sp;
1506 struct srb_iocb *iocb;
3822263e 1507 struct sts_entry_24xx *sts = (struct sts_entry_24xx *)tsk;
3822263e
MI		 1508
1509 sp = qla2x00_get_sp_from_handle(vha, func, req, tsk);
1510 if (!sp)
1511 return;
1512
9ba56b95
GM		 1513 iocb = &sp->u.iocb_cmd;
1514 type = sp->name;
3822263e 1515 fcport = sp->fcport;
faef62d1 1516 iocb->u.tmf.data = QLA_SUCCESS;
3822263e
MI		 1517
1518 if (sts->entry_status) {
5e19ed90 1519 ql_log(ql_log_warn, fcport->vha, 0x5038,
cfb0919c
CD		 1520 "Async-%s error - hdl=%x entry-status(%x).\n",
1521 type, sp->handle, sts->entry_status);
faef62d1 1522 iocb->u.tmf.data = QLA_FUNCTION_FAILED;
3822263e 1523 } else if (sts->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
5e19ed90 1524 ql_log(ql_log_warn, fcport->vha, 0x5039,
cfb0919c
CD		 1525 "Async-%s error - hdl=%x completion status(%x).\n",
1526 type, sp->handle, sts->comp_status);
faef62d1
AB		 1527 iocb->u.tmf.data = QLA_FUNCTION_FAILED;
1528 } else if ((le16_to_cpu(sts->scsi_status) &
3822263e 1529 SS_RESPONSE_INFO_LEN_VALID)) {
faef62d1
AB		 1530 if (le32_to_cpu(sts->rsp_data_len) < 4) {
1531 ql_log(ql_log_warn, fcport->vha, 0x503b,
1532 "Async-%s error - hdl=%x not enough response(%d).\n",
1533 type, sp->handle, sts->rsp_data_len);
1534 } else if (sts->data[3]) {
1535 ql_log(ql_log_warn, fcport->vha, 0x503c,
1536 "Async-%s error - hdl=%x response(%x).\n",
1537 type, sp->handle, sts->data[3]);
1538 iocb->u.tmf.data = QLA_FUNCTION_FAILED;
1539 }
3822263e
MI		 1540 }
1541
faef62d1 1542 if (iocb->u.tmf.data != QLA_SUCCESS)
7c3df132
SK		 1543 ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5055,
1544 (uint8_t *)sts, sizeof(*sts));
3822263e 1545
9ba56b95 1546 sp->done(vha, sp, 0);
3822263e
MI		 1547}
1548
1da177e4
LT		 1549/**
1550 * qla2x00_process_response_queue() - Process response queue entries.
1551 * @ha: SCSI driver HA context
1552 */
1553void
73208dfd 1554qla2x00_process_response_queue(struct rsp_que *rsp)
1da177e4 1555{
73208dfd
AC		 1556 struct scsi_qla_host *vha;
1557 struct qla_hw_data *ha = rsp->hw;
3d71644c 1558 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1da177e4
LT		 1559 sts_entry_t *pkt;
1560 uint16_t handle_cnt;
1561 uint16_t cnt;
73208dfd 1562
2afa19a9 1563 vha = pci_get_drvdata(ha->pdev);
1da177e4 1564
e315cd28 1565 if (!vha->flags.online)
1da177e4
LT		 1566 return;
1567
e315cd28
AC		 1568 while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
1569 pkt = (sts_entry_t *)rsp->ring_ptr;
1da177e4 1570
e315cd28
AC		 1571 rsp->ring_index++;
1572 if (rsp->ring_index == rsp->length) {
1573 rsp->ring_index = 0;
1574 rsp->ring_ptr = rsp->ring;
1da177e4 1575 } else {
e315cd28 1576 rsp->ring_ptr++;
1da177e4
LT		 1577 }
1578
1579 if (pkt->entry_status != 0) {
73208dfd 1580 qla2x00_error_entry(vha, rsp, pkt);
1da177e4
LT		 1581 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1582 wmb();
1583 continue;
1584 }
1585
1586 switch (pkt->entry_type) {
1587 case STATUS_TYPE:
73208dfd 1588 qla2x00_status_entry(vha, rsp, pkt);
1da177e4
LT		 1589 break;
1590 case STATUS_TYPE_21:
1591 handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
1592 for (cnt = 0; cnt < handle_cnt; cnt++) {
73208dfd 1593 qla2x00_process_completed_request(vha, rsp->req,
1da177e4
LT		 1594 ((sts21_entry_t *)pkt)->handle[cnt]);
1595 }
1596 break;
1597 case STATUS_TYPE_22:
1598 handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
1599 for (cnt = 0; cnt < handle_cnt; cnt++) {
73208dfd 1600 qla2x00_process_completed_request(vha, rsp->req,
1da177e4
LT		 1601 ((sts22_entry_t *)pkt)->handle[cnt]);
1602 }
1603 break;
1604 case STATUS_CONT_TYPE:
2afa19a9 1605 qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
1da177e4 1606 break;
ac280b67
AV		 1607 case MBX_IOCB_TYPE:
1608 qla2x00_mbx_iocb_entry(vha, rsp->req,
1609 (struct mbx_entry *)pkt);
3822263e 1610 break;
9bc4f4fb
HZ		 1611 case CT_IOCB_TYPE:
1612 qla2x00_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
1613 break;
1da177e4
LT		 1614 default:
1615 /* Type Not Supported. */
7c3df132
SK		 1616 ql_log(ql_log_warn, vha, 0x504a,
1617 "Received unknown response pkt type %x "
1da177e4 1618 "entry status=%x.\n",
7c3df132 1619 pkt->entry_type, pkt->entry_status);
1da177e4
LT		 1620 break;
1621 }
1622 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
1623 wmb();
1624 }
1625
1626 /* Adjust ring index */
e315cd28 1627 WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), rsp->ring_index);
1da177e4
LT		 1628}
1629
4733fcb1 1630static inline void
5544213b 1631qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
9ba56b95 1632 uint32_t sense_len, struct rsp_que *rsp, int res)
4733fcb1 1633{
7c3df132 1634 struct scsi_qla_host *vha = sp->fcport->vha;
9ba56b95
GM		 1635 struct scsi_cmnd *cp = GET_CMD_SP(sp);
1636 uint32_t track_sense_len;
4733fcb1
AV		 1637
1638 if (sense_len >= SCSI_SENSE_BUFFERSIZE)
1639 sense_len = SCSI_SENSE_BUFFERSIZE;
1640
9ba56b95
GM		 1641 SET_CMD_SENSE_LEN(sp, sense_len);
1642 SET_CMD_SENSE_PTR(sp, cp->sense_buffer);
1643 track_sense_len = sense_len;
1644
1645 if (sense_len > par_sense_len)
5544213b 1646 sense_len = par_sense_len;
4733fcb1
AV		 1647
1648 memcpy(cp->sense_buffer, sense_data, sense_len);
1649
9ba56b95
GM		 1650 SET_CMD_SENSE_PTR(sp, cp->sense_buffer + sense_len);
1651 track_sense_len -= sense_len;
1652 SET_CMD_SENSE_LEN(sp, track_sense_len);
1653
1654 if (track_sense_len != 0) {
2afa19a9 1655 rsp->status_srb = sp;
9ba56b95
GM		 1656 cp->result = res;
1657 }
4733fcb1 1658
cfb0919c
CD		 1659 if (sense_len) {
1660 ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x301c,
9cb78c16 1661 "Check condition Sense data, nexus%ld:%d:%llu cmd=%p.\n",
cfb0919c
CD		 1662 sp->fcport->vha->host_no, cp->device->id, cp->device->lun,
1663 cp);
7c3df132
SK		 1664 ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
1665 cp->sense_buffer, sense_len);
cfb0919c 1666 }
4733fcb1
AV		 1667}
1668
bad75002
AE		 1669struct scsi_dif_tuple {
1670 __be16 guard; /* Checksum */
d6a03581 1671 __be16 app_tag; /* APPL identifier */
bad75002
AE		 1672 __be32 ref_tag; /* Target LBA or indirect LBA */
1673};
1674
1675/*
1676 * Checks the guard or meta-data for the type of error
1677 * detected by the HBA. In case of errors, we set the
1678 * ASC/ASCQ fields in the sense buffer with ILLEGAL_REQUEST
1679 * to indicate to the kernel that the HBA detected error.
1680 */
8cb2049c 1681static inline int
bad75002
AE		 1682qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
1683{
7c3df132 1684 struct scsi_qla_host *vha = sp->fcport->vha;
9ba56b95 1685 struct scsi_cmnd *cmd = GET_CMD_SP(sp);
8cb2049c
AE		 1686 uint8_t *ap = &sts24->data[12];
1687 uint8_t *ep = &sts24->data[20];
bad75002
AE		 1688 uint32_t e_ref_tag, a_ref_tag;
1689 uint16_t e_app_tag, a_app_tag;
1690 uint16_t e_guard, a_guard;
1691
8cb2049c
AE		 1692 /*
1693 * swab32 of the "data" field in the beginning of qla2x00_status_entry()
1694 * would make guard field appear at offset 2
1695 */
1696 a_guard = le16_to_cpu(*(uint16_t *)(ap + 2));
1697 a_app_tag = le16_to_cpu(*(uint16_t *)(ap + 0));
1698 a_ref_tag = le32_to_cpu(*(uint32_t *)(ap + 4));
1699 e_guard = le16_to_cpu(*(uint16_t *)(ep + 2));
1700 e_app_tag = le16_to_cpu(*(uint16_t *)(ep + 0));
1701 e_ref_tag = le32_to_cpu(*(uint32_t *)(ep + 4));
bad75002 1702
7c3df132
SK		 1703 ql_dbg(ql_dbg_io, vha, 0x3023,
1704 "iocb(s) %p Returned STATUS.\n", sts24);
bad75002 1705
7c3df132
SK		 1706 ql_dbg(ql_dbg_io, vha, 0x3024,
1707 "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
bad75002 1708 " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
7c3df132 1709 " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
bad75002 1710 cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
7c3df132 1711 a_app_tag, e_app_tag, a_guard, e_guard);
bad75002 1712
8cb2049c
AE		 1713 /*
1714 * Ignore sector if:
1715 * For type 3: ref & app tag is all 'f's
1716 * For type 0,1,2: app tag is all 'f's
1717 */
1718 if ((a_app_tag == 0xffff) &&
1719 ((scsi_get_prot_type(cmd) != SCSI_PROT_DIF_TYPE3) ||
1720 (a_ref_tag == 0xffffffff))) {
1721 uint32_t blocks_done, resid;
1722 sector_t lba_s = scsi_get_lba(cmd);
1723
1724 /* 2TB boundary case covered automatically with this */
1725 blocks_done = e_ref_tag - (uint32_t)lba_s + 1;
1726
1727 resid = scsi_bufflen(cmd) - (blocks_done *
1728 cmd->device->sector_size);
1729
1730 scsi_set_resid(cmd, resid);
1731 cmd->result = DID_OK << 16;
1732
1733 /* Update protection tag */
1734 if (scsi_prot_sg_count(cmd)) {
1735 uint32_t i, j = 0, k = 0, num_ent;
1736 struct scatterlist *sg;
1737 struct sd_dif_tuple *spt;
1738
1739 /* Patch the corresponding protection tags */
1740 scsi_for_each_prot_sg(cmd, sg,
1741 scsi_prot_sg_count(cmd), i) {
1742 num_ent = sg_dma_len(sg) / 8;
1743 if (k + num_ent < blocks_done) {
1744 k += num_ent;
1745 continue;
1746 }
1747 j = blocks_done - k - 1;
1748 k = blocks_done;
1749 break;
1750 }
1751
1752 if (k != blocks_done) {
cfb0919c 1753 ql_log(ql_log_warn, vha, 0x302f,
8ec9c7fb
RD		 1754 "unexpected tag values tag:lba=%x:%llx)\n",
1755 e_ref_tag, (unsigned long long)lba_s);
8cb2049c
AE		 1756 return 1;
1757 }
1758
1759 spt = page_address(sg_page(sg)) + sg->offset;
1760 spt += j;
1761
1762 spt->app_tag = 0xffff;
1763 if (scsi_get_prot_type(cmd) == SCSI_PROT_DIF_TYPE3)
1764 spt->ref_tag = 0xffffffff;
1765 }
1766
1767 return 0;
1768 }
1769
bad75002
AE		 1770 /* check guard */
1771 if (e_guard != a_guard) {
1772 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1773 0x10, 0x1);
1774 set_driver_byte(cmd, DRIVER_SENSE);
1775 set_host_byte(cmd, DID_ABORT);
1776 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
8cb2049c 1777 return 1;
bad75002
AE		 1778 }
1779
e02587d7
AE		 1780 /* check ref tag */
1781 if (e_ref_tag != a_ref_tag) {
bad75002 1782 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
e02587d7 1783 0x10, 0x3);
bad75002
AE		 1784 set_driver_byte(cmd, DRIVER_SENSE);
1785 set_host_byte(cmd, DID_ABORT);
1786 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
8cb2049c 1787 return 1;
bad75002
AE		 1788 }
1789
e02587d7
AE		 1790 /* check appl tag */
1791 if (e_app_tag != a_app_tag) {
bad75002 1792 scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
e02587d7 1793 0x10, 0x2);
bad75002
AE		 1794 set_driver_byte(cmd, DRIVER_SENSE);
1795 set_host_byte(cmd, DID_ABORT);
1796 cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
8cb2049c 1797 return 1;
bad75002 1798 }
e02587d7 1799
8cb2049c 1800 return 1;
bad75002
AE		 1801}
1802
a9b6f722
SK		 1803static void
1804qla25xx_process_bidir_status_iocb(scsi_qla_host_t *vha, void *pkt,
1805 struct req_que *req, uint32_t index)
1806{
1807 struct qla_hw_data *ha = vha->hw;
1808 srb_t *sp;
1809 uint16_t comp_status;
1810 uint16_t scsi_status;
1811 uint16_t thread_id;
1812 uint32_t rval = EXT_STATUS_OK;
1813 struct fc_bsg_job *bsg_job = NULL;
1814 sts_entry_t *sts;
1815 struct sts_entry_24xx *sts24;
1816 sts = (sts_entry_t *) pkt;
1817 sts24 = (struct sts_entry_24xx *) pkt;
1818
1819 /* Validate handle. */
8d93f550 1820 if (index >= req->num_outstanding_cmds) {
a9b6f722
SK		 1821 ql_log(ql_log_warn, vha, 0x70af,
1822 "Invalid SCSI completion handle 0x%x.\n", index);
1823 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1824 return;
1825 }
1826
1827 sp = req->outstanding_cmds[index];
1828 if (sp) {
1829 /* Free outstanding command slot. */
1830 req->outstanding_cmds[index] = NULL;
1831 bsg_job = sp->u.bsg_job;
1832 } else {
1833 ql_log(ql_log_warn, vha, 0x70b0,
1834 "Req:%d: Invalid ISP SCSI completion handle(0x%x)\n",
1835 req->id, index);
1836
1837 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1838 return;
1839 }
1840
1841 if (IS_FWI2_CAPABLE(ha)) {
1842 comp_status = le16_to_cpu(sts24->comp_status);
1843 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
1844 } else {
1845 comp_status = le16_to_cpu(sts->comp_status);
1846 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
1847 }
1848
1849 thread_id = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
1850 switch (comp_status) {
1851 case CS_COMPLETE:
1852 if (scsi_status == 0) {
1853 bsg_job->reply->reply_payload_rcv_len =
1854 bsg_job->reply_payload.payload_len;
fabbb8df
JC		 1855 vha->qla_stats.input_bytes +=
1856 bsg_job->reply->reply_payload_rcv_len;
1857 vha->qla_stats.input_requests++;
a9b6f722
SK		 1858 rval = EXT_STATUS_OK;
1859 }
1860 goto done;
1861
1862 case CS_DATA_OVERRUN:
1863 ql_dbg(ql_dbg_user, vha, 0x70b1,
1864 "Command completed with date overrun thread_id=%d\n",
1865 thread_id);
1866 rval = EXT_STATUS_DATA_OVERRUN;
1867 break;
1868
1869 case CS_DATA_UNDERRUN:
1870 ql_dbg(ql_dbg_user, vha, 0x70b2,
1871 "Command completed with date underrun thread_id=%d\n",
1872 thread_id);
1873 rval = EXT_STATUS_DATA_UNDERRUN;
1874 break;
1875 case CS_BIDIR_RD_OVERRUN:
1876 ql_dbg(ql_dbg_user, vha, 0x70b3,
1877 "Command completed with read data overrun thread_id=%d\n",
1878 thread_id);
1879 rval = EXT_STATUS_DATA_OVERRUN;
1880 break;
1881
1882 case CS_BIDIR_RD_WR_OVERRUN:
1883 ql_dbg(ql_dbg_user, vha, 0x70b4,
1884 "Command completed with read and write data overrun "
1885 "thread_id=%d\n", thread_id);
1886 rval = EXT_STATUS_DATA_OVERRUN;
1887 break;
1888
1889 case CS_BIDIR_RD_OVERRUN_WR_UNDERRUN:
1890 ql_dbg(ql_dbg_user, vha, 0x70b5,
1891 "Command completed with read data over and write data "
1892 "underrun thread_id=%d\n", thread_id);
1893 rval = EXT_STATUS_DATA_OVERRUN;
1894 break;
1895
1896 case CS_BIDIR_RD_UNDERRUN:
1897 ql_dbg(ql_dbg_user, vha, 0x70b6,
1898 "Command completed with read data data underrun "
1899 "thread_id=%d\n", thread_id);
1900 rval = EXT_STATUS_DATA_UNDERRUN;
1901 break;
1902
1903 case CS_BIDIR_RD_UNDERRUN_WR_OVERRUN:
1904 ql_dbg(ql_dbg_user, vha, 0x70b7,
1905 "Command completed with read data under and write data "
1906 "overrun thread_id=%d\n", thread_id);
1907 rval = EXT_STATUS_DATA_UNDERRUN;
1908 break;
1909
1910 case CS_BIDIR_RD_WR_UNDERRUN:
1911 ql_dbg(ql_dbg_user, vha, 0x70b8,
1912 "Command completed with read and write data underrun "
1913 "thread_id=%d\n", thread_id);
1914 rval = EXT_STATUS_DATA_UNDERRUN;
1915 break;
1916
1917 case CS_BIDIR_DMA:
1918 ql_dbg(ql_dbg_user, vha, 0x70b9,
1919 "Command completed with data DMA error thread_id=%d\n",
1920 thread_id);
1921 rval = EXT_STATUS_DMA_ERR;
1922 break;
1923
1924 case CS_TIMEOUT:
1925 ql_dbg(ql_dbg_user, vha, 0x70ba,
1926 "Command completed with timeout thread_id=%d\n",
1927 thread_id);
1928 rval = EXT_STATUS_TIMEOUT;
1929 break;
1930 default:
1931 ql_dbg(ql_dbg_user, vha, 0x70bb,
1932 "Command completed with completion status=0x%x "
1933 "thread_id=%d\n", comp_status, thread_id);
1934 rval = EXT_STATUS_ERR;
1935 break;
1936 }
1937 bsg_job->reply->reply_payload_rcv_len = 0;
1938
1939done:
1940 /* Return the vendor specific reply to API */
1941 bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = rval;
1942 bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1943 /* Always return DID_OK, bsg will send the vendor specific response
1944 * in this case only */
1945 sp->done(vha, sp, (DID_OK << 6));
1946
1947}
1948
1da177e4
LT		 1949/**
1950 * qla2x00_status_entry() - Process a Status IOCB entry.
1951 * @ha: SCSI driver HA context
1952 * @pkt: Entry pointer
1953 */
1954static void
73208dfd 1955qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
1da177e4 1956{
1da177e4 1957 srb_t *sp;
1da177e4
LT		 1958 fc_port_t *fcport;
1959 struct scsi_cmnd *cp;
9a853f71
AV		 1960 sts_entry_t *sts;
1961 struct sts_entry_24xx *sts24;
1da177e4
LT		 1962 uint16_t comp_status;
1963 uint16_t scsi_status;
b7d2280c 1964 uint16_t ox_id;
1da177e4
LT		 1965 uint8_t lscsi_status;
1966 int32_t resid;
5544213b
AV		 1967 uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
1968 fw_resid_len;
9a853f71 1969 uint8_t *rsp_info, *sense_data;
e315cd28 1970 struct qla_hw_data *ha = vha->hw;
2afa19a9
AC		 1971 uint32_t handle;
1972 uint16_t que;
1973 struct req_que *req;
b7d2280c 1974 int logit = 1;
9ba56b95 1975 int res = 0;
a9b6f722 1976 uint16_t state_flags = 0;
9a853f71
AV		 1977
1978 sts = (sts_entry_t *) pkt;
1979 sts24 = (struct sts_entry_24xx *) pkt;
e428924c 1980 if (IS_FWI2_CAPABLE(ha)) {
9a853f71
AV		 1981 comp_status = le16_to_cpu(sts24->comp_status);
1982 scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
a9b6f722 1983 state_flags = le16_to_cpu(sts24->state_flags);
9a853f71
AV		 1984 } else {
1985 comp_status = le16_to_cpu(sts->comp_status);
1986 scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
1987 }
2afa19a9
AC		 1988 handle = (uint32_t) LSW(sts->handle);
1989 que = MSW(sts->handle);
1990 req = ha->req_q_map[que];
a9083016 1991
36008cf1
CD		 1992 /* Check for invalid queue pointer */
1993 if (req == NULL ||
1994 que >= find_first_zero_bit(ha->req_qid_map, ha->max_req_queues)) {
1995 ql_dbg(ql_dbg_io, vha, 0x3059,
1996 "Invalid status handle (0x%x): Bad req pointer. req=%p, "
1997 "que=%u.\n", sts->handle, req, que);
1998 return;
1999 }
2000
1da177e4 2001 /* Validate handle. */
8d93f550 2002 if (handle < req->num_outstanding_cmds)
2afa19a9 2003 sp = req->outstanding_cmds[handle];
8d93f550 2004 else
1da177e4
LT		 2005 sp = NULL;
2006
2007 if (sp == NULL) {
cfb0919c 2008 ql_dbg(ql_dbg_io, vha, 0x3017,
7c3df132 2009 "Invalid status handle (0x%x).\n", sts->handle);
1da177e4 2010
acd3ce88
CD		 2011 if (!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) {
2012 if (IS_P3P_TYPE(ha))
2013 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
2014 else
2015 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2016 qla2xxx_wake_dpc(vha);
2017 }
1da177e4
LT		 2018 return;
2019 }
a9b6f722
SK		 2020
2021 if (unlikely((state_flags & BIT_1) && (sp->type == SRB_BIDI_CMD))) {
2022 qla25xx_process_bidir_status_iocb(vha, pkt, req, handle);
2023 return;
2024 }
2025
faef62d1
AB		 2026 /* Task Management completion. */
2027 if (sp->type == SRB_TM_CMD) {
2028 qla24xx_tm_iocb_entry(vha, req, pkt);
2029 return;
2030 }
2031
a9b6f722
SK		 2032 /* Fast path completion. */
2033 if (comp_status == CS_COMPLETE && scsi_status == 0) {
2034 qla2x00_process_completed_request(vha, req, handle);
2035
2036 return;
2037 }
2038
2039 req->outstanding_cmds[handle] = NULL;
9ba56b95 2040 cp = GET_CMD_SP(sp);
1da177e4 2041 if (cp == NULL) {
cfb0919c 2042 ql_dbg(ql_dbg_io, vha, 0x3018,
7c3df132
SK		 2043 "Command already returned (0x%x/%p).\n",
2044 sts->handle, sp);
1da177e4
LT		 2045
2046 return;
2047 }
2048
8ae6d9c7 2049 lscsi_status = scsi_status & STATUS_MASK;
1da177e4 2050
bdf79621 2051 fcport = sp->fcport;
1da177e4 2052
b7d2280c 2053 ox_id = 0;
5544213b
AV		 2054 sense_len = par_sense_len = rsp_info_len = resid_len =
2055 fw_resid_len = 0;
e428924c 2056 if (IS_FWI2_CAPABLE(ha)) {
0f00a206
LC		 2057 if (scsi_status & SS_SENSE_LEN_VALID)
2058 sense_len = le32_to_cpu(sts24->sense_len);
2059 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
2060 rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
2061 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER))
2062 resid_len = le32_to_cpu(sts24->rsp_residual_count);
2063 if (comp_status == CS_DATA_UNDERRUN)
2064 fw_resid_len = le32_to_cpu(sts24->residual_len);
9a853f71
AV		 2065 rsp_info = sts24->data;
2066 sense_data = sts24->data;
2067 host_to_fcp_swap(sts24->data, sizeof(sts24->data));
b7d2280c 2068 ox_id = le16_to_cpu(sts24->ox_id);
5544213b 2069 par_sense_len = sizeof(sts24->data);
9a853f71 2070 } else {
0f00a206
LC		 2071 if (scsi_status & SS_SENSE_LEN_VALID)
2072 sense_len = le16_to_cpu(sts->req_sense_length);
2073 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
2074 rsp_info_len = le16_to_cpu(sts->rsp_info_len);
9a853f71
AV		 2075 resid_len = le32_to_cpu(sts->residual_length);
2076 rsp_info = sts->rsp_info;
2077 sense_data = sts->req_sense_data;
5544213b 2078 par_sense_len = sizeof(sts->req_sense_data);
9a853f71
AV		 2079 }
2080
1da177e4
LT		 2081 /* Check for any FCP transport errors. */
2082 if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
9a853f71 2083 /* Sense data lies beyond any FCP RESPONSE data. */
5544213b 2084 if (IS_FWI2_CAPABLE(ha)) {
9a853f71 2085 sense_data += rsp_info_len;
5544213b
AV		 2086 par_sense_len -= rsp_info_len;
2087 }
9a853f71 2088 if (rsp_info_len > 3 && rsp_info[3]) {
5e19ed90 2089 ql_dbg(ql_dbg_io, fcport->vha, 0x3019,
7c3df132
SK		 2090 "FCP I/O protocol failure (0x%x/0x%x).\n",
2091 rsp_info_len, rsp_info[3]);
1da177e4 2092
9ba56b95 2093 res = DID_BUS_BUSY << 16;
b7d2280c 2094 goto out;
1da177e4
LT		 2095 }
2096 }
2097
3e8ce320
AV		 2098 /* Check for overrun. */
2099 if (IS_FWI2_CAPABLE(ha) && comp_status == CS_COMPLETE &&
2100 scsi_status & SS_RESIDUAL_OVER)
2101 comp_status = CS_DATA_OVERRUN;
2102
1da177e4
LT		 2103 /*
2104 * Based on Host and scsi status generate status code for Linux
2105 */
2106 switch (comp_status) {
2107 case CS_COMPLETE:
df7baa50 2108 case CS_QUEUE_FULL:
1da177e4 2109 if (scsi_status == 0) {
9ba56b95 2110 res = DID_OK << 16;
1da177e4
LT		 2111 break;
2112 }
2113 if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
9a853f71 2114 resid = resid_len;
385d70b4 2115 scsi_set_resid(cp, resid);
0da69df1
AV		 2116
2117 if (!lscsi_status &&
385d70b4 2118 ((unsigned)(scsi_bufflen(cp) - resid) <
0da69df1 2119 cp->underflow)) {
5e19ed90 2120 ql_dbg(ql_dbg_io, fcport->vha, 0x301a,
7c3df132 2121 "Mid-layer underflow "
b7d2280c 2122 "detected (0x%x of 0x%x bytes).\n",
7c3df132 2123 resid, scsi_bufflen(cp));
0da69df1 2124
9ba56b95 2125 res = DID_ERROR << 16;
0da69df1
AV		 2126 break;
2127 }
1da177e4 2128 }
9ba56b95 2129 res = DID_OK << 16 | lscsi_status;
1da177e4 2130
df7baa50 2131 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
5e19ed90 2132 ql_dbg(ql_dbg_io, fcport->vha, 0x301b,
7c3df132 2133 "QUEUE FULL detected.\n");
df7baa50
AV		 2134 break;
2135 }
b7d2280c 2136 logit = 0;
1da177e4
LT		 2137 if (lscsi_status != SS_CHECK_CONDITION)
2138 break;
2139
b80ca4f7 2140 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 2141 if (!(scsi_status & SS_SENSE_LEN_VALID))
2142 break;
2143
5544213b 2144 qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
9ba56b95 2145 rsp, res);
1da177e4
LT		 2146 break;
2147
2148 case CS_DATA_UNDERRUN:
ed17c71b 2149 /* Use F/W calculated residual length. */
0f00a206
LC		 2150 resid = IS_FWI2_CAPABLE(ha) ? fw_resid_len : resid_len;
2151 scsi_set_resid(cp, resid);
2152 if (scsi_status & SS_RESIDUAL_UNDER) {
2153 if (IS_FWI2_CAPABLE(ha) && fw_resid_len != resid_len) {
5e19ed90 2154 ql_dbg(ql_dbg_io, fcport->vha, 0x301d,
7c3df132
SK		 2155 "Dropped frame(s) detected "
2156 "(0x%x of 0x%x bytes).\n",
2157 resid, scsi_bufflen(cp));
0f00a206 2158
9ba56b95 2159 res = DID_ERROR << 16 | lscsi_status;
4e85e3d9 2160 goto check_scsi_status;
6acf8190 2161 }
ed17c71b 2162
0f00a206
LC		 2163 if (!lscsi_status &&
2164 ((unsigned)(scsi_bufflen(cp) - resid) <
2165 cp->underflow)) {
5e19ed90 2166 ql_dbg(ql_dbg_io, fcport->vha, 0x301e,
7c3df132 2167 "Mid-layer underflow "
b7d2280c 2168 "detected (0x%x of 0x%x bytes).\n",
7c3df132 2169 resid, scsi_bufflen(cp));
e038a1be 2170
9ba56b95 2171 res = DID_ERROR << 16;
0f00a206
LC		 2172 break;
2173 }
4aee5766
GM		 2174 } else if (lscsi_status != SAM_STAT_TASK_SET_FULL &&
2175 lscsi_status != SAM_STAT_BUSY) {
2176 /*
2177 * scsi status of task set and busy are considered to be
2178 * task not completed.
2179 */
2180
5e19ed90 2181 ql_dbg(ql_dbg_io, fcport->vha, 0x301f,
7c3df132 2182 "Dropped frame(s) detected (0x%x "
4aee5766
GM		 2183 "of 0x%x bytes).\n", resid,
2184 scsi_bufflen(cp));
0f00a206 2185
9ba56b95 2186 res = DID_ERROR << 16 | lscsi_status;
0374f55e 2187 goto check_scsi_status;
4aee5766
GM		 2188 } else {
2189 ql_dbg(ql_dbg_io, fcport->vha, 0x3030,
2190 "scsi_status: 0x%x, lscsi_status: 0x%x\n",
2191 scsi_status, lscsi_status);
1da177e4
LT		 2192 }
2193
9ba56b95 2194 res = DID_OK << 16 | lscsi_status;
b7d2280c 2195 logit = 0;
0f00a206 2196
0374f55e 2197check_scsi_status:
1da177e4 2198 /*
fa2a1ce5 2199 * Check to see if SCSI Status is non zero. If so report SCSI
1da177e4
LT		 2200 * Status.
2201 */
2202 if (lscsi_status != 0) {
ffec28a3 2203 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
5e19ed90 2204 ql_dbg(ql_dbg_io, fcport->vha, 0x3020,
7c3df132 2205 "QUEUE FULL detected.\n");
b7d2280c 2206 logit = 1;
ffec28a3
AV		 2207 break;
2208 }
1da177e4
LT		 2209 if (lscsi_status != SS_CHECK_CONDITION)
2210 break;
2211
b80ca4f7 2212 memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 2213 if (!(scsi_status & SS_SENSE_LEN_VALID))
2214 break;
2215
5544213b 2216 qla2x00_handle_sense(sp, sense_data, par_sense_len,
9ba56b95 2217 sense_len, rsp, res);
1da177e4
LT		 2218 }
2219 break;
2220
1da177e4
LT		 2221 case CS_PORT_LOGGED_OUT:
2222 case CS_PORT_CONFIG_CHG:
2223 case CS_PORT_BUSY:
2224 case CS_INCOMPLETE:
2225 case CS_PORT_UNAVAILABLE:
b7d2280c 2226 case CS_TIMEOUT:
ff454b01
CD		 2227 case CS_RESET:
2228
056a4483
MC		 2229 /*
2230 * We are going to have the fc class block the rport
2231 * while we try to recover so instruct the mid layer
2232 * to requeue until the class decides how to handle this.
2233 */
9ba56b95 2234 res = DID_TRANSPORT_DISRUPTED << 16;
b7d2280c
AV		 2235
2236 if (comp_status == CS_TIMEOUT) {
2237 if (IS_FWI2_CAPABLE(ha))
2238 break;
2239 else if ((le16_to_cpu(sts->status_flags) &
2240 SF_LOGOUT_SENT) == 0)
2241 break;
2242 }
2243
5e19ed90 2244 ql_dbg(ql_dbg_io, fcport->vha, 0x3021,
0e948975
CD		 2245 "Port to be marked lost on fcport=%02x%02x%02x, current "
2246 "port state= %s.\n", fcport->d_id.b.domain,
2247 fcport->d_id.b.area, fcport->d_id.b.al_pa,
2248 port_state_str[atomic_read(&fcport->state)]);
b7d2280c 2249
a7a28504 2250 if (atomic_read(&fcport->state) == FCS_ONLINE)
e315cd28 2251 qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
1da177e4
LT		 2252 break;
2253
1da177e4 2254 case CS_ABORTED:
9ba56b95 2255 res = DID_RESET << 16;
1da177e4 2256 break;
bad75002
AE		 2257
2258 case CS_DIF_ERROR:
8cb2049c 2259 logit = qla2x00_handle_dif_error(sp, sts24);
fb6e4668 2260 res = cp->result;
bad75002 2261 break;
9e522cd8
AE		 2262
2263 case CS_TRANSPORT:
2264 res = DID_ERROR << 16;
2265
2266 if (!IS_PI_SPLIT_DET_CAPABLE(ha))
2267 break;
2268
2269 if (state_flags & BIT_4)
2270 scmd_printk(KERN_WARNING, cp,
2271 "Unsupported device '%s' found.\n",
2272 cp->device->vendor);
2273 break;
2274
1da177e4 2275 default:
9ba56b95 2276 res = DID_ERROR << 16;
1da177e4
LT		 2277 break;
2278 }
2279
b7d2280c
AV		 2280out:
2281 if (logit)
5e19ed90 2282 ql_dbg(ql_dbg_io, fcport->vha, 0x3022,
9cb78c16 2283 "FCP command status: 0x%x-0x%x (0x%x) nexus=%ld:%d:%llu "
7b833558 2284 "portid=%02x%02x%02x oxid=0x%x cdb=%10phN len=0x%x "
7c3df132 2285 "rsp_info=0x%x resid=0x%x fw_resid=0x%x.\n",
9ba56b95 2286 comp_status, scsi_status, res, vha->host_no,
cfb0919c
CD		 2287 cp->device->id, cp->device->lun, fcport->d_id.b.domain,
2288 fcport->d_id.b.area, fcport->d_id.b.al_pa, ox_id,
7b833558 2289 cp->cmnd, scsi_bufflen(cp), rsp_info_len,
7c3df132 2290 resid_len, fw_resid_len);
b7d2280c 2291
2afa19a9 2292 if (rsp->status_srb == NULL)
9ba56b95 2293 sp->done(ha, sp, res);
1da177e4
LT		 2294}
2295
2296/**
2297 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
2298 * @ha: SCSI driver HA context
2299 * @pkt: Entry pointer
2300 *
2301 * Extended sense data.
2302 */
2303static void
2afa19a9 2304qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
1da177e4 2305{
9ba56b95 2306 uint8_t sense_sz = 0;
2afa19a9 2307 struct qla_hw_data *ha = rsp->hw;
7c3df132 2308 struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
9ba56b95 2309 srb_t *sp = rsp->status_srb;
1da177e4 2310 struct scsi_cmnd *cp;
9ba56b95
GM		 2311 uint32_t sense_len;
2312 uint8_t *sense_ptr;
1da177e4 2313
9ba56b95
GM		 2314 if (!sp || !GET_CMD_SENSE_LEN(sp))
2315 return;
1da177e4 2316
9ba56b95
GM		 2317 sense_len = GET_CMD_SENSE_LEN(sp);
2318 sense_ptr = GET_CMD_SENSE_PTR(sp);
1da177e4 2319
9ba56b95
GM		 2320 cp = GET_CMD_SP(sp);
2321 if (cp == NULL) {
2322 ql_log(ql_log_warn, vha, 0x3025,
2323 "cmd is NULL: already returned to OS (sp=%p).\n", sp);
1da177e4 2324
9ba56b95
GM		 2325 rsp->status_srb = NULL;
2326 return;
1da177e4 2327 }
1da177e4 2328
9ba56b95
GM		 2329 if (sense_len > sizeof(pkt->data))
2330 sense_sz = sizeof(pkt->data);
2331 else
2332 sense_sz = sense_len;
c4631191 2333
9ba56b95
GM		 2334 /* Move sense data. */
2335 if (IS_FWI2_CAPABLE(ha))
2336 host_to_fcp_swap(pkt->data, sizeof(pkt->data));
2337 memcpy(sense_ptr, pkt->data, sense_sz);
2338 ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302c,
2339 sense_ptr, sense_sz);
c4631191 2340
9ba56b95
GM		 2341 sense_len -= sense_sz;
2342 sense_ptr += sense_sz;
c4631191 2343
9ba56b95
GM		 2344 SET_CMD_SENSE_PTR(sp, sense_ptr);
2345 SET_CMD_SENSE_LEN(sp, sense_len);
2346
2347 /* Place command on done queue. */
2348 if (sense_len == 0) {
2349 rsp->status_srb = NULL;
2350 sp->done(ha, sp, cp->result);
c4631191 2351 }
c4631191
GM		 2352}
2353
1da177e4
LT		 2354/**
2355 * qla2x00_error_entry() - Process an error entry.
2356 * @ha: SCSI driver HA context
2357 * @pkt: Entry pointer
2358 */
2359static void
73208dfd 2360qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
1da177e4
LT		 2361{
2362 srb_t *sp;
e315cd28 2363 struct qla_hw_data *ha = vha->hw;
c4631191 2364 const char func[] = "ERROR-IOCB";
2afa19a9 2365 uint16_t que = MSW(pkt->handle);
a6fe35c0 2366 struct req_que *req = NULL;
9ba56b95 2367 int res = DID_ERROR << 16;
7c3df132 2368
9ba56b95
GM		 2369 ql_dbg(ql_dbg_async, vha, 0x502a,
2370 "type of error status in response: 0x%x\n", pkt->entry_status);
2371
a6fe35c0
AE		 2372 if (que >= ha->max_req_queues || !ha->req_q_map[que])
2373 goto fatal;
2374
2375 req = ha->req_q_map[que];
2376
9ba56b95
GM		 2377 if (pkt->entry_status & RF_BUSY)
2378 res = DID_BUS_BUSY << 16;
1da177e4 2379
c4631191 2380 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
a6fe35c0 2381 if (sp) {
9ba56b95 2382 sp->done(ha, sp, res);
a6fe35c0 2383 return;
1da177e4 2384 }
a6fe35c0
AE		 2385fatal:
2386 ql_log(ql_log_warn, vha, 0x5030,
2387 "Error entry - invalid handle/queue.\n");
2388
7ec0effd 2389 if (IS_P3P_TYPE(ha))
a6fe35c0
AE		 2390 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
2391 else
2392 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2393 qla2xxx_wake_dpc(vha);
1da177e4
LT		 2394}
2395
9a853f71
AV		 2396/**
2397 * qla24xx_mbx_completion() - Process mailbox command completions.
2398 * @ha: SCSI driver HA context
2399 * @mb0: Mailbox0 register
2400 */
2401static void
e315cd28 2402qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
9a853f71
AV		 2403{
2404 uint16_t cnt;
4fa94f83 2405 uint32_t mboxes;
9a853f71 2406 uint16_t __iomem *wptr;
e315cd28 2407 struct qla_hw_data *ha = vha->hw;
9a853f71
AV		 2408 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
2409
4fa94f83
AV		 2410 /* Read all mbox registers? */
2411 mboxes = (1 << ha->mbx_count) - 1;
2412 if (!ha->mcp)
a720101d 2413 ql_dbg(ql_dbg_async, vha, 0x504e, "MBX pointer ERROR.\n");
4fa94f83
AV		 2414 else
2415 mboxes = ha->mcp->in_mb;
2416
9a853f71
AV		 2417 /* Load return mailbox registers. */
2418 ha->flags.mbox_int = 1;
2419 ha->mailbox_out[0] = mb0;
4fa94f83 2420 mboxes >>= 1;
9a853f71
AV		 2421 wptr = (uint16_t __iomem *)&reg->mailbox1;
2422
2423 for (cnt = 1; cnt < ha->mbx_count; cnt++) {
4fa94f83
AV		 2424 if (mboxes & BIT_0)
2425 ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
2426
2427 mboxes >>= 1;
9a853f71
AV		 2428 wptr++;
2429 }
9a853f71
AV		 2430}
2431
4440e46d
AB		 2432static void
2433qla24xx_abort_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
2434 struct abort_entry_24xx *pkt)
2435{
2436 const char func[] = "ABT_IOCB";
2437 srb_t *sp;
2438 struct srb_iocb *abt;
2439
2440 sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2441 if (!sp)
2442 return;
2443
2444 abt = &sp->u.iocb_cmd;
2445 abt->u.abt.comp_status = le32_to_cpu(pkt->nport_handle);
2446 sp->done(vha, sp, 0);
2447}
2448
9a853f71
AV		 2449/**
2450 * qla24xx_process_response_queue() - Process response queue entries.
2451 * @ha: SCSI driver HA context
2452 */
2afa19a9
AC		 2453void qla24xx_process_response_queue(struct scsi_qla_host *vha,
2454 struct rsp_que *rsp)
9a853f71 2455{
9a853f71 2456 struct sts_entry_24xx *pkt;
a9083016 2457 struct qla_hw_data *ha = vha->hw;
9a853f71 2458
e315cd28 2459 if (!vha->flags.online)
9a853f71
AV		 2460 return;
2461
e315cd28
AC		 2462 while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
2463 pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
9a853f71 2464
e315cd28
AC		 2465 rsp->ring_index++;
2466 if (rsp->ring_index == rsp->length) {
2467 rsp->ring_index = 0;
2468 rsp->ring_ptr = rsp->ring;
9a853f71 2469 } else {
e315cd28 2470 rsp->ring_ptr++;
9a853f71
AV		 2471 }
2472
2473 if (pkt->entry_status != 0) {
73208dfd 2474 qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
2d70c103 2475
f83adb61
QT		 2476 if (qlt_24xx_process_response_error(vha, pkt))
2477 goto process_err;
2d70c103 2478
9a853f71
AV		 2479 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
2480 wmb();
2481 continue;
2482 }
f83adb61 2483process_err:
9a853f71
AV		 2484
2485 switch (pkt->entry_type) {
2486 case STATUS_TYPE:
73208dfd 2487 qla2x00_status_entry(vha, rsp, pkt);
9a853f71
AV		 2488 break;
2489 case STATUS_CONT_TYPE:
2afa19a9 2490 qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
9a853f71 2491 break;
2c3dfe3f 2492 case VP_RPT_ID_IOCB_TYPE:
e315cd28 2493 qla24xx_report_id_acquisition(vha,
2c3dfe3f
SJ		 2494 (struct vp_rpt_id_entry_24xx *)pkt);
2495 break;
ac280b67
AV		 2496 case LOGINOUT_PORT_IOCB_TYPE:
2497 qla24xx_logio_entry(vha, rsp->req,
2498 (struct logio_entry_24xx *)pkt);
2499 break;
f83adb61 2500 case CT_IOCB_TYPE:
9a069e19 2501 qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
9a069e19 2502 break;
f83adb61 2503 case ELS_IOCB_TYPE:
9a069e19
GM		 2504 qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
2505 break;
2d70c103
NB		 2506 case ABTS_RECV_24XX:
2507 /* ensure that the ATIO queue is empty */
2508 qlt_24xx_process_atio_queue(vha);
2509 case ABTS_RESP_24XX:
2510 case CTIO_TYPE7:
2511 case NOTIFY_ACK_TYPE:
f83adb61 2512 case CTIO_CRC2:
2d70c103
NB		 2513 qlt_response_pkt_all_vps(vha, (response_t *)pkt);
2514 break;
54883291
SK		 2515 case MARKER_TYPE:
2516 /* Do nothing in this case, this check is to prevent it
2517 * from falling into default case
2518 */
2519 break;
4440e46d
AB		 2520 case ABORT_IOCB_TYPE:
2521 qla24xx_abort_iocb_entry(vha, rsp->req,
2522 (struct abort_entry_24xx *)pkt);
2523 break;
9a853f71
AV		 2524 default:
2525 /* Type Not Supported. */
7c3df132
SK		 2526 ql_dbg(ql_dbg_async, vha, 0x5042,
2527 "Received unknown response pkt type %x "
9a853f71 2528 "entry status=%x.\n",
7c3df132 2529 pkt->entry_type, pkt->entry_status);
9a853f71
AV		 2530 break;
2531 }
2532 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
2533 wmb();
2534 }
2535
2536 /* Adjust ring index */
7ec0effd 2537 if (IS_P3P_TYPE(ha)) {
a9083016
GM		 2538 struct device_reg_82xx __iomem *reg = &ha->iobase->isp82;
2539 WRT_REG_DWORD(&reg->rsp_q_out[0], rsp->ring_index);
2540 } else
2541 WRT_REG_DWORD(rsp->rsp_q_out, rsp->ring_index);
9a853f71
AV		 2542}
2543
05236a05 2544static void
e315cd28 2545qla2xxx_check_risc_status(scsi_qla_host_t *vha)
05236a05
AV		 2546{
2547 int rval;
2548 uint32_t cnt;
e315cd28 2549 struct qla_hw_data *ha = vha->hw;
05236a05
AV		 2550 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
2551
f73cb695
CD		 2552 if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
2553 !IS_QLA27XX(ha))
05236a05
AV		 2554 return;
2555
2556 rval = QLA_SUCCESS;
2557 WRT_REG_DWORD(&reg->iobase_addr, 0x7C00);
2558 RD_REG_DWORD(&reg->iobase_addr);
2559 WRT_REG_DWORD(&reg->iobase_window, 0x0001);
2560 for (cnt = 10000; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
2561 rval == QLA_SUCCESS; cnt--) {
2562 if (cnt) {
2563 WRT_REG_DWORD(&reg->iobase_window, 0x0001);
2564 udelay(10);
2565 } else
2566 rval = QLA_FUNCTION_TIMEOUT;
2567 }
2568 if (rval == QLA_SUCCESS)
2569 goto next_test;
2570
b2ec76c5 2571 rval = QLA_SUCCESS;
05236a05
AV		 2572 WRT_REG_DWORD(&reg->iobase_window, 0x0003);
2573 for (cnt = 100; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
2574 rval == QLA_SUCCESS; cnt--) {
2575 if (cnt) {
2576 WRT_REG_DWORD(&reg->iobase_window, 0x0003);
2577 udelay(10);
2578 } else
2579 rval = QLA_FUNCTION_TIMEOUT;
2580 }
2581 if (rval != QLA_SUCCESS)
2582 goto done;
2583
2584next_test:
2585 if (RD_REG_DWORD(&reg->iobase_c8) & BIT_3)
7c3df132
SK		 2586 ql_log(ql_log_info, vha, 0x504c,
2587 "Additional code -- 0x55AA.\n");
05236a05
AV		 2588
2589done:
2590 WRT_REG_DWORD(&reg->iobase_window, 0x0000);
2591 RD_REG_DWORD(&reg->iobase_window);
2592}
2593
9a853f71 2594/**
6246b8a1 2595 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP24xx.
9a853f71
AV		 2596 * @irq:
2597 * @dev_id: SCSI driver HA context
9a853f71
AV		 2598 *
2599 * Called by system whenever the host adapter generates an interrupt.
2600 *
2601 * Returns handled flag.
2602 */
2603irqreturn_t
7d12e780 2604qla24xx_intr_handler(int irq, void *dev_id)
9a853f71 2605{
e315cd28
AC		 2606 scsi_qla_host_t *vha;
2607 struct qla_hw_data *ha;
9a853f71
AV		 2608 struct device_reg_24xx __iomem *reg;
2609 int status;
9a853f71
AV		 2610 unsigned long iter;
2611 uint32_t stat;
2612 uint32_t hccr;
7d613ac6 2613 uint16_t mb[8];
e315cd28 2614 struct rsp_que *rsp;
43fac4d9 2615 unsigned long flags;
9a853f71 2616
e315cd28
AC		 2617 rsp = (struct rsp_que *) dev_id;
2618 if (!rsp) {
3256b435
CD		 2619 ql_log(ql_log_info, NULL, 0x5059,
2620 "%s: NULL response queue pointer.\n", __func__);
9a853f71
AV		 2621 return IRQ_NONE;
2622 }
2623
e315cd28 2624 ha = rsp->hw;
9a853f71
AV		 2625 reg = &ha->iobase->isp24;
2626 status = 0;
2627
85880801
AV		 2628 if (unlikely(pci_channel_offline(ha->pdev)))
2629 return IRQ_HANDLED;
2630
43fac4d9 2631 spin_lock_irqsave(&ha->hardware_lock, flags);
2afa19a9 2632 vha = pci_get_drvdata(ha->pdev);
9a853f71
AV		 2633 for (iter = 50; iter--; ) {
2634 stat = RD_REG_DWORD(&reg->host_status);
c821e0d5 2635 if (qla2x00_check_reg32_for_disconnect(vha, stat))
f3ddac19 2636 break;
9a853f71 2637 if (stat & HSRX_RISC_PAUSED) {
85880801 2638 if (unlikely(pci_channel_offline(ha->pdev)))
14e660e6
SJ		 2639 break;
2640
9a853f71
AV		 2641 hccr = RD_REG_DWORD(&reg->hccr);
2642
7c3df132
SK		 2643 ql_log(ql_log_warn, vha, 0x504b,
2644 "RISC paused -- HCCR=%x, Dumping firmware.\n",
2645 hccr);
05236a05 2646
e315cd28 2647 qla2xxx_check_risc_status(vha);
05236a05 2648
e315cd28
AC		 2649 ha->isp_ops->fw_dump(vha, 1);
2650 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
9a853f71
AV		 2651 break;
2652 } else if ((stat & HSRX_RISC_INT) == 0)
2653 break;
2654
2655 switch (stat & 0xff) {
fafbda9f
AE		 2656 case INTR_ROM_MB_SUCCESS:
2657 case INTR_ROM_MB_FAILED:
2658 case INTR_MB_SUCCESS:
2659 case INTR_MB_FAILED:
e315cd28 2660 qla24xx_mbx_completion(vha, MSW(stat));
9a853f71
AV		 2661 status |= MBX_INTERRUPT;
2662
2663 break;
fafbda9f 2664 case INTR_ASYNC_EVENT:
9a853f71
AV		 2665 mb[0] = MSW(stat);
2666 mb[1] = RD_REG_WORD(&reg->mailbox1);
2667 mb[2] = RD_REG_WORD(&reg->mailbox2);
2668 mb[3] = RD_REG_WORD(&reg->mailbox3);
73208dfd 2669 qla2x00_async_event(vha, rsp, mb);
9a853f71 2670 break;
fafbda9f
AE		 2671 case INTR_RSP_QUE_UPDATE:
2672 case INTR_RSP_QUE_UPDATE_83XX:
2afa19a9 2673 qla24xx_process_response_queue(vha, rsp);
9a853f71 2674 break;
fafbda9f 2675 case INTR_ATIO_QUE_UPDATE:
2d70c103
NB		 2676 qlt_24xx_process_atio_queue(vha);
2677 break;
fafbda9f 2678 case INTR_ATIO_RSP_QUE_UPDATE:
2d70c103
NB		 2679 qlt_24xx_process_atio_queue(vha);
2680 qla24xx_process_response_queue(vha, rsp);
2681 break;
9a853f71 2682 default:
7c3df132
SK		 2683 ql_dbg(ql_dbg_async, vha, 0x504f,
2684 "Unrecognized interrupt type (%d).\n", stat * 0xff);
9a853f71
AV		 2685 break;
2686 }
2687 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2688 RD_REG_DWORD_RELAXED(&reg->hccr);
cb860bbd
GM		 2689 if (unlikely(IS_QLA83XX(ha) && (ha->pdev->revision == 1)))
2690 ndelay(3500);
9a853f71 2691 }
36439832 2692 qla2x00_handle_mbx_completion(ha, status);
43fac4d9 2693 spin_unlock_irqrestore(&ha->hardware_lock, flags);
9a853f71 2694
9a853f71
AV		 2695 return IRQ_HANDLED;
2696}
2697
a8488abe
AV		 2698static irqreturn_t
2699qla24xx_msix_rsp_q(int irq, void *dev_id)
2700{
e315cd28
AC		 2701 struct qla_hw_data *ha;
2702 struct rsp_que *rsp;
a8488abe 2703 struct device_reg_24xx __iomem *reg;
2afa19a9 2704 struct scsi_qla_host *vha;
0f19bc68 2705 unsigned long flags;
f3ddac19 2706 uint32_t stat = 0;
a8488abe 2707
e315cd28
AC		 2708 rsp = (struct rsp_que *) dev_id;
2709 if (!rsp) {
3256b435
CD		 2710 ql_log(ql_log_info, NULL, 0x505a,
2711 "%s: NULL response queue pointer.\n", __func__);
e315cd28
AC		 2712 return IRQ_NONE;
2713 }
2714 ha = rsp->hw;
a8488abe
AV		 2715 reg = &ha->iobase->isp24;
2716
0f19bc68 2717 spin_lock_irqsave(&ha->hardware_lock, flags);
a8488abe 2718
a67093d4 2719 vha = pci_get_drvdata(ha->pdev);
f3ddac19
CD		 2720 /*
2721 * Use host_status register to check to PCI disconnection before we
2722 * we process the response queue.
2723 */
2724 stat = RD_REG_DWORD(&reg->host_status);
c821e0d5 2725 if (qla2x00_check_reg32_for_disconnect(vha, stat))
f3ddac19 2726 goto out;
2afa19a9 2727 qla24xx_process_response_queue(vha, rsp);
3155754a 2728 if (!ha->flags.disable_msix_handshake) {
eb94114b
AC		 2729 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2730 RD_REG_DWORD_RELAXED(&reg->hccr);
2731 }
f3ddac19 2732out:
0f19bc68 2733 spin_unlock_irqrestore(&ha->hardware_lock, flags);
a8488abe
AV		 2734
2735 return IRQ_HANDLED;
2736}
2737
68ca949c
AC		 2738static irqreturn_t
2739qla25xx_msix_rsp_q(int irq, void *dev_id)
2740{
2741 struct qla_hw_data *ha;
f3ddac19 2742 scsi_qla_host_t *vha;
68ca949c 2743 struct rsp_que *rsp;
3155754a 2744 struct device_reg_24xx __iomem *reg;
0f19bc68 2745 unsigned long flags;
f3ddac19 2746 uint32_t hccr = 0;
68ca949c
AC		 2747
2748 rsp = (struct rsp_que *) dev_id;
2749 if (!rsp) {
3256b435
CD		 2750 ql_log(ql_log_info, NULL, 0x505b,
2751 "%s: NULL response queue pointer.\n", __func__);
68ca949c
AC		 2752 return IRQ_NONE;
2753 }
2754 ha = rsp->hw;
f3ddac19 2755 vha = pci_get_drvdata(ha->pdev);
68ca949c 2756
3155754a 2757 /* Clear the interrupt, if enabled, for this response queue */
d424754c 2758 if (!ha->flags.disable_msix_handshake) {
3155754a 2759 reg = &ha->iobase->isp24;
0f19bc68 2760 spin_lock_irqsave(&ha->hardware_lock, flags);
3155754a 2761 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
f3ddac19 2762 hccr = RD_REG_DWORD_RELAXED(&reg->hccr);
0f19bc68 2763 spin_unlock_irqrestore(&ha->hardware_lock, flags);
3155754a 2764 }
c821e0d5 2765 if (qla2x00_check_reg32_for_disconnect(vha, hccr))
f3ddac19 2766 goto out;
68ca949c
AC		 2767 queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);
2768
f3ddac19 2769out:
68ca949c
AC		 2770 return IRQ_HANDLED;
2771}
2772
a8488abe
AV		 2773static irqreturn_t
2774qla24xx_msix_default(int irq, void *dev_id)
2775{
e315cd28
AC		 2776 scsi_qla_host_t *vha;
2777 struct qla_hw_data *ha;
2778 struct rsp_que *rsp;
a8488abe
AV		 2779 struct device_reg_24xx __iomem *reg;
2780 int status;
a8488abe
AV		 2781 uint32_t stat;
2782 uint32_t hccr;
7d613ac6 2783 uint16_t mb[8];
0f19bc68 2784 unsigned long flags;
a8488abe 2785
e315cd28
AC		 2786 rsp = (struct rsp_que *) dev_id;
2787 if (!rsp) {
3256b435
CD		 2788 ql_log(ql_log_info, NULL, 0x505c,
2789 "%s: NULL response queue pointer.\n", __func__);
e315cd28
AC		 2790 return IRQ_NONE;
2791 }
2792 ha = rsp->hw;
a8488abe
AV		 2793 reg = &ha->iobase->isp24;
2794 status = 0;
2795
0f19bc68 2796 spin_lock_irqsave(&ha->hardware_lock, flags);
2afa19a9 2797 vha = pci_get_drvdata(ha->pdev);
87f27015 2798 do {
a8488abe 2799 stat = RD_REG_DWORD(&reg->host_status);
c821e0d5 2800 if (qla2x00_check_reg32_for_disconnect(vha, stat))
f3ddac19 2801 break;
a8488abe 2802 if (stat & HSRX_RISC_PAUSED) {
85880801 2803 if (unlikely(pci_channel_offline(ha->pdev)))
14e660e6
SJ		 2804 break;
2805
a8488abe
AV		 2806 hccr = RD_REG_DWORD(&reg->hccr);
2807
7c3df132
SK		 2808 ql_log(ql_log_info, vha, 0x5050,
2809 "RISC paused -- HCCR=%x, Dumping firmware.\n",
2810 hccr);
05236a05 2811
e315cd28 2812 qla2xxx_check_risc_status(vha);
05236a05 2813
e315cd28
AC		 2814 ha->isp_ops->fw_dump(vha, 1);
2815 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
a8488abe
AV		 2816 break;
2817 } else if ((stat & HSRX_RISC_INT) == 0)
2818 break;
2819
2820 switch (stat & 0xff) {
fafbda9f
AE		 2821 case INTR_ROM_MB_SUCCESS:
2822 case INTR_ROM_MB_FAILED:
2823 case INTR_MB_SUCCESS:
2824 case INTR_MB_FAILED:
e315cd28 2825 qla24xx_mbx_completion(vha, MSW(stat));
a8488abe
AV		 2826 status |= MBX_INTERRUPT;
2827
2828 break;
fafbda9f 2829 case INTR_ASYNC_EVENT:
a8488abe
AV		 2830 mb[0] = MSW(stat);
2831 mb[1] = RD_REG_WORD(&reg->mailbox1);
2832 mb[2] = RD_REG_WORD(&reg->mailbox2);
2833 mb[3] = RD_REG_WORD(&reg->mailbox3);
73208dfd 2834 qla2x00_async_event(vha, rsp, mb);
a8488abe 2835 break;
fafbda9f
AE		 2836 case INTR_RSP_QUE_UPDATE:
2837 case INTR_RSP_QUE_UPDATE_83XX:
2afa19a9 2838 qla24xx_process_response_queue(vha, rsp);
a8488abe 2839 break;
fafbda9f 2840 case INTR_ATIO_QUE_UPDATE:
2d70c103
NB		 2841 qlt_24xx_process_atio_queue(vha);
2842 break;
fafbda9f 2843 case INTR_ATIO_RSP_QUE_UPDATE:
2d70c103
NB		 2844 qlt_24xx_process_atio_queue(vha);
2845 qla24xx_process_response_queue(vha, rsp);
2846 break;
a8488abe 2847 default:
7c3df132
SK		 2848 ql_dbg(ql_dbg_async, vha, 0x5051,
2849 "Unrecognized interrupt type (%d).\n", stat & 0xff);
a8488abe
AV		 2850 break;
2851 }
2852 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
87f27015 2853 } while (0);
36439832 2854 qla2x00_handle_mbx_completion(ha, status);
0f19bc68 2855 spin_unlock_irqrestore(&ha->hardware_lock, flags);
a8488abe 2856
a8488abe
AV		 2857 return IRQ_HANDLED;
2858}
2859
2860/* Interrupt handling helpers. */
2861
2862struct qla_init_msix_entry {
a8488abe 2863 const char *name;
476834c2 2864 irq_handler_t handler;
a8488abe
AV		 2865};
2866
68ca949c 2867static struct qla_init_msix_entry msix_entries[3] = {
2afa19a9
AC		 2868 { "qla2xxx (default)", qla24xx_msix_default },
2869 { "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
68ca949c 2870 { "qla2xxx (multiq)", qla25xx_msix_rsp_q },
a8488abe
AV		 2871};
2872
a9083016
GM		 2873static struct qla_init_msix_entry qla82xx_msix_entries[2] = {
2874 { "qla2xxx (default)", qla82xx_msix_default },
2875 { "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
2876};
2877
aa230bc5
AE		 2878static struct qla_init_msix_entry qla83xx_msix_entries[3] = {
2879 { "qla2xxx (default)", qla24xx_msix_default },
2880 { "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
2881 { "qla2xxx (atio_q)", qla83xx_msix_atio_q },
2882};
2883
a8488abe 2884static void
e315cd28 2885qla24xx_disable_msix(struct qla_hw_data *ha)
a8488abe
AV		 2886{
2887 int i;
2888 struct qla_msix_entry *qentry;
7c3df132 2889 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
a8488abe 2890
73208dfd
AC		 2891 for (i = 0; i < ha->msix_count; i++) {
2892 qentry = &ha->msix_entries[i];
a8488abe 2893 if (qentry->have_irq)
73208dfd 2894 free_irq(qentry->vector, qentry->rsp);
a8488abe
AV		 2895 }
2896 pci_disable_msix(ha->pdev);
73208dfd
AC		 2897 kfree(ha->msix_entries);
2898 ha->msix_entries = NULL;
2899 ha->flags.msix_enabled = 0;
7c3df132
SK		 2900 ql_dbg(ql_dbg_init, vha, 0x0042,
2901 "Disabled the MSI.\n");
a8488abe
AV		 2902}
2903
2904static int
73208dfd 2905qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
a8488abe 2906{
ad038fa8 2907#define MIN_MSIX_COUNT 2
f324777e 2908#define ATIO_VECTOR 2
a8488abe 2909 int i, ret;
73208dfd 2910 struct msix_entry *entries;
a8488abe 2911 struct qla_msix_entry *qentry;
7c3df132 2912 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
73208dfd
AC		 2913
2914 entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
a9083016 2915 GFP_KERNEL);
7c3df132
SK		 2916 if (!entries) {
2917 ql_log(ql_log_warn, vha, 0x00bc,
2918 "Failed to allocate memory for msix_entry.\n");
73208dfd 2919 return -ENOMEM;
7c3df132 2920 }
a8488abe 2921
73208dfd
AC		 2922 for (i = 0; i < ha->msix_count; i++)
2923 entries[i].entry = i;
a8488abe 2924
84e32a06
AG		 2925 ret = pci_enable_msix_range(ha->pdev,
2926 entries, MIN_MSIX_COUNT, ha->msix_count);
2927 if (ret < 0) {
2928 ql_log(ql_log_fatal, vha, 0x00c7,
2929 "MSI-X: Failed to enable support, "
2930 "giving up -- %d/%d.\n",
2931 ha->msix_count, ret);
2932 goto msix_out;
2933 } else if (ret < ha->msix_count) {
7c3df132
SK		 2934 ql_log(ql_log_warn, vha, 0x00c6,
2935 "MSI-X: Failed to enable support "
2936 "-- %d/%d\n Retry with %d vectors.\n",
2937 ha->msix_count, ret, ret);
73208dfd 2938 }
84e32a06
AG		 2939 ha->msix_count = ret;
2940 ha->max_rsp_queues = ha->msix_count - 1;
73208dfd
AC		 2941 ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
2942 ha->msix_count, GFP_KERNEL);
2943 if (!ha->msix_entries) {
7c3df132
SK		 2944 ql_log(ql_log_fatal, vha, 0x00c8,
2945 "Failed to allocate memory for ha->msix_entries.\n");
73208dfd 2946 ret = -ENOMEM;
a8488abe
AV		 2947 goto msix_out;
2948 }
2949 ha->flags.msix_enabled = 1;
2950
73208dfd
AC		 2951 for (i = 0; i < ha->msix_count; i++) {
2952 qentry = &ha->msix_entries[i];
2953 qentry->vector = entries[i].vector;
2954 qentry->entry = entries[i].entry;
a8488abe 2955 qentry->have_irq = 0;
73208dfd 2956 qentry->rsp = NULL;
a8488abe
AV		 2957 }
2958
2afa19a9 2959 /* Enable MSI-X vectors for the base queue */
f324777e 2960 for (i = 0; i < 2; i++) {
2afa19a9 2961 qentry = &ha->msix_entries[i];
f324777e 2962 if (IS_P3P_TYPE(ha))
a9083016
GM		 2963 ret = request_irq(qentry->vector,
2964 qla82xx_msix_entries[i].handler,
2965 0, qla82xx_msix_entries[i].name, rsp);
f324777e 2966 else
a9083016
GM		 2967 ret = request_irq(qentry->vector,
2968 msix_entries[i].handler,
2969 0, msix_entries[i].name, rsp);
f324777e
CD		 2970 if (ret)
2971 goto msix_register_fail;
2972 qentry->have_irq = 1;
2973 qentry->rsp = rsp;
2974 rsp->msix = qentry;
2975 }
2976
2977 /*
2978 * If target mode is enable, also request the vector for the ATIO
2979 * queue.
2980 */
2981 if (QLA_TGT_MODE_ENABLED() && IS_ATIO_MSIX_CAPABLE(ha)) {
2982 qentry = &ha->msix_entries[ATIO_VECTOR];
2983 ret = request_irq(qentry->vector,
2984 qla83xx_msix_entries[ATIO_VECTOR].handler,
2985 0, qla83xx_msix_entries[ATIO_VECTOR].name, rsp);
2afa19a9
AC		 2986 qentry->have_irq = 1;
2987 qentry->rsp = rsp;
2988 rsp->msix = qentry;
73208dfd 2989 }
73208dfd 2990
f324777e
CD		 2991msix_register_fail:
2992 if (ret) {
2993 ql_log(ql_log_fatal, vha, 0x00cb,
2994 "MSI-X: unable to register handler -- %x/%d.\n",
2995 qentry->vector, ret);
2996 qla24xx_disable_msix(ha);
2997 ha->mqenable = 0;
2998 goto msix_out;
2999 }
3000
73208dfd 3001 /* Enable MSI-X vector for response queue update for queue 0 */
f73cb695 3002 if (IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
6246b8a1
GM		 3003 if (ha->msixbase && ha->mqiobase &&
3004 (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
3005 ha->mqenable = 1;
3006 } else
3007 if (ha->mqiobase
3008 && (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
3009 ha->mqenable = 1;
7c3df132
SK		 3010 ql_dbg(ql_dbg_multiq, vha, 0xc005,
3011 "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
3012 ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
3013 ql_dbg(ql_dbg_init, vha, 0x0055,
3014 "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
3015 ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
73208dfd 3016
a8488abe 3017msix_out:
73208dfd 3018 kfree(entries);
a8488abe
AV		 3019 return ret;
3020}
3021
3022int
73208dfd 3023qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
a8488abe 3024{
7fa3e239 3025 int ret = QLA_FUNCTION_FAILED;
f73cb695 3026 device_reg_t *reg = ha->iobase;
7c3df132 3027 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
a8488abe
AV		 3028
3029 /* If possible, enable MSI-X. */
6246b8a1 3030 if (!IS_QLA2432(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
f73cb695
CD		 3031 !IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha) && !IS_QLAFX00(ha) &&
3032 !IS_QLA27XX(ha))
6377a7ae
BH		 3033 goto skip_msi;
3034
3035 if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
3036 (ha->pdev->subsystem_device == 0x7040 ||
3037 ha->pdev->subsystem_device == 0x7041 ||
3038 ha->pdev->subsystem_device == 0x1705)) {
7c3df132
SK		 3039 ql_log(ql_log_warn, vha, 0x0034,
3040 "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
6377a7ae 3041 ha->pdev->subsystem_vendor,
7c3df132 3042 ha->pdev->subsystem_device);
6377a7ae
BH		 3043 goto skip_msi;
3044 }
a8488abe 3045
42cd4f5d 3046 if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
7c3df132
SK		 3047 ql_log(ql_log_warn, vha, 0x0035,
3048 "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
42cd4f5d 3049 ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
a8488abe
AV		 3050 goto skip_msix;
3051 }
3052
73208dfd 3053 ret = qla24xx_enable_msix(ha, rsp);
a8488abe 3054 if (!ret) {
7c3df132
SK		 3055 ql_dbg(ql_dbg_init, vha, 0x0036,
3056 "MSI-X: Enabled (0x%X, 0x%X).\n",
3057 ha->chip_revision, ha->fw_attributes);
963b0fdd 3058 goto clear_risc_ints;
a8488abe 3059 }
7fa3e239 3060
a8488abe 3061skip_msix:
cbedb601 3062
7fa3e239
SC		 3063 ql_log(ql_log_info, vha, 0x0037,
3064 "Falling back-to MSI mode -%d.\n", ret);
3065
3a03eb79 3066 if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
f73cb695
CD		 3067 !IS_QLA8001(ha) && !IS_P3P_TYPE(ha) && !IS_QLAFX00(ha) &&
3068 !IS_QLA27XX(ha))
cbedb601
AV		 3069 goto skip_msi;
3070
3071 ret = pci_enable_msi(ha->pdev);
3072 if (!ret) {
7c3df132
SK		 3073 ql_dbg(ql_dbg_init, vha, 0x0038,
3074 "MSI: Enabled.\n");
cbedb601 3075 ha->flags.msi_enabled = 1;
a9083016 3076 } else
7c3df132 3077 ql_log(ql_log_warn, vha, 0x0039,
7fa3e239
SC		 3078 "Falling back-to INTa mode -- %d.\n", ret);
3079skip_msi:
a033b655
GM		 3080
3081 /* Skip INTx on ISP82xx. */
3082 if (!ha->flags.msi_enabled && IS_QLA82XX(ha))
3083 return QLA_FUNCTION_FAILED;
3084
fd34f556 3085 ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
7992abfc
MH		 3086 ha->flags.msi_enabled ? 0 : IRQF_SHARED,
3087 QLA2XXX_DRIVER_NAME, rsp);
963b0fdd 3088 if (ret) {
7c3df132 3089 ql_log(ql_log_warn, vha, 0x003a,
a8488abe
AV		 3090 "Failed to reserve interrupt %d already in use.\n",
3091 ha->pdev->irq);
963b0fdd 3092 goto fail;
8ae6d9c7 3093 } else if (!ha->flags.msi_enabled) {
68d91cbd
SK		 3094 ql_dbg(ql_dbg_init, vha, 0x0125,
3095 "INTa mode: Enabled.\n");
8ae6d9c7
GM		 3096 ha->flags.mr_intr_valid = 1;
3097 }
7992abfc 3098
963b0fdd
AV		 3099clear_risc_ints:
3100
c6952483 3101 spin_lock_irq(&ha->hardware_lock);
c1114953 3102 if (!IS_FWI2_CAPABLE(ha))
963b0fdd 3103 WRT_REG_WORD(&reg->isp.semaphore, 0);
c6952483 3104 spin_unlock_irq(&ha->hardware_lock);
a8488abe 3105
963b0fdd 3106fail:
a8488abe
AV		 3107 return ret;
3108}
3109
3110void
e315cd28 3111qla2x00_free_irqs(scsi_qla_host_t *vha)
a8488abe 3112{
e315cd28 3113 struct qla_hw_data *ha = vha->hw;
9a347ff4
CD		 3114 struct rsp_que *rsp;
3115
3116 /*
3117 * We need to check that ha->rsp_q_map is valid in case we are called
3118 * from a probe failure context.
3119 */
3120 if (!ha->rsp_q_map || !ha->rsp_q_map[0])
3121 return;
3122 rsp = ha->rsp_q_map[0];
a8488abe
AV		 3123
3124 if (ha->flags.msix_enabled)
3125 qla24xx_disable_msix(ha);
90a86fc0 3126 else if (ha->flags.msi_enabled) {
e315cd28 3127 free_irq(ha->pdev->irq, rsp);
cbedb601 3128 pci_disable_msi(ha->pdev);
90a86fc0
JC		 3129 } else
3130 free_irq(ha->pdev->irq, rsp);
a8488abe 3131}
e315cd28 3132
73208dfd
AC		 3133
3134int qla25xx_request_irq(struct rsp_que *rsp)
3135{
3136 struct qla_hw_data *ha = rsp->hw;
2afa19a9 3137 struct qla_init_msix_entry *intr = &msix_entries[2];
73208dfd 3138 struct qla_msix_entry *msix = rsp->msix;
7c3df132 3139 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
73208dfd
AC		 3140 int ret;
3141
3142 ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
3143 if (ret) {
7c3df132
SK		 3144 ql_log(ql_log_fatal, vha, 0x00e6,
3145 "MSI-X: Unable to register handler -- %x/%d.\n",
3146 msix->vector, ret);
73208dfd
AC		 3147 return ret;
3148 }
3149 msix->have_irq = 1;
3150 msix->rsp = rsp;
3151 return ret;
3152}
Linux 6.x block layer and io_uring tree(s)