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

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

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

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

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

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

55
	spin_lock_irqsave(&ha->hardware_lock, flags);
56
	vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
57
	for (iter = 50; iter--; ) {
58
		hccr = RD_REG_WORD(&reg->hccr);
59 60 61 62 63 64 65 66 67 68
		/* Check for PCI disconnection */
		if (hccr == 0xffff) {
			/*
			 * Schedule this on the default system workqueue so that
			 * all the adapter workqueues and the DPC thread can be
			 * shutdown cleanly.
			 */
			schedule_work(&ha->board_disable);
			break;
		}
69 70 71 72 73 74
		if (hccr & HCCR_RISC_PAUSE) {
			if (pci_channel_offline(ha->pdev))
				break;

			/*
			 * Issue a "HARD" reset in order for the RISC interrupt
75
			 * bit to be cleared.  Schedule a big hammer to get
76 77 78 79 80
			 * out of the RISC PAUSED state.
			 */
			WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
			RD_REG_WORD(&reg->hccr);

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

			WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
			RD_REG_WORD(&reg->hccr);
		}
	}
117
	qla2x00_handle_mbx_completion(ha, status);
118
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
L
Linus Torvalds 已提交
119 120 121 122

	return (IRQ_HANDLED);
}

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
bool
qla2x00_check_reg_for_disconnect(scsi_qla_host_t *vha, uint32_t reg)
{
	/* Check for PCI disconnection */
	if (reg == 0xffffffff) {
		/*
		 * Schedule this 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);
		return true;
	} else
		return false;
}

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 178
		if (qla2x00_check_reg_for_disconnect(vha, stat))
			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 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
	switch (aen) {
	/* Handle IDC Error completion case. */
	case MBA_IDC_COMPLETE:
		if (mb[1] >> 15) {
			vha->hw->flags.idc_compl_status = 1;
			if (vha->hw->notify_dcbx_comp)
				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 361
	static const char * const link_speeds[] = {
		"1", "2", "?", "4", "8", "16", "10"
	};
362 363

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

373
static void
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 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
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]);
529 530
		if (ha->flags.nic_core_reset_owner)
			return;
531 532 533 534
		qla83xx_schedule_work(vha, MBA_IDC_AEN);
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

919 920 921
		ql_dbg(ql_dbg_async, vha, 0x5012,
		    "Port database changed %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
922 923
		ql_log(ql_log_warn, vha, 0x505f,
		    "Link is operational (%s Gbps).\n",
924
		    qla2x00_get_link_speed_str(ha, ha->link_data_rate));
L
Linus Torvalds 已提交
925 926 927 928

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1215
		goto logio_done;
1216 1217
	}

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

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

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

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

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

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

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

1279
	bsg_job = sp->u.bsg_job;
1280

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

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

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

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

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

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

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

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

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

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

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

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

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

1439
		goto logio_done;
1440 1441 1442
	}

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

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

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

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

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

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

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

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

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

1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
static void
qla24xx_tm_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
    struct tsk_mgmt_entry *tsk)
{
	const char func[] = "TMF-IOCB";
	const char *type;
	fc_port_t *fcport;
	srb_t *sp;
	struct srb_iocb *iocb;
	struct sts_entry_24xx *sts = (struct sts_entry_24xx *)tsk;
	int error = 1;

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

1515 1516
	iocb = &sp->u.iocb_cmd;
	type = sp->name;
1517 1518 1519
	fcport = sp->fcport;

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

	if (error) {
		iocb->u.tmf.data = error;
1546 1547
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5055,
		    (uint8_t *)sts, sizeof(*sts));
1548 1549
	}

1550
	sp->done(vha, sp, 0);
1551 1552
}

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

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

1569
	if (!vha->flags.online)
L
Linus Torvalds 已提交
1570 1571
		return;

1572 1573
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (sts_entry_t *)rsp->ring_ptr;
L
Linus Torvalds 已提交
1574

1575 1576 1577 1578
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
L
Linus Torvalds 已提交
1579
		} else {
1580
			rsp->ring_ptr++;
L
Linus Torvalds 已提交
1581 1582 1583
		}

		if (pkt->entry_status != 0) {
1584
			qla2x00_error_entry(vha, rsp, pkt);
L
Linus Torvalds 已提交
1585 1586 1587 1588 1589 1590 1591
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

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

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

1634
static inline void
1635
qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
1636
		     uint32_t sense_len, struct rsp_que *rsp, int res)
1637
{
1638
	struct scsi_qla_host *vha = sp->fcport->vha;
1639 1640
	struct scsi_cmnd *cp = GET_CMD_SP(sp);
	uint32_t track_sense_len;
1641 1642 1643 1644

	if (sense_len >= SCSI_SENSE_BUFFERSIZE)
		sense_len = SCSI_SENSE_BUFFERSIZE;

1645 1646 1647 1648 1649
	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)
1650
		sense_len = par_sense_len;
1651 1652 1653

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

1654 1655 1656 1657 1658
	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) {
1659
		rsp->status_srb = sp;
1660 1661
		cp->result = res;
	}
1662

1663 1664 1665 1666 1667
	if (sense_len) {
		ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x301c,
		    "Check condition Sense data, nexus%ld:%d:%d cmd=%p.\n",
		    sp->fcport->vha->host_no, cp->device->id, cp->device->lun,
		    cp);
1668 1669
		ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
		    cp->sense_buffer, sense_len);
1670
	}
1671 1672
}

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

1696 1697 1698 1699 1700 1701 1702 1703 1704 1705
	/*
	 * 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));
1706

1707 1708
	ql_dbg(ql_dbg_io, vha, 0x3023,
	    "iocb(s) %p Returned STATUS.\n", sts24);
1709

1710 1711
	ql_dbg(ql_dbg_io, vha, 0x3024,
	    "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
1712
	    " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
1713
	    " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
1714
	    cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
1715
	    a_app_tag, e_app_tag, a_guard, e_guard);
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 1752 1753 1754 1755 1756
	/*
	 * 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) {
1757
				ql_log(ql_log_warn, vha, 0x302f,
1758 1759
				    "unexpected tag values tag:lba=%x:%llx)\n",
				    e_ref_tag, (unsigned long long)lba_s);
1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773
				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;
	}

1774 1775 1776 1777 1778 1779 1780
	/* 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;
1781
		return 1;
1782 1783
	}

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

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

1804
	return 1;
1805 1806
}

1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823
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. */
1824
	if (index >= req->num_outstanding_cmds) {
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858
		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;
1859 1860 1861
			vha->qla_stats.input_bytes +=
				bsg_job->reply->reply_payload_rcv_len;
			vha->qla_stats.input_requests++;
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 1948 1949 1950 1951 1952
			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 已提交
1953 1954 1955 1956 1957 1958
/**
 * qla2x00_status_entry() - Process a Status IOCB entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
1959
qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
L
Linus Torvalds 已提交
1960 1961 1962 1963
{
	srb_t		*sp;
	fc_port_t	*fcport;
	struct scsi_cmnd *cp;
1964 1965
	sts_entry_t *sts;
	struct sts_entry_24xx *sts24;
L
Linus Torvalds 已提交
1966 1967
	uint16_t	comp_status;
	uint16_t	scsi_status;
1968
	uint16_t	ox_id;
L
Linus Torvalds 已提交
1969 1970
	uint8_t		lscsi_status;
	int32_t		resid;
1971 1972
	uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
	    fw_resid_len;
1973
	uint8_t		*rsp_info, *sense_data;
1974
	struct qla_hw_data *ha = vha->hw;
1975 1976 1977
	uint32_t handle;
	uint16_t que;
	struct req_que *req;
1978
	int logit = 1;
1979
	int res = 0;
1980
	uint16_t state_flags = 0;
1981 1982 1983

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

1996 1997 1998 1999 2000 2001 2002 2003 2004
	/* 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 已提交
2005
	/* Validate handle. */
2006
	if (handle < req->num_outstanding_cmds)
2007
		sp = req->outstanding_cmds[handle];
2008
	else
L
Linus Torvalds 已提交
2009 2010 2011
		sp = NULL;

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

2015
		if (IS_P3P_TYPE(ha))
2016 2017 2018
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2019
		qla2xxx_wake_dpc(vha);
L
Linus Torvalds 已提交
2020 2021
		return;
	}
2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035

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

	/* Fast path completion. */
	if (comp_status == CS_COMPLETE && scsi_status == 0) {
		qla2x00_process_completed_request(vha, req, handle);

		return;
	}

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

		return;
	}

2045
	lscsi_status = scsi_status & STATUS_MASK;
L
Linus Torvalds 已提交
2046

2047
	fcport = sp->fcport;
L
Linus Torvalds 已提交
2048

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

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

2089
			res = DID_BUS_BUSY << 16;
2090
			goto out;
L
Linus Torvalds 已提交
2091 2092 2093
		}
	}

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

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

2121
				res = DID_ERROR << 16;
2122 2123
				break;
			}
L
Linus Torvalds 已提交
2124
		}
2125
		res = DID_OK << 16 | lscsi_status;
L
Linus Torvalds 已提交
2126

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

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

2140
		qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
2141
		    rsp, res);
L
Linus Torvalds 已提交
2142 2143 2144
		break;

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

2155
				res = DID_ERROR << 16 | lscsi_status;
2156
				goto check_scsi_status;
2157
			}
2158

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

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

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

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

2190
		res = DID_OK << 16 | lscsi_status;
2191
		logit = 0;
2192

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

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

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

	case CS_PORT_LOGGED_OUT:
	case CS_PORT_CONFIG_CHG:
	case CS_PORT_BUSY:
	case CS_INCOMPLETE:
	case CS_PORT_UNAVAILABLE:
2222
	case CS_TIMEOUT:
2223 2224
	case CS_RESET:

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

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

2240
		ql_dbg(ql_dbg_io, fcport->vha, 0x3021,
2241 2242 2243 2244
		    "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)]);
2245

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

	case CS_ABORTED:
2251
		res = DID_RESET << 16;
L
Linus Torvalds 已提交
2252
		break;
2253 2254

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

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

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

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

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

2310 2311
	if (!sp || !GET_CMD_SENSE_LEN(sp))
		return;
L
Linus Torvalds 已提交
2312

2313 2314
	sense_len = GET_CMD_SENSE_LEN(sp);
	sense_ptr = GET_CMD_SENSE_PTR(sp);
L
Linus Torvalds 已提交
2315

2316 2317 2318 2319
	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 已提交
2320

2321 2322
		rsp->status_srb = NULL;
		return;
L
Linus Torvalds 已提交
2323 2324
	}

2325 2326 2327 2328
	if (sense_len > sizeof(pkt->data))
		sense_sz = sizeof(pkt->data);
	else
		sense_sz = sense_len;
2329

2330 2331 2332 2333 2334 2335
	/* 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);
2336

2337 2338
	sense_len -= sense_sz;
	sense_ptr += sense_sz;
2339

2340 2341 2342 2343 2344 2345 2346
	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);
2347 2348 2349
	}
}

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

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

2368 2369 2370 2371 2372
	if (que >= ha->max_req_queues || !ha->req_q_map[que])
		goto fatal;

	req = ha->req_q_map[que];

2373 2374
	if (pkt->entry_status & RF_BUSY)
		res = DID_BUS_BUSY << 16;
L
Linus Torvalds 已提交
2375

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

2385
	if (IS_P3P_TYPE(ha))
2386 2387 2388 2389
		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 已提交
2390 2391
}

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

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

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

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

		mboxes >>= 1;
2424 2425 2426 2427 2428 2429 2430 2431
		wptr++;
	}
}

/**
 * qla24xx_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
2432 2433
void qla24xx_process_response_queue(struct scsi_qla_host *vha,
	struct rsp_que *rsp)
2434 2435
{
	struct sts_entry_24xx *pkt;
2436
	struct qla_hw_data *ha = vha->hw;
2437

2438
	if (!vha->flags.online)
2439 2440
		return;

2441 2442
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
2443

2444 2445 2446 2447
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
2448
		} else {
2449
			rsp->ring_ptr++;
2450 2451 2452
		}

		if (pkt->entry_status != 0) {
2453
			qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
2454 2455 2456

			(void)qlt_24xx_process_response_error(vha, pkt);

2457 2458 2459 2460 2461 2462 2463
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

		switch (pkt->entry_type) {
		case STATUS_TYPE:
2464
			qla2x00_status_entry(vha, rsp, pkt);
2465 2466
			break;
		case STATUS_CONT_TYPE:
2467
			qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
2468
			break;
2469
		case VP_RPT_ID_IOCB_TYPE:
2470
			qla24xx_report_id_acquisition(vha,
2471 2472
			    (struct vp_rpt_id_entry_24xx *)pkt);
			break;
2473 2474 2475 2476
		case LOGINOUT_PORT_IOCB_TYPE:
			qla24xx_logio_entry(vha, rsp->req,
			    (struct logio_entry_24xx *)pkt);
			break;
2477 2478 2479 2480
		case TSK_MGMT_IOCB_TYPE:
			qla24xx_tm_iocb_entry(vha, rsp->req,
			    (struct tsk_mgmt_entry *)pkt);
			break;
2481 2482 2483 2484 2485 2486
                case CT_IOCB_TYPE:
			qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
			break;
                case ELS_IOCB_TYPE:
			qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
			break;
2487 2488 2489 2490 2491 2492 2493 2494
		case ABTS_RECV_24XX:
			/* ensure that the ATIO queue is empty */
			qlt_24xx_process_atio_queue(vha);
		case ABTS_RESP_24XX:
		case CTIO_TYPE7:
		case NOTIFY_ACK_TYPE:
			qlt_response_pkt_all_vps(vha, (response_t *)pkt);
			break;
2495 2496 2497 2498 2499
		case MARKER_TYPE:
			/* Do nothing in this case, this check is to prevent it
			 * from falling into default case
			 */
			break;
2500 2501
		default:
			/* Type Not Supported. */
2502 2503
			ql_dbg(ql_dbg_async, vha, 0x5042,
			    "Received unknown response pkt type %x "
2504
			    "entry status=%x.\n",
2505
			    pkt->entry_type, pkt->entry_status);
2506 2507 2508 2509 2510 2511 2512
			break;
		}
		((response_t *)pkt)->signature = RESPONSE_PROCESSED;
		wmb();
	}

	/* Adjust ring index */
2513
	if (IS_P3P_TYPE(ha)) {
2514 2515 2516 2517
		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);
2518 2519
}

2520
static void
2521
qla2xxx_check_risc_status(scsi_qla_host_t *vha)
2522 2523 2524
{
	int rval;
	uint32_t cnt;
2525
	struct qla_hw_data *ha = vha->hw;
2526 2527
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

2528
	if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha))
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545
		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;

2546
	rval = QLA_SUCCESS;
2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
	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)
2561 2562
		ql_log(ql_log_info, vha, 0x504c,
		    "Additional code -- 0x55AA.\n");
2563 2564 2565 2566 2567 2568

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

2569
/**
2570
 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP24xx.
2571 2572 2573 2574 2575 2576 2577 2578
 * @irq:
 * @dev_id: SCSI driver HA context
 *
 * Called by system whenever the host adapter generates an interrupt.
 *
 * Returns handled flag.
 */
irqreturn_t
2579
qla24xx_intr_handler(int irq, void *dev_id)
2580
{
2581 2582
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
2583 2584 2585 2586 2587
	struct device_reg_24xx __iomem *reg;
	int		status;
	unsigned long	iter;
	uint32_t	stat;
	uint32_t	hccr;
2588
	uint16_t	mb[8];
2589
	struct rsp_que *rsp;
2590
	unsigned long	flags;
2591

2592 2593
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2594 2595
		ql_log(ql_log_info, NULL, 0x5059,
		    "%s: NULL response queue pointer.\n", __func__);
2596 2597 2598
		return IRQ_NONE;
	}

2599
	ha = rsp->hw;
2600 2601 2602
	reg = &ha->iobase->isp24;
	status = 0;

2603 2604 2605
	if (unlikely(pci_channel_offline(ha->pdev)))
		return IRQ_HANDLED;

2606
	spin_lock_irqsave(&ha->hardware_lock, flags);
2607
	vha = pci_get_drvdata(ha->pdev);
2608 2609
	for (iter = 50; iter--; ) {
		stat = RD_REG_DWORD(&reg->host_status);
2610 2611
		if (qla2x00_check_reg_for_disconnect(vha, stat))
			break;
2612
		if (stat & HSRX_RISC_PAUSED) {
2613
			if (unlikely(pci_channel_offline(ha->pdev)))
2614 2615
				break;

2616 2617
			hccr = RD_REG_DWORD(&reg->hccr);

2618 2619 2620
			ql_log(ql_log_warn, vha, 0x504b,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2621

2622
			qla2xxx_check_risc_status(vha);
2623

2624 2625
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2626 2627 2628 2629 2630
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
2631 2632 2633 2634
		case INTR_ROM_MB_SUCCESS:
		case INTR_ROM_MB_FAILED:
		case INTR_MB_SUCCESS:
		case INTR_MB_FAILED:
2635
			qla24xx_mbx_completion(vha, MSW(stat));
2636 2637 2638
			status |= MBX_INTERRUPT;

			break;
2639
		case INTR_ASYNC_EVENT:
2640 2641 2642 2643
			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);
2644
			qla2x00_async_event(vha, rsp, mb);
2645
			break;
2646 2647
		case INTR_RSP_QUE_UPDATE:
		case INTR_RSP_QUE_UPDATE_83XX:
2648
			qla24xx_process_response_queue(vha, rsp);
2649
			break;
2650
		case INTR_ATIO_QUE_UPDATE:
2651 2652
			qlt_24xx_process_atio_queue(vha);
			break;
2653
		case INTR_ATIO_RSP_QUE_UPDATE:
2654 2655 2656
			qlt_24xx_process_atio_queue(vha);
			qla24xx_process_response_queue(vha, rsp);
			break;
2657
		default:
2658 2659
			ql_dbg(ql_dbg_async, vha, 0x504f,
			    "Unrecognized interrupt type (%d).\n", stat * 0xff);
2660 2661 2662 2663
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
2664 2665
		if (unlikely(IS_QLA83XX(ha) && (ha->pdev->revision == 1)))
			ndelay(3500);
2666
	}
2667
	qla2x00_handle_mbx_completion(ha, status);
2668
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2669 2670 2671 2672

	return IRQ_HANDLED;
}

2673 2674 2675
static irqreturn_t
qla24xx_msix_rsp_q(int irq, void *dev_id)
{
2676 2677
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2678
	struct device_reg_24xx __iomem *reg;
2679
	struct scsi_qla_host *vha;
2680
	unsigned long flags;
2681
	uint32_t stat = 0;
2682

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

2692
	spin_lock_irqsave(&ha->hardware_lock, flags);
2693

2694
	vha = pci_get_drvdata(ha->pdev);
2695 2696 2697 2698 2699 2700 2701
	/*
	 * Use host_status register to check to PCI disconnection before we
	 * we process the response queue.
	 */
	stat = RD_REG_DWORD(&reg->host_status);
	if (qla2x00_check_reg_for_disconnect(vha, stat))
		goto out;
2702
	qla24xx_process_response_queue(vha, rsp);
2703
	if (!ha->flags.disable_msix_handshake) {
2704 2705 2706
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
	}
2707
out:
2708
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2709 2710 2711 2712

	return IRQ_HANDLED;
}

2713 2714 2715 2716
static irqreturn_t
qla25xx_msix_rsp_q(int irq, void *dev_id)
{
	struct qla_hw_data *ha;
2717
	scsi_qla_host_t *vha;
2718
	struct rsp_que *rsp;
2719
	struct device_reg_24xx __iomem *reg;
2720
	unsigned long flags;
2721
	uint32_t hccr = 0;
2722 2723 2724

	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2725 2726
		ql_log(ql_log_info, NULL, 0x505b,
		    "%s: NULL response queue pointer.\n", __func__);
2727 2728 2729
		return IRQ_NONE;
	}
	ha = rsp->hw;
2730
	vha = pci_get_drvdata(ha->pdev);
2731

2732
	/* Clear the interrupt, if enabled, for this response queue */
2733
	if (!ha->flags.disable_msix_handshake) {
2734
		reg = &ha->iobase->isp24;
2735
		spin_lock_irqsave(&ha->hardware_lock, flags);
2736
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2737
		hccr = RD_REG_DWORD_RELAXED(&reg->hccr);
2738
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
2739
	}
2740 2741
	if (qla2x00_check_reg_for_disconnect(vha, hccr))
		goto out;
2742 2743
	queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);

2744
out:
2745 2746 2747
	return IRQ_HANDLED;
}

2748 2749 2750
static irqreturn_t
qla24xx_msix_default(int irq, void *dev_id)
{
2751 2752 2753
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2754 2755 2756 2757
	struct device_reg_24xx __iomem *reg;
	int		status;
	uint32_t	stat;
	uint32_t	hccr;
2758
	uint16_t	mb[8];
2759
	unsigned long flags;
2760

2761 2762
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2763 2764
		ql_log(ql_log_info, NULL, 0x505c,
		    "%s: NULL response queue pointer.\n", __func__);
2765 2766 2767
		return IRQ_NONE;
	}
	ha = rsp->hw;
2768 2769 2770
	reg = &ha->iobase->isp24;
	status = 0;

2771
	spin_lock_irqsave(&ha->hardware_lock, flags);
2772
	vha = pci_get_drvdata(ha->pdev);
2773
	do {
2774
		stat = RD_REG_DWORD(&reg->host_status);
2775 2776
		if (qla2x00_check_reg_for_disconnect(vha, stat))
			break;
2777
		if (stat & HSRX_RISC_PAUSED) {
2778
			if (unlikely(pci_channel_offline(ha->pdev)))
2779 2780
				break;

2781 2782
			hccr = RD_REG_DWORD(&reg->hccr);

2783 2784 2785
			ql_log(ql_log_info, vha, 0x5050,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2786

2787
			qla2xxx_check_risc_status(vha);
2788

2789 2790
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2791 2792 2793 2794 2795
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
2796 2797 2798 2799
		case INTR_ROM_MB_SUCCESS:
		case INTR_ROM_MB_FAILED:
		case INTR_MB_SUCCESS:
		case INTR_MB_FAILED:
2800
			qla24xx_mbx_completion(vha, MSW(stat));
2801 2802 2803
			status |= MBX_INTERRUPT;

			break;
2804
		case INTR_ASYNC_EVENT:
2805 2806 2807 2808
			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);
2809
			qla2x00_async_event(vha, rsp, mb);
2810
			break;
2811 2812
		case INTR_RSP_QUE_UPDATE:
		case INTR_RSP_QUE_UPDATE_83XX:
2813
			qla24xx_process_response_queue(vha, rsp);
2814
			break;
2815
		case INTR_ATIO_QUE_UPDATE:
2816 2817
			qlt_24xx_process_atio_queue(vha);
			break;
2818
		case INTR_ATIO_RSP_QUE_UPDATE:
2819 2820 2821
			qlt_24xx_process_atio_queue(vha);
			qla24xx_process_response_queue(vha, rsp);
			break;
2822
		default:
2823 2824
			ql_dbg(ql_dbg_async, vha, 0x5051,
			    "Unrecognized interrupt type (%d).\n", stat & 0xff);
2825 2826 2827
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2828
	} while (0);
2829
	qla2x00_handle_mbx_completion(ha, status);
2830
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2831 2832 2833 2834 2835 2836 2837 2838

	return IRQ_HANDLED;
}

/* Interrupt handling helpers. */

struct qla_init_msix_entry {
	const char *name;
2839
	irq_handler_t handler;
2840 2841
};

2842
static struct qla_init_msix_entry msix_entries[3] = {
2843 2844
	{ "qla2xxx (default)", qla24xx_msix_default },
	{ "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
2845
	{ "qla2xxx (multiq)", qla25xx_msix_rsp_q },
2846 2847
};

2848 2849 2850 2851 2852
static struct qla_init_msix_entry qla82xx_msix_entries[2] = {
	{ "qla2xxx (default)", qla82xx_msix_default },
	{ "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
};

2853 2854 2855 2856 2857 2858
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 },
};

2859
static void
2860
qla24xx_disable_msix(struct qla_hw_data *ha)
2861 2862 2863
{
	int i;
	struct qla_msix_entry *qentry;
2864
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2865

2866 2867
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
2868
		if (qentry->have_irq)
2869
			free_irq(qentry->vector, qentry->rsp);
2870 2871
	}
	pci_disable_msix(ha->pdev);
2872 2873 2874
	kfree(ha->msix_entries);
	ha->msix_entries = NULL;
	ha->flags.msix_enabled = 0;
2875 2876
	ql_dbg(ql_dbg_init, vha, 0x0042,
	    "Disabled the MSI.\n");
2877 2878 2879
}

static int
2880
qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
2881
{
2882
#define MIN_MSIX_COUNT	2
2883
	int i, ret;
2884
	struct msix_entry *entries;
2885
	struct qla_msix_entry *qentry;
2886
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2887 2888

	entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
2889
			GFP_KERNEL);
2890 2891 2892
	if (!entries) {
		ql_log(ql_log_warn, vha, 0x00bc,
		    "Failed to allocate memory for msix_entry.\n");
2893
		return -ENOMEM;
2894
	}
2895

2896 2897
	for (i = 0; i < ha->msix_count; i++)
		entries[i].entry = i;
2898

2899
	ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
2900
	if (ret) {
2901 2902 2903
		if (ret < MIN_MSIX_COUNT)
			goto msix_failed;

2904 2905 2906 2907
		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);
2908 2909 2910
		ha->msix_count = ret;
		ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
		if (ret) {
2911
msix_failed:
2912 2913 2914 2915
			ql_log(ql_log_fatal, vha, 0x00c7,
			    "MSI-X: Failed to enable support, "
			    "giving   up -- %d/%d.\n",
			    ha->msix_count, ret);
2916 2917
			goto msix_out;
		}
2918
		ha->max_rsp_queues = ha->msix_count - 1;
2919 2920 2921 2922
	}
	ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
				ha->msix_count, GFP_KERNEL);
	if (!ha->msix_entries) {
2923 2924
		ql_log(ql_log_fatal, vha, 0x00c8,
		    "Failed to allocate memory for ha->msix_entries.\n");
2925
		ret = -ENOMEM;
2926 2927 2928 2929
		goto msix_out;
	}
	ha->flags.msix_enabled = 1;

2930 2931 2932 2933
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
		qentry->vector = entries[i].vector;
		qentry->entry = entries[i].entry;
2934
		qentry->have_irq = 0;
2935
		qentry->rsp = NULL;
2936 2937
	}

2938
	/* Enable MSI-X vectors for the base queue */
2939
	for (i = 0; i < ha->msix_count; i++) {
2940
		qentry = &ha->msix_entries[i];
2941 2942 2943 2944
		if (QLA_TGT_MODE_ENABLED() && IS_ATIO_MSIX_CAPABLE(ha)) {
			ret = request_irq(qentry->vector,
				qla83xx_msix_entries[i].handler,
				0, qla83xx_msix_entries[i].name, rsp);
2945
		} else if (IS_P3P_TYPE(ha)) {
2946 2947 2948 2949 2950 2951 2952 2953
			ret = request_irq(qentry->vector,
				qla82xx_msix_entries[i].handler,
				0, qla82xx_msix_entries[i].name, rsp);
		} else {
			ret = request_irq(qentry->vector,
				msix_entries[i].handler,
				0, msix_entries[i].name, rsp);
		}
2954
		if (ret) {
2955 2956 2957
			ql_log(ql_log_fatal, vha, 0x00cb,
			    "MSI-X: unable to register handler -- %x/%d.\n",
			    qentry->vector, ret);
2958 2959 2960 2961 2962 2963 2964
			qla24xx_disable_msix(ha);
			ha->mqenable = 0;
			goto msix_out;
		}
		qentry->have_irq = 1;
		qentry->rsp = rsp;
		rsp->msix = qentry;
2965 2966 2967
	}

	/* Enable MSI-X vector for response queue update for queue 0 */
2968 2969 2970 2971 2972 2973 2974 2975
	if (IS_QLA83XX(ha)) {
		if (ha->msixbase && ha->mqiobase &&
		    (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
			ha->mqenable = 1;
	} else
		if (ha->mqiobase
		    && (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
			ha->mqenable = 1;
2976 2977 2978 2979 2980 2981
	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);
2982

2983
msix_out:
2984
	kfree(entries);
2985 2986 2987 2988
	return ret;
}

int
2989
qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
2990
{
2991
	int ret = QLA_FUNCTION_FAILED;
2992
	device_reg_t __iomem *reg = ha->iobase;
2993
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2994 2995

	/* If possible, enable MSI-X. */
2996
	if (!IS_QLA2432(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
2997
		!IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha) && !IS_QLAFX00(ha))
2998 2999 3000 3001 3002 3003
		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)) {
3004 3005
		ql_log(ql_log_warn, vha, 0x0034,
		    "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
3006
			ha->pdev->subsystem_vendor,
3007
			ha->pdev->subsystem_device);
3008 3009
		goto skip_msi;
	}
3010

3011
	if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
3012 3013
		ql_log(ql_log_warn, vha, 0x0035,
		    "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
3014
		    ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
3015 3016 3017
		goto skip_msix;
	}

3018
	ret = qla24xx_enable_msix(ha, rsp);
3019
	if (!ret) {
3020 3021 3022
		ql_dbg(ql_dbg_init, vha, 0x0036,
		    "MSI-X: Enabled (0x%X, 0x%X).\n",
		    ha->chip_revision, ha->fw_attributes);
3023
		goto clear_risc_ints;
3024
	}
3025

3026
skip_msix:
3027

3028 3029 3030
	ql_log(ql_log_info, vha, 0x0037,
	    "Falling back-to MSI mode -%d.\n", ret);

3031
	if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
3032
	    !IS_QLA8001(ha) && !IS_P3P_TYPE(ha) && !IS_QLAFX00(ha))
3033 3034 3035 3036
		goto skip_msi;

	ret = pci_enable_msi(ha->pdev);
	if (!ret) {
3037 3038
		ql_dbg(ql_dbg_init, vha, 0x0038,
		    "MSI: Enabled.\n");
3039
		ha->flags.msi_enabled = 1;
3040
	} else
3041
		ql_log(ql_log_warn, vha, 0x0039,
3042 3043
		    "Falling back-to INTa mode -- %d.\n", ret);
skip_msi:
3044 3045 3046 3047 3048

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

3049
	ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
3050 3051
	    ha->flags.msi_enabled ? 0 : IRQF_SHARED,
	    QLA2XXX_DRIVER_NAME, rsp);
3052
	if (ret) {
3053
		ql_log(ql_log_warn, vha, 0x003a,
3054 3055
		    "Failed to reserve interrupt %d already in use.\n",
		    ha->pdev->irq);
3056
		goto fail;
3057
	} else if (!ha->flags.msi_enabled) {
3058 3059
		ql_dbg(ql_dbg_init, vha, 0x0125,
		    "INTa mode: Enabled.\n");
3060 3061
		ha->flags.mr_intr_valid = 1;
	}
3062

3063 3064
clear_risc_ints:

3065
	spin_lock_irq(&ha->hardware_lock);
3066
	if (!IS_FWI2_CAPABLE(ha))
3067
		WRT_REG_WORD(&reg->isp.semaphore, 0);
3068
	spin_unlock_irq(&ha->hardware_lock);
3069

3070
fail:
3071 3072 3073 3074
	return ret;
}

void
3075
qla2x00_free_irqs(scsi_qla_host_t *vha)
3076
{
3077
	struct qla_hw_data *ha = vha->hw;
3078 3079 3080 3081 3082 3083 3084 3085 3086
	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];
3087 3088 3089

	if (ha->flags.msix_enabled)
		qla24xx_disable_msix(ha);
3090
	else if (ha->flags.msi_enabled) {
3091
		free_irq(ha->pdev->irq, rsp);
3092
		pci_disable_msi(ha->pdev);
3093 3094
	} else
		free_irq(ha->pdev->irq, rsp);
3095
}
3096

3097 3098 3099 3100

int qla25xx_request_irq(struct rsp_que *rsp)
{
	struct qla_hw_data *ha = rsp->hw;
3101
	struct qla_init_msix_entry *intr = &msix_entries[2];
3102
	struct qla_msix_entry *msix = rsp->msix;
3103
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
3104 3105 3106 3107
	int ret;

	ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
	if (ret) {
3108 3109 3110
		ql_log(ql_log_fatal, vha, 0x00e6,
		    "MSI-X: Unable to register handler -- %x/%d.\n",
		    msix->vector, ret);
3111 3112 3113 3114 3115 3116
		return ret;
	}
	msix->have_irq = 1;
	msix->rsp = rsp;
	return ret;
}