qla_isr.c 80.8 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
A
Andrew Vasquez 已提交
2
 * QLogic Fibre Channel HBA Driver
3
 * Copyright (c)  2003-2013 QLogic Corporation
L
Linus Torvalds 已提交
4
 *
A
Andrew Vasquez 已提交
5
 * See LICENSE.qla2xxx for copyright and licensing details.
L
Linus Torvalds 已提交
6 7
 */
#include "qla_def.h"
8
#include "qla_target.h"
L
Linus Torvalds 已提交
9

10
#include <linux/delay.h>
11
#include <linux/slab.h>
12
#include <scsi/scsi_tcq.h>
13
#include <scsi/scsi_bsg_fc.h>
14
#include <scsi/scsi_eh.h>
15

L
Linus Torvalds 已提交
16
static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
17
static void qla2x00_status_entry(scsi_qla_host_t *, struct rsp_que *, void *);
18
static void qla2x00_status_cont_entry(struct rsp_que *, sts_cont_entry_t *);
19 20
static void qla2x00_error_entry(scsi_qla_host_t *, struct rsp_que *,
	sts_entry_t *);
21

L
Linus Torvalds 已提交
22 23 24 25 26 27 28 29 30 31
/**
 * qla2100_intr_handler() - Process interrupts for the ISP2100 and ISP2200.
 * @irq:
 * @dev_id: SCSI driver HA context
 *
 * Called by system whenever the host adapter generates an interrupt.
 *
 * Returns handled flag.
 */
irqreturn_t
32
qla2100_intr_handler(int irq, void *dev_id)
L
Linus Torvalds 已提交
33
{
34 35
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
36
	struct device_reg_2xxx __iomem *reg;
L
Linus Torvalds 已提交
37 38
	int		status;
	unsigned long	iter;
39
	uint16_t	hccr;
40
	uint16_t	mb[4];
41
	struct rsp_que *rsp;
42
	unsigned long	flags;
L
Linus Torvalds 已提交
43

44 45
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
46 47
		ql_log(ql_log_info, NULL, 0x505d,
		    "%s: NULL response queue pointer.\n", __func__);
L
Linus Torvalds 已提交
48 49 50
		return (IRQ_NONE);
	}

51
	ha = rsp->hw;
52
	reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
53 54
	status = 0;

55
	spin_lock_irqsave(&ha->hardware_lock, flags);
56
	vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
57
	for (iter = 50; iter--; ) {
58 59 60 61 62 63 64
		hccr = RD_REG_WORD(&reg->hccr);
		if (hccr & HCCR_RISC_PAUSE) {
			if (pci_channel_offline(ha->pdev))
				break;

			/*
			 * Issue a "HARD" reset in order for the RISC interrupt
65
			 * bit to be cleared.  Schedule a big hammer to get
66 67 68 69 70
			 * out of the RISC PAUSED state.
			 */
			WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
			RD_REG_WORD(&reg->hccr);

71 72
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
73 74
			break;
		} else if ((RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) == 0)
L
Linus Torvalds 已提交
75 76 77 78 79 80 81
			break;

		if (RD_REG_WORD(&reg->semaphore) & BIT_0) {
			WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
			RD_REG_WORD(&reg->hccr);

			/* Get mailbox data. */
82 83
			mb[0] = RD_MAILBOX_REG(ha, reg, 0);
			if (mb[0] > 0x3fff && mb[0] < 0x8000) {
84
				qla2x00_mbx_completion(vha, mb[0]);
L
Linus Torvalds 已提交
85
				status |= MBX_INTERRUPT;
86 87 88 89
			} else if (mb[0] > 0x7fff && mb[0] < 0xc000) {
				mb[1] = RD_MAILBOX_REG(ha, reg, 1);
				mb[2] = RD_MAILBOX_REG(ha, reg, 2);
				mb[3] = RD_MAILBOX_REG(ha, reg, 3);
90
				qla2x00_async_event(vha, rsp, mb);
L
Linus Torvalds 已提交
91 92
			} else {
				/*EMPTY*/
93 94 95
				ql_dbg(ql_dbg_async, vha, 0x5025,
				    "Unrecognized interrupt type (%d).\n",
				    mb[0]);
L
Linus Torvalds 已提交
96 97 98 99 100
			}
			/* Release mailbox registers. */
			WRT_REG_WORD(&reg->semaphore, 0);
			RD_REG_WORD(&reg->semaphore);
		} else {
101
			qla2x00_process_response_queue(rsp);
L
Linus Torvalds 已提交
102 103 104 105 106

			WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
			RD_REG_WORD(&reg->hccr);
		}
	}
107
	qla2x00_handle_mbx_completion(ha, status);
108
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
L
Linus Torvalds 已提交
109 110 111 112 113 114 115 116 117 118 119 120 121 122

	return (IRQ_HANDLED);
}

/**
 * qla2300_intr_handler() - Process interrupts for the ISP23xx and ISP63xx.
 * @irq:
 * @dev_id: SCSI driver HA context
 *
 * Called by system whenever the host adapter generates an interrupt.
 *
 * Returns handled flag.
 */
irqreturn_t
123
qla2300_intr_handler(int irq, void *dev_id)
L
Linus Torvalds 已提交
124
{
125
	scsi_qla_host_t	*vha;
126
	struct device_reg_2xxx __iomem *reg;
L
Linus Torvalds 已提交
127 128 129 130
	int		status;
	unsigned long	iter;
	uint32_t	stat;
	uint16_t	hccr;
131
	uint16_t	mb[4];
132 133
	struct rsp_que *rsp;
	struct qla_hw_data *ha;
134
	unsigned long	flags;
L
Linus Torvalds 已提交
135

136 137
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
138 139
		ql_log(ql_log_info, NULL, 0x5058,
		    "%s: NULL response queue pointer.\n", __func__);
L
Linus Torvalds 已提交
140 141 142
		return (IRQ_NONE);
	}

143
	ha = rsp->hw;
144
	reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
145 146
	status = 0;

147
	spin_lock_irqsave(&ha->hardware_lock, flags);
148
	vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
149 150 151
	for (iter = 50; iter--; ) {
		stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
		if (stat & HSR_RISC_PAUSED) {
152
			if (unlikely(pci_channel_offline(ha->pdev)))
153 154
				break;

L
Linus Torvalds 已提交
155 156
			hccr = RD_REG_WORD(&reg->hccr);
			if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
157 158 159
				ql_log(ql_log_warn, vha, 0x5026,
				    "Parity error -- HCCR=%x, Dumping "
				    "firmware.\n", hccr);
L
Linus Torvalds 已提交
160
			else
161 162 163
				ql_log(ql_log_warn, vha, 0x5027,
				    "RISC paused -- HCCR=%x, Dumping "
				    "firmware.\n", hccr);
L
Linus Torvalds 已提交
164 165 166 167

			/*
			 * Issue a "HARD" reset in order for the RISC
			 * interrupt bit to be cleared.  Schedule a big
168
			 * hammer to get out of the RISC PAUSED state.
L
Linus Torvalds 已提交
169 170 171
			 */
			WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
			RD_REG_WORD(&reg->hccr);
172

173 174
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
175 176 177 178 179 180 181 182 183
			break;
		} else if ((stat & HSR_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
		case 0x1:
		case 0x2:
		case 0x10:
		case 0x11:
184
			qla2x00_mbx_completion(vha, MSW(stat));
L
Linus Torvalds 已提交
185 186 187 188 189 190
			status |= MBX_INTERRUPT;

			/* Release mailbox registers. */
			WRT_REG_WORD(&reg->semaphore, 0);
			break;
		case 0x12:
191 192 193 194
			mb[0] = MSW(stat);
			mb[1] = RD_MAILBOX_REG(ha, reg, 1);
			mb[2] = RD_MAILBOX_REG(ha, reg, 2);
			mb[3] = RD_MAILBOX_REG(ha, reg, 3);
195
			qla2x00_async_event(vha, rsp, mb);
196 197
			break;
		case 0x13:
198
			qla2x00_process_response_queue(rsp);
L
Linus Torvalds 已提交
199 200
			break;
		case 0x15:
201 202
			mb[0] = MBA_CMPLT_1_16BIT;
			mb[1] = MSW(stat);
203
			qla2x00_async_event(vha, rsp, mb);
L
Linus Torvalds 已提交
204 205
			break;
		case 0x16:
206 207 208
			mb[0] = MBA_SCSI_COMPLETION;
			mb[1] = MSW(stat);
			mb[2] = RD_MAILBOX_REG(ha, reg, 2);
209
			qla2x00_async_event(vha, rsp, mb);
L
Linus Torvalds 已提交
210 211
			break;
		default:
212 213
			ql_dbg(ql_dbg_async, vha, 0x5028,
			    "Unrecognized interrupt type (%d).\n", stat & 0xff);
L
Linus Torvalds 已提交
214 215 216 217 218
			break;
		}
		WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
		RD_REG_WORD_RELAXED(&reg->hccr);
	}
219
	qla2x00_handle_mbx_completion(ha, status);
220
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
L
Linus Torvalds 已提交
221 222 223 224 225 226 227 228 229 230

	return (IRQ_HANDLED);
}

/**
 * qla2x00_mbx_completion() - Process mailbox command completions.
 * @ha: SCSI driver HA context
 * @mb0: Mailbox0 register
 */
static void
231
qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
L
Linus Torvalds 已提交
232 233
{
	uint16_t	cnt;
234
	uint32_t	mboxes;
L
Linus Torvalds 已提交
235
	uint16_t __iomem *wptr;
236
	struct qla_hw_data *ha = vha->hw;
237
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
238

239 240 241
	/* Read all mbox registers? */
	mboxes = (1 << ha->mbx_count) - 1;
	if (!ha->mcp)
242
		ql_dbg(ql_dbg_async, vha, 0x5001, "MBX pointer ERROR.\n");
243 244 245
	else
		mboxes = ha->mcp->in_mb;

L
Linus Torvalds 已提交
246 247 248
	/* Load return mailbox registers. */
	ha->flags.mbox_int = 1;
	ha->mailbox_out[0] = mb0;
249
	mboxes >>= 1;
L
Linus Torvalds 已提交
250 251 252
	wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);

	for (cnt = 1; cnt < ha->mbx_count; cnt++) {
A
Andrew Vasquez 已提交
253
		if (IS_QLA2200(ha) && cnt == 8)
L
Linus Torvalds 已提交
254
			wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
255
		if ((cnt == 4 || cnt == 5) && (mboxes & BIT_0))
L
Linus Torvalds 已提交
256
			ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
257
		else if (mboxes & BIT_0)
L
Linus Torvalds 已提交
258
			ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
A
Andrew Vasquez 已提交
259

L
Linus Torvalds 已提交
260
		wptr++;
261
		mboxes >>= 1;
L
Linus Torvalds 已提交
262 263 264
	}
}

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
static void
qla81xx_idc_event(scsi_qla_host_t *vha, uint16_t aen, uint16_t descr)
{
	static char *event[] =
		{ "Complete", "Request Notification", "Time Extension" };
	int rval;
	struct device_reg_24xx __iomem *reg24 = &vha->hw->iobase->isp24;
	uint16_t __iomem *wptr;
	uint16_t cnt, timeout, mb[QLA_IDC_ACK_REGS];

	/* Seed data -- mailbox1 -> mailbox7. */
	wptr = (uint16_t __iomem *)&reg24->mailbox1;
	for (cnt = 0; cnt < QLA_IDC_ACK_REGS; cnt++, wptr++)
		mb[cnt] = RD_REG_WORD(wptr);

280
	ql_dbg(ql_dbg_async, vha, 0x5021,
281
	    "Inter-Driver Communication %s -- "
282 283 284
	    "%04x %04x %04x %04x %04x %04x %04x.\n",
	    event[aen & 0xff], mb[0], mb[1], mb[2], mb[3],
	    mb[4], mb[5], mb[6]);
285 286 287 288 289
	if ((aen == MBA_IDC_COMPLETE && mb[1] >> 15)) {
		vha->hw->flags.idc_compl_status = 1;
		if (vha->hw->notify_dcbx_comp)
			complete(&vha->hw->dcbx_comp);
	}
290

291 292 293 294
	/* Acknowledgement needed? [Notify && non-zero timeout]. */
	timeout = (descr >> 8) & 0xf;
	if (aen != MBA_IDC_NOTIFY || !timeout)
		return;
295

296 297 298
	ql_dbg(ql_dbg_async, vha, 0x5022,
	    "%lu Inter-Driver Communication %s -- ACK timeout=%d.\n",
	    vha->host_no, event[aen & 0xff], timeout);
299 300 301

	rval = qla2x00_post_idc_ack_work(vha, mb);
	if (rval != QLA_SUCCESS)
302
		ql_log(ql_log_warn, vha, 0x5023,
303 304 305
		    "IDC failed to post ACK.\n");
}

306
#define LS_UNKNOWN	2
307 308
const char *
qla2x00_get_link_speed_str(struct qla_hw_data *ha, uint16_t speed)
309
{
310 311 312
	static const char * const link_speeds[] = {
		"1", "2", "?", "4", "8", "16", "10"
	};
313 314

	if (IS_QLA2100(ha) || IS_QLA2200(ha))
315 316 317 318 319 320 321
		return link_speeds[0];
	else if (speed == 0x13)
		return link_speeds[6];
	else if (speed < 6)
		return link_speeds[speed];
	else
		return link_speeds[LS_UNKNOWN];
322 323
}

324
static void
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
qla83xx_handle_8200_aen(scsi_qla_host_t *vha, uint16_t *mb)
{
	struct qla_hw_data *ha = vha->hw;

	/*
	 * 8200 AEN Interpretation:
	 * mb[0] = AEN code
	 * mb[1] = AEN Reason code
	 * mb[2] = LSW of Peg-Halt Status-1 Register
	 * mb[6] = MSW of Peg-Halt Status-1 Register
	 * mb[3] = LSW of Peg-Halt Status-2 register
	 * mb[7] = MSW of Peg-Halt Status-2 register
	 * mb[4] = IDC Device-State Register value
	 * mb[5] = IDC Driver-Presence Register value
	 */
	ql_dbg(ql_dbg_async, vha, 0x506b, "AEN Code: mb[0] = 0x%x AEN reason: "
	    "mb[1] = 0x%x PH-status1: mb[2] = 0x%x PH-status1: mb[6] = 0x%x.\n",
	    mb[0], mb[1], mb[2], mb[6]);
	ql_dbg(ql_dbg_async, vha, 0x506c, "PH-status2: mb[3] = 0x%x "
	    "PH-status2: mb[7] = 0x%x Device-State: mb[4] = 0x%x "
	    "Drv-Presence: mb[5] = 0x%x.\n", mb[3], mb[7], mb[4], mb[5]);

	if (mb[1] & (IDC_PEG_HALT_STATUS_CHANGE | IDC_NIC_FW_REPORTED_FAILURE |
				IDC_HEARTBEAT_FAILURE)) {
		ha->flags.nic_core_hung = 1;
		ql_log(ql_log_warn, vha, 0x5060,
		    "83XX: F/W Error Reported: Check if reset required.\n");

		if (mb[1] & IDC_PEG_HALT_STATUS_CHANGE) {
			uint32_t protocol_engine_id, fw_err_code, err_level;

			/*
			 * IDC_PEG_HALT_STATUS_CHANGE interpretation:
			 *  - PEG-Halt Status-1 Register:
			 *	(LSW = mb[2], MSW = mb[6])
			 *	Bits 0-7   = protocol-engine ID
			 *	Bits 8-28  = f/w error code
			 *	Bits 29-31 = Error-level
			 *	    Error-level 0x1 = Non-Fatal error
			 *	    Error-level 0x2 = Recoverable Fatal error
			 *	    Error-level 0x4 = UnRecoverable Fatal error
			 *  - PEG-Halt Status-2 Register:
			 *	(LSW = mb[3], MSW = mb[7])
			 */
			protocol_engine_id = (mb[2] & 0xff);
			fw_err_code = (((mb[2] & 0xff00) >> 8) |
			    ((mb[6] & 0x1fff) << 8));
			err_level = ((mb[6] & 0xe000) >> 13);
			ql_log(ql_log_warn, vha, 0x5061, "PegHalt Status-1 "
			    "Register: protocol_engine_id=0x%x "
			    "fw_err_code=0x%x err_level=0x%x.\n",
			    protocol_engine_id, fw_err_code, err_level);
			ql_log(ql_log_warn, vha, 0x5062, "PegHalt Status-2 "
			    "Register: 0x%x%x.\n", mb[7], mb[3]);
			if (err_level == ERR_LEVEL_NON_FATAL) {
				ql_log(ql_log_warn, vha, 0x5063,
				    "Not a fatal error, f/w has recovered "
				    "iteself.\n");
			} else if (err_level == ERR_LEVEL_RECOVERABLE_FATAL) {
				ql_log(ql_log_fatal, vha, 0x5064,
				    "Recoverable Fatal error: Chip reset "
				    "required.\n");
				qla83xx_schedule_work(vha,
				    QLA83XX_NIC_CORE_RESET);
			} else if (err_level == ERR_LEVEL_UNRECOVERABLE_FATAL) {
				ql_log(ql_log_fatal, vha, 0x5065,
				    "Unrecoverable Fatal error: Set FAILED "
				    "state, reboot required.\n");
				qla83xx_schedule_work(vha,
				    QLA83XX_NIC_CORE_UNRECOVERABLE);
			}
		}

		if (mb[1] & IDC_NIC_FW_REPORTED_FAILURE) {
			uint16_t peg_fw_state, nw_interface_link_up;
			uint16_t nw_interface_signal_detect, sfp_status;
			uint16_t htbt_counter, htbt_monitor_enable;
			uint16_t sfp_additonal_info, sfp_multirate;
			uint16_t sfp_tx_fault, link_speed, dcbx_status;

			/*
			 * IDC_NIC_FW_REPORTED_FAILURE interpretation:
			 *  - PEG-to-FC Status Register:
			 *	(LSW = mb[2], MSW = mb[6])
			 *	Bits 0-7   = Peg-Firmware state
			 *	Bit 8      = N/W Interface Link-up
			 *	Bit 9      = N/W Interface signal detected
			 *	Bits 10-11 = SFP Status
			 *	  SFP Status 0x0 = SFP+ transceiver not expected
			 *	  SFP Status 0x1 = SFP+ transceiver not present
			 *	  SFP Status 0x2 = SFP+ transceiver invalid
			 *	  SFP Status 0x3 = SFP+ transceiver present and
			 *	  valid
			 *	Bits 12-14 = Heartbeat Counter
			 *	Bit 15     = Heartbeat Monitor Enable
			 *	Bits 16-17 = SFP Additional Info
			 *	  SFP info 0x0 = Unregocnized transceiver for
			 *	  Ethernet
			 *	  SFP info 0x1 = SFP+ brand validation failed
			 *	  SFP info 0x2 = SFP+ speed validation failed
			 *	  SFP info 0x3 = SFP+ access error
			 *	Bit 18     = SFP Multirate
			 *	Bit 19     = SFP Tx Fault
			 *	Bits 20-22 = Link Speed
			 *	Bits 23-27 = Reserved
			 *	Bits 28-30 = DCBX Status
			 *	  DCBX Status 0x0 = DCBX Disabled
			 *	  DCBX Status 0x1 = DCBX Enabled
			 *	  DCBX Status 0x2 = DCBX Exchange error
			 *	Bit 31     = Reserved
			 */
			peg_fw_state = (mb[2] & 0x00ff);
			nw_interface_link_up = ((mb[2] & 0x0100) >> 8);
			nw_interface_signal_detect = ((mb[2] & 0x0200) >> 9);
			sfp_status = ((mb[2] & 0x0c00) >> 10);
			htbt_counter = ((mb[2] & 0x7000) >> 12);
			htbt_monitor_enable = ((mb[2] & 0x8000) >> 15);
			sfp_additonal_info = (mb[6] & 0x0003);
			sfp_multirate = ((mb[6] & 0x0004) >> 2);
			sfp_tx_fault = ((mb[6] & 0x0008) >> 3);
			link_speed = ((mb[6] & 0x0070) >> 4);
			dcbx_status = ((mb[6] & 0x7000) >> 12);

			ql_log(ql_log_warn, vha, 0x5066,
			    "Peg-to-Fc Status Register:\n"
			    "peg_fw_state=0x%x, nw_interface_link_up=0x%x, "
			    "nw_interface_signal_detect=0x%x"
			    "\nsfp_statis=0x%x.\n ", peg_fw_state,
			    nw_interface_link_up, nw_interface_signal_detect,
			    sfp_status);
			ql_log(ql_log_warn, vha, 0x5067,
			    "htbt_counter=0x%x, htbt_monitor_enable=0x%x, "
			    "sfp_additonal_info=0x%x, sfp_multirate=0x%x.\n ",
			    htbt_counter, htbt_monitor_enable,
			    sfp_additonal_info, sfp_multirate);
			ql_log(ql_log_warn, vha, 0x5068,
			    "sfp_tx_fault=0x%x, link_state=0x%x, "
			    "dcbx_status=0x%x.\n", sfp_tx_fault, link_speed,
			    dcbx_status);

			qla83xx_schedule_work(vha, QLA83XX_NIC_CORE_RESET);
		}

		if (mb[1] & IDC_HEARTBEAT_FAILURE) {
			ql_log(ql_log_warn, vha, 0x5069,
			    "Heartbeat Failure encountered, chip reset "
			    "required.\n");

			qla83xx_schedule_work(vha, QLA83XX_NIC_CORE_RESET);
		}
	}

	if (mb[1] & IDC_DEVICE_STATE_CHANGE) {
		ql_log(ql_log_info, vha, 0x506a,
		    "IDC Device-State changed = 0x%x.\n", mb[4]);
480 481
		if (ha->flags.nic_core_reset_owner)
			return;
482 483 484 485
		qla83xx_schedule_work(vha, MBA_IDC_AEN);
	}
}

486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
int
qla2x00_is_a_vp_did(scsi_qla_host_t *vha, uint32_t rscn_entry)
{
	struct qla_hw_data *ha = vha->hw;
	scsi_qla_host_t *vp;
	uint32_t vp_did;
	unsigned long flags;
	int ret = 0;

	if (!ha->num_vhosts)
		return ret;

	spin_lock_irqsave(&ha->vport_slock, flags);
	list_for_each_entry(vp, &ha->vp_list, list) {
		vp_did = vp->d_id.b24;
		if (vp_did == rscn_entry) {
			ret = 1;
			break;
		}
	}
	spin_unlock_irqrestore(&ha->vport_slock, flags);

	return ret;
}

L
Linus Torvalds 已提交
511 512 513
/**
 * qla2x00_async_event() - Process aynchronous events.
 * @ha: SCSI driver HA context
514
 * @mb: Mailbox registers (0 - 3)
L
Linus Torvalds 已提交
515
 */
516
void
517
qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
L
Linus Torvalds 已提交
518 519
{
	uint16_t	handle_cnt;
520
	uint16_t	cnt, mbx;
L
Linus Torvalds 已提交
521
	uint32_t	handles[5];
522
	struct qla_hw_data *ha = vha->hw;
523
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
524
	struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
525
	struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
L
Linus Torvalds 已提交
526
	uint32_t	rscn_entry, host_pid;
527
	unsigned long	flags;
L
Linus Torvalds 已提交
528 529 530

	/* Setup to process RIO completion. */
	handle_cnt = 0;
531
	if (IS_CNA_CAPABLE(ha))
532
		goto skip_rio;
L
Linus Torvalds 已提交
533 534
	switch (mb[0]) {
	case MBA_SCSI_COMPLETION:
535
		handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
L
Linus Torvalds 已提交
536 537 538
		handle_cnt = 1;
		break;
	case MBA_CMPLT_1_16BIT:
539
		handles[0] = mb[1];
L
Linus Torvalds 已提交
540 541 542 543
		handle_cnt = 1;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_2_16BIT:
544 545
		handles[0] = mb[1];
		handles[1] = mb[2];
L
Linus Torvalds 已提交
546 547 548 549
		handle_cnt = 2;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_3_16BIT:
550 551 552
		handles[0] = mb[1];
		handles[1] = mb[2];
		handles[2] = mb[3];
L
Linus Torvalds 已提交
553 554 555 556
		handle_cnt = 3;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_4_16BIT:
557 558 559
		handles[0] = mb[1];
		handles[1] = mb[2];
		handles[2] = mb[3];
L
Linus Torvalds 已提交
560 561 562 563 564
		handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
		handle_cnt = 4;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_5_16BIT:
565 566 567
		handles[0] = mb[1];
		handles[1] = mb[2];
		handles[2] = mb[3];
L
Linus Torvalds 已提交
568 569 570 571 572 573
		handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
		handles[4] = (uint32_t)RD_MAILBOX_REG(ha, reg, 7);
		handle_cnt = 5;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_2_32BIT:
574
		handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
L
Linus Torvalds 已提交
575 576 577 578 579 580 581 582 583
		handles[1] = le32_to_cpu(
		    ((uint32_t)(RD_MAILBOX_REG(ha, reg, 7) << 16)) |
		    RD_MAILBOX_REG(ha, reg, 6));
		handle_cnt = 2;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	default:
		break;
	}
584
skip_rio:
L
Linus Torvalds 已提交
585 586
	switch (mb[0]) {
	case MBA_SCSI_COMPLETION:	/* Fast Post */
587
		if (!vha->flags.online)
L
Linus Torvalds 已提交
588 589 590
			break;

		for (cnt = 0; cnt < handle_cnt; cnt++)
591 592
			qla2x00_process_completed_request(vha, rsp->req,
				handles[cnt]);
L
Linus Torvalds 已提交
593 594 595
		break;

	case MBA_RESET:			/* Reset */
596 597
		ql_dbg(ql_dbg_async, vha, 0x5002,
		    "Asynchronous RESET.\n");
L
Linus Torvalds 已提交
598

599
		set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
600 601 602
		break;

	case MBA_SYSTEM_ERR:		/* System Error */
603 604
		mbx = (IS_QLA81XX(ha) || IS_QLA83XX(ha)) ?
			RD_REG_WORD(&reg24->mailbox7) : 0;
605
		ql_log(ql_log_warn, vha, 0x5003,
606 607
		    "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh "
		    "mbx7=%xh.\n", mb[1], mb[2], mb[3], mbx);
L
Linus Torvalds 已提交
608

609
		ha->isp_ops->fw_dump(vha, 1);
L
Linus Torvalds 已提交
610

611
		if (IS_FWI2_CAPABLE(ha)) {
612
			if (mb[1] == 0 && mb[2] == 0) {
613
				ql_log(ql_log_fatal, vha, 0x5004,
614 615
				    "Unrecoverable Hardware Error: adapter "
				    "marked OFFLINE!\n");
616
				vha->flags.online = 0;
617
				vha->device_flags |= DFLG_DEV_FAILED;
618
			} else {
L
Lucas De Marchi 已提交
619
				/* Check to see if MPI timeout occurred */
620 621 622 623
				if ((mbx & MBX_3) && (ha->flags.port0))
					set_bit(MPI_RESET_NEEDED,
					    &vha->dpc_flags);

624
				set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
625
			}
626
		} else if (mb[1] == 0) {
627
			ql_log(ql_log_fatal, vha, 0x5005,
L
Linus Torvalds 已提交
628 629
			    "Unrecoverable Hardware Error: adapter marked "
			    "OFFLINE!\n");
630
			vha->flags.online = 0;
631
			vha->device_flags |= DFLG_DEV_FAILED;
L
Linus Torvalds 已提交
632
		} else
633
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
634 635 636
		break;

	case MBA_REQ_TRANSFER_ERR:	/* Request Transfer Error */
637 638
		ql_log(ql_log_warn, vha, 0x5006,
		    "ISP Request Transfer Error (%x).\n",  mb[1]);
L
Linus Torvalds 已提交
639

640
		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
641 642 643
		break;

	case MBA_RSP_TRANSFER_ERR:	/* Response Transfer Error */
644 645
		ql_log(ql_log_warn, vha, 0x5007,
		    "ISP Response Transfer Error.\n");
L
Linus Torvalds 已提交
646

647
		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
648 649 650
		break;

	case MBA_WAKEUP_THRES:		/* Request Queue Wake-up */
651 652
		ql_dbg(ql_dbg_async, vha, 0x5008,
		    "Asynchronous WAKEUP_THRES.\n");
L
Linus Torvalds 已提交
653

654
		break;
L
Linus Torvalds 已提交
655
	case MBA_LIP_OCCURRED:		/* Loop Initialization Procedure */
656
		ql_dbg(ql_dbg_async, vha, 0x5009,
657
		    "LIP occurred (%x).\n", mb[1]);
L
Linus Torvalds 已提交
658

659 660 661 662
		if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
			atomic_set(&vha->loop_state, LOOP_DOWN);
			atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
			qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
663 664
		}

665 666 667
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
668 669
		}

670 671
		set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
		set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
672

673 674
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
L
Linus Torvalds 已提交
675 676 677
		break;

	case MBA_LOOP_UP:		/* Loop Up Event */
678
		if (IS_QLA2100(ha) || IS_QLA2200(ha))
679
			ha->link_data_rate = PORT_SPEED_1GB;
680
		else
L
Linus Torvalds 已提交
681 682
			ha->link_data_rate = mb[1];

683
		ql_dbg(ql_dbg_async, vha, 0x500a,
684
		    "LOOP UP detected (%s Gbps).\n",
685
		    qla2x00_get_link_speed_str(ha, ha->link_data_rate));
L
Linus Torvalds 已提交
686

687 688
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
L
Linus Torvalds 已提交
689 690 691
		break;

	case MBA_LOOP_DOWN:		/* Loop Down Event */
692 693
		mbx = (IS_QLA81XX(ha) || IS_QLA8031(ha))
			? RD_REG_WORD(&reg24->mailbox4) : 0;
694 695
		mbx = (IS_P3P_TYPE(ha)) ? RD_REG_WORD(&reg82->mailbox_out[4])
			: mbx;
696
		ql_dbg(ql_dbg_async, vha, 0x500b,
697 698
		    "LOOP DOWN detected (%x %x %x %x).\n",
		    mb[1], mb[2], mb[3], mbx);
L
Linus Torvalds 已提交
699

700 701 702 703 704
		if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
			atomic_set(&vha->loop_state, LOOP_DOWN);
			atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
			vha->device_flags |= DFLG_NO_CABLE;
			qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
705 706
		}

707 708 709
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
710 711
		}

712
		vha->flags.management_server_logged_in = 0;
713
		ha->link_data_rate = PORT_SPEED_UNKNOWN;
714
		qla2x00_post_aen_work(vha, FCH_EVT_LINKDOWN, 0);
L
Linus Torvalds 已提交
715 716 717
		break;

	case MBA_LIP_RESET:		/* LIP reset occurred */
718
		ql_dbg(ql_dbg_async, vha, 0x500c,
719
		    "LIP reset occurred (%x).\n", mb[1]);
L
Linus Torvalds 已提交
720

721 722 723 724
		if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
			atomic_set(&vha->loop_state, LOOP_DOWN);
			atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
			qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
725 726
		}

727 728 729
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
730 731
		}

732
		set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
733 734

		ha->operating_mode = LOOP;
735 736
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
L
Linus Torvalds 已提交
737 738
		break;

739
	/* case MBA_DCBX_COMPLETE: */
L
Linus Torvalds 已提交
740 741 742 743
	case MBA_POINT_TO_POINT:	/* Point-to-Point */
		if (IS_QLA2100(ha))
			break;

744
		if (IS_CNA_CAPABLE(ha)) {
745 746 747
			ql_dbg(ql_dbg_async, vha, 0x500d,
			    "DCBX Completed -- %04x %04x %04x.\n",
			    mb[1], mb[2], mb[3]);
748 749 750 751
			if (ha->notify_dcbx_comp)
				complete(&ha->dcbx_comp);

		} else
752 753
			ql_dbg(ql_dbg_async, vha, 0x500e,
			    "Asynchronous P2P MODE received.\n");
L
Linus Torvalds 已提交
754 755 756 757 758

		/*
		 * Until there's a transition from loop down to loop up, treat
		 * this as loop down only.
		 */
759 760 761 762
		if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
			atomic_set(&vha->loop_state, LOOP_DOWN);
			if (!atomic_read(&vha->loop_down_timer))
				atomic_set(&vha->loop_down_timer,
L
Linus Torvalds 已提交
763
				    LOOP_DOWN_TIME);
764
			qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
765 766
		}

767 768 769
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
770 771
		}

772 773 774 775 776
		if (!(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)))
			set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);

		set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
		set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
777 778

		ha->flags.gpsc_supported = 1;
779
		vha->flags.management_server_logged_in = 0;
L
Linus Torvalds 已提交
780 781 782 783 784 785
		break;

	case MBA_CHG_IN_CONNECTION:	/* Change in connection mode */
		if (IS_QLA2100(ha))
			break;

786
		ql_dbg(ql_dbg_async, vha, 0x500f,
L
Linus Torvalds 已提交
787 788
		    "Configuration change detected: value=%x.\n", mb[1]);

789 790 791 792
		if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
			atomic_set(&vha->loop_state, LOOP_DOWN);
			if (!atomic_read(&vha->loop_down_timer))
				atomic_set(&vha->loop_down_timer,
L
Linus Torvalds 已提交
793
				    LOOP_DOWN_TIME);
794
			qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
795 796
		}

797 798 799
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
800 801
		}

802 803
		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
L
Linus Torvalds 已提交
804 805 806
		break;

	case MBA_PORT_UPDATE:		/* Port database update */
807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
		/*
		 * Handle only global and vn-port update events
		 *
		 * Relevant inputs:
		 * mb[1] = N_Port handle of changed port
		 * OR 0xffff for global event
		 * mb[2] = New login state
		 * 7 = Port logged out
		 * mb[3] = LSB is vp_idx, 0xff = all vps
		 *
		 * Skip processing if:
		 *       Event is global, vp_idx is NOT all vps,
		 *           vp_idx does not match
		 *       Event is not global, vp_idx does not match
		 */
822 823 824 825
		if (IS_QLA2XXX_MIDTYPE(ha) &&
		    ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff) ||
			(mb[1] != 0xffff)) && vha->vp_idx != (mb[3] & 0xff))
			break;
826

827 828
		/* Global event -- port logout or port unavailable. */
		if (mb[1] == 0xffff && mb[2] == 0x7) {
829 830 831
			ql_dbg(ql_dbg_async, vha, 0x5010,
			    "Port unavailable %04x %04x %04x.\n",
			    mb[1], mb[2], mb[3]);
832 833
			ql_log(ql_log_warn, vha, 0x505e,
			    "Link is offline.\n");
834 835 836 837 838 839 840 841 842 843 844 845 846

			if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
				atomic_set(&vha->loop_state, LOOP_DOWN);
				atomic_set(&vha->loop_down_timer,
				    LOOP_DOWN_TIME);
				vha->device_flags |= DFLG_NO_CABLE;
				qla2x00_mark_all_devices_lost(vha, 1);
			}

			if (vha->vp_idx) {
				atomic_set(&vha->vp_state, VP_FAILED);
				fc_vport_set_state(vha->fc_vport,
				    FC_VPORT_FAILED);
847
				qla2x00_mark_all_devices_lost(vha, 1);
848 849 850 851 852 853 854
			}

			vha->flags.management_server_logged_in = 0;
			ha->link_data_rate = PORT_SPEED_UNKNOWN;
			break;
		}

L
Linus Torvalds 已提交
855
		/*
856
		 * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
L
Linus Torvalds 已提交
857 858 859
		 * event etc. earlier indicating loop is down) then process
		 * it.  Otherwise ignore it and Wait for RSCN to come in.
		 */
860
		atomic_set(&vha->loop_down_timer, 0);
861
		if (mb[1] != 0xffff || (mb[2] != 0x6 && mb[2] != 0x4)) {
862 863 864
			ql_dbg(ql_dbg_async, vha, 0x5011,
			    "Asynchronous PORT UPDATE ignored %04x/%04x/%04x.\n",
			    mb[1], mb[2], mb[3]);
865 866

			qlt_async_event(mb[0], vha, mb);
L
Linus Torvalds 已提交
867 868 869
			break;
		}

870 871 872
		ql_dbg(ql_dbg_async, vha, 0x5012,
		    "Port database changed %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
873 874
		ql_log(ql_log_warn, vha, 0x505f,
		    "Link is operational (%s Gbps).\n",
875
		    qla2x00_get_link_speed_str(ha, ha->link_data_rate));
L
Linus Torvalds 已提交
876 877 878 879

		/*
		 * Mark all devices as missing so we will login again.
		 */
880
		atomic_set(&vha->loop_state, LOOP_UP);
L
Linus Torvalds 已提交
881

882
		qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
883

884 885 886
		if (vha->vp_idx == 0 && !qla_ini_mode_enabled(vha))
			set_bit(SCR_PENDING, &vha->dpc_flags);

887 888
		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
889 890

		qlt_async_event(mb[0], vha, mb);
L
Linus Torvalds 已提交
891 892 893
		break;

	case MBA_RSCN_UPDATE:		/* State Change Registration */
894
		/* Check if the Vport has issued a SCR */
895
		if (vha->vp_idx && test_bit(VP_SCR_NEEDED, &vha->vp_flags))
896 897
			break;
		/* Only handle SCNs for our Vport index. */
898
		if (ha->flags.npiv_supported && vha->vp_idx != (mb[3] & 0xff))
899
			break;
900

901 902 903
		ql_dbg(ql_dbg_async, vha, 0x5013,
		    "RSCN database changed -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
L
Linus Torvalds 已提交
904

905
		rscn_entry = ((mb[1] & 0xff) << 16) | mb[2];
906 907
		host_pid = (vha->d_id.b.domain << 16) | (vha->d_id.b.area << 8)
				| vha->d_id.b.al_pa;
L
Linus Torvalds 已提交
908
		if (rscn_entry == host_pid) {
909 910 911
			ql_dbg(ql_dbg_async, vha, 0x5014,
			    "Ignoring RSCN update to local host "
			    "port ID (%06x).\n", host_pid);
L
Linus Torvalds 已提交
912 913 914
			break;
		}

915 916
		/* Ignore reserved bits from RSCN-payload. */
		rscn_entry = ((mb[1] & 0x3ff) << 16) | mb[2];
L
Linus Torvalds 已提交
917

918 919 920 921
		/* Skip RSCNs for virtual ports on the same physical port */
		if (qla2x00_is_a_vp_did(vha, rscn_entry))
			break;

922 923
		atomic_set(&vha->loop_down_timer, 0);
		vha->flags.management_server_logged_in = 0;
L
Linus Torvalds 已提交
924

925 926 927
		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
		set_bit(RSCN_UPDATE, &vha->dpc_flags);
		qla2x00_post_aen_work(vha, FCH_EVT_RSCN, rscn_entry);
L
Linus Torvalds 已提交
928 929 930 931
		break;

	/* case MBA_RIO_RESPONSE: */
	case MBA_ZIO_RESPONSE:
932 933
		ql_dbg(ql_dbg_async, vha, 0x5015,
		    "[R|Z]IO update completion.\n");
L
Linus Torvalds 已提交
934

935
		if (IS_FWI2_CAPABLE(ha))
936
			qla24xx_process_response_queue(vha, rsp);
937
		else
938
			qla2x00_process_response_queue(rsp);
L
Linus Torvalds 已提交
939
		break;
940 941

	case MBA_DISCARD_RND_FRAME:
942 943 944
		ql_dbg(ql_dbg_async, vha, 0x5016,
		    "Discard RND Frame -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
945
		break;
946 947

	case MBA_TRACE_NOTIFICATION:
948 949
		ql_dbg(ql_dbg_async, vha, 0x5017,
		    "Trace Notification -- %04x %04x.\n", mb[1], mb[2]);
950
		break;
951 952

	case MBA_ISP84XX_ALERT:
953 954 955
		ql_dbg(ql_dbg_async, vha, 0x5018,
		    "ISP84XX Alert Notification -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
956 957 958 959

		spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
		switch (mb[1]) {
		case A84_PANIC_RECOVERY:
960 961 962
			ql_log(ql_log_info, vha, 0x5019,
			    "Alert 84XX: panic recovery %04x %04x.\n",
			    mb[2], mb[3]);
963 964 965
			break;
		case A84_OP_LOGIN_COMPLETE:
			ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
966 967 968
			ql_log(ql_log_info, vha, 0x501a,
			    "Alert 84XX: firmware version %x.\n",
			    ha->cs84xx->op_fw_version);
969 970 971
			break;
		case A84_DIAG_LOGIN_COMPLETE:
			ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
972 973 974
			ql_log(ql_log_info, vha, 0x501b,
			    "Alert 84XX: diagnostic firmware version %x.\n",
			    ha->cs84xx->diag_fw_version);
975 976 977 978
			break;
		case A84_GOLD_LOGIN_COMPLETE:
			ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
			ha->cs84xx->fw_update = 1;
979 980 981
			ql_log(ql_log_info, vha, 0x501c,
			    "Alert 84XX: gold firmware version %x.\n",
			    ha->cs84xx->gold_fw_version);
982 983
			break;
		default:
984 985
			ql_log(ql_log_warn, vha, 0x501d,
			    "Alert 84xx: Invalid Alert %04x %04x %04x.\n",
986 987 988 989
			    mb[1], mb[2], mb[3]);
		}
		spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
		break;
990
	case MBA_DCBX_START:
991 992 993
		ql_dbg(ql_dbg_async, vha, 0x501e,
		    "DCBX Started -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
994 995
		break;
	case MBA_DCBX_PARAM_UPDATE:
996 997 998
		ql_dbg(ql_dbg_async, vha, 0x501f,
		    "DCBX Parameters Updated -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
999 1000
		break;
	case MBA_FCF_CONF_ERR:
1001 1002 1003
		ql_dbg(ql_dbg_async, vha, 0x5020,
		    "FCF Configuration Error -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
1004 1005
		break;
	case MBA_IDC_NOTIFY:
1006
		if (IS_QLA8031(vha->hw) || IS_QLA8044(ha)) {
1007 1008 1009 1010
			mb[4] = RD_REG_WORD(&reg24->mailbox4);
			if (((mb[2] & 0x7fff) == MBC_PORT_RESET ||
			    (mb[2] & 0x7fff) == MBC_SET_PORT_CONFIG) &&
			    (mb[4] & INTERNAL_LOOPBACK_MASK) != 0) {
1011
				set_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags);
1012 1013 1014 1015 1016 1017
				/*
				 * Extend loop down timer since port is active.
				 */
				if (atomic_read(&vha->loop_state) == LOOP_DOWN)
					atomic_set(&vha->loop_down_timer,
					    LOOP_DOWN_TIME);
1018 1019
				qla2xxx_wake_dpc(vha);
			}
1020
		}
1021
	case MBA_IDC_COMPLETE:
1022 1023 1024
		if (ha->notify_lb_portup_comp)
			complete(&ha->lb_portup_comp);
		/* Fallthru */
1025
	case MBA_IDC_TIME_EXT:
1026 1027
		if (IS_QLA81XX(vha->hw) || IS_QLA8031(vha->hw) ||
		    IS_QLA8044(ha))
1028 1029 1030 1031 1032 1033 1034 1035 1036
			qla81xx_idc_event(vha, mb[0], mb[1]);
		break;

	case MBA_IDC_AEN:
		mb[4] = RD_REG_WORD(&reg24->mailbox4);
		mb[5] = RD_REG_WORD(&reg24->mailbox5);
		mb[6] = RD_REG_WORD(&reg24->mailbox6);
		mb[7] = RD_REG_WORD(&reg24->mailbox7);
		qla83xx_handle_8200_aen(vha, mb);
1037
		break;
1038

1039 1040 1041 1042
	default:
		ql_dbg(ql_dbg_async, vha, 0x5057,
		    "Unknown AEN:%04x %04x %04x %04x\n",
		    mb[0], mb[1], mb[2], mb[3]);
L
Linus Torvalds 已提交
1043
	}
1044

1045 1046
	qlt_async_event(mb[0], vha, mb);

1047
	if (!vha->vp_idx && ha->num_vhosts)
1048
		qla2x00_alert_all_vps(rsp, mb);
L
Linus Torvalds 已提交
1049 1050 1051 1052 1053 1054 1055
}

/**
 * qla2x00_process_completed_request() - Process a Fast Post response.
 * @ha: SCSI driver HA context
 * @index: SRB index
 */
1056
void
1057
qla2x00_process_completed_request(struct scsi_qla_host *vha,
1058
				  struct req_que *req, uint32_t index)
L
Linus Torvalds 已提交
1059 1060
{
	srb_t *sp;
1061
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1062 1063

	/* Validate handle. */
1064
	if (index >= req->num_outstanding_cmds) {
1065 1066
		ql_log(ql_log_warn, vha, 0x3014,
		    "Invalid SCSI command index (%x).\n", index);
L
Linus Torvalds 已提交
1067

1068
		if (IS_P3P_TYPE(ha))
1069 1070 1071
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
1072 1073 1074
		return;
	}

1075
	sp = req->outstanding_cmds[index];
L
Linus Torvalds 已提交
1076 1077
	if (sp) {
		/* Free outstanding command slot. */
1078
		req->outstanding_cmds[index] = NULL;
L
Linus Torvalds 已提交
1079 1080

		/* Save ISP completion status */
1081
		sp->done(ha, sp, DID_OK << 16);
L
Linus Torvalds 已提交
1082
	} else {
1083
		ql_log(ql_log_warn, vha, 0x3016, "Invalid SCSI SRB.\n");
L
Linus Torvalds 已提交
1084

1085
		if (IS_P3P_TYPE(ha))
1086 1087 1088
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
1089 1090 1091
	}
}

1092
srb_t *
1093 1094 1095 1096 1097 1098 1099 1100 1101
qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
    struct req_que *req, void *iocb)
{
	struct qla_hw_data *ha = vha->hw;
	sts_entry_t *pkt = iocb;
	srb_t *sp = NULL;
	uint16_t index;

	index = LSW(pkt->handle);
1102
	if (index >= req->num_outstanding_cmds) {
1103 1104
		ql_log(ql_log_warn, vha, 0x5031,
		    "Invalid command index (%x).\n", index);
1105
		if (IS_P3P_TYPE(ha))
1106 1107 1108
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1109 1110 1111 1112
		goto done;
	}
	sp = req->outstanding_cmds[index];
	if (!sp) {
1113 1114
		ql_log(ql_log_warn, vha, 0x5032,
		    "Invalid completion handle (%x) -- timed-out.\n", index);
1115 1116 1117
		return sp;
	}
	if (sp->handle != index) {
1118 1119
		ql_log(ql_log_warn, vha, 0x5033,
		    "SRB handle (%x) mismatch %x.\n", sp->handle, index);
1120 1121
		return NULL;
	}
1122

1123
	req->outstanding_cmds[index] = NULL;
1124

1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
done:
	return sp;
}

static void
qla2x00_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
    struct mbx_entry *mbx)
{
	const char func[] = "MBX-IOCB";
	const char *type;
	fc_port_t *fcport;
	srb_t *sp;
1137
	struct srb_iocb *lio;
1138
	uint16_t *data;
1139
	uint16_t status;
1140 1141 1142 1143 1144

	sp = qla2x00_get_sp_from_handle(vha, func, req, mbx);
	if (!sp)
		return;

1145 1146
	lio = &sp->u.iocb_cmd;
	type = sp->name;
1147
	fcport = sp->fcport;
1148
	data = lio->u.logio.data;
1149

1150
	data[0] = MBS_COMMAND_ERROR;
1151
	data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
1152
	    QLA_LOGIO_LOGIN_RETRIED : 0;
1153
	if (mbx->entry_status) {
1154
		ql_dbg(ql_dbg_async, vha, 0x5043,
1155
		    "Async-%s error entry - hdl=%x portid=%02x%02x%02x "
1156
		    "entry-status=%x status=%x state-flag=%x "
1157 1158
		    "status-flags=%x.\n", type, sp->handle,
		    fcport->d_id.b.domain, fcport->d_id.b.area,
1159 1160
		    fcport->d_id.b.al_pa, mbx->entry_status,
		    le16_to_cpu(mbx->status), le16_to_cpu(mbx->state_flags),
1161
		    le16_to_cpu(mbx->status_flags));
1162

1163
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5029,
1164
		    (uint8_t *)mbx, sizeof(*mbx));
1165

1166
		goto logio_done;
1167 1168
	}

1169
	status = le16_to_cpu(mbx->status);
1170
	if (status == 0x30 && sp->type == SRB_LOGIN_CMD &&
1171 1172 1173
	    le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
		status = 0;
	if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
1174
		ql_dbg(ql_dbg_async, vha, 0x5045,
1175 1176 1177 1178
		    "Async-%s complete - hdl=%x portid=%02x%02x%02x mbx1=%x.\n",
		    type, sp->handle, fcport->d_id.b.domain,
		    fcport->d_id.b.area, fcport->d_id.b.al_pa,
		    le16_to_cpu(mbx->mb1));
1179 1180

		data[0] = MBS_COMMAND_COMPLETE;
1181
		if (sp->type == SRB_LOGIN_CMD) {
1182 1183 1184
			fcport->port_type = FCT_TARGET;
			if (le16_to_cpu(mbx->mb1) & BIT_0)
				fcport->port_type = FCT_INITIATOR;
1185
			else if (le16_to_cpu(mbx->mb1) & BIT_1)
1186
				fcport->flags |= FCF_FCP2_DEVICE;
1187
		}
1188
		goto logio_done;
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
	}

	data[0] = le16_to_cpu(mbx->mb0);
	switch (data[0]) {
	case MBS_PORT_ID_USED:
		data[1] = le16_to_cpu(mbx->mb1);
		break;
	case MBS_LOOP_ID_USED:
		break;
	default:
		data[0] = MBS_COMMAND_ERROR;
		break;
	}

1203
	ql_log(ql_log_warn, vha, 0x5046,
1204 1205 1206 1207
	    "Async-%s failed - hdl=%x portid=%02x%02x%02x status=%x "
	    "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n", type, sp->handle,
	    fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa,
	    status, le16_to_cpu(mbx->mb0), le16_to_cpu(mbx->mb1),
1208
	    le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
1209
	    le16_to_cpu(mbx->mb7));
1210

1211
logio_done:
1212
	sp->done(vha, sp, 0);
1213 1214
}

1215 1216 1217 1218 1219 1220 1221 1222 1223
static void
qla2x00_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
    sts_entry_t *pkt, int iocb_type)
{
	const char func[] = "CT_IOCB";
	const char *type;
	srb_t *sp;
	struct fc_bsg_job *bsg_job;
	uint16_t comp_status;
1224
	int res;
1225 1226 1227 1228 1229

	sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
	if (!sp)
		return;

1230
	bsg_job = sp->u.bsg_job;
1231

1232
	type = "ct pass-through";
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243

	comp_status = le16_to_cpu(pkt->comp_status);

	/* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
	 * fc payload  to the caller
	 */
	bsg_job->reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
	bsg_job->reply_len = sizeof(struct fc_bsg_reply);

	if (comp_status != CS_COMPLETE) {
		if (comp_status == CS_DATA_UNDERRUN) {
1244
			res = DID_OK << 16;
1245 1246 1247
			bsg_job->reply->reply_payload_rcv_len =
			    le16_to_cpu(((sts_entry_t *)pkt)->rsp_info_len);

1248 1249
			ql_log(ql_log_warn, vha, 0x5048,
			    "CT pass-through-%s error "
1250
			    "comp_status-status=0x%x total_byte = 0x%x.\n",
1251 1252
			    type, comp_status,
			    bsg_job->reply->reply_payload_rcv_len);
1253
		} else {
1254 1255 1256
			ql_log(ql_log_warn, vha, 0x5049,
			    "CT pass-through-%s error "
			    "comp_status-status=0x%x.\n", type, comp_status);
1257
			res = DID_ERROR << 16;
1258 1259
			bsg_job->reply->reply_payload_rcv_len = 0;
		}
1260
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5035,
1261
		    (uint8_t *)pkt, sizeof(*pkt));
1262
	} else {
1263
		res = DID_OK << 16;
1264 1265 1266 1267 1268
		bsg_job->reply->reply_payload_rcv_len =
		    bsg_job->reply_payload.payload_len;
		bsg_job->reply_len = 0;
	}

1269
	sp->done(vha, sp, res);
1270 1271
}

1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
static void
qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
    struct sts_entry_24xx *pkt, int iocb_type)
{
	const char func[] = "ELS_CT_IOCB";
	const char *type;
	srb_t *sp;
	struct fc_bsg_job *bsg_job;
	uint16_t comp_status;
	uint32_t fw_status[3];
	uint8_t* fw_sts_ptr;
1283
	int res;
1284 1285 1286 1287

	sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
	if (!sp)
		return;
1288
	bsg_job = sp->u.bsg_job;
1289 1290

	type = NULL;
1291
	switch (sp->type) {
1292 1293 1294 1295 1296 1297 1298 1299
	case SRB_ELS_CMD_RPT:
	case SRB_ELS_CMD_HST:
		type = "els";
		break;
	case SRB_CT_CMD:
		type = "ct pass-through";
		break;
	default:
1300
		ql_dbg(ql_dbg_user, vha, 0x503e,
1301
		    "Unrecognized SRB: (%p) type=%d.\n", sp, sp->type);
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
		return;
	}

	comp_status = fw_status[0] = le16_to_cpu(pkt->comp_status);
	fw_status[1] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1);
	fw_status[2] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2);

	/* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
	 * fc payload  to the caller
	 */
	bsg_job->reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
	bsg_job->reply_len = sizeof(struct fc_bsg_reply) + sizeof(fw_status);

	if (comp_status != CS_COMPLETE) {
		if (comp_status == CS_DATA_UNDERRUN) {
1317
			res = DID_OK << 16;
1318
			bsg_job->reply->reply_payload_rcv_len =
1319
			    le16_to_cpu(((struct els_sts_entry_24xx *)pkt)->total_byte_count);
1320

1321
			ql_dbg(ql_dbg_user, vha, 0x503f,
1322
			    "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
1323
			    "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
1324
			    type, sp->handle, comp_status, fw_status[1], fw_status[2],
1325 1326
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				pkt)->total_byte_count));
1327 1328 1329 1330
			fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
			memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
		}
		else {
1331
			ql_dbg(ql_dbg_user, vha, 0x5040,
1332
			    "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
1333
			    "error subcode 1=0x%x error subcode 2=0x%x.\n",
1334
			    type, sp->handle, comp_status,
1335 1336 1337 1338
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				pkt)->error_subcode_1),
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				    pkt)->error_subcode_2));
1339
			res = DID_ERROR << 16;
1340 1341 1342 1343
			bsg_job->reply->reply_payload_rcv_len = 0;
			fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
			memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
		}
1344
		ql_dump_buffer(ql_dbg_user + ql_dbg_buffer, vha, 0x5056,
1345
				(uint8_t *)pkt, sizeof(*pkt));
1346 1347
	}
	else {
1348
		res =  DID_OK << 16;
1349 1350 1351 1352
		bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
		bsg_job->reply_len = 0;
	}

1353
	sp->done(vha, sp, res);
1354 1355
}

1356 1357 1358 1359 1360 1361 1362 1363
static void
qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
    struct logio_entry_24xx *logio)
{
	const char func[] = "LOGIO-IOCB";
	const char *type;
	fc_port_t *fcport;
	srb_t *sp;
1364
	struct srb_iocb *lio;
1365
	uint16_t *data;
1366 1367 1368 1369 1370 1371
	uint32_t iop[2];

	sp = qla2x00_get_sp_from_handle(vha, func, req, logio);
	if (!sp)
		return;

1372 1373
	lio = &sp->u.iocb_cmd;
	type = sp->name;
1374
	fcport = sp->fcport;
1375
	data = lio->u.logio.data;
1376

1377
	data[0] = MBS_COMMAND_ERROR;
1378
	data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
1379
		QLA_LOGIO_LOGIN_RETRIED : 0;
1380
	if (logio->entry_status) {
1381
		ql_log(ql_log_warn, fcport->vha, 0x5034,
1382
		    "Async-%s error entry - hdl=%x"
1383
		    "portid=%02x%02x%02x entry-status=%x.\n",
1384 1385 1386 1387
		    type, sp->handle, fcport->d_id.b.domain,
		    fcport->d_id.b.area, fcport->d_id.b.al_pa,
		    logio->entry_status);
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x504d,
1388
		    (uint8_t *)logio, sizeof(*logio));
1389

1390
		goto logio_done;
1391 1392 1393
	}

	if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
1394
		ql_dbg(ql_dbg_async, fcport->vha, 0x5036,
1395 1396 1397
		    "Async-%s complete - hdl=%x portid=%02x%02x%02x "
		    "iop0=%x.\n", type, sp->handle, fcport->d_id.b.domain,
		    fcport->d_id.b.area, fcport->d_id.b.al_pa,
1398
		    le32_to_cpu(logio->io_parameter[0]));
1399 1400

		data[0] = MBS_COMMAND_COMPLETE;
1401
		if (sp->type != SRB_LOGIN_CMD)
1402
			goto logio_done;
1403 1404 1405 1406 1407

		iop[0] = le32_to_cpu(logio->io_parameter[0]);
		if (iop[0] & BIT_4) {
			fcport->port_type = FCT_TARGET;
			if (iop[0] & BIT_8)
1408
				fcport->flags |= FCF_FCP2_DEVICE;
1409
		} else if (iop[0] & BIT_5)
1410
			fcport->port_type = FCT_INITIATOR;
1411

1412 1413 1414
		if (iop[0] & BIT_7)
			fcport->flags |= FCF_CONF_COMP_SUPPORTED;

1415 1416 1417 1418 1419
		if (logio->io_parameter[7] || logio->io_parameter[8])
			fcport->supported_classes |= FC_COS_CLASS2;
		if (logio->io_parameter[9] || logio->io_parameter[10])
			fcport->supported_classes |= FC_COS_CLASS3;

1420
		goto logio_done;
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
	}

	iop[0] = le32_to_cpu(logio->io_parameter[0]);
	iop[1] = le32_to_cpu(logio->io_parameter[1]);
	switch (iop[0]) {
	case LSC_SCODE_PORTID_USED:
		data[0] = MBS_PORT_ID_USED;
		data[1] = LSW(iop[1]);
		break;
	case LSC_SCODE_NPORT_USED:
		data[0] = MBS_LOOP_ID_USED;
		break;
	default:
		data[0] = MBS_COMMAND_ERROR;
		break;
	}

1438
	ql_dbg(ql_dbg_async, fcport->vha, 0x5037,
1439 1440
	    "Async-%s failed - hdl=%x portid=%02x%02x%02x comp=%x "
	    "iop0=%x iop1=%x.\n", type, sp->handle, fcport->d_id.b.domain,
1441
	    fcport->d_id.b.area, fcport->d_id.b.al_pa,
1442 1443
	    le16_to_cpu(logio->comp_status),
	    le32_to_cpu(logio->io_parameter[0]),
1444
	    le32_to_cpu(logio->io_parameter[1]));
1445

1446
logio_done:
1447
	sp->done(vha, sp, 0);
1448 1449
}

1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
static void
qla24xx_tm_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
    struct tsk_mgmt_entry *tsk)
{
	const char func[] = "TMF-IOCB";
	const char *type;
	fc_port_t *fcport;
	srb_t *sp;
	struct srb_iocb *iocb;
	struct sts_entry_24xx *sts = (struct sts_entry_24xx *)tsk;
	int error = 1;

	sp = qla2x00_get_sp_from_handle(vha, func, req, tsk);
	if (!sp)
		return;

1466 1467
	iocb = &sp->u.iocb_cmd;
	type = sp->name;
1468 1469 1470
	fcport = sp->fcport;

	if (sts->entry_status) {
1471
		ql_log(ql_log_warn, fcport->vha, 0x5038,
1472 1473
		    "Async-%s error - hdl=%x entry-status(%x).\n",
		    type, sp->handle, sts->entry_status);
1474
	} else if (sts->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1475
		ql_log(ql_log_warn, fcport->vha, 0x5039,
1476 1477
		    "Async-%s error - hdl=%x completion status(%x).\n",
		    type, sp->handle, sts->comp_status);
1478 1479
	} else if (!(le16_to_cpu(sts->scsi_status) &
	    SS_RESPONSE_INFO_LEN_VALID)) {
1480
		ql_log(ql_log_warn, fcport->vha, 0x503a,
1481 1482
		    "Async-%s error - hdl=%x no response info(%x).\n",
		    type, sp->handle, sts->scsi_status);
1483
	} else if (le32_to_cpu(sts->rsp_data_len) < 4) {
1484
		ql_log(ql_log_warn, fcport->vha, 0x503b,
1485 1486
		    "Async-%s error - hdl=%x not enough response(%d).\n",
		    type, sp->handle, sts->rsp_data_len);
1487
	} else if (sts->data[3]) {
1488
		ql_log(ql_log_warn, fcport->vha, 0x503c,
1489 1490
		    "Async-%s error - hdl=%x response(%x).\n",
		    type, sp->handle, sts->data[3]);
1491 1492 1493 1494 1495 1496
	} else {
		error = 0;
	}

	if (error) {
		iocb->u.tmf.data = error;
1497 1498
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5055,
		    (uint8_t *)sts, sizeof(*sts));
1499 1500
	}

1501
	sp->done(vha, sp, 0);
1502 1503
}

L
Linus Torvalds 已提交
1504 1505 1506 1507 1508
/**
 * qla2x00_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
void
1509
qla2x00_process_response_queue(struct rsp_que *rsp)
L
Linus Torvalds 已提交
1510
{
1511 1512
	struct scsi_qla_host *vha;
	struct qla_hw_data *ha = rsp->hw;
1513
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
1514 1515 1516
	sts_entry_t	*pkt;
	uint16_t        handle_cnt;
	uint16_t        cnt;
1517

1518
	vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
1519

1520
	if (!vha->flags.online)
L
Linus Torvalds 已提交
1521 1522
		return;

1523 1524
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (sts_entry_t *)rsp->ring_ptr;
L
Linus Torvalds 已提交
1525

1526 1527 1528 1529
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
L
Linus Torvalds 已提交
1530
		} else {
1531
			rsp->ring_ptr++;
L
Linus Torvalds 已提交
1532 1533 1534
		}

		if (pkt->entry_status != 0) {
1535
			qla2x00_error_entry(vha, rsp, pkt);
L
Linus Torvalds 已提交
1536 1537 1538 1539 1540 1541 1542
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

		switch (pkt->entry_type) {
		case STATUS_TYPE:
1543
			qla2x00_status_entry(vha, rsp, pkt);
L
Linus Torvalds 已提交
1544 1545 1546 1547
			break;
		case STATUS_TYPE_21:
			handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
			for (cnt = 0; cnt < handle_cnt; cnt++) {
1548
				qla2x00_process_completed_request(vha, rsp->req,
L
Linus Torvalds 已提交
1549 1550 1551 1552 1553 1554
				    ((sts21_entry_t *)pkt)->handle[cnt]);
			}
			break;
		case STATUS_TYPE_22:
			handle_cnt = ((sts22_entry_t *)pkt)->handle_count;
			for (cnt = 0; cnt < handle_cnt; cnt++) {
1555
				qla2x00_process_completed_request(vha, rsp->req,
L
Linus Torvalds 已提交
1556 1557 1558 1559
				    ((sts22_entry_t *)pkt)->handle[cnt]);
			}
			break;
		case STATUS_CONT_TYPE:
1560
			qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
L
Linus Torvalds 已提交
1561
			break;
1562 1563 1564
		case MBX_IOCB_TYPE:
			qla2x00_mbx_iocb_entry(vha, rsp->req,
			    (struct mbx_entry *)pkt);
1565
			break;
1566 1567 1568
		case CT_IOCB_TYPE:
			qla2x00_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
			break;
L
Linus Torvalds 已提交
1569 1570
		default:
			/* Type Not Supported. */
1571 1572
			ql_log(ql_log_warn, vha, 0x504a,
			    "Received unknown response pkt type %x "
L
Linus Torvalds 已提交
1573
			    "entry status=%x.\n",
1574
			    pkt->entry_type, pkt->entry_status);
L
Linus Torvalds 已提交
1575 1576 1577 1578 1579 1580 1581
			break;
		}
		((response_t *)pkt)->signature = RESPONSE_PROCESSED;
		wmb();
	}

	/* Adjust ring index */
1582
	WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), rsp->ring_index);
L
Linus Torvalds 已提交
1583 1584
}

1585
static inline void
1586
qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
1587
		     uint32_t sense_len, struct rsp_que *rsp, int res)
1588
{
1589
	struct scsi_qla_host *vha = sp->fcport->vha;
1590 1591
	struct scsi_cmnd *cp = GET_CMD_SP(sp);
	uint32_t track_sense_len;
1592 1593 1594 1595

	if (sense_len >= SCSI_SENSE_BUFFERSIZE)
		sense_len = SCSI_SENSE_BUFFERSIZE;

1596 1597 1598 1599 1600
	SET_CMD_SENSE_LEN(sp, sense_len);
	SET_CMD_SENSE_PTR(sp, cp->sense_buffer);
	track_sense_len = sense_len;

	if (sense_len > par_sense_len)
1601
		sense_len = par_sense_len;
1602 1603 1604

	memcpy(cp->sense_buffer, sense_data, sense_len);

1605 1606 1607 1608 1609
	SET_CMD_SENSE_PTR(sp, cp->sense_buffer + sense_len);
	track_sense_len -= sense_len;
	SET_CMD_SENSE_LEN(sp, track_sense_len);

	if (track_sense_len != 0) {
1610
		rsp->status_srb = sp;
1611 1612
		cp->result = res;
	}
1613

1614 1615 1616 1617 1618
	if (sense_len) {
		ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x301c,
		    "Check condition Sense data, nexus%ld:%d:%d cmd=%p.\n",
		    sp->fcport->vha->host_no, cp->device->id, cp->device->lun,
		    cp);
1619 1620
		ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
		    cp->sense_buffer, sense_len);
1621
	}
1622 1623
}

1624 1625
struct scsi_dif_tuple {
	__be16 guard;       /* Checksum */
1626
	__be16 app_tag;         /* APPL identifier */
1627 1628 1629 1630 1631 1632 1633 1634 1635
	__be32 ref_tag;         /* Target LBA or indirect LBA */
};

/*
 * Checks the guard or meta-data for the type of error
 * detected by the HBA. In case of errors, we set the
 * ASC/ASCQ fields in the sense buffer with ILLEGAL_REQUEST
 * to indicate to the kernel that the HBA detected error.
 */
1636
static inline int
1637 1638
qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
{
1639
	struct scsi_qla_host *vha = sp->fcport->vha;
1640
	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1641 1642
	uint8_t		*ap = &sts24->data[12];
	uint8_t		*ep = &sts24->data[20];
1643 1644 1645 1646
	uint32_t	e_ref_tag, a_ref_tag;
	uint16_t	e_app_tag, a_app_tag;
	uint16_t	e_guard, a_guard;

1647 1648 1649 1650 1651 1652 1653 1654 1655 1656
	/*
	 * swab32 of the "data" field in the beginning of qla2x00_status_entry()
	 * would make guard field appear at offset 2
	 */
	a_guard   = le16_to_cpu(*(uint16_t *)(ap + 2));
	a_app_tag = le16_to_cpu(*(uint16_t *)(ap + 0));
	a_ref_tag = le32_to_cpu(*(uint32_t *)(ap + 4));
	e_guard   = le16_to_cpu(*(uint16_t *)(ep + 2));
	e_app_tag = le16_to_cpu(*(uint16_t *)(ep + 0));
	e_ref_tag = le32_to_cpu(*(uint32_t *)(ep + 4));
1657

1658 1659
	ql_dbg(ql_dbg_io, vha, 0x3023,
	    "iocb(s) %p Returned STATUS.\n", sts24);
1660

1661 1662
	ql_dbg(ql_dbg_io, vha, 0x3024,
	    "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
1663
	    " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
1664
	    " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
1665
	    cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
1666
	    a_app_tag, e_app_tag, a_guard, e_guard);
1667

1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
	/*
	 * Ignore sector if:
	 * For type     3: ref & app tag is all 'f's
	 * For type 0,1,2: app tag is all 'f's
	 */
	if ((a_app_tag == 0xffff) &&
	    ((scsi_get_prot_type(cmd) != SCSI_PROT_DIF_TYPE3) ||
	     (a_ref_tag == 0xffffffff))) {
		uint32_t blocks_done, resid;
		sector_t lba_s = scsi_get_lba(cmd);

		/* 2TB boundary case covered automatically with this */
		blocks_done = e_ref_tag - (uint32_t)lba_s + 1;

		resid = scsi_bufflen(cmd) - (blocks_done *
		    cmd->device->sector_size);

		scsi_set_resid(cmd, resid);
		cmd->result = DID_OK << 16;

		/* Update protection tag */
		if (scsi_prot_sg_count(cmd)) {
			uint32_t i, j = 0, k = 0, num_ent;
			struct scatterlist *sg;
			struct sd_dif_tuple *spt;

			/* Patch the corresponding protection tags */
			scsi_for_each_prot_sg(cmd, sg,
			    scsi_prot_sg_count(cmd), i) {
				num_ent = sg_dma_len(sg) / 8;
				if (k + num_ent < blocks_done) {
					k += num_ent;
					continue;
				}
				j = blocks_done - k - 1;
				k = blocks_done;
				break;
			}

			if (k != blocks_done) {
1708
				ql_log(ql_log_warn, vha, 0x302f,
1709 1710
				    "unexpected tag values tag:lba=%x:%llx)\n",
				    e_ref_tag, (unsigned long long)lba_s);
1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724
				return 1;
			}

			spt = page_address(sg_page(sg)) + sg->offset;
			spt += j;

			spt->app_tag = 0xffff;
			if (scsi_get_prot_type(cmd) == SCSI_PROT_DIF_TYPE3)
				spt->ref_tag = 0xffffffff;
		}

		return 0;
	}

1725 1726 1727 1728 1729 1730 1731
	/* check guard */
	if (e_guard != a_guard) {
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
		    0x10, 0x1);
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1732
		return 1;
1733 1734
	}

1735 1736
	/* check ref tag */
	if (e_ref_tag != a_ref_tag) {
1737
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1738
		    0x10, 0x3);
1739 1740 1741
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1742
		return 1;
1743 1744
	}

1745 1746
	/* check appl tag */
	if (e_app_tag != a_app_tag) {
1747
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1748
		    0x10, 0x2);
1749 1750 1751
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1752
		return 1;
1753
	}
1754

1755
	return 1;
1756 1757
}

1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774
static void
qla25xx_process_bidir_status_iocb(scsi_qla_host_t *vha, void *pkt,
				  struct req_que *req, uint32_t index)
{
	struct qla_hw_data *ha = vha->hw;
	srb_t *sp;
	uint16_t	comp_status;
	uint16_t	scsi_status;
	uint16_t thread_id;
	uint32_t rval = EXT_STATUS_OK;
	struct fc_bsg_job *bsg_job = NULL;
	sts_entry_t *sts;
	struct sts_entry_24xx *sts24;
	sts = (sts_entry_t *) pkt;
	sts24 = (struct sts_entry_24xx *) pkt;

	/* Validate handle. */
1775
	if (index >= req->num_outstanding_cmds) {
1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
		ql_log(ql_log_warn, vha, 0x70af,
		    "Invalid SCSI completion handle 0x%x.\n", index);
		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
		return;
	}

	sp = req->outstanding_cmds[index];
	if (sp) {
		/* Free outstanding command slot. */
		req->outstanding_cmds[index] = NULL;
		bsg_job = sp->u.bsg_job;
	} else {
		ql_log(ql_log_warn, vha, 0x70b0,
		    "Req:%d: Invalid ISP SCSI completion handle(0x%x)\n",
		    req->id, index);

		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
		return;
	}

	if (IS_FWI2_CAPABLE(ha)) {
		comp_status = le16_to_cpu(sts24->comp_status);
		scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
	} else {
		comp_status = le16_to_cpu(sts->comp_status);
		scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
	}

	thread_id = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
	switch (comp_status) {
	case CS_COMPLETE:
		if (scsi_status == 0) {
			bsg_job->reply->reply_payload_rcv_len =
					bsg_job->reply_payload.payload_len;
			rval = EXT_STATUS_OK;
		}
		goto done;

	case CS_DATA_OVERRUN:
		ql_dbg(ql_dbg_user, vha, 0x70b1,
		    "Command completed with date overrun thread_id=%d\n",
		    thread_id);
		rval = EXT_STATUS_DATA_OVERRUN;
		break;

	case CS_DATA_UNDERRUN:
		ql_dbg(ql_dbg_user, vha, 0x70b2,
		    "Command completed with date underrun thread_id=%d\n",
		    thread_id);
		rval = EXT_STATUS_DATA_UNDERRUN;
		break;
	case CS_BIDIR_RD_OVERRUN:
		ql_dbg(ql_dbg_user, vha, 0x70b3,
		    "Command completed with read data overrun thread_id=%d\n",
		    thread_id);
		rval = EXT_STATUS_DATA_OVERRUN;
		break;

	case CS_BIDIR_RD_WR_OVERRUN:
		ql_dbg(ql_dbg_user, vha, 0x70b4,
		    "Command completed with read and write data overrun "
		    "thread_id=%d\n", thread_id);
		rval = EXT_STATUS_DATA_OVERRUN;
		break;

	case CS_BIDIR_RD_OVERRUN_WR_UNDERRUN:
		ql_dbg(ql_dbg_user, vha, 0x70b5,
		    "Command completed with read data over and write data "
		    "underrun thread_id=%d\n", thread_id);
		rval = EXT_STATUS_DATA_OVERRUN;
		break;

	case CS_BIDIR_RD_UNDERRUN:
		ql_dbg(ql_dbg_user, vha, 0x70b6,
		    "Command completed with read data data underrun "
		    "thread_id=%d\n", thread_id);
		rval = EXT_STATUS_DATA_UNDERRUN;
		break;

	case CS_BIDIR_RD_UNDERRUN_WR_OVERRUN:
		ql_dbg(ql_dbg_user, vha, 0x70b7,
		    "Command completed with read data under and write data "
		    "overrun thread_id=%d\n", thread_id);
		rval = EXT_STATUS_DATA_UNDERRUN;
		break;

	case CS_BIDIR_RD_WR_UNDERRUN:
		ql_dbg(ql_dbg_user, vha, 0x70b8,
		    "Command completed with read and write data underrun "
		    "thread_id=%d\n", thread_id);
		rval = EXT_STATUS_DATA_UNDERRUN;
		break;

	case CS_BIDIR_DMA:
		ql_dbg(ql_dbg_user, vha, 0x70b9,
		    "Command completed with data DMA error thread_id=%d\n",
		    thread_id);
		rval = EXT_STATUS_DMA_ERR;
		break;

	case CS_TIMEOUT:
		ql_dbg(ql_dbg_user, vha, 0x70ba,
		    "Command completed with timeout thread_id=%d\n",
		    thread_id);
		rval = EXT_STATUS_TIMEOUT;
		break;
	default:
		ql_dbg(ql_dbg_user, vha, 0x70bb,
		    "Command completed with completion status=0x%x "
		    "thread_id=%d\n", comp_status, thread_id);
		rval = EXT_STATUS_ERR;
		break;
	}
		bsg_job->reply->reply_payload_rcv_len = 0;

done:
	/* Return the vendor specific reply to API */
	bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = rval;
	bsg_job->reply_len = sizeof(struct fc_bsg_reply);
	/* Always return DID_OK, bsg will send the vendor specific response
	 * in this case only */
	sp->done(vha, sp, (DID_OK << 6));

}

L
Linus Torvalds 已提交
1901 1902 1903 1904 1905 1906
/**
 * qla2x00_status_entry() - Process a Status IOCB entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
1907
qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
L
Linus Torvalds 已提交
1908 1909 1910 1911
{
	srb_t		*sp;
	fc_port_t	*fcport;
	struct scsi_cmnd *cp;
1912 1913
	sts_entry_t *sts;
	struct sts_entry_24xx *sts24;
L
Linus Torvalds 已提交
1914 1915
	uint16_t	comp_status;
	uint16_t	scsi_status;
1916
	uint16_t	ox_id;
L
Linus Torvalds 已提交
1917 1918
	uint8_t		lscsi_status;
	int32_t		resid;
1919 1920
	uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
	    fw_resid_len;
1921
	uint8_t		*rsp_info, *sense_data;
1922
	struct qla_hw_data *ha = vha->hw;
1923 1924 1925
	uint32_t handle;
	uint16_t que;
	struct req_que *req;
1926
	int logit = 1;
1927
	int res = 0;
1928
	uint16_t state_flags = 0;
1929 1930 1931

	sts = (sts_entry_t *) pkt;
	sts24 = (struct sts_entry_24xx *) pkt;
1932
	if (IS_FWI2_CAPABLE(ha)) {
1933 1934
		comp_status = le16_to_cpu(sts24->comp_status);
		scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
1935
		state_flags = le16_to_cpu(sts24->state_flags);
1936 1937 1938 1939
	} else {
		comp_status = le16_to_cpu(sts->comp_status);
		scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
	}
1940 1941 1942
	handle = (uint32_t) LSW(sts->handle);
	que = MSW(sts->handle);
	req = ha->req_q_map[que];
1943

L
Linus Torvalds 已提交
1944
	/* Validate handle. */
1945
	if (handle < req->num_outstanding_cmds)
1946
		sp = req->outstanding_cmds[handle];
1947
	else
L
Linus Torvalds 已提交
1948 1949 1950
		sp = NULL;

	if (sp == NULL) {
1951
		ql_dbg(ql_dbg_io, vha, 0x3017,
1952
		    "Invalid status handle (0x%x).\n", sts->handle);
L
Linus Torvalds 已提交
1953

1954
		if (IS_P3P_TYPE(ha))
1955 1956 1957
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1958
		qla2xxx_wake_dpc(vha);
L
Linus Torvalds 已提交
1959 1960
		return;
	}
1961 1962 1963 1964 1965 1966 1967 1968

	if (unlikely((state_flags & BIT_1) && (sp->type == SRB_BIDI_CMD))) {
		qla25xx_process_bidir_status_iocb(vha, pkt, req, handle);
		return;
	}

	/* Fast path completion. */
	if (comp_status == CS_COMPLETE && scsi_status == 0) {
1969
		qla2x00_do_host_ramp_up(vha);
1970 1971 1972 1973 1974 1975
		qla2x00_process_completed_request(vha, req, handle);

		return;
	}

	req->outstanding_cmds[handle] = NULL;
1976
	cp = GET_CMD_SP(sp);
L
Linus Torvalds 已提交
1977
	if (cp == NULL) {
1978
		ql_dbg(ql_dbg_io, vha, 0x3018,
1979 1980
		    "Command already returned (0x%x/%p).\n",
		    sts->handle, sp);
L
Linus Torvalds 已提交
1981 1982 1983 1984

		return;
	}

1985
	lscsi_status = scsi_status & STATUS_MASK;
L
Linus Torvalds 已提交
1986

1987
	fcport = sp->fcport;
L
Linus Torvalds 已提交
1988

1989
	ox_id = 0;
1990 1991
	sense_len = par_sense_len = rsp_info_len = resid_len =
	    fw_resid_len = 0;
1992
	if (IS_FWI2_CAPABLE(ha)) {
1993 1994 1995 1996 1997 1998 1999 2000
		if (scsi_status & SS_SENSE_LEN_VALID)
			sense_len = le32_to_cpu(sts24->sense_len);
		if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
			rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
		if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER))
			resid_len = le32_to_cpu(sts24->rsp_residual_count);
		if (comp_status == CS_DATA_UNDERRUN)
			fw_resid_len = le32_to_cpu(sts24->residual_len);
2001 2002 2003
		rsp_info = sts24->data;
		sense_data = sts24->data;
		host_to_fcp_swap(sts24->data, sizeof(sts24->data));
2004
		ox_id = le16_to_cpu(sts24->ox_id);
2005
		par_sense_len = sizeof(sts24->data);
2006
	} else {
2007 2008 2009 2010
		if (scsi_status & SS_SENSE_LEN_VALID)
			sense_len = le16_to_cpu(sts->req_sense_length);
		if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
			rsp_info_len = le16_to_cpu(sts->rsp_info_len);
2011 2012 2013
		resid_len = le32_to_cpu(sts->residual_length);
		rsp_info = sts->rsp_info;
		sense_data = sts->req_sense_data;
2014
		par_sense_len = sizeof(sts->req_sense_data);
2015 2016
	}

L
Linus Torvalds 已提交
2017 2018
	/* Check for any FCP transport errors. */
	if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
2019
		/* Sense data lies beyond any FCP RESPONSE data. */
2020
		if (IS_FWI2_CAPABLE(ha)) {
2021
			sense_data += rsp_info_len;
2022 2023
			par_sense_len -= rsp_info_len;
		}
2024
		if (rsp_info_len > 3 && rsp_info[3]) {
2025
			ql_dbg(ql_dbg_io, fcport->vha, 0x3019,
2026 2027
			    "FCP I/O protocol failure (0x%x/0x%x).\n",
			    rsp_info_len, rsp_info[3]);
L
Linus Torvalds 已提交
2028

2029
			res = DID_BUS_BUSY << 16;
2030
			goto out;
L
Linus Torvalds 已提交
2031 2032 2033
		}
	}

2034 2035 2036 2037 2038
	/* Check for overrun. */
	if (IS_FWI2_CAPABLE(ha) && comp_status == CS_COMPLETE &&
	    scsi_status & SS_RESIDUAL_OVER)
		comp_status = CS_DATA_OVERRUN;

L
Linus Torvalds 已提交
2039 2040 2041 2042 2043
	/*
	 * Based on Host and scsi status generate status code for Linux
	 */
	switch (comp_status) {
	case CS_COMPLETE:
2044
	case CS_QUEUE_FULL:
L
Linus Torvalds 已提交
2045
		if (scsi_status == 0) {
2046
			res = DID_OK << 16;
L
Linus Torvalds 已提交
2047 2048 2049
			break;
		}
		if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
2050
			resid = resid_len;
2051
			scsi_set_resid(cp, resid);
2052 2053

			if (!lscsi_status &&
2054
			    ((unsigned)(scsi_bufflen(cp) - resid) <
2055
			     cp->underflow)) {
2056
				ql_dbg(ql_dbg_io, fcport->vha, 0x301a,
2057
				    "Mid-layer underflow "
2058
				    "detected (0x%x of 0x%x bytes).\n",
2059
				    resid, scsi_bufflen(cp));
2060

2061
				res = DID_ERROR << 16;
2062 2063
				break;
			}
L
Linus Torvalds 已提交
2064
		}
2065
		res = DID_OK << 16 | lscsi_status;
L
Linus Torvalds 已提交
2066

2067
		if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
2068
			ql_dbg(ql_dbg_io, fcport->vha, 0x301b,
2069
			    "QUEUE FULL detected.\n");
2070 2071
			break;
		}
2072
		logit = 0;
L
Linus Torvalds 已提交
2073 2074 2075
		if (lscsi_status != SS_CHECK_CONDITION)
			break;

2076
		memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
2077 2078 2079
		if (!(scsi_status & SS_SENSE_LEN_VALID))
			break;

2080
		qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
2081
		    rsp, res);
L
Linus Torvalds 已提交
2082 2083 2084
		break;

	case CS_DATA_UNDERRUN:
2085
		/* Use F/W calculated residual length. */
2086 2087 2088 2089
		resid = IS_FWI2_CAPABLE(ha) ? fw_resid_len : resid_len;
		scsi_set_resid(cp, resid);
		if (scsi_status & SS_RESIDUAL_UNDER) {
			if (IS_FWI2_CAPABLE(ha) && fw_resid_len != resid_len) {
2090
				ql_dbg(ql_dbg_io, fcport->vha, 0x301d,
2091 2092 2093
				    "Dropped frame(s) detected "
				    "(0x%x of 0x%x bytes).\n",
				    resid, scsi_bufflen(cp));
2094

2095
				res = DID_ERROR << 16 | lscsi_status;
2096
				goto check_scsi_status;
2097
			}
2098

2099 2100 2101
			if (!lscsi_status &&
			    ((unsigned)(scsi_bufflen(cp) - resid) <
			    cp->underflow)) {
2102
				ql_dbg(ql_dbg_io, fcport->vha, 0x301e,
2103
				    "Mid-layer underflow "
2104
				    "detected (0x%x of 0x%x bytes).\n",
2105
				    resid, scsi_bufflen(cp));
2106

2107
				res = DID_ERROR << 16;
2108 2109
				break;
			}
2110 2111 2112 2113 2114 2115 2116
		} else if (lscsi_status != SAM_STAT_TASK_SET_FULL &&
			    lscsi_status != SAM_STAT_BUSY) {
			/*
			 * scsi status of task set and busy are considered to be
			 * task not completed.
			 */

2117
			ql_dbg(ql_dbg_io, fcport->vha, 0x301f,
2118
			    "Dropped frame(s) detected (0x%x "
2119 2120
			    "of 0x%x bytes).\n", resid,
			    scsi_bufflen(cp));
2121

2122
			res = DID_ERROR << 16 | lscsi_status;
2123
			goto check_scsi_status;
2124 2125 2126 2127
		} else {
			ql_dbg(ql_dbg_io, fcport->vha, 0x3030,
			    "scsi_status: 0x%x, lscsi_status: 0x%x\n",
			    scsi_status, lscsi_status);
L
Linus Torvalds 已提交
2128 2129
		}

2130
		res = DID_OK << 16 | lscsi_status;
2131
		logit = 0;
2132

2133
check_scsi_status:
L
Linus Torvalds 已提交
2134
		/*
A
Andrew Vasquez 已提交
2135
		 * Check to see if SCSI Status is non zero. If so report SCSI
L
Linus Torvalds 已提交
2136 2137 2138
		 * Status.
		 */
		if (lscsi_status != 0) {
2139
			if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
2140
				ql_dbg(ql_dbg_io, fcport->vha, 0x3020,
2141
				    "QUEUE FULL detected.\n");
2142
				logit = 1;
2143 2144
				break;
			}
L
Linus Torvalds 已提交
2145 2146 2147
			if (lscsi_status != SS_CHECK_CONDITION)
				break;

2148
			memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
2149 2150 2151
			if (!(scsi_status & SS_SENSE_LEN_VALID))
				break;

2152
			qla2x00_handle_sense(sp, sense_data, par_sense_len,
2153
			    sense_len, rsp, res);
L
Linus Torvalds 已提交
2154 2155 2156 2157 2158 2159 2160 2161
		}
		break;

	case CS_PORT_LOGGED_OUT:
	case CS_PORT_CONFIG_CHG:
	case CS_PORT_BUSY:
	case CS_INCOMPLETE:
	case CS_PORT_UNAVAILABLE:
2162
	case CS_TIMEOUT:
2163 2164
	case CS_RESET:

2165 2166 2167 2168 2169
		/*
		 * We are going to have the fc class block the rport
		 * while we try to recover so instruct the mid layer
		 * to requeue until the class decides how to handle this.
		 */
2170
		res = DID_TRANSPORT_DISRUPTED << 16;
2171 2172 2173 2174 2175 2176 2177 2178 2179

		if (comp_status == CS_TIMEOUT) {
			if (IS_FWI2_CAPABLE(ha))
				break;
			else if ((le16_to_cpu(sts->status_flags) &
			    SF_LOGOUT_SENT) == 0)
				break;
		}

2180
		ql_dbg(ql_dbg_io, fcport->vha, 0x3021,
2181 2182
		    "Port down status: port-state=0x%x.\n",
		    atomic_read(&fcport->state));
2183

2184
		if (atomic_read(&fcport->state) == FCS_ONLINE)
2185
			qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
L
Linus Torvalds 已提交
2186 2187 2188
		break;

	case CS_ABORTED:
2189
		res = DID_RESET << 16;
L
Linus Torvalds 已提交
2190
		break;
2191 2192

	case CS_DIF_ERROR:
2193
		logit = qla2x00_handle_dif_error(sp, sts24);
2194
		res = cp->result;
2195
		break;
2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208

	case CS_TRANSPORT:
		res = DID_ERROR << 16;

		if (!IS_PI_SPLIT_DET_CAPABLE(ha))
			break;

		if (state_flags & BIT_4)
			scmd_printk(KERN_WARNING, cp,
			    "Unsupported device '%s' found.\n",
			    cp->device->vendor);
		break;

L
Linus Torvalds 已提交
2209
	default:
2210
		res = DID_ERROR << 16;
L
Linus Torvalds 已提交
2211 2212 2213
		break;
	}

2214 2215
out:
	if (logit)
2216
		ql_dbg(ql_dbg_io, fcport->vha, 0x3022,
2217 2218
		    "FCP command status: 0x%x-0x%x (0x%x) nexus=%ld:%d:%d "
		    "portid=%02x%02x%02x oxid=0x%x cdb=%10phN len=0x%x "
2219
		    "rsp_info=0x%x resid=0x%x fw_resid=0x%x.\n",
2220
		    comp_status, scsi_status, res, vha->host_no,
2221 2222
		    cp->device->id, cp->device->lun, fcport->d_id.b.domain,
		    fcport->d_id.b.area, fcport->d_id.b.al_pa, ox_id,
2223
		    cp->cmnd, scsi_bufflen(cp), rsp_info_len,
2224
		    resid_len, fw_resid_len);
2225

2226 2227 2228
	if (!res)
		qla2x00_do_host_ramp_up(vha);

2229
	if (rsp->status_srb == NULL)
2230
		sp->done(ha, sp, res);
L
Linus Torvalds 已提交
2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
}

/**
 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 *
 * Extended sense data.
 */
static void
2241
qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
L
Linus Torvalds 已提交
2242
{
2243
	uint8_t	sense_sz = 0;
2244
	struct qla_hw_data *ha = rsp->hw;
2245
	struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
2246
	srb_t *sp = rsp->status_srb;
L
Linus Torvalds 已提交
2247
	struct scsi_cmnd *cp;
2248 2249
	uint32_t sense_len;
	uint8_t *sense_ptr;
L
Linus Torvalds 已提交
2250

2251 2252
	if (!sp || !GET_CMD_SENSE_LEN(sp))
		return;
L
Linus Torvalds 已提交
2253

2254 2255
	sense_len = GET_CMD_SENSE_LEN(sp);
	sense_ptr = GET_CMD_SENSE_PTR(sp);
L
Linus Torvalds 已提交
2256

2257 2258 2259 2260
	cp = GET_CMD_SP(sp);
	if (cp == NULL) {
		ql_log(ql_log_warn, vha, 0x3025,
		    "cmd is NULL: already returned to OS (sp=%p).\n", sp);
L
Linus Torvalds 已提交
2261

2262 2263
		rsp->status_srb = NULL;
		return;
L
Linus Torvalds 已提交
2264 2265
	}

2266 2267 2268 2269
	if (sense_len > sizeof(pkt->data))
		sense_sz = sizeof(pkt->data);
	else
		sense_sz = sense_len;
2270

2271 2272 2273 2274 2275 2276
	/* Move sense data. */
	if (IS_FWI2_CAPABLE(ha))
		host_to_fcp_swap(pkt->data, sizeof(pkt->data));
	memcpy(sense_ptr, pkt->data, sense_sz);
	ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302c,
		sense_ptr, sense_sz);
2277

2278 2279
	sense_len -= sense_sz;
	sense_ptr += sense_sz;
2280

2281 2282 2283 2284 2285 2286 2287
	SET_CMD_SENSE_PTR(sp, sense_ptr);
	SET_CMD_SENSE_LEN(sp, sense_len);

	/* Place command on done queue. */
	if (sense_len == 0) {
		rsp->status_srb = NULL;
		sp->done(ha, sp, cp->result);
2288 2289 2290
	}
}

L
Linus Torvalds 已提交
2291 2292 2293 2294 2295 2296
/**
 * qla2x00_error_entry() - Process an error entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
2297
qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
L
Linus Torvalds 已提交
2298 2299
{
	srb_t *sp;
2300
	struct qla_hw_data *ha = vha->hw;
2301
	const char func[] = "ERROR-IOCB";
2302
	uint16_t que = MSW(pkt->handle);
2303
	struct req_que *req = NULL;
2304
	int res = DID_ERROR << 16;
2305

2306 2307 2308
	ql_dbg(ql_dbg_async, vha, 0x502a,
	    "type of error status in response: 0x%x\n", pkt->entry_status);

2309 2310 2311 2312 2313
	if (que >= ha->max_req_queues || !ha->req_q_map[que])
		goto fatal;

	req = ha->req_q_map[que];

2314 2315
	if (pkt->entry_status & RF_BUSY)
		res = DID_BUS_BUSY << 16;
L
Linus Torvalds 已提交
2316

2317
	sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2318
	if (sp) {
2319
		sp->done(ha, sp, res);
2320
		return;
L
Linus Torvalds 已提交
2321
	}
2322 2323 2324 2325
fatal:
	ql_log(ql_log_warn, vha, 0x5030,
	    "Error entry - invalid handle/queue.\n");

2326
	if (IS_P3P_TYPE(ha))
2327 2328 2329 2330
		set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
	else
		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
	qla2xxx_wake_dpc(vha);
L
Linus Torvalds 已提交
2331 2332
}

2333 2334 2335 2336 2337 2338
/**
 * qla24xx_mbx_completion() - Process mailbox command completions.
 * @ha: SCSI driver HA context
 * @mb0: Mailbox0 register
 */
static void
2339
qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
2340 2341
{
	uint16_t	cnt;
2342
	uint32_t	mboxes;
2343
	uint16_t __iomem *wptr;
2344
	struct qla_hw_data *ha = vha->hw;
2345 2346
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

2347 2348 2349
	/* Read all mbox registers? */
	mboxes = (1 << ha->mbx_count) - 1;
	if (!ha->mcp)
2350
		ql_dbg(ql_dbg_async, vha, 0x504e, "MBX pointer ERROR.\n");
2351 2352 2353
	else
		mboxes = ha->mcp->in_mb;

2354 2355 2356
	/* Load return mailbox registers. */
	ha->flags.mbox_int = 1;
	ha->mailbox_out[0] = mb0;
2357
	mboxes >>= 1;
2358 2359 2360
	wptr = (uint16_t __iomem *)&reg->mailbox1;

	for (cnt = 1; cnt < ha->mbx_count; cnt++) {
2361 2362 2363 2364
		if (mboxes & BIT_0)
			ha->mailbox_out[cnt] = RD_REG_WORD(wptr);

		mboxes >>= 1;
2365 2366 2367 2368 2369 2370 2371 2372
		wptr++;
	}
}

/**
 * qla24xx_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
2373 2374
void qla24xx_process_response_queue(struct scsi_qla_host *vha,
	struct rsp_que *rsp)
2375 2376
{
	struct sts_entry_24xx *pkt;
2377
	struct qla_hw_data *ha = vha->hw;
2378

2379
	if (!vha->flags.online)
2380 2381
		return;

2382 2383
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
2384

2385 2386 2387 2388
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
2389
		} else {
2390
			rsp->ring_ptr++;
2391 2392 2393
		}

		if (pkt->entry_status != 0) {
2394
			qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
2395 2396 2397

			(void)qlt_24xx_process_response_error(vha, pkt);

2398 2399 2400 2401 2402 2403 2404
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

		switch (pkt->entry_type) {
		case STATUS_TYPE:
2405
			qla2x00_status_entry(vha, rsp, pkt);
2406 2407
			break;
		case STATUS_CONT_TYPE:
2408
			qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
2409
			break;
2410
		case VP_RPT_ID_IOCB_TYPE:
2411
			qla24xx_report_id_acquisition(vha,
2412 2413
			    (struct vp_rpt_id_entry_24xx *)pkt);
			break;
2414 2415 2416 2417
		case LOGINOUT_PORT_IOCB_TYPE:
			qla24xx_logio_entry(vha, rsp->req,
			    (struct logio_entry_24xx *)pkt);
			break;
2418 2419 2420 2421
		case TSK_MGMT_IOCB_TYPE:
			qla24xx_tm_iocb_entry(vha, rsp->req,
			    (struct tsk_mgmt_entry *)pkt);
			break;
2422 2423 2424 2425 2426 2427
                case CT_IOCB_TYPE:
			qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
			break;
                case ELS_IOCB_TYPE:
			qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
			break;
2428 2429 2430 2431 2432 2433 2434 2435
		case ABTS_RECV_24XX:
			/* ensure that the ATIO queue is empty */
			qlt_24xx_process_atio_queue(vha);
		case ABTS_RESP_24XX:
		case CTIO_TYPE7:
		case NOTIFY_ACK_TYPE:
			qlt_response_pkt_all_vps(vha, (response_t *)pkt);
			break;
2436 2437 2438 2439 2440
		case MARKER_TYPE:
			/* Do nothing in this case, this check is to prevent it
			 * from falling into default case
			 */
			break;
2441 2442
		default:
			/* Type Not Supported. */
2443 2444
			ql_dbg(ql_dbg_async, vha, 0x5042,
			    "Received unknown response pkt type %x "
2445
			    "entry status=%x.\n",
2446
			    pkt->entry_type, pkt->entry_status);
2447 2448 2449 2450 2451 2452 2453
			break;
		}
		((response_t *)pkt)->signature = RESPONSE_PROCESSED;
		wmb();
	}

	/* Adjust ring index */
2454
	if (IS_P3P_TYPE(ha)) {
2455 2456 2457 2458
		struct device_reg_82xx __iomem *reg = &ha->iobase->isp82;
		WRT_REG_DWORD(&reg->rsp_q_out[0], rsp->ring_index);
	} else
		WRT_REG_DWORD(rsp->rsp_q_out, rsp->ring_index);
2459 2460
}

2461
static void
2462
qla2xxx_check_risc_status(scsi_qla_host_t *vha)
2463 2464 2465
{
	int rval;
	uint32_t cnt;
2466
	struct qla_hw_data *ha = vha->hw;
2467 2468
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

2469
	if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha))
2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
		return;

	rval = QLA_SUCCESS;
	WRT_REG_DWORD(&reg->iobase_addr, 0x7C00);
	RD_REG_DWORD(&reg->iobase_addr);
	WRT_REG_DWORD(&reg->iobase_window, 0x0001);
	for (cnt = 10000; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
	    rval == QLA_SUCCESS; cnt--) {
		if (cnt) {
			WRT_REG_DWORD(&reg->iobase_window, 0x0001);
			udelay(10);
		} else
			rval = QLA_FUNCTION_TIMEOUT;
	}
	if (rval == QLA_SUCCESS)
		goto next_test;

2487
	rval = QLA_SUCCESS;
2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501
	WRT_REG_DWORD(&reg->iobase_window, 0x0003);
	for (cnt = 100; (RD_REG_DWORD(&reg->iobase_window) & BIT_0) == 0 &&
	    rval == QLA_SUCCESS; cnt--) {
		if (cnt) {
			WRT_REG_DWORD(&reg->iobase_window, 0x0003);
			udelay(10);
		} else
			rval = QLA_FUNCTION_TIMEOUT;
	}
	if (rval != QLA_SUCCESS)
		goto done;

next_test:
	if (RD_REG_DWORD(&reg->iobase_c8) & BIT_3)
2502 2503
		ql_log(ql_log_info, vha, 0x504c,
		    "Additional code -- 0x55AA.\n");
2504 2505 2506 2507 2508 2509

done:
	WRT_REG_DWORD(&reg->iobase_window, 0x0000);
	RD_REG_DWORD(&reg->iobase_window);
}

2510
/**
2511
 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP24xx.
2512 2513 2514 2515 2516 2517 2518 2519
 * @irq:
 * @dev_id: SCSI driver HA context
 *
 * Called by system whenever the host adapter generates an interrupt.
 *
 * Returns handled flag.
 */
irqreturn_t
2520
qla24xx_intr_handler(int irq, void *dev_id)
2521
{
2522 2523
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
2524 2525 2526 2527 2528
	struct device_reg_24xx __iomem *reg;
	int		status;
	unsigned long	iter;
	uint32_t	stat;
	uint32_t	hccr;
2529
	uint16_t	mb[8];
2530
	struct rsp_que *rsp;
2531
	unsigned long	flags;
2532

2533 2534
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2535 2536
		ql_log(ql_log_info, NULL, 0x5059,
		    "%s: NULL response queue pointer.\n", __func__);
2537 2538 2539
		return IRQ_NONE;
	}

2540
	ha = rsp->hw;
2541 2542 2543
	reg = &ha->iobase->isp24;
	status = 0;

2544 2545 2546
	if (unlikely(pci_channel_offline(ha->pdev)))
		return IRQ_HANDLED;

2547
	spin_lock_irqsave(&ha->hardware_lock, flags);
2548
	vha = pci_get_drvdata(ha->pdev);
2549 2550 2551
	for (iter = 50; iter--; ) {
		stat = RD_REG_DWORD(&reg->host_status);
		if (stat & HSRX_RISC_PAUSED) {
2552
			if (unlikely(pci_channel_offline(ha->pdev)))
2553 2554
				break;

2555 2556
			hccr = RD_REG_DWORD(&reg->hccr);

2557 2558 2559
			ql_log(ql_log_warn, vha, 0x504b,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2560

2561
			qla2xxx_check_risc_status(vha);
2562

2563 2564
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2565 2566 2567 2568 2569
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
2570 2571 2572 2573
		case INTR_ROM_MB_SUCCESS:
		case INTR_ROM_MB_FAILED:
		case INTR_MB_SUCCESS:
		case INTR_MB_FAILED:
2574
			qla24xx_mbx_completion(vha, MSW(stat));
2575 2576 2577
			status |= MBX_INTERRUPT;

			break;
2578
		case INTR_ASYNC_EVENT:
2579 2580 2581 2582
			mb[0] = MSW(stat);
			mb[1] = RD_REG_WORD(&reg->mailbox1);
			mb[2] = RD_REG_WORD(&reg->mailbox2);
			mb[3] = RD_REG_WORD(&reg->mailbox3);
2583
			qla2x00_async_event(vha, rsp, mb);
2584
			break;
2585 2586
		case INTR_RSP_QUE_UPDATE:
		case INTR_RSP_QUE_UPDATE_83XX:
2587
			qla24xx_process_response_queue(vha, rsp);
2588
			break;
2589
		case INTR_ATIO_QUE_UPDATE:
2590 2591
			qlt_24xx_process_atio_queue(vha);
			break;
2592
		case INTR_ATIO_RSP_QUE_UPDATE:
2593 2594 2595
			qlt_24xx_process_atio_queue(vha);
			qla24xx_process_response_queue(vha, rsp);
			break;
2596
		default:
2597 2598
			ql_dbg(ql_dbg_async, vha, 0x504f,
			    "Unrecognized interrupt type (%d).\n", stat * 0xff);
2599 2600 2601 2602
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
2603 2604
		if (unlikely(IS_QLA83XX(ha) && (ha->pdev->revision == 1)))
			ndelay(3500);
2605
	}
2606
	qla2x00_handle_mbx_completion(ha, status);
2607
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2608 2609 2610 2611

	return IRQ_HANDLED;
}

2612 2613 2614
static irqreturn_t
qla24xx_msix_rsp_q(int irq, void *dev_id)
{
2615 2616
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2617
	struct device_reg_24xx __iomem *reg;
2618
	struct scsi_qla_host *vha;
2619
	unsigned long flags;
2620

2621 2622
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2623 2624
		ql_log(ql_log_info, NULL, 0x505a,
		    "%s: NULL response queue pointer.\n", __func__);
2625 2626 2627
		return IRQ_NONE;
	}
	ha = rsp->hw;
2628 2629
	reg = &ha->iobase->isp24;

2630
	spin_lock_irqsave(&ha->hardware_lock, flags);
2631

2632
	vha = pci_get_drvdata(ha->pdev);
2633
	qla24xx_process_response_queue(vha, rsp);
2634
	if (!ha->flags.disable_msix_handshake) {
2635 2636 2637
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
	}
2638
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2639 2640 2641 2642

	return IRQ_HANDLED;
}

2643 2644 2645 2646 2647
static irqreturn_t
qla25xx_msix_rsp_q(int irq, void *dev_id)
{
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2648
	struct device_reg_24xx __iomem *reg;
2649
	unsigned long flags;
2650 2651 2652

	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2653 2654
		ql_log(ql_log_info, NULL, 0x505b,
		    "%s: NULL response queue pointer.\n", __func__);
2655 2656 2657 2658
		return IRQ_NONE;
	}
	ha = rsp->hw;

2659
	/* Clear the interrupt, if enabled, for this response queue */
2660
	if (!ha->flags.disable_msix_handshake) {
2661
		reg = &ha->iobase->isp24;
2662
		spin_lock_irqsave(&ha->hardware_lock, flags);
2663 2664
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
2665
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
2666
	}
2667 2668 2669 2670 2671
	queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);

	return IRQ_HANDLED;
}

2672 2673 2674
static irqreturn_t
qla24xx_msix_default(int irq, void *dev_id)
{
2675 2676 2677
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2678 2679 2680 2681
	struct device_reg_24xx __iomem *reg;
	int		status;
	uint32_t	stat;
	uint32_t	hccr;
2682
	uint16_t	mb[8];
2683
	unsigned long flags;
2684

2685 2686
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2687 2688
		ql_log(ql_log_info, NULL, 0x505c,
		    "%s: NULL response queue pointer.\n", __func__);
2689 2690 2691
		return IRQ_NONE;
	}
	ha = rsp->hw;
2692 2693 2694
	reg = &ha->iobase->isp24;
	status = 0;

2695
	spin_lock_irqsave(&ha->hardware_lock, flags);
2696
	vha = pci_get_drvdata(ha->pdev);
2697
	do {
2698 2699
		stat = RD_REG_DWORD(&reg->host_status);
		if (stat & HSRX_RISC_PAUSED) {
2700
			if (unlikely(pci_channel_offline(ha->pdev)))
2701 2702
				break;

2703 2704
			hccr = RD_REG_DWORD(&reg->hccr);

2705 2706 2707
			ql_log(ql_log_info, vha, 0x5050,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2708

2709
			qla2xxx_check_risc_status(vha);
2710

2711 2712
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2713 2714 2715 2716 2717
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
2718 2719 2720 2721
		case INTR_ROM_MB_SUCCESS:
		case INTR_ROM_MB_FAILED:
		case INTR_MB_SUCCESS:
		case INTR_MB_FAILED:
2722
			qla24xx_mbx_completion(vha, MSW(stat));
2723 2724 2725
			status |= MBX_INTERRUPT;

			break;
2726
		case INTR_ASYNC_EVENT:
2727 2728 2729 2730
			mb[0] = MSW(stat);
			mb[1] = RD_REG_WORD(&reg->mailbox1);
			mb[2] = RD_REG_WORD(&reg->mailbox2);
			mb[3] = RD_REG_WORD(&reg->mailbox3);
2731
			qla2x00_async_event(vha, rsp, mb);
2732
			break;
2733 2734
		case INTR_RSP_QUE_UPDATE:
		case INTR_RSP_QUE_UPDATE_83XX:
2735
			qla24xx_process_response_queue(vha, rsp);
2736
			break;
2737
		case INTR_ATIO_QUE_UPDATE:
2738 2739
			qlt_24xx_process_atio_queue(vha);
			break;
2740
		case INTR_ATIO_RSP_QUE_UPDATE:
2741 2742 2743
			qlt_24xx_process_atio_queue(vha);
			qla24xx_process_response_queue(vha, rsp);
			break;
2744
		default:
2745 2746
			ql_dbg(ql_dbg_async, vha, 0x5051,
			    "Unrecognized interrupt type (%d).\n", stat & 0xff);
2747 2748 2749
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2750
	} while (0);
2751
	qla2x00_handle_mbx_completion(ha, status);
2752
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2753 2754 2755 2756 2757 2758 2759 2760

	return IRQ_HANDLED;
}

/* Interrupt handling helpers. */

struct qla_init_msix_entry {
	const char *name;
2761
	irq_handler_t handler;
2762 2763
};

2764
static struct qla_init_msix_entry msix_entries[3] = {
2765 2766
	{ "qla2xxx (default)", qla24xx_msix_default },
	{ "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
2767
	{ "qla2xxx (multiq)", qla25xx_msix_rsp_q },
2768 2769
};

2770 2771 2772 2773 2774
static struct qla_init_msix_entry qla82xx_msix_entries[2] = {
	{ "qla2xxx (default)", qla82xx_msix_default },
	{ "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
};

2775 2776 2777 2778 2779 2780
static struct qla_init_msix_entry qla83xx_msix_entries[3] = {
	{ "qla2xxx (default)", qla24xx_msix_default },
	{ "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
	{ "qla2xxx (atio_q)", qla83xx_msix_atio_q },
};

2781
static void
2782
qla24xx_disable_msix(struct qla_hw_data *ha)
2783 2784 2785
{
	int i;
	struct qla_msix_entry *qentry;
2786
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2787

2788 2789
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
2790
		if (qentry->have_irq)
2791
			free_irq(qentry->vector, qentry->rsp);
2792 2793
	}
	pci_disable_msix(ha->pdev);
2794 2795 2796
	kfree(ha->msix_entries);
	ha->msix_entries = NULL;
	ha->flags.msix_enabled = 0;
2797 2798
	ql_dbg(ql_dbg_init, vha, 0x0042,
	    "Disabled the MSI.\n");
2799 2800 2801
}

static int
2802
qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
2803
{
2804
#define MIN_MSIX_COUNT	2
2805
	int i, ret;
2806
	struct msix_entry *entries;
2807
	struct qla_msix_entry *qentry;
2808
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2809 2810

	entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
2811
			GFP_KERNEL);
2812 2813 2814
	if (!entries) {
		ql_log(ql_log_warn, vha, 0x00bc,
		    "Failed to allocate memory for msix_entry.\n");
2815
		return -ENOMEM;
2816
	}
2817

2818 2819
	for (i = 0; i < ha->msix_count; i++)
		entries[i].entry = i;
2820

2821
	ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
2822
	if (ret) {
2823 2824 2825
		if (ret < MIN_MSIX_COUNT)
			goto msix_failed;

2826 2827 2828 2829
		ql_log(ql_log_warn, vha, 0x00c6,
		    "MSI-X: Failed to enable support "
		    "-- %d/%d\n Retry with %d vectors.\n",
		    ha->msix_count, ret, ret);
2830 2831 2832
		ha->msix_count = ret;
		ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
		if (ret) {
2833
msix_failed:
2834 2835 2836 2837
			ql_log(ql_log_fatal, vha, 0x00c7,
			    "MSI-X: Failed to enable support, "
			    "giving   up -- %d/%d.\n",
			    ha->msix_count, ret);
2838 2839
			goto msix_out;
		}
2840
		ha->max_rsp_queues = ha->msix_count - 1;
2841 2842 2843 2844
	}
	ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
				ha->msix_count, GFP_KERNEL);
	if (!ha->msix_entries) {
2845 2846
		ql_log(ql_log_fatal, vha, 0x00c8,
		    "Failed to allocate memory for ha->msix_entries.\n");
2847
		ret = -ENOMEM;
2848 2849 2850 2851
		goto msix_out;
	}
	ha->flags.msix_enabled = 1;

2852 2853 2854 2855
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
		qentry->vector = entries[i].vector;
		qentry->entry = entries[i].entry;
2856
		qentry->have_irq = 0;
2857
		qentry->rsp = NULL;
2858 2859
	}

2860
	/* Enable MSI-X vectors for the base queue */
2861
	for (i = 0; i < ha->msix_count; i++) {
2862
		qentry = &ha->msix_entries[i];
2863 2864 2865 2866
		if (QLA_TGT_MODE_ENABLED() && IS_ATIO_MSIX_CAPABLE(ha)) {
			ret = request_irq(qentry->vector,
				qla83xx_msix_entries[i].handler,
				0, qla83xx_msix_entries[i].name, rsp);
2867
		} else if (IS_P3P_TYPE(ha)) {
2868 2869 2870 2871 2872 2873 2874 2875
			ret = request_irq(qentry->vector,
				qla82xx_msix_entries[i].handler,
				0, qla82xx_msix_entries[i].name, rsp);
		} else {
			ret = request_irq(qentry->vector,
				msix_entries[i].handler,
				0, msix_entries[i].name, rsp);
		}
2876
		if (ret) {
2877 2878 2879
			ql_log(ql_log_fatal, vha, 0x00cb,
			    "MSI-X: unable to register handler -- %x/%d.\n",
			    qentry->vector, ret);
2880 2881 2882 2883 2884 2885 2886
			qla24xx_disable_msix(ha);
			ha->mqenable = 0;
			goto msix_out;
		}
		qentry->have_irq = 1;
		qentry->rsp = rsp;
		rsp->msix = qentry;
2887 2888 2889
	}

	/* Enable MSI-X vector for response queue update for queue 0 */
2890 2891 2892 2893 2894 2895 2896 2897
	if (IS_QLA83XX(ha)) {
		if (ha->msixbase && ha->mqiobase &&
		    (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
			ha->mqenable = 1;
	} else
		if (ha->mqiobase
		    && (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
			ha->mqenable = 1;
2898 2899 2900 2901 2902 2903
	ql_dbg(ql_dbg_multiq, vha, 0xc005,
	    "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
	    ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
	ql_dbg(ql_dbg_init, vha, 0x0055,
	    "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
	    ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
2904

2905
msix_out:
2906
	kfree(entries);
2907 2908 2909 2910
	return ret;
}

int
2911
qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
2912 2913
{
	int ret;
2914
	device_reg_t __iomem *reg = ha->iobase;
2915
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2916 2917

	/* If possible, enable MSI-X. */
2918
	if (!IS_QLA2432(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
2919
		!IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha) && !IS_QLAFX00(ha))
2920 2921 2922 2923 2924 2925
		goto skip_msi;

	if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
		(ha->pdev->subsystem_device == 0x7040 ||
		ha->pdev->subsystem_device == 0x7041 ||
		ha->pdev->subsystem_device == 0x1705)) {
2926 2927
		ql_log(ql_log_warn, vha, 0x0034,
		    "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
2928
			ha->pdev->subsystem_vendor,
2929
			ha->pdev->subsystem_device);
2930 2931
		goto skip_msi;
	}
2932

2933
	if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
2934 2935
		ql_log(ql_log_warn, vha, 0x0035,
		    "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
2936
		    ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
2937 2938 2939
		goto skip_msix;
	}

2940
	ret = qla24xx_enable_msix(ha, rsp);
2941
	if (!ret) {
2942 2943 2944
		ql_dbg(ql_dbg_init, vha, 0x0036,
		    "MSI-X: Enabled (0x%X, 0x%X).\n",
		    ha->chip_revision, ha->fw_attributes);
2945
		goto clear_risc_ints;
2946
	}
2947 2948
	ql_log(ql_log_info, vha, 0x0037,
	    "MSI-X Falling back-to MSI mode -%d.\n", ret);
2949
skip_msix:
2950

2951
	if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
2952
	    !IS_QLA8001(ha) && !IS_P3P_TYPE(ha) && !IS_QLAFX00(ha))
2953 2954 2955 2956
		goto skip_msi;

	ret = pci_enable_msi(ha->pdev);
	if (!ret) {
2957 2958
		ql_dbg(ql_dbg_init, vha, 0x0038,
		    "MSI: Enabled.\n");
2959
		ha->flags.msi_enabled = 1;
2960
	} else
2961 2962
		ql_log(ql_log_warn, vha, 0x0039,
		    "MSI-X; Falling back-to INTa mode -- %d.\n", ret);
2963 2964 2965 2966 2967

	/* Skip INTx on ISP82xx. */
	if (!ha->flags.msi_enabled && IS_QLA82XX(ha))
		return QLA_FUNCTION_FAILED;

2968 2969
skip_msi:

2970
	ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
2971 2972
	    ha->flags.msi_enabled ? 0 : IRQF_SHARED,
	    QLA2XXX_DRIVER_NAME, rsp);
2973
	if (ret) {
2974
		ql_log(ql_log_warn, vha, 0x003a,
2975 2976
		    "Failed to reserve interrupt %d already in use.\n",
		    ha->pdev->irq);
2977
		goto fail;
2978
	} else if (!ha->flags.msi_enabled) {
2979 2980
		ql_dbg(ql_dbg_init, vha, 0x0125,
		    "INTa mode: Enabled.\n");
2981 2982
		ha->flags.mr_intr_valid = 1;
	}
2983

2984 2985
clear_risc_ints:

2986
	spin_lock_irq(&ha->hardware_lock);
2987
	if (!IS_FWI2_CAPABLE(ha))
2988
		WRT_REG_WORD(&reg->isp.semaphore, 0);
2989
	spin_unlock_irq(&ha->hardware_lock);
2990

2991
fail:
2992 2993 2994 2995
	return ret;
}

void
2996
qla2x00_free_irqs(scsi_qla_host_t *vha)
2997
{
2998
	struct qla_hw_data *ha = vha->hw;
2999 3000 3001 3002 3003 3004 3005 3006 3007
	struct rsp_que *rsp;

	/*
	 * We need to check that ha->rsp_q_map is valid in case we are called
	 * from a probe failure context.
	 */
	if (!ha->rsp_q_map || !ha->rsp_q_map[0])
		return;
	rsp = ha->rsp_q_map[0];
3008 3009 3010

	if (ha->flags.msix_enabled)
		qla24xx_disable_msix(ha);
3011
	else if (ha->flags.msi_enabled) {
3012
		free_irq(ha->pdev->irq, rsp);
3013
		pci_disable_msi(ha->pdev);
3014 3015
	} else
		free_irq(ha->pdev->irq, rsp);
3016
}
3017

3018 3019 3020 3021

int qla25xx_request_irq(struct rsp_que *rsp)
{
	struct qla_hw_data *ha = rsp->hw;
3022
	struct qla_init_msix_entry *intr = &msix_entries[2];
3023
	struct qla_msix_entry *msix = rsp->msix;
3024
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
3025 3026 3027 3028
	int ret;

	ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
	if (ret) {
3029 3030 3031
		ql_log(ql_log_fatal, vha, 0x00e6,
		    "MSI-X: Unable to register handler -- %x/%d.\n",
		    msix->vector, ret);
3032 3033 3034 3035 3036 3037
		return ret;
	}
	msix->have_irq = 1;
	msix->rsp = rsp;
	return ret;
}