qla_isr.c 83.9 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
A
Andrew Vasquez 已提交
2
 * QLogic Fibre Channel HBA Driver
3
 * Copyright (c)  2003-2014 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
		hccr = RD_REG_WORD(&reg->hccr);
59
		if (qla2x00_check_reg16_for_disconnect(vha, hccr))
60
			break;
61 62 63 64 65 66
		if (hccr & HCCR_RISC_PAUSE) {
			if (pci_channel_offline(ha->pdev))
				break;

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

73 74
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
75 76
			break;
		} else if ((RD_REG_WORD(&reg->istatus) & ISR_RISC_INT) == 0)
L
Linus Torvalds 已提交
77 78 79 80 81 82 83
			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. */
84 85
			mb[0] = RD_MAILBOX_REG(ha, reg, 0);
			if (mb[0] > 0x3fff && mb[0] < 0x8000) {
86
				qla2x00_mbx_completion(vha, mb[0]);
L
Linus Torvalds 已提交
87
				status |= MBX_INTERRUPT;
88 89 90 91
			} 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);
92
				qla2x00_async_event(vha, rsp, mb);
L
Linus Torvalds 已提交
93 94
			} else {
				/*EMPTY*/
95 96 97
				ql_dbg(ql_dbg_async, vha, 0x5025,
				    "Unrecognized interrupt type (%d).\n",
				    mb[0]);
L
Linus Torvalds 已提交
98 99 100 101 102
			}
			/* Release mailbox registers. */
			WRT_REG_WORD(&reg->semaphore, 0);
			RD_REG_WORD(&reg->semaphore);
		} else {
103
			qla2x00_process_response_queue(rsp);
L
Linus Torvalds 已提交
104 105 106 107 108

			WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
			RD_REG_WORD(&reg->hccr);
		}
	}
109
	qla2x00_handle_mbx_completion(ha, status);
110
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
L
Linus Torvalds 已提交
111 112 113 114

	return (IRQ_HANDLED);
}

115
bool
116
qla2x00_check_reg32_for_disconnect(scsi_qla_host_t *vha, uint32_t reg)
117 118 119
{
	/* Check for PCI disconnection */
	if (reg == 0xffffffff) {
120 121 122 123 124 125 126 127
		if (!test_and_set_bit(PFLG_DISCONNECTED, &vha->pci_flags)) {
			/*
			 * Schedule this (only once) on the default system
			 * workqueue so that all the adapter workqueues and the
			 * DPC thread can be shutdown cleanly.
			 */
			schedule_work(&vha->hw->board_disable);
		}
128 129 130 131 132
		return true;
	} else
		return false;
}

133 134 135 136 137 138
bool
qla2x00_check_reg16_for_disconnect(scsi_qla_host_t *vha, uint16_t reg)
{
	return qla2x00_check_reg32_for_disconnect(vha, 0xffff0000 | reg);
}

L
Linus Torvalds 已提交
139 140 141 142 143 144 145 146 147 148
/**
 * 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
149
qla2300_intr_handler(int irq, void *dev_id)
L
Linus Torvalds 已提交
150
{
151
	scsi_qla_host_t	*vha;
152
	struct device_reg_2xxx __iomem *reg;
L
Linus Torvalds 已提交
153 154 155 156
	int		status;
	unsigned long	iter;
	uint32_t	stat;
	uint16_t	hccr;
157
	uint16_t	mb[4];
158 159
	struct rsp_que *rsp;
	struct qla_hw_data *ha;
160
	unsigned long	flags;
L
Linus Torvalds 已提交
161

162 163
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
164 165
		ql_log(ql_log_info, NULL, 0x5058,
		    "%s: NULL response queue pointer.\n", __func__);
L
Linus Torvalds 已提交
166 167 168
		return (IRQ_NONE);
	}

169
	ha = rsp->hw;
170
	reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
171 172
	status = 0;

173
	spin_lock_irqsave(&ha->hardware_lock, flags);
174
	vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
175 176
	for (iter = 50; iter--; ) {
		stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
177
		if (qla2x00_check_reg32_for_disconnect(vha, stat))
178
			break;
L
Linus Torvalds 已提交
179
		if (stat & HSR_RISC_PAUSED) {
180
			if (unlikely(pci_channel_offline(ha->pdev)))
181 182
				break;

L
Linus Torvalds 已提交
183
			hccr = RD_REG_WORD(&reg->hccr);
184

L
Linus Torvalds 已提交
185
			if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
186 187 188
				ql_log(ql_log_warn, vha, 0x5026,
				    "Parity error -- HCCR=%x, Dumping "
				    "firmware.\n", hccr);
L
Linus Torvalds 已提交
189
			else
190 191 192
				ql_log(ql_log_warn, vha, 0x5027,
				    "RISC paused -- HCCR=%x, Dumping "
				    "firmware.\n", hccr);
L
Linus Torvalds 已提交
193 194 195 196

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

202 203
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
204 205 206 207 208 209 210 211 212
			break;
		} else if ((stat & HSR_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
		case 0x1:
		case 0x2:
		case 0x10:
		case 0x11:
213
			qla2x00_mbx_completion(vha, MSW(stat));
L
Linus Torvalds 已提交
214 215 216 217 218 219
			status |= MBX_INTERRUPT;

			/* Release mailbox registers. */
			WRT_REG_WORD(&reg->semaphore, 0);
			break;
		case 0x12:
220 221 222 223
			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);
224
			qla2x00_async_event(vha, rsp, mb);
225 226
			break;
		case 0x13:
227
			qla2x00_process_response_queue(rsp);
L
Linus Torvalds 已提交
228 229
			break;
		case 0x15:
230 231
			mb[0] = MBA_CMPLT_1_16BIT;
			mb[1] = MSW(stat);
232
			qla2x00_async_event(vha, rsp, mb);
L
Linus Torvalds 已提交
233 234
			break;
		case 0x16:
235 236 237
			mb[0] = MBA_SCSI_COMPLETION;
			mb[1] = MSW(stat);
			mb[2] = RD_MAILBOX_REG(ha, reg, 2);
238
			qla2x00_async_event(vha, rsp, mb);
L
Linus Torvalds 已提交
239 240
			break;
		default:
241 242
			ql_dbg(ql_dbg_async, vha, 0x5028,
			    "Unrecognized interrupt type (%d).\n", stat & 0xff);
L
Linus Torvalds 已提交
243 244 245 246 247
			break;
		}
		WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
		RD_REG_WORD_RELAXED(&reg->hccr);
	}
248
	qla2x00_handle_mbx_completion(ha, status);
249
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
L
Linus Torvalds 已提交
250 251 252 253 254 255 256 257 258 259

	return (IRQ_HANDLED);
}

/**
 * qla2x00_mbx_completion() - Process mailbox command completions.
 * @ha: SCSI driver HA context
 * @mb0: Mailbox0 register
 */
static void
260
qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
L
Linus Torvalds 已提交
261 262
{
	uint16_t	cnt;
263
	uint32_t	mboxes;
L
Linus Torvalds 已提交
264
	uint16_t __iomem *wptr;
265
	struct qla_hw_data *ha = vha->hw;
266
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
267

268 269 270
	/* Read all mbox registers? */
	mboxes = (1 << ha->mbx_count) - 1;
	if (!ha->mcp)
271
		ql_dbg(ql_dbg_async, vha, 0x5001, "MBX pointer ERROR.\n");
272 273 274
	else
		mboxes = ha->mcp->in_mb;

L
Linus Torvalds 已提交
275 276 277
	/* Load return mailbox registers. */
	ha->flags.mbox_int = 1;
	ha->mailbox_out[0] = mb0;
278
	mboxes >>= 1;
L
Linus Torvalds 已提交
279 280 281
	wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);

	for (cnt = 1; cnt < ha->mbx_count; cnt++) {
A
Andrew Vasquez 已提交
282
		if (IS_QLA2200(ha) && cnt == 8)
L
Linus Torvalds 已提交
283
			wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
284
		if ((cnt == 4 || cnt == 5) && (mboxes & BIT_0))
L
Linus Torvalds 已提交
285
			ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
286
		else if (mboxes & BIT_0)
L
Linus Torvalds 已提交
287
			ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
A
Andrew Vasquez 已提交
288

L
Linus Torvalds 已提交
289
		wptr++;
290
		mboxes >>= 1;
L
Linus Torvalds 已提交
291 292 293
	}
}

294 295 296 297 298 299 300
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;
301
	struct device_reg_82xx __iomem *reg82 = &vha->hw->iobase->isp82;
302 303 304 305
	uint16_t __iomem *wptr;
	uint16_t cnt, timeout, mb[QLA_IDC_ACK_REGS];

	/* Seed data -- mailbox1 -> mailbox7. */
306 307 308 309 310 311 312
	if (IS_QLA81XX(vha->hw) || IS_QLA83XX(vha->hw))
		wptr = (uint16_t __iomem *)&reg24->mailbox1;
	else if (IS_QLA8044(vha->hw))
		wptr = (uint16_t __iomem *)&reg82->mailbox_out[1];
	else
		return;

313 314 315
	for (cnt = 0; cnt < QLA_IDC_ACK_REGS; cnt++, wptr++)
		mb[cnt] = RD_REG_WORD(wptr);

316
	ql_dbg(ql_dbg_async, vha, 0x5021,
317
	    "Inter-Driver Communication %s -- "
318 319 320
	    "%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]);
321 322 323 324 325
	switch (aen) {
	/* Handle IDC Error completion case. */
	case MBA_IDC_COMPLETE:
		if (mb[1] >> 15) {
			vha->hw->flags.idc_compl_status = 1;
326
			if (vha->hw->notify_dcbx_comp && !vha->vp_idx)
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
				complete(&vha->hw->dcbx_comp);
		}
		break;

	case MBA_IDC_NOTIFY:
		/* Acknowledgement needed? [Notify && non-zero timeout]. */
		timeout = (descr >> 8) & 0xf;
		ql_dbg(ql_dbg_async, vha, 0x5022,
		    "%lu Inter-Driver Communication %s -- ACK timeout=%d.\n",
		    vha->host_no, event[aen & 0xff], timeout);

		if (!timeout)
			return;
		rval = qla2x00_post_idc_ack_work(vha, mb);
		if (rval != QLA_SUCCESS)
			ql_log(ql_log_warn, vha, 0x5023,
			    "IDC failed to post ACK.\n");
		break;
	case MBA_IDC_TIME_EXT:
		vha->hw->idc_extend_tmo = descr;
		ql_dbg(ql_dbg_async, vha, 0x5087,
		    "%lu Inter-Driver Communication %s -- "
		    "Extend timeout by=%d.\n",
		    vha->host_no, event[aen & 0xff], vha->hw->idc_extend_tmo);
		break;
352
	}
353 354
}

355
#define LS_UNKNOWN	2
356 357
const char *
qla2x00_get_link_speed_str(struct qla_hw_data *ha, uint16_t speed)
358
{
359 360
	static const char *const link_speeds[] = {
		"1", "2", "?", "4", "8", "16", "32", "10"
361
	};
362
#define	QLA_LAST_SPEED	7
363 364

	if (IS_QLA2100(ha) || IS_QLA2200(ha))
365 366
		return link_speeds[0];
	else if (speed == 0x13)
367 368
		return link_speeds[QLA_LAST_SPEED];
	else if (speed < QLA_LAST_SPEED)
369 370 371
		return link_speeds[speed];
	else
		return link_speeds[LS_UNKNOWN];
372 373
}

374
static void
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 480 481 482 483 484 485 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 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529
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]);
530 531
		if (ha->flags.nic_core_reset_owner)
			return;
532 533 534 535
		qla83xx_schedule_work(vha, MBA_IDC_AEN);
	}
}

536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
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 已提交
561 562 563
/**
 * qla2x00_async_event() - Process aynchronous events.
 * @ha: SCSI driver HA context
564
 * @mb: Mailbox registers (0 - 3)
L
Linus Torvalds 已提交
565
 */
566
void
567
qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
L
Linus Torvalds 已提交
568 569
{
	uint16_t	handle_cnt;
570
	uint16_t	cnt, mbx;
L
Linus Torvalds 已提交
571
	uint32_t	handles[5];
572
	struct qla_hw_data *ha = vha->hw;
573
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
574
	struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
575
	struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
L
Linus Torvalds 已提交
576
	uint32_t	rscn_entry, host_pid;
577
	unsigned long	flags;
L
Linus Torvalds 已提交
578 579 580

	/* Setup to process RIO completion. */
	handle_cnt = 0;
581
	if (IS_CNA_CAPABLE(ha))
582
		goto skip_rio;
L
Linus Torvalds 已提交
583 584
	switch (mb[0]) {
	case MBA_SCSI_COMPLETION:
585
		handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
L
Linus Torvalds 已提交
586 587 588
		handle_cnt = 1;
		break;
	case MBA_CMPLT_1_16BIT:
589
		handles[0] = mb[1];
L
Linus Torvalds 已提交
590 591 592 593
		handle_cnt = 1;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_2_16BIT:
594 595
		handles[0] = mb[1];
		handles[1] = mb[2];
L
Linus Torvalds 已提交
596 597 598 599
		handle_cnt = 2;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_3_16BIT:
600 601 602
		handles[0] = mb[1];
		handles[1] = mb[2];
		handles[2] = mb[3];
L
Linus Torvalds 已提交
603 604 605 606
		handle_cnt = 3;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_4_16BIT:
607 608 609
		handles[0] = mb[1];
		handles[1] = mb[2];
		handles[2] = mb[3];
L
Linus Torvalds 已提交
610 611 612 613 614
		handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
		handle_cnt = 4;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_5_16BIT:
615 616 617
		handles[0] = mb[1];
		handles[1] = mb[2];
		handles[2] = mb[3];
L
Linus Torvalds 已提交
618 619 620 621 622 623
		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:
624
		handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
L
Linus Torvalds 已提交
625 626 627 628 629 630 631 632 633
		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;
	}
634
skip_rio:
L
Linus Torvalds 已提交
635 636
	switch (mb[0]) {
	case MBA_SCSI_COMPLETION:	/* Fast Post */
637
		if (!vha->flags.online)
L
Linus Torvalds 已提交
638 639 640
			break;

		for (cnt = 0; cnt < handle_cnt; cnt++)
641 642
			qla2x00_process_completed_request(vha, rsp->req,
				handles[cnt]);
L
Linus Torvalds 已提交
643 644 645
		break;

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

649
		set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
650 651 652
		break;

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

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

661
		if (IS_FWI2_CAPABLE(ha)) {
662
			if (mb[1] == 0 && mb[2] == 0) {
663
				ql_log(ql_log_fatal, vha, 0x5004,
664 665
				    "Unrecoverable Hardware Error: adapter "
				    "marked OFFLINE!\n");
666
				vha->flags.online = 0;
667
				vha->device_flags |= DFLG_DEV_FAILED;
668
			} else {
L
Lucas De Marchi 已提交
669
				/* Check to see if MPI timeout occurred */
670
				if ((mbx & MBX_3) && (ha->port_no == 0))
671 672 673
					set_bit(MPI_RESET_NEEDED,
					    &vha->dpc_flags);

674
				set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
675
			}
676
		} else if (mb[1] == 0) {
677
			ql_log(ql_log_fatal, vha, 0x5005,
L
Linus Torvalds 已提交
678 679
			    "Unrecoverable Hardware Error: adapter marked "
			    "OFFLINE!\n");
680
			vha->flags.online = 0;
681
			vha->device_flags |= DFLG_DEV_FAILED;
L
Linus Torvalds 已提交
682
		} else
683
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
684 685 686
		break;

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

690
		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
691 692 693
		break;

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

697
		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
698 699 700
		break;

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

704
		break;
L
Linus Torvalds 已提交
705
	case MBA_LIP_OCCURRED:		/* Loop Initialization Procedure */
706
		ql_dbg(ql_dbg_async, vha, 0x5009,
707
		    "LIP occurred (%x).\n", mb[1]);
L
Linus Torvalds 已提交
708

709 710 711 712
		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 已提交
713 714
		}

715 716 717
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
718 719
		}

720 721
		set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
		set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
722

723 724
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
L
Linus Torvalds 已提交
725 726 727
		break;

	case MBA_LOOP_UP:		/* Loop Up Event */
728
		if (IS_QLA2100(ha) || IS_QLA2200(ha))
729
			ha->link_data_rate = PORT_SPEED_1GB;
730
		else
L
Linus Torvalds 已提交
731 732
			ha->link_data_rate = mb[1];

733
		ql_log(ql_log_info, vha, 0x500a,
734
		    "LOOP UP detected (%s Gbps).\n",
735
		    qla2x00_get_link_speed_str(ha, ha->link_data_rate));
L
Linus Torvalds 已提交
736

737 738
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
L
Linus Torvalds 已提交
739 740 741
		break;

	case MBA_LOOP_DOWN:		/* Loop Down Event */
742 743
		mbx = (IS_QLA81XX(ha) || IS_QLA8031(ha))
			? RD_REG_WORD(&reg24->mailbox4) : 0;
744 745
		mbx = (IS_P3P_TYPE(ha)) ? RD_REG_WORD(&reg82->mailbox_out[4])
			: mbx;
746
		ql_log(ql_log_info, vha, 0x500b,
747 748
		    "LOOP DOWN detected (%x %x %x %x).\n",
		    mb[1], mb[2], mb[3], mbx);
L
Linus Torvalds 已提交
749

750 751 752 753 754
		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 已提交
755 756
		}

757 758 759
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
760 761
		}

762
		vha->flags.management_server_logged_in = 0;
763
		ha->link_data_rate = PORT_SPEED_UNKNOWN;
764
		qla2x00_post_aen_work(vha, FCH_EVT_LINKDOWN, 0);
L
Linus Torvalds 已提交
765 766 767
		break;

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

771 772 773 774
		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 已提交
775 776
		}

777 778 779
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
780 781
		}

782
		set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
783 784

		ha->operating_mode = LOOP;
785 786
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
L
Linus Torvalds 已提交
787 788
		break;

789
	/* case MBA_DCBX_COMPLETE: */
L
Linus Torvalds 已提交
790 791 792 793
	case MBA_POINT_TO_POINT:	/* Point-to-Point */
		if (IS_QLA2100(ha))
			break;

794
		if (IS_CNA_CAPABLE(ha)) {
795 796 797
			ql_dbg(ql_dbg_async, vha, 0x500d,
			    "DCBX Completed -- %04x %04x %04x.\n",
			    mb[1], mb[2], mb[3]);
798
			if (ha->notify_dcbx_comp && !vha->vp_idx)
799 800 801
				complete(&ha->dcbx_comp);

		} else
802 803
			ql_dbg(ql_dbg_async, vha, 0x500e,
			    "Asynchronous P2P MODE received.\n");
L
Linus Torvalds 已提交
804 805 806 807 808

		/*
		 * Until there's a transition from loop down to loop up, treat
		 * this as loop down only.
		 */
809 810 811 812
		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 已提交
813
				    LOOP_DOWN_TIME);
814
			qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
815 816
		}

817 818 819
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
820 821
		}

822 823 824 825 826
		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);
827 828

		ha->flags.gpsc_supported = 1;
829
		vha->flags.management_server_logged_in = 0;
L
Linus Torvalds 已提交
830 831 832 833 834 835
		break;

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

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

839 840 841 842
		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 已提交
843
				    LOOP_DOWN_TIME);
844
			qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
845 846
		}

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

852 853
		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
L
Linus Torvalds 已提交
854 855 856
		break;

	case MBA_PORT_UPDATE:		/* Port database update */
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
		/*
		 * 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
		 */
872 873 874 875
		if (IS_QLA2XXX_MIDTYPE(ha) &&
		    ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff) ||
			(mb[1] != 0xffff)) && vha->vp_idx != (mb[3] & 0xff))
			break;
876

877 878
		/* Global event -- port logout or port unavailable. */
		if (mb[1] == 0xffff && mb[2] == 0x7) {
879 880 881
			ql_dbg(ql_dbg_async, vha, 0x5010,
			    "Port unavailable %04x %04x %04x.\n",
			    mb[1], mb[2], mb[3]);
882 883
			ql_log(ql_log_warn, vha, 0x505e,
			    "Link is offline.\n");
884 885 886 887 888 889 890 891 892 893 894 895 896

			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);
897
				qla2x00_mark_all_devices_lost(vha, 1);
898 899 900 901 902 903 904
			}

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

L
Linus Torvalds 已提交
905
		/*
906
		 * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
L
Linus Torvalds 已提交
907 908 909
		 * event etc. earlier indicating loop is down) then process
		 * it.  Otherwise ignore it and Wait for RSCN to come in.
		 */
910
		atomic_set(&vha->loop_down_timer, 0);
911 912
		if (atomic_read(&vha->loop_state) != LOOP_DOWN &&
		    atomic_read(&vha->loop_state) != LOOP_DEAD) {
913 914 915
			ql_dbg(ql_dbg_async, vha, 0x5011,
			    "Asynchronous PORT UPDATE ignored %04x/%04x/%04x.\n",
			    mb[1], mb[2], mb[3]);
916 917

			qlt_async_event(mb[0], vha, mb);
L
Linus Torvalds 已提交
918 919 920
			break;
		}

921 922 923
		ql_dbg(ql_dbg_async, vha, 0x5012,
		    "Port database changed %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
L
Linus Torvalds 已提交
924 925 926 927

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

930
		qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
931

932 933 934
		if (vha->vp_idx == 0 && !qla_ini_mode_enabled(vha))
			set_bit(SCR_PENDING, &vha->dpc_flags);

935 936
		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
937 938

		qlt_async_event(mb[0], vha, mb);
L
Linus Torvalds 已提交
939 940 941
		break;

	case MBA_RSCN_UPDATE:		/* State Change Registration */
942
		/* Check if the Vport has issued a SCR */
943
		if (vha->vp_idx && test_bit(VP_SCR_NEEDED, &vha->vp_flags))
944 945
			break;
		/* Only handle SCNs for our Vport index. */
946
		if (ha->flags.npiv_supported && vha->vp_idx != (mb[3] & 0xff))
947
			break;
948

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

953
		rscn_entry = ((mb[1] & 0xff) << 16) | mb[2];
954 955
		host_pid = (vha->d_id.b.domain << 16) | (vha->d_id.b.area << 8)
				| vha->d_id.b.al_pa;
L
Linus Torvalds 已提交
956
		if (rscn_entry == host_pid) {
957 958 959
			ql_dbg(ql_dbg_async, vha, 0x5014,
			    "Ignoring RSCN update to local host "
			    "port ID (%06x).\n", host_pid);
L
Linus Torvalds 已提交
960 961 962
			break;
		}

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

966 967 968 969
		/* Skip RSCNs for virtual ports on the same physical port */
		if (qla2x00_is_a_vp_did(vha, rscn_entry))
			break;

970 971
		atomic_set(&vha->loop_down_timer, 0);
		vha->flags.management_server_logged_in = 0;
L
Linus Torvalds 已提交
972

973 974 975
		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 已提交
976 977 978 979
		break;

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

983
		if (IS_FWI2_CAPABLE(ha))
984
			qla24xx_process_response_queue(vha, rsp);
985
		else
986
			qla2x00_process_response_queue(rsp);
L
Linus Torvalds 已提交
987
		break;
988 989

	case MBA_DISCARD_RND_FRAME:
990 991 992
		ql_dbg(ql_dbg_async, vha, 0x5016,
		    "Discard RND Frame -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
993
		break;
994 995

	case MBA_TRACE_NOTIFICATION:
996 997
		ql_dbg(ql_dbg_async, vha, 0x5017,
		    "Trace Notification -- %04x %04x.\n", mb[1], mb[2]);
998
		break;
999 1000

	case MBA_ISP84XX_ALERT:
1001 1002 1003
		ql_dbg(ql_dbg_async, vha, 0x5018,
		    "ISP84XX Alert Notification -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
1004 1005 1006 1007

		spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
		switch (mb[1]) {
		case A84_PANIC_RECOVERY:
1008 1009 1010
			ql_log(ql_log_info, vha, 0x5019,
			    "Alert 84XX: panic recovery %04x %04x.\n",
			    mb[2], mb[3]);
1011 1012 1013
			break;
		case A84_OP_LOGIN_COMPLETE:
			ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
1014 1015 1016
			ql_log(ql_log_info, vha, 0x501a,
			    "Alert 84XX: firmware version %x.\n",
			    ha->cs84xx->op_fw_version);
1017 1018 1019
			break;
		case A84_DIAG_LOGIN_COMPLETE:
			ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
1020 1021 1022
			ql_log(ql_log_info, vha, 0x501b,
			    "Alert 84XX: diagnostic firmware version %x.\n",
			    ha->cs84xx->diag_fw_version);
1023 1024 1025 1026
			break;
		case A84_GOLD_LOGIN_COMPLETE:
			ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
			ha->cs84xx->fw_update = 1;
1027 1028 1029
			ql_log(ql_log_info, vha, 0x501c,
			    "Alert 84XX: gold firmware version %x.\n",
			    ha->cs84xx->gold_fw_version);
1030 1031
			break;
		default:
1032 1033
			ql_log(ql_log_warn, vha, 0x501d,
			    "Alert 84xx: Invalid Alert %04x %04x %04x.\n",
1034 1035 1036 1037
			    mb[1], mb[2], mb[3]);
		}
		spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
		break;
1038
	case MBA_DCBX_START:
1039 1040 1041
		ql_dbg(ql_dbg_async, vha, 0x501e,
		    "DCBX Started -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
1042 1043
		break;
	case MBA_DCBX_PARAM_UPDATE:
1044 1045 1046
		ql_dbg(ql_dbg_async, vha, 0x501f,
		    "DCBX Parameters Updated -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
1047 1048
		break;
	case MBA_FCF_CONF_ERR:
1049 1050 1051
		ql_dbg(ql_dbg_async, vha, 0x5020,
		    "FCF Configuration Error -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
1052 1053
		break;
	case MBA_IDC_NOTIFY:
1054
		if (IS_QLA8031(vha->hw) || IS_QLA8044(ha)) {
1055 1056 1057 1058
			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) {
1059
				set_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags);
1060 1061 1062 1063 1064 1065
				/*
				 * 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);
1066 1067
				qla2xxx_wake_dpc(vha);
			}
1068
		}
1069
	case MBA_IDC_COMPLETE:
1070
		if (ha->notify_lb_portup_comp && !vha->vp_idx)
1071 1072
			complete(&ha->lb_portup_comp);
		/* Fallthru */
1073
	case MBA_IDC_TIME_EXT:
1074 1075
		if (IS_QLA81XX(vha->hw) || IS_QLA8031(vha->hw) ||
		    IS_QLA8044(ha))
1076 1077 1078 1079 1080 1081 1082 1083 1084
			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);
1085
		break;
1086

1087 1088 1089 1090
	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 已提交
1091
	}
1092

1093 1094
	qlt_async_event(mb[0], vha, mb);

1095
	if (!vha->vp_idx && ha->num_vhosts)
1096
		qla2x00_alert_all_vps(rsp, mb);
L
Linus Torvalds 已提交
1097 1098 1099 1100 1101 1102 1103
}

/**
 * qla2x00_process_completed_request() - Process a Fast Post response.
 * @ha: SCSI driver HA context
 * @index: SRB index
 */
1104
void
1105
qla2x00_process_completed_request(struct scsi_qla_host *vha,
1106
				  struct req_que *req, uint32_t index)
L
Linus Torvalds 已提交
1107 1108
{
	srb_t *sp;
1109
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1110 1111

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

1116
		if (IS_P3P_TYPE(ha))
1117 1118 1119
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
1120 1121 1122
		return;
	}

1123
	sp = req->outstanding_cmds[index];
L
Linus Torvalds 已提交
1124 1125
	if (sp) {
		/* Free outstanding command slot. */
1126
		req->outstanding_cmds[index] = NULL;
L
Linus Torvalds 已提交
1127 1128

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

1133
		if (IS_P3P_TYPE(ha))
1134 1135 1136
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
1137 1138 1139
	}
}

1140
srb_t *
1141 1142 1143 1144 1145 1146 1147 1148 1149
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);
1150
	if (index >= req->num_outstanding_cmds) {
1151 1152
		ql_log(ql_log_warn, vha, 0x5031,
		    "Invalid command index (%x).\n", index);
1153
		if (IS_P3P_TYPE(ha))
1154 1155 1156
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1157 1158 1159 1160
		goto done;
	}
	sp = req->outstanding_cmds[index];
	if (!sp) {
1161 1162
		ql_log(ql_log_warn, vha, 0x5032,
		    "Invalid completion handle (%x) -- timed-out.\n", index);
1163 1164 1165
		return sp;
	}
	if (sp->handle != index) {
1166 1167
		ql_log(ql_log_warn, vha, 0x5033,
		    "SRB handle (%x) mismatch %x.\n", sp->handle, index);
1168 1169
		return NULL;
	}
1170

1171
	req->outstanding_cmds[index] = NULL;
1172

1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
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;
1185
	struct srb_iocb *lio;
1186
	uint16_t *data;
1187
	uint16_t status;
1188 1189 1190 1191 1192

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

1193 1194
	lio = &sp->u.iocb_cmd;
	type = sp->name;
1195
	fcport = sp->fcport;
1196
	data = lio->u.logio.data;
1197

1198
	data[0] = MBS_COMMAND_ERROR;
1199
	data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
1200
	    QLA_LOGIO_LOGIN_RETRIED : 0;
1201
	if (mbx->entry_status) {
1202
		ql_dbg(ql_dbg_async, vha, 0x5043,
1203
		    "Async-%s error entry - hdl=%x portid=%02x%02x%02x "
1204
		    "entry-status=%x status=%x state-flag=%x "
1205 1206
		    "status-flags=%x.\n", type, sp->handle,
		    fcport->d_id.b.domain, fcport->d_id.b.area,
1207 1208
		    fcport->d_id.b.al_pa, mbx->entry_status,
		    le16_to_cpu(mbx->status), le16_to_cpu(mbx->state_flags),
1209
		    le16_to_cpu(mbx->status_flags));
1210

1211
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5029,
1212
		    (uint8_t *)mbx, sizeof(*mbx));
1213

1214
		goto logio_done;
1215 1216
	}

1217
	status = le16_to_cpu(mbx->status);
1218
	if (status == 0x30 && sp->type == SRB_LOGIN_CMD &&
1219 1220 1221
	    le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
		status = 0;
	if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
1222
		ql_dbg(ql_dbg_async, vha, 0x5045,
1223 1224 1225 1226
		    "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));
1227 1228

		data[0] = MBS_COMMAND_COMPLETE;
1229
		if (sp->type == SRB_LOGIN_CMD) {
1230 1231 1232
			fcport->port_type = FCT_TARGET;
			if (le16_to_cpu(mbx->mb1) & BIT_0)
				fcport->port_type = FCT_INITIATOR;
1233
			else if (le16_to_cpu(mbx->mb1) & BIT_1)
1234
				fcport->flags |= FCF_FCP2_DEVICE;
1235
		}
1236
		goto logio_done;
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
	}

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

1251
	ql_log(ql_log_warn, vha, 0x5046,
1252 1253 1254 1255
	    "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),
1256
	    le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
1257
	    le16_to_cpu(mbx->mb7));
1258

1259
logio_done:
1260
	sp->done(vha, sp, 0);
1261 1262
}

1263 1264 1265 1266 1267 1268 1269 1270 1271
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;
1272
	int res;
1273 1274 1275 1276 1277

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

1278
	bsg_job = sp->u.bsg_job;
1279

1280
	type = "ct pass-through";
1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291

	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) {
1292
			res = DID_OK << 16;
1293 1294 1295
			bsg_job->reply->reply_payload_rcv_len =
			    le16_to_cpu(((sts_entry_t *)pkt)->rsp_info_len);

1296 1297
			ql_log(ql_log_warn, vha, 0x5048,
			    "CT pass-through-%s error "
1298
			    "comp_status-status=0x%x total_byte = 0x%x.\n",
1299 1300
			    type, comp_status,
			    bsg_job->reply->reply_payload_rcv_len);
1301
		} else {
1302 1303 1304
			ql_log(ql_log_warn, vha, 0x5049,
			    "CT pass-through-%s error "
			    "comp_status-status=0x%x.\n", type, comp_status);
1305
			res = DID_ERROR << 16;
1306 1307
			bsg_job->reply->reply_payload_rcv_len = 0;
		}
1308
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5035,
1309
		    (uint8_t *)pkt, sizeof(*pkt));
1310
	} else {
1311
		res = DID_OK << 16;
1312 1313 1314 1315 1316
		bsg_job->reply->reply_payload_rcv_len =
		    bsg_job->reply_payload.payload_len;
		bsg_job->reply_len = 0;
	}

1317
	sp->done(vha, sp, res);
1318 1319
}

1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
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;
1331
	int res;
1332 1333 1334 1335

	sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
	if (!sp)
		return;
1336
	bsg_job = sp->u.bsg_job;
1337 1338

	type = NULL;
1339
	switch (sp->type) {
1340 1341 1342 1343 1344 1345 1346 1347
	case SRB_ELS_CMD_RPT:
	case SRB_ELS_CMD_HST:
		type = "els";
		break;
	case SRB_CT_CMD:
		type = "ct pass-through";
		break;
	default:
1348
		ql_dbg(ql_dbg_user, vha, 0x503e,
1349
		    "Unrecognized SRB: (%p) type=%d.\n", sp, sp->type);
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
		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) {
1365
			res = DID_OK << 16;
1366
			bsg_job->reply->reply_payload_rcv_len =
1367
			    le16_to_cpu(((struct els_sts_entry_24xx *)pkt)->total_byte_count);
1368

1369
			ql_dbg(ql_dbg_user, vha, 0x503f,
1370
			    "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
1371
			    "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
1372
			    type, sp->handle, comp_status, fw_status[1], fw_status[2],
1373 1374
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				pkt)->total_byte_count));
1375 1376 1377 1378
			fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
			memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
		}
		else {
1379
			ql_dbg(ql_dbg_user, vha, 0x5040,
1380
			    "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
1381
			    "error subcode 1=0x%x error subcode 2=0x%x.\n",
1382
			    type, sp->handle, comp_status,
1383 1384 1385 1386
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				pkt)->error_subcode_1),
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				    pkt)->error_subcode_2));
1387
			res = DID_ERROR << 16;
1388 1389 1390 1391
			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));
		}
1392
		ql_dump_buffer(ql_dbg_user + ql_dbg_buffer, vha, 0x5056,
1393
				(uint8_t *)pkt, sizeof(*pkt));
1394 1395
	}
	else {
1396
		res =  DID_OK << 16;
1397 1398 1399 1400
		bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
		bsg_job->reply_len = 0;
	}

1401
	sp->done(vha, sp, res);
1402 1403
}

1404 1405 1406 1407 1408 1409 1410 1411
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;
1412
	struct srb_iocb *lio;
1413
	uint16_t *data;
1414 1415 1416 1417 1418 1419
	uint32_t iop[2];

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

1420 1421
	lio = &sp->u.iocb_cmd;
	type = sp->name;
1422
	fcport = sp->fcport;
1423
	data = lio->u.logio.data;
1424

1425
	data[0] = MBS_COMMAND_ERROR;
1426
	data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
1427
		QLA_LOGIO_LOGIN_RETRIED : 0;
1428
	if (logio->entry_status) {
1429
		ql_log(ql_log_warn, fcport->vha, 0x5034,
1430
		    "Async-%s error entry - hdl=%x"
1431
		    "portid=%02x%02x%02x entry-status=%x.\n",
1432 1433 1434 1435
		    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,
1436
		    (uint8_t *)logio, sizeof(*logio));
1437

1438
		goto logio_done;
1439 1440 1441
	}

	if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
1442
		ql_dbg(ql_dbg_async, fcport->vha, 0x5036,
1443 1444 1445
		    "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,
1446
		    le32_to_cpu(logio->io_parameter[0]));
1447 1448

		data[0] = MBS_COMMAND_COMPLETE;
1449
		if (sp->type != SRB_LOGIN_CMD)
1450
			goto logio_done;
1451 1452 1453 1454 1455

		iop[0] = le32_to_cpu(logio->io_parameter[0]);
		if (iop[0] & BIT_4) {
			fcport->port_type = FCT_TARGET;
			if (iop[0] & BIT_8)
1456
				fcport->flags |= FCF_FCP2_DEVICE;
1457
		} else if (iop[0] & BIT_5)
1458
			fcport->port_type = FCT_INITIATOR;
1459

1460 1461 1462
		if (iop[0] & BIT_7)
			fcport->flags |= FCF_CONF_COMP_SUPPORTED;

1463 1464 1465 1466 1467
		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;

1468
		goto logio_done;
1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
	}

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

1486
	ql_dbg(ql_dbg_async, fcport->vha, 0x5037,
1487 1488
	    "Async-%s failed - hdl=%x portid=%02x%02x%02x comp=%x "
	    "iop0=%x iop1=%x.\n", type, sp->handle, fcport->d_id.b.domain,
1489
	    fcport->d_id.b.area, fcport->d_id.b.al_pa,
1490 1491
	    le16_to_cpu(logio->comp_status),
	    le32_to_cpu(logio->io_parameter[0]),
1492
	    le32_to_cpu(logio->io_parameter[1]));
1493

1494
logio_done:
1495
	sp->done(vha, sp, 0);
1496 1497
}

1498
static void
1499
qla24xx_tm_iocb_entry(scsi_qla_host_t *vha, struct req_que *req, void *tsk)
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
{
	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;

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

1512 1513
	iocb = &sp->u.iocb_cmd;
	type = sp->name;
1514
	fcport = sp->fcport;
1515
	iocb->u.tmf.data = QLA_SUCCESS;
1516 1517

	if (sts->entry_status) {
1518
		ql_log(ql_log_warn, fcport->vha, 0x5038,
1519 1520
		    "Async-%s error - hdl=%x entry-status(%x).\n",
		    type, sp->handle, sts->entry_status);
1521
		iocb->u.tmf.data = QLA_FUNCTION_FAILED;
1522
	} else if (sts->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1523
		ql_log(ql_log_warn, fcport->vha, 0x5039,
1524 1525
		    "Async-%s error - hdl=%x completion status(%x).\n",
		    type, sp->handle, sts->comp_status);
1526 1527
		iocb->u.tmf.data = QLA_FUNCTION_FAILED;
	} else if ((le16_to_cpu(sts->scsi_status) &
1528
	    SS_RESPONSE_INFO_LEN_VALID)) {
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538
		if (le32_to_cpu(sts->rsp_data_len) < 4) {
			ql_log(ql_log_warn, fcport->vha, 0x503b,
			    "Async-%s error - hdl=%x not enough response(%d).\n",
			    type, sp->handle, sts->rsp_data_len);
		} else if (sts->data[3]) {
			ql_log(ql_log_warn, fcport->vha, 0x503c,
			    "Async-%s error - hdl=%x response(%x).\n",
			    type, sp->handle, sts->data[3]);
		iocb->u.tmf.data = QLA_FUNCTION_FAILED;
		}
1539 1540
	}

1541
	if (iocb->u.tmf.data != QLA_SUCCESS)
1542 1543
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5055,
		    (uint8_t *)sts, sizeof(*sts));
1544

1545
	sp->done(vha, sp, 0);
1546 1547
}

L
Linus Torvalds 已提交
1548 1549 1550 1551 1552
/**
 * qla2x00_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
void
1553
qla2x00_process_response_queue(struct rsp_que *rsp)
L
Linus Torvalds 已提交
1554
{
1555 1556
	struct scsi_qla_host *vha;
	struct qla_hw_data *ha = rsp->hw;
1557
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
1558 1559 1560
	sts_entry_t	*pkt;
	uint16_t        handle_cnt;
	uint16_t        cnt;
1561

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

1564
	if (!vha->flags.online)
L
Linus Torvalds 已提交
1565 1566
		return;

1567 1568
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (sts_entry_t *)rsp->ring_ptr;
L
Linus Torvalds 已提交
1569

1570 1571 1572 1573
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
L
Linus Torvalds 已提交
1574
		} else {
1575
			rsp->ring_ptr++;
L
Linus Torvalds 已提交
1576 1577 1578
		}

		if (pkt->entry_status != 0) {
1579
			qla2x00_error_entry(vha, rsp, pkt);
L
Linus Torvalds 已提交
1580 1581 1582 1583 1584 1585 1586
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

		switch (pkt->entry_type) {
		case STATUS_TYPE:
1587
			qla2x00_status_entry(vha, rsp, pkt);
L
Linus Torvalds 已提交
1588 1589 1590 1591
			break;
		case STATUS_TYPE_21:
			handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
			for (cnt = 0; cnt < handle_cnt; cnt++) {
1592
				qla2x00_process_completed_request(vha, rsp->req,
L
Linus Torvalds 已提交
1593 1594 1595 1596 1597 1598
				    ((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++) {
1599
				qla2x00_process_completed_request(vha, rsp->req,
L
Linus Torvalds 已提交
1600 1601 1602 1603
				    ((sts22_entry_t *)pkt)->handle[cnt]);
			}
			break;
		case STATUS_CONT_TYPE:
1604
			qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
L
Linus Torvalds 已提交
1605
			break;
1606 1607 1608
		case MBX_IOCB_TYPE:
			qla2x00_mbx_iocb_entry(vha, rsp->req,
			    (struct mbx_entry *)pkt);
1609
			break;
1610 1611 1612
		case CT_IOCB_TYPE:
			qla2x00_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
			break;
L
Linus Torvalds 已提交
1613 1614
		default:
			/* Type Not Supported. */
1615 1616
			ql_log(ql_log_warn, vha, 0x504a,
			    "Received unknown response pkt type %x "
L
Linus Torvalds 已提交
1617
			    "entry status=%x.\n",
1618
			    pkt->entry_type, pkt->entry_status);
L
Linus Torvalds 已提交
1619 1620 1621 1622 1623 1624 1625
			break;
		}
		((response_t *)pkt)->signature = RESPONSE_PROCESSED;
		wmb();
	}

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

1629
static inline void
1630
qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
1631
		     uint32_t sense_len, struct rsp_que *rsp, int res)
1632
{
1633
	struct scsi_qla_host *vha = sp->fcport->vha;
1634 1635
	struct scsi_cmnd *cp = GET_CMD_SP(sp);
	uint32_t track_sense_len;
1636 1637 1638 1639

	if (sense_len >= SCSI_SENSE_BUFFERSIZE)
		sense_len = SCSI_SENSE_BUFFERSIZE;

1640 1641 1642 1643 1644
	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)
1645
		sense_len = par_sense_len;
1646 1647 1648

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

1649 1650 1651 1652 1653
	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) {
1654
		rsp->status_srb = sp;
1655 1656
		cp->result = res;
	}
1657

1658 1659
	if (sense_len) {
		ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x301c,
H
Hannes Reinecke 已提交
1660
		    "Check condition Sense data, nexus%ld:%d:%llu cmd=%p.\n",
1661 1662
		    sp->fcport->vha->host_no, cp->device->id, cp->device->lun,
		    cp);
1663 1664
		ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
		    cp->sense_buffer, sense_len);
1665
	}
1666 1667
}

1668 1669
struct scsi_dif_tuple {
	__be16 guard;       /* Checksum */
1670
	__be16 app_tag;         /* APPL identifier */
1671 1672 1673 1674 1675 1676 1677 1678 1679
	__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.
 */
1680
static inline int
1681 1682
qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
{
1683
	struct scsi_qla_host *vha = sp->fcport->vha;
1684
	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1685 1686
	uint8_t		*ap = &sts24->data[12];
	uint8_t		*ep = &sts24->data[20];
1687 1688 1689 1690
	uint32_t	e_ref_tag, a_ref_tag;
	uint16_t	e_app_tag, a_app_tag;
	uint16_t	e_guard, a_guard;

1691 1692 1693 1694 1695 1696 1697 1698 1699 1700
	/*
	 * 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));
1701

1702 1703
	ql_dbg(ql_dbg_io, vha, 0x3023,
	    "iocb(s) %p Returned STATUS.\n", sts24);
1704

1705 1706
	ql_dbg(ql_dbg_io, vha, 0x3024,
	    "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
1707
	    " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
1708
	    " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
1709
	    cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
1710
	    a_app_tag, e_app_tag, a_guard, e_guard);
1711

1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751
	/*
	 * 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) {
1752
				ql_log(ql_log_warn, vha, 0x302f,
1753 1754
				    "unexpected tag values tag:lba=%x:%llx)\n",
				    e_ref_tag, (unsigned long long)lba_s);
1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
				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;
	}

1769 1770 1771 1772 1773 1774 1775
	/* 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;
1776
		return 1;
1777 1778
	}

1779 1780
	/* check ref tag */
	if (e_ref_tag != a_ref_tag) {
1781
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1782
		    0x10, 0x3);
1783 1784 1785
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1786
		return 1;
1787 1788
	}

1789 1790
	/* check appl tag */
	if (e_app_tag != a_app_tag) {
1791
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1792
		    0x10, 0x2);
1793 1794 1795
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1796
		return 1;
1797
	}
1798

1799
	return 1;
1800 1801
}

1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
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. */
1819
	if (index >= req->num_outstanding_cmds) {
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
		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;
1854 1855 1856
			vha->qla_stats.input_bytes +=
				bsg_job->reply->reply_payload_rcv_len;
			vha->qla_stats.input_requests++;
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 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947
			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 已提交
1948 1949 1950 1951 1952 1953
/**
 * qla2x00_status_entry() - Process a Status IOCB entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
1954
qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
L
Linus Torvalds 已提交
1955 1956 1957 1958
{
	srb_t		*sp;
	fc_port_t	*fcport;
	struct scsi_cmnd *cp;
1959 1960
	sts_entry_t *sts;
	struct sts_entry_24xx *sts24;
L
Linus Torvalds 已提交
1961 1962
	uint16_t	comp_status;
	uint16_t	scsi_status;
1963
	uint16_t	ox_id;
L
Linus Torvalds 已提交
1964 1965
	uint8_t		lscsi_status;
	int32_t		resid;
1966 1967
	uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
	    fw_resid_len;
1968
	uint8_t		*rsp_info, *sense_data;
1969
	struct qla_hw_data *ha = vha->hw;
1970 1971 1972
	uint32_t handle;
	uint16_t que;
	struct req_que *req;
1973
	int logit = 1;
1974
	int res = 0;
1975
	uint16_t state_flags = 0;
1976 1977 1978

	sts = (sts_entry_t *) pkt;
	sts24 = (struct sts_entry_24xx *) pkt;
1979
	if (IS_FWI2_CAPABLE(ha)) {
1980 1981
		comp_status = le16_to_cpu(sts24->comp_status);
		scsi_status = le16_to_cpu(sts24->scsi_status) & SS_MASK;
1982
		state_flags = le16_to_cpu(sts24->state_flags);
1983 1984 1985 1986
	} else {
		comp_status = le16_to_cpu(sts->comp_status);
		scsi_status = le16_to_cpu(sts->scsi_status) & SS_MASK;
	}
1987 1988 1989
	handle = (uint32_t) LSW(sts->handle);
	que = MSW(sts->handle);
	req = ha->req_q_map[que];
1990

1991 1992 1993 1994 1995 1996 1997 1998 1999
	/* Check for invalid queue pointer */
	if (req == NULL ||
	    que >= find_first_zero_bit(ha->req_qid_map, ha->max_req_queues)) {
		ql_dbg(ql_dbg_io, vha, 0x3059,
		    "Invalid status handle (0x%x): Bad req pointer. req=%p, "
		    "que=%u.\n", sts->handle, req, que);
		return;
	}

L
Linus Torvalds 已提交
2000
	/* Validate handle. */
2001
	if (handle < req->num_outstanding_cmds)
2002
		sp = req->outstanding_cmds[handle];
2003
	else
L
Linus Torvalds 已提交
2004 2005 2006
		sp = NULL;

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

2010 2011 2012 2013 2014 2015 2016
		if (!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) {
			if (IS_P3P_TYPE(ha))
				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 已提交
2017 2018
		return;
	}
2019 2020 2021 2022 2023 2024

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

2025 2026 2027 2028 2029 2030
	/* Task Management completion. */
	if (sp->type == SRB_TM_CMD) {
		qla24xx_tm_iocb_entry(vha, req, pkt);
		return;
	}

2031 2032 2033 2034 2035 2036 2037 2038
	/* Fast path completion. */
	if (comp_status == CS_COMPLETE && scsi_status == 0) {
		qla2x00_process_completed_request(vha, req, handle);

		return;
	}

	req->outstanding_cmds[handle] = NULL;
2039
	cp = GET_CMD_SP(sp);
L
Linus Torvalds 已提交
2040
	if (cp == NULL) {
2041
		ql_dbg(ql_dbg_io, vha, 0x3018,
2042 2043
		    "Command already returned (0x%x/%p).\n",
		    sts->handle, sp);
L
Linus Torvalds 已提交
2044 2045 2046 2047

		return;
	}

2048
	lscsi_status = scsi_status & STATUS_MASK;
L
Linus Torvalds 已提交
2049

2050
	fcport = sp->fcport;
L
Linus Torvalds 已提交
2051

2052
	ox_id = 0;
2053 2054
	sense_len = par_sense_len = rsp_info_len = resid_len =
	    fw_resid_len = 0;
2055
	if (IS_FWI2_CAPABLE(ha)) {
2056 2057 2058 2059 2060 2061 2062 2063
		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);
2064 2065 2066
		rsp_info = sts24->data;
		sense_data = sts24->data;
		host_to_fcp_swap(sts24->data, sizeof(sts24->data));
2067
		ox_id = le16_to_cpu(sts24->ox_id);
2068
		par_sense_len = sizeof(sts24->data);
2069
	} else {
2070 2071 2072 2073
		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);
2074 2075 2076
		resid_len = le32_to_cpu(sts->residual_length);
		rsp_info = sts->rsp_info;
		sense_data = sts->req_sense_data;
2077
		par_sense_len = sizeof(sts->req_sense_data);
2078 2079
	}

L
Linus Torvalds 已提交
2080 2081
	/* Check for any FCP transport errors. */
	if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
2082
		/* Sense data lies beyond any FCP RESPONSE data. */
2083
		if (IS_FWI2_CAPABLE(ha)) {
2084
			sense_data += rsp_info_len;
2085 2086
			par_sense_len -= rsp_info_len;
		}
2087
		if (rsp_info_len > 3 && rsp_info[3]) {
2088
			ql_dbg(ql_dbg_io, fcport->vha, 0x3019,
2089 2090
			    "FCP I/O protocol failure (0x%x/0x%x).\n",
			    rsp_info_len, rsp_info[3]);
L
Linus Torvalds 已提交
2091

2092
			res = DID_BUS_BUSY << 16;
2093
			goto out;
L
Linus Torvalds 已提交
2094 2095 2096
		}
	}

2097 2098 2099 2100 2101
	/* 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 已提交
2102 2103 2104 2105 2106
	/*
	 * Based on Host and scsi status generate status code for Linux
	 */
	switch (comp_status) {
	case CS_COMPLETE:
2107
	case CS_QUEUE_FULL:
L
Linus Torvalds 已提交
2108
		if (scsi_status == 0) {
2109
			res = DID_OK << 16;
L
Linus Torvalds 已提交
2110 2111 2112
			break;
		}
		if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
2113
			resid = resid_len;
2114
			scsi_set_resid(cp, resid);
2115 2116

			if (!lscsi_status &&
2117
			    ((unsigned)(scsi_bufflen(cp) - resid) <
2118
			     cp->underflow)) {
2119
				ql_dbg(ql_dbg_io, fcport->vha, 0x301a,
2120
				    "Mid-layer underflow "
2121
				    "detected (0x%x of 0x%x bytes).\n",
2122
				    resid, scsi_bufflen(cp));
2123

2124
				res = DID_ERROR << 16;
2125 2126
				break;
			}
L
Linus Torvalds 已提交
2127
		}
2128
		res = DID_OK << 16 | lscsi_status;
L
Linus Torvalds 已提交
2129

2130
		if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
2131
			ql_dbg(ql_dbg_io, fcport->vha, 0x301b,
2132
			    "QUEUE FULL detected.\n");
2133 2134
			break;
		}
2135
		logit = 0;
L
Linus Torvalds 已提交
2136 2137 2138
		if (lscsi_status != SS_CHECK_CONDITION)
			break;

2139
		memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
2140 2141 2142
		if (!(scsi_status & SS_SENSE_LEN_VALID))
			break;

2143
		qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
2144
		    rsp, res);
L
Linus Torvalds 已提交
2145 2146 2147
		break;

	case CS_DATA_UNDERRUN:
2148
		/* Use F/W calculated residual length. */
2149 2150 2151 2152
		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) {
2153
				ql_dbg(ql_dbg_io, fcport->vha, 0x301d,
2154 2155 2156
				    "Dropped frame(s) detected "
				    "(0x%x of 0x%x bytes).\n",
				    resid, scsi_bufflen(cp));
2157

2158
				res = DID_ERROR << 16 | lscsi_status;
2159
				goto check_scsi_status;
2160
			}
2161

2162 2163 2164
			if (!lscsi_status &&
			    ((unsigned)(scsi_bufflen(cp) - resid) <
			    cp->underflow)) {
2165
				ql_dbg(ql_dbg_io, fcport->vha, 0x301e,
2166
				    "Mid-layer underflow "
2167
				    "detected (0x%x of 0x%x bytes).\n",
2168
				    resid, scsi_bufflen(cp));
2169

2170
				res = DID_ERROR << 16;
2171 2172
				break;
			}
2173 2174 2175 2176 2177 2178 2179
		} 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.
			 */

2180
			ql_dbg(ql_dbg_io, fcport->vha, 0x301f,
2181
			    "Dropped frame(s) detected (0x%x "
2182 2183
			    "of 0x%x bytes).\n", resid,
			    scsi_bufflen(cp));
2184

2185
			res = DID_ERROR << 16 | lscsi_status;
2186
			goto check_scsi_status;
2187 2188 2189 2190
		} 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 已提交
2191 2192
		}

2193
		res = DID_OK << 16 | lscsi_status;
2194
		logit = 0;
2195

2196
check_scsi_status:
L
Linus Torvalds 已提交
2197
		/*
A
Andrew Vasquez 已提交
2198
		 * Check to see if SCSI Status is non zero. If so report SCSI
L
Linus Torvalds 已提交
2199 2200 2201
		 * Status.
		 */
		if (lscsi_status != 0) {
2202
			if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
2203
				ql_dbg(ql_dbg_io, fcport->vha, 0x3020,
2204
				    "QUEUE FULL detected.\n");
2205
				logit = 1;
2206 2207
				break;
			}
L
Linus Torvalds 已提交
2208 2209 2210
			if (lscsi_status != SS_CHECK_CONDITION)
				break;

2211
			memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
2212 2213 2214
			if (!(scsi_status & SS_SENSE_LEN_VALID))
				break;

2215
			qla2x00_handle_sense(sp, sense_data, par_sense_len,
2216
			    sense_len, rsp, res);
L
Linus Torvalds 已提交
2217 2218 2219 2220 2221 2222 2223 2224
		}
		break;

	case CS_PORT_LOGGED_OUT:
	case CS_PORT_CONFIG_CHG:
	case CS_PORT_BUSY:
	case CS_INCOMPLETE:
	case CS_PORT_UNAVAILABLE:
2225
	case CS_TIMEOUT:
2226 2227
	case CS_RESET:

2228 2229 2230 2231 2232
		/*
		 * 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.
		 */
2233
		res = DID_TRANSPORT_DISRUPTED << 16;
2234 2235 2236 2237 2238 2239 2240 2241 2242

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

2243
		ql_dbg(ql_dbg_io, fcport->vha, 0x3021,
2244 2245 2246 2247
		    "Port to be marked lost on fcport=%02x%02x%02x, current "
		    "port state= %s.\n", fcport->d_id.b.domain,
		    fcport->d_id.b.area, fcport->d_id.b.al_pa,
		    port_state_str[atomic_read(&fcport->state)]);
2248

2249
		if (atomic_read(&fcport->state) == FCS_ONLINE)
2250
			qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
L
Linus Torvalds 已提交
2251 2252 2253
		break;

	case CS_ABORTED:
2254
		res = DID_RESET << 16;
L
Linus Torvalds 已提交
2255
		break;
2256 2257

	case CS_DIF_ERROR:
2258
		logit = qla2x00_handle_dif_error(sp, sts24);
2259
		res = cp->result;
2260
		break;
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273

	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 已提交
2274
	default:
2275
		res = DID_ERROR << 16;
L
Linus Torvalds 已提交
2276 2277 2278
		break;
	}

2279 2280
out:
	if (logit)
2281
		ql_dbg(ql_dbg_io, fcport->vha, 0x3022,
H
Hannes Reinecke 已提交
2282
		    "FCP command status: 0x%x-0x%x (0x%x) nexus=%ld:%d:%llu "
2283
		    "portid=%02x%02x%02x oxid=0x%x cdb=%10phN len=0x%x "
2284
		    "rsp_info=0x%x resid=0x%x fw_resid=0x%x.\n",
2285
		    comp_status, scsi_status, res, vha->host_no,
2286 2287
		    cp->device->id, cp->device->lun, fcport->d_id.b.domain,
		    fcport->d_id.b.area, fcport->d_id.b.al_pa, ox_id,
2288
		    cp->cmnd, scsi_bufflen(cp), rsp_info_len,
2289
		    resid_len, fw_resid_len);
2290

2291
	if (rsp->status_srb == NULL)
2292
		sp->done(ha, sp, res);
L
Linus Torvalds 已提交
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302
}

/**
 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 *
 * Extended sense data.
 */
static void
2303
qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
L
Linus Torvalds 已提交
2304
{
2305
	uint8_t	sense_sz = 0;
2306
	struct qla_hw_data *ha = rsp->hw;
2307
	struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
2308
	srb_t *sp = rsp->status_srb;
L
Linus Torvalds 已提交
2309
	struct scsi_cmnd *cp;
2310 2311
	uint32_t sense_len;
	uint8_t *sense_ptr;
L
Linus Torvalds 已提交
2312

2313 2314
	if (!sp || !GET_CMD_SENSE_LEN(sp))
		return;
L
Linus Torvalds 已提交
2315

2316 2317
	sense_len = GET_CMD_SENSE_LEN(sp);
	sense_ptr = GET_CMD_SENSE_PTR(sp);
L
Linus Torvalds 已提交
2318

2319 2320 2321 2322
	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 已提交
2323

2324 2325
		rsp->status_srb = NULL;
		return;
L
Linus Torvalds 已提交
2326 2327
	}

2328 2329 2330 2331
	if (sense_len > sizeof(pkt->data))
		sense_sz = sizeof(pkt->data);
	else
		sense_sz = sense_len;
2332

2333 2334 2335 2336 2337 2338
	/* 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);
2339

2340 2341
	sense_len -= sense_sz;
	sense_ptr += sense_sz;
2342

2343 2344 2345 2346 2347 2348 2349
	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);
2350 2351 2352
	}
}

L
Linus Torvalds 已提交
2353 2354 2355 2356 2357 2358
/**
 * qla2x00_error_entry() - Process an error entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
2359
qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
L
Linus Torvalds 已提交
2360 2361
{
	srb_t *sp;
2362
	struct qla_hw_data *ha = vha->hw;
2363
	const char func[] = "ERROR-IOCB";
2364
	uint16_t que = MSW(pkt->handle);
2365
	struct req_que *req = NULL;
2366
	int res = DID_ERROR << 16;
2367

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

2371 2372 2373 2374 2375
	if (que >= ha->max_req_queues || !ha->req_q_map[que])
		goto fatal;

	req = ha->req_q_map[que];

2376 2377
	if (pkt->entry_status & RF_BUSY)
		res = DID_BUS_BUSY << 16;
L
Linus Torvalds 已提交
2378

2379
	sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
2380
	if (sp) {
2381
		sp->done(ha, sp, res);
2382
		return;
L
Linus Torvalds 已提交
2383
	}
2384 2385 2386 2387
fatal:
	ql_log(ql_log_warn, vha, 0x5030,
	    "Error entry - invalid handle/queue.\n");

2388
	if (IS_P3P_TYPE(ha))
2389 2390 2391 2392
		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 已提交
2393 2394
}

2395 2396 2397 2398 2399 2400
/**
 * qla24xx_mbx_completion() - Process mailbox command completions.
 * @ha: SCSI driver HA context
 * @mb0: Mailbox0 register
 */
static void
2401
qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
2402 2403
{
	uint16_t	cnt;
2404
	uint32_t	mboxes;
2405
	uint16_t __iomem *wptr;
2406
	struct qla_hw_data *ha = vha->hw;
2407 2408
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

2409 2410 2411
	/* Read all mbox registers? */
	mboxes = (1 << ha->mbx_count) - 1;
	if (!ha->mcp)
2412
		ql_dbg(ql_dbg_async, vha, 0x504e, "MBX pointer ERROR.\n");
2413 2414 2415
	else
		mboxes = ha->mcp->in_mb;

2416 2417 2418
	/* Load return mailbox registers. */
	ha->flags.mbox_int = 1;
	ha->mailbox_out[0] = mb0;
2419
	mboxes >>= 1;
2420 2421 2422
	wptr = (uint16_t __iomem *)&reg->mailbox1;

	for (cnt = 1; cnt < ha->mbx_count; cnt++) {
2423 2424 2425 2426
		if (mboxes & BIT_0)
			ha->mailbox_out[cnt] = RD_REG_WORD(wptr);

		mboxes >>= 1;
2427 2428 2429 2430
		wptr++;
	}
}

2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447
static void
qla24xx_abort_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
	struct abort_entry_24xx *pkt)
{
	const char func[] = "ABT_IOCB";
	srb_t *sp;
	struct srb_iocb *abt;

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

	abt = &sp->u.iocb_cmd;
	abt->u.abt.comp_status = le32_to_cpu(pkt->nport_handle);
	sp->done(vha, sp, 0);
}

2448 2449 2450 2451
/**
 * qla24xx_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
2452 2453
void qla24xx_process_response_queue(struct scsi_qla_host *vha,
	struct rsp_que *rsp)
2454 2455
{
	struct sts_entry_24xx *pkt;
2456
	struct qla_hw_data *ha = vha->hw;
2457

2458
	if (!vha->flags.online)
2459 2460
		return;

2461 2462
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
2463

2464 2465 2466 2467
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
2468
		} else {
2469
			rsp->ring_ptr++;
2470 2471 2472
		}

		if (pkt->entry_status != 0) {
2473
			qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
2474

2475 2476
			if (qlt_24xx_process_response_error(vha, pkt))
				goto process_err;
2477

2478 2479 2480 2481
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}
2482
process_err:
2483 2484 2485

		switch (pkt->entry_type) {
		case STATUS_TYPE:
2486
			qla2x00_status_entry(vha, rsp, pkt);
2487 2488
			break;
		case STATUS_CONT_TYPE:
2489
			qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
2490
			break;
2491
		case VP_RPT_ID_IOCB_TYPE:
2492
			qla24xx_report_id_acquisition(vha,
2493 2494
			    (struct vp_rpt_id_entry_24xx *)pkt);
			break;
2495 2496 2497 2498
		case LOGINOUT_PORT_IOCB_TYPE:
			qla24xx_logio_entry(vha, rsp->req,
			    (struct logio_entry_24xx *)pkt);
			break;
2499
		case CT_IOCB_TYPE:
2500 2501
			qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
			break;
2502
		case ELS_IOCB_TYPE:
2503 2504
			qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
			break;
2505 2506 2507 2508 2509 2510
		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:
2511
		case CTIO_CRC2:
2512 2513
			qlt_response_pkt_all_vps(vha, (response_t *)pkt);
			break;
2514 2515 2516 2517 2518
		case MARKER_TYPE:
			/* Do nothing in this case, this check is to prevent it
			 * from falling into default case
			 */
			break;
2519 2520 2521 2522
		case ABORT_IOCB_TYPE:
			qla24xx_abort_iocb_entry(vha, rsp->req,
			    (struct abort_entry_24xx *)pkt);
			break;
2523 2524
		default:
			/* Type Not Supported. */
2525 2526
			ql_dbg(ql_dbg_async, vha, 0x5042,
			    "Received unknown response pkt type %x "
2527
			    "entry status=%x.\n",
2528
			    pkt->entry_type, pkt->entry_status);
2529 2530 2531 2532 2533 2534 2535
			break;
		}
		((response_t *)pkt)->signature = RESPONSE_PROCESSED;
		wmb();
	}

	/* Adjust ring index */
2536
	if (IS_P3P_TYPE(ha)) {
2537 2538 2539 2540
		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);
2541 2542
}

2543
static void
2544
qla2xxx_check_risc_status(scsi_qla_host_t *vha)
2545 2546 2547
{
	int rval;
	uint32_t cnt;
2548
	struct qla_hw_data *ha = vha->hw;
2549 2550
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

2551 2552
	if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
	    !IS_QLA27XX(ha))
2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569
		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;

2570
	rval = QLA_SUCCESS;
2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
	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)
2585 2586
		ql_log(ql_log_info, vha, 0x504c,
		    "Additional code -- 0x55AA.\n");
2587 2588 2589 2590 2591 2592

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

2593
/**
2594
 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP24xx.
2595 2596 2597 2598 2599 2600 2601 2602
 * @irq:
 * @dev_id: SCSI driver HA context
 *
 * Called by system whenever the host adapter generates an interrupt.
 *
 * Returns handled flag.
 */
irqreturn_t
2603
qla24xx_intr_handler(int irq, void *dev_id)
2604
{
2605 2606
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
2607 2608 2609 2610 2611
	struct device_reg_24xx __iomem *reg;
	int		status;
	unsigned long	iter;
	uint32_t	stat;
	uint32_t	hccr;
2612
	uint16_t	mb[8];
2613
	struct rsp_que *rsp;
2614
	unsigned long	flags;
2615

2616 2617
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2618 2619
		ql_log(ql_log_info, NULL, 0x5059,
		    "%s: NULL response queue pointer.\n", __func__);
2620 2621 2622
		return IRQ_NONE;
	}

2623
	ha = rsp->hw;
2624 2625 2626
	reg = &ha->iobase->isp24;
	status = 0;

2627 2628 2629
	if (unlikely(pci_channel_offline(ha->pdev)))
		return IRQ_HANDLED;

2630
	spin_lock_irqsave(&ha->hardware_lock, flags);
2631
	vha = pci_get_drvdata(ha->pdev);
2632 2633
	for (iter = 50; iter--; ) {
		stat = RD_REG_DWORD(&reg->host_status);
2634
		if (qla2x00_check_reg32_for_disconnect(vha, stat))
2635
			break;
2636
		if (stat & HSRX_RISC_PAUSED) {
2637
			if (unlikely(pci_channel_offline(ha->pdev)))
2638 2639
				break;

2640 2641
			hccr = RD_REG_DWORD(&reg->hccr);

2642 2643 2644
			ql_log(ql_log_warn, vha, 0x504b,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2645

2646
			qla2xxx_check_risc_status(vha);
2647

2648 2649
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2650 2651 2652 2653 2654
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
2655 2656 2657 2658
		case INTR_ROM_MB_SUCCESS:
		case INTR_ROM_MB_FAILED:
		case INTR_MB_SUCCESS:
		case INTR_MB_FAILED:
2659
			qla24xx_mbx_completion(vha, MSW(stat));
2660 2661 2662
			status |= MBX_INTERRUPT;

			break;
2663
		case INTR_ASYNC_EVENT:
2664 2665 2666 2667
			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);
2668
			qla2x00_async_event(vha, rsp, mb);
2669
			break;
2670 2671
		case INTR_RSP_QUE_UPDATE:
		case INTR_RSP_QUE_UPDATE_83XX:
2672
			qla24xx_process_response_queue(vha, rsp);
2673
			break;
2674
		case INTR_ATIO_QUE_UPDATE:
2675 2676
			qlt_24xx_process_atio_queue(vha);
			break;
2677
		case INTR_ATIO_RSP_QUE_UPDATE:
2678 2679 2680
			qlt_24xx_process_atio_queue(vha);
			qla24xx_process_response_queue(vha, rsp);
			break;
2681
		default:
2682 2683
			ql_dbg(ql_dbg_async, vha, 0x504f,
			    "Unrecognized interrupt type (%d).\n", stat * 0xff);
2684 2685 2686 2687
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
2688 2689
		if (unlikely(IS_QLA83XX(ha) && (ha->pdev->revision == 1)))
			ndelay(3500);
2690
	}
2691
	qla2x00_handle_mbx_completion(ha, status);
2692
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2693 2694 2695 2696

	return IRQ_HANDLED;
}

2697 2698 2699
static irqreturn_t
qla24xx_msix_rsp_q(int irq, void *dev_id)
{
2700 2701
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2702
	struct device_reg_24xx __iomem *reg;
2703
	struct scsi_qla_host *vha;
2704
	unsigned long flags;
2705
	uint32_t stat = 0;
2706

2707 2708
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2709 2710
		ql_log(ql_log_info, NULL, 0x505a,
		    "%s: NULL response queue pointer.\n", __func__);
2711 2712 2713
		return IRQ_NONE;
	}
	ha = rsp->hw;
2714 2715
	reg = &ha->iobase->isp24;

2716
	spin_lock_irqsave(&ha->hardware_lock, flags);
2717

2718
	vha = pci_get_drvdata(ha->pdev);
2719 2720 2721 2722 2723
	/*
	 * Use host_status register to check to PCI disconnection before we
	 * we process the response queue.
	 */
	stat = RD_REG_DWORD(&reg->host_status);
2724
	if (qla2x00_check_reg32_for_disconnect(vha, stat))
2725
		goto out;
2726
	qla24xx_process_response_queue(vha, rsp);
2727
	if (!ha->flags.disable_msix_handshake) {
2728 2729 2730
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
	}
2731
out:
2732
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2733 2734 2735 2736

	return IRQ_HANDLED;
}

2737 2738 2739 2740
static irqreturn_t
qla25xx_msix_rsp_q(int irq, void *dev_id)
{
	struct qla_hw_data *ha;
2741
	scsi_qla_host_t *vha;
2742
	struct rsp_que *rsp;
2743
	struct device_reg_24xx __iomem *reg;
2744
	unsigned long flags;
2745
	uint32_t hccr = 0;
2746 2747 2748

	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2749 2750
		ql_log(ql_log_info, NULL, 0x505b,
		    "%s: NULL response queue pointer.\n", __func__);
2751 2752 2753
		return IRQ_NONE;
	}
	ha = rsp->hw;
2754
	vha = pci_get_drvdata(ha->pdev);
2755

2756
	/* Clear the interrupt, if enabled, for this response queue */
2757
	if (!ha->flags.disable_msix_handshake) {
2758
		reg = &ha->iobase->isp24;
2759
		spin_lock_irqsave(&ha->hardware_lock, flags);
2760
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2761
		hccr = RD_REG_DWORD_RELAXED(&reg->hccr);
2762
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
2763
	}
2764
	if (qla2x00_check_reg32_for_disconnect(vha, hccr))
2765
		goto out;
2766 2767
	queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);

2768
out:
2769 2770 2771
	return IRQ_HANDLED;
}

2772 2773 2774
static irqreturn_t
qla24xx_msix_default(int irq, void *dev_id)
{
2775 2776 2777
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2778 2779 2780 2781
	struct device_reg_24xx __iomem *reg;
	int		status;
	uint32_t	stat;
	uint32_t	hccr;
2782
	uint16_t	mb[8];
2783
	unsigned long flags;
2784

2785 2786
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2787 2788
		ql_log(ql_log_info, NULL, 0x505c,
		    "%s: NULL response queue pointer.\n", __func__);
2789 2790 2791
		return IRQ_NONE;
	}
	ha = rsp->hw;
2792 2793 2794
	reg = &ha->iobase->isp24;
	status = 0;

2795
	spin_lock_irqsave(&ha->hardware_lock, flags);
2796
	vha = pci_get_drvdata(ha->pdev);
2797
	do {
2798
		stat = RD_REG_DWORD(&reg->host_status);
2799
		if (qla2x00_check_reg32_for_disconnect(vha, stat))
2800
			break;
2801
		if (stat & HSRX_RISC_PAUSED) {
2802
			if (unlikely(pci_channel_offline(ha->pdev)))
2803 2804
				break;

2805 2806
			hccr = RD_REG_DWORD(&reg->hccr);

2807 2808 2809
			ql_log(ql_log_info, vha, 0x5050,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2810

2811
			qla2xxx_check_risc_status(vha);
2812

2813 2814
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2815 2816 2817 2818 2819
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
2820 2821 2822 2823
		case INTR_ROM_MB_SUCCESS:
		case INTR_ROM_MB_FAILED:
		case INTR_MB_SUCCESS:
		case INTR_MB_FAILED:
2824
			qla24xx_mbx_completion(vha, MSW(stat));
2825 2826 2827
			status |= MBX_INTERRUPT;

			break;
2828
		case INTR_ASYNC_EVENT:
2829 2830 2831 2832
			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);
2833
			qla2x00_async_event(vha, rsp, mb);
2834
			break;
2835 2836
		case INTR_RSP_QUE_UPDATE:
		case INTR_RSP_QUE_UPDATE_83XX:
2837
			qla24xx_process_response_queue(vha, rsp);
2838
			break;
2839
		case INTR_ATIO_QUE_UPDATE:
2840 2841
			qlt_24xx_process_atio_queue(vha);
			break;
2842
		case INTR_ATIO_RSP_QUE_UPDATE:
2843 2844 2845
			qlt_24xx_process_atio_queue(vha);
			qla24xx_process_response_queue(vha, rsp);
			break;
2846
		default:
2847 2848
			ql_dbg(ql_dbg_async, vha, 0x5051,
			    "Unrecognized interrupt type (%d).\n", stat & 0xff);
2849 2850 2851
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2852
	} while (0);
2853
	qla2x00_handle_mbx_completion(ha, status);
2854
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2855 2856 2857 2858 2859 2860 2861 2862

	return IRQ_HANDLED;
}

/* Interrupt handling helpers. */

struct qla_init_msix_entry {
	const char *name;
2863
	irq_handler_t handler;
2864 2865
};

2866
static struct qla_init_msix_entry msix_entries[3] = {
2867 2868
	{ "qla2xxx (default)", qla24xx_msix_default },
	{ "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
2869
	{ "qla2xxx (multiq)", qla25xx_msix_rsp_q },
2870 2871
};

2872 2873 2874 2875 2876
static struct qla_init_msix_entry qla82xx_msix_entries[2] = {
	{ "qla2xxx (default)", qla82xx_msix_default },
	{ "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
};

2877 2878 2879 2880 2881 2882
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 },
};

2883
static void
2884
qla24xx_disable_msix(struct qla_hw_data *ha)
2885 2886 2887
{
	int i;
	struct qla_msix_entry *qentry;
2888
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2889

2890 2891
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
2892
		if (qentry->have_irq)
2893
			free_irq(qentry->vector, qentry->rsp);
2894 2895
	}
	pci_disable_msix(ha->pdev);
2896 2897 2898
	kfree(ha->msix_entries);
	ha->msix_entries = NULL;
	ha->flags.msix_enabled = 0;
2899 2900
	ql_dbg(ql_dbg_init, vha, 0x0042,
	    "Disabled the MSI.\n");
2901 2902 2903
}

static int
2904
qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
2905
{
2906
#define MIN_MSIX_COUNT	2
2907
#define ATIO_VECTOR	2
2908
	int i, ret;
2909
	struct msix_entry *entries;
2910
	struct qla_msix_entry *qentry;
2911
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2912 2913

	entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
2914
			GFP_KERNEL);
2915 2916 2917
	if (!entries) {
		ql_log(ql_log_warn, vha, 0x00bc,
		    "Failed to allocate memory for msix_entry.\n");
2918
		return -ENOMEM;
2919
	}
2920

2921 2922
	for (i = 0; i < ha->msix_count; i++)
		entries[i].entry = i;
2923

2924 2925 2926 2927 2928 2929 2930 2931 2932
	ret = pci_enable_msix_range(ha->pdev,
				    entries, MIN_MSIX_COUNT, ha->msix_count);
	if (ret < 0) {
		ql_log(ql_log_fatal, vha, 0x00c7,
		    "MSI-X: Failed to enable support, "
		    "giving   up -- %d/%d.\n",
		    ha->msix_count, ret);
		goto msix_out;
	} else if (ret < ha->msix_count) {
2933 2934 2935 2936
		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);
2937
	}
2938 2939
	ha->msix_count = ret;
	ha->max_rsp_queues = ha->msix_count - 1;
2940 2941 2942
	ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
				ha->msix_count, GFP_KERNEL);
	if (!ha->msix_entries) {
2943 2944
		ql_log(ql_log_fatal, vha, 0x00c8,
		    "Failed to allocate memory for ha->msix_entries.\n");
2945
		ret = -ENOMEM;
2946 2947 2948 2949
		goto msix_out;
	}
	ha->flags.msix_enabled = 1;

2950 2951 2952 2953
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
		qentry->vector = entries[i].vector;
		qentry->entry = entries[i].entry;
2954
		qentry->have_irq = 0;
2955
		qentry->rsp = NULL;
2956 2957
	}

2958
	/* Enable MSI-X vectors for the base queue */
2959
	for (i = 0; i < 2; i++) {
2960
		qentry = &ha->msix_entries[i];
2961
		if (IS_P3P_TYPE(ha))
2962 2963 2964
			ret = request_irq(qentry->vector,
				qla82xx_msix_entries[i].handler,
				0, qla82xx_msix_entries[i].name, rsp);
2965
		else
2966 2967 2968
			ret = request_irq(qentry->vector,
				msix_entries[i].handler,
				0, msix_entries[i].name, rsp);
2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984
		if (ret)
			goto msix_register_fail;
		qentry->have_irq = 1;
		qentry->rsp = rsp;
		rsp->msix = qentry;
	}

	/*
	 * If target mode is enable, also request the vector for the ATIO
	 * queue.
	 */
	if (QLA_TGT_MODE_ENABLED() && IS_ATIO_MSIX_CAPABLE(ha)) {
		qentry = &ha->msix_entries[ATIO_VECTOR];
		ret = request_irq(qentry->vector,
			qla83xx_msix_entries[ATIO_VECTOR].handler,
			0, qla83xx_msix_entries[ATIO_VECTOR].name, rsp);
2985 2986 2987
		qentry->have_irq = 1;
		qentry->rsp = rsp;
		rsp->msix = qentry;
2988 2989
	}

2990 2991 2992 2993 2994 2995 2996 2997 2998 2999
msix_register_fail:
	if (ret) {
		ql_log(ql_log_fatal, vha, 0x00cb,
		    "MSI-X: unable to register handler -- %x/%d.\n",
		    qentry->vector, ret);
		qla24xx_disable_msix(ha);
		ha->mqenable = 0;
		goto msix_out;
	}

3000
	/* Enable MSI-X vector for response queue update for queue 0 */
3001
	if (IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
3002 3003 3004 3005 3006 3007 3008
		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;
3009 3010 3011 3012 3013 3014
	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);
3015

3016
msix_out:
3017
	kfree(entries);
3018 3019 3020 3021
	return ret;
}

int
3022
qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
3023
{
3024
	int ret = QLA_FUNCTION_FAILED;
3025
	device_reg_t *reg = ha->iobase;
3026
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
3027 3028

	/* If possible, enable MSI-X. */
3029
	if (!IS_QLA2432(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
3030 3031
	    !IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha) && !IS_QLAFX00(ha) &&
	    !IS_QLA27XX(ha))
3032 3033 3034 3035 3036 3037
		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)) {
3038 3039
		ql_log(ql_log_warn, vha, 0x0034,
		    "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
3040
			ha->pdev->subsystem_vendor,
3041
			ha->pdev->subsystem_device);
3042 3043
		goto skip_msi;
	}
3044

3045
	if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
3046 3047
		ql_log(ql_log_warn, vha, 0x0035,
		    "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
3048
		    ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
3049 3050 3051
		goto skip_msix;
	}

3052
	ret = qla24xx_enable_msix(ha, rsp);
3053
	if (!ret) {
3054 3055 3056
		ql_dbg(ql_dbg_init, vha, 0x0036,
		    "MSI-X: Enabled (0x%X, 0x%X).\n",
		    ha->chip_revision, ha->fw_attributes);
3057
		goto clear_risc_ints;
3058
	}
3059

3060
skip_msix:
3061

3062 3063 3064
	ql_log(ql_log_info, vha, 0x0037,
	    "Falling back-to MSI mode -%d.\n", ret);

3065
	if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
3066 3067
	    !IS_QLA8001(ha) && !IS_P3P_TYPE(ha) && !IS_QLAFX00(ha) &&
	    !IS_QLA27XX(ha))
3068 3069 3070 3071
		goto skip_msi;

	ret = pci_enable_msi(ha->pdev);
	if (!ret) {
3072 3073
		ql_dbg(ql_dbg_init, vha, 0x0038,
		    "MSI: Enabled.\n");
3074
		ha->flags.msi_enabled = 1;
3075
	} else
3076
		ql_log(ql_log_warn, vha, 0x0039,
3077 3078
		    "Falling back-to INTa mode -- %d.\n", ret);
skip_msi:
3079 3080 3081 3082 3083

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

3084
	ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
3085 3086
	    ha->flags.msi_enabled ? 0 : IRQF_SHARED,
	    QLA2XXX_DRIVER_NAME, rsp);
3087
	if (ret) {
3088
		ql_log(ql_log_warn, vha, 0x003a,
3089 3090
		    "Failed to reserve interrupt %d already in use.\n",
		    ha->pdev->irq);
3091
		goto fail;
3092
	} else if (!ha->flags.msi_enabled) {
3093 3094
		ql_dbg(ql_dbg_init, vha, 0x0125,
		    "INTa mode: Enabled.\n");
3095 3096
		ha->flags.mr_intr_valid = 1;
	}
3097

3098 3099
clear_risc_ints:

3100
	spin_lock_irq(&ha->hardware_lock);
3101
	if (!IS_FWI2_CAPABLE(ha))
3102
		WRT_REG_WORD(&reg->isp.semaphore, 0);
3103
	spin_unlock_irq(&ha->hardware_lock);
3104

3105
fail:
3106 3107 3108 3109
	return ret;
}

void
3110
qla2x00_free_irqs(scsi_qla_host_t *vha)
3111
{
3112
	struct qla_hw_data *ha = vha->hw;
3113 3114 3115 3116 3117 3118 3119 3120 3121
	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];
3122 3123 3124

	if (ha->flags.msix_enabled)
		qla24xx_disable_msix(ha);
3125
	else if (ha->flags.msi_enabled) {
3126
		free_irq(ha->pdev->irq, rsp);
3127
		pci_disable_msi(ha->pdev);
3128 3129
	} else
		free_irq(ha->pdev->irq, rsp);
3130
}
3131

3132 3133 3134 3135

int qla25xx_request_irq(struct rsp_que *rsp)
{
	struct qla_hw_data *ha = rsp->hw;
3136
	struct qla_init_msix_entry *intr = &msix_entries[2];
3137
	struct qla_msix_entry *msix = rsp->msix;
3138
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
3139 3140 3141 3142
	int ret;

	ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
	if (ret) {
3143 3144 3145
		ql_log(ql_log_fatal, vha, 0x00e6,
		    "MSI-X: Unable to register handler -- %x/%d.\n",
		    msix->vector, ret);
3146 3147 3148 3149 3150 3151
		return ret;
	}
	msix->have_irq = 1;
	msix->rsp = rsp;
	return ret;
}