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

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

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

L
Linus Torvalds 已提交
23 24 25 26 27 28 29 30 31 32
/**
 * 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
33
qla2100_intr_handler(int irq, void *dev_id)
L
Linus Torvalds 已提交
34
{
35 36
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
37
	struct device_reg_2xxx __iomem *reg;
L
Linus Torvalds 已提交
38 39
	int		status;
	unsigned long	iter;
40
	uint16_t	hccr;
41
	uint16_t	mb[4];
42
	struct rsp_que *rsp;
43
	unsigned long	flags;
L
Linus Torvalds 已提交
44

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

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

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

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

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

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

	if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
	    (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
		set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
113
		complete(&ha->mbx_intr_comp);
L
Linus Torvalds 已提交
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
	}

	return (IRQ_HANDLED);
}

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

142 143
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
L
Linus Torvalds 已提交
144
		printk(KERN_INFO
145
		    "%s(): NULL response queue pointer.\n", __func__);
L
Linus Torvalds 已提交
146 147 148
		return (IRQ_NONE);
	}

149
	ha = rsp->hw;
150
	reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
151 152
	status = 0;

153
	spin_lock_irqsave(&ha->hardware_lock, flags);
154
	vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
155 156 157
	for (iter = 50; iter--; ) {
		stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
		if (stat & HSR_RISC_PAUSED) {
158
			if (unlikely(pci_channel_offline(ha->pdev)))
159 160
				break;

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

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

179 180
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
181 182 183 184 185 186 187 188 189
			break;
		} else if ((stat & HSR_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
		case 0x1:
		case 0x2:
		case 0x10:
		case 0x11:
190
			qla2x00_mbx_completion(vha, MSW(stat));
L
Linus Torvalds 已提交
191 192 193 194 195 196
			status |= MBX_INTERRUPT;

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

	if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
	    (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
		set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
230
		complete(&ha->mbx_intr_comp);
L
Linus Torvalds 已提交
231 232 233 234 235 236 237 238 239 240 241
	}

	return (IRQ_HANDLED);
}

/**
 * qla2x00_mbx_completion() - Process mailbox command completions.
 * @ha: SCSI driver HA context
 * @mb0: Mailbox0 register
 */
static void
242
qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
L
Linus Torvalds 已提交
243 244 245
{
	uint16_t	cnt;
	uint16_t __iomem *wptr;
246
	struct qla_hw_data *ha = vha->hw;
247
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
248 249 250 251 252 253 254

	/* Load return mailbox registers. */
	ha->flags.mbox_int = 1;
	ha->mailbox_out[0] = mb0;
	wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);

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

L
Linus Torvalds 已提交
262 263 264 265
		wptr++;
	}

	if (ha->mcp) {
266 267
		ql_dbg(ql_dbg_async, vha, 0x5000,
		    "Got mbx completion. cmd=%x.\n", ha->mcp->mb[0]);
L
Linus Torvalds 已提交
268
	} else {
269 270
		ql_dbg(ql_dbg_async, vha, 0x5001,
		    "MBX pointer ERROR.\n");
L
Linus Torvalds 已提交
271 272 273
	}
}

274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
static void
qla81xx_idc_event(scsi_qla_host_t *vha, uint16_t aen, uint16_t descr)
{
	static char *event[] =
		{ "Complete", "Request Notification", "Time Extension" };
	int rval;
	struct device_reg_24xx __iomem *reg24 = &vha->hw->iobase->isp24;
	uint16_t __iomem *wptr;
	uint16_t cnt, timeout, mb[QLA_IDC_ACK_REGS];

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

289 290 291 292 293
	ql_dbg(ql_dbg_async, vha, 0x5021,
	    "Inter-Driver Commucation %s -- "
	    "%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]);
294 295 296 297 298 299

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

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

	rval = qla2x00_post_idc_ack_work(vha, mb);
	if (rval != QLA_SUCCESS)
306
		ql_log(ql_log_warn, vha, 0x5023,
307 308 309
		    "IDC failed to post ACK.\n");
}

L
Linus Torvalds 已提交
310 311 312
/**
 * qla2x00_async_event() - Process aynchronous events.
 * @ha: SCSI driver HA context
313
 * @mb: Mailbox registers (0 - 3)
L
Linus Torvalds 已提交
314
 */
315
void
316
qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
L
Linus Torvalds 已提交
317
{
318
#define LS_UNKNOWN	2
319
	static char	*link_speeds[] = { "1", "2", "?", "4", "8", "10" };
L
Linus Torvalds 已提交
320 321
	char		*link_speed;
	uint16_t	handle_cnt;
322
	uint16_t	cnt, mbx;
L
Linus Torvalds 已提交
323
	uint32_t	handles[5];
324
	struct qla_hw_data *ha = vha->hw;
325
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
326
	struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
327
	struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
L
Linus Torvalds 已提交
328 329
	uint32_t	rscn_entry, host_pid;
	uint8_t		rscn_queue_index;
330
	unsigned long	flags;
L
Linus Torvalds 已提交
331 332 333

	/* Setup to process RIO completion. */
	handle_cnt = 0;
334
	if (IS_QLA8XXX_TYPE(ha))
335
		goto skip_rio;
L
Linus Torvalds 已提交
336 337
	switch (mb[0]) {
	case MBA_SCSI_COMPLETION:
338
		handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
L
Linus Torvalds 已提交
339 340 341
		handle_cnt = 1;
		break;
	case MBA_CMPLT_1_16BIT:
342
		handles[0] = mb[1];
L
Linus Torvalds 已提交
343 344 345 346
		handle_cnt = 1;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_2_16BIT:
347 348
		handles[0] = mb[1];
		handles[1] = mb[2];
L
Linus Torvalds 已提交
349 350 351 352
		handle_cnt = 2;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_3_16BIT:
353 354 355
		handles[0] = mb[1];
		handles[1] = mb[2];
		handles[2] = mb[3];
L
Linus Torvalds 已提交
356 357 358 359
		handle_cnt = 3;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_4_16BIT:
360 361 362
		handles[0] = mb[1];
		handles[1] = mb[2];
		handles[2] = mb[3];
L
Linus Torvalds 已提交
363 364 365 366 367
		handles[3] = (uint32_t)RD_MAILBOX_REG(ha, reg, 6);
		handle_cnt = 4;
		mb[0] = MBA_SCSI_COMPLETION;
		break;
	case MBA_CMPLT_5_16BIT:
368 369 370
		handles[0] = mb[1];
		handles[1] = mb[2];
		handles[2] = mb[3];
L
Linus Torvalds 已提交
371 372 373 374 375 376
		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:
377
		handles[0] = le32_to_cpu((uint32_t)((mb[2] << 16) | mb[1]));
L
Linus Torvalds 已提交
378 379 380 381 382 383 384 385 386
		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;
	}
387
skip_rio:
L
Linus Torvalds 已提交
388 389
	switch (mb[0]) {
	case MBA_SCSI_COMPLETION:	/* Fast Post */
390
		if (!vha->flags.online)
L
Linus Torvalds 已提交
391 392 393
			break;

		for (cnt = 0; cnt < handle_cnt; cnt++)
394 395
			qla2x00_process_completed_request(vha, rsp->req,
				handles[cnt]);
L
Linus Torvalds 已提交
396 397 398
		break;

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

402
		set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
403 404 405
		break;

	case MBA_SYSTEM_ERR:		/* System Error */
406
		mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox7) : 0;
407
		ql_log(ql_log_warn, vha, 0x5003,
408 409
		    "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh "
		    "mbx7=%xh.\n", mb[1], mb[2], mb[3], mbx);
L
Linus Torvalds 已提交
410

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

413
		if (IS_FWI2_CAPABLE(ha)) {
414
			if (mb[1] == 0 && mb[2] == 0) {
415
				ql_log(ql_log_fatal, vha, 0x5004,
416 417
				    "Unrecoverable Hardware Error: adapter "
				    "marked OFFLINE!\n");
418
				vha->flags.online = 0;
419
			} else {
L
Lucas De Marchi 已提交
420
				/* Check to see if MPI timeout occurred */
421 422 423 424
				if ((mbx & MBX_3) && (ha->flags.port0))
					set_bit(MPI_RESET_NEEDED,
					    &vha->dpc_flags);

425
				set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
426
			}
427
		} else if (mb[1] == 0) {
428
			ql_log(ql_log_fatal, vha, 0x5005,
L
Linus Torvalds 已提交
429 430
			    "Unrecoverable Hardware Error: adapter marked "
			    "OFFLINE!\n");
431
			vha->flags.online = 0;
L
Linus Torvalds 已提交
432
		} else
433
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
434 435 436
		break;

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

440
		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
441 442 443
		break;

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

447
		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
448 449 450
		break;

	case MBA_WAKEUP_THRES:		/* Request Queue Wake-up */
451 452
		ql_dbg(ql_dbg_async, vha, 0x5008,
		    "Asynchronous WAKEUP_THRES.\n");
L
Linus Torvalds 已提交
453 454 455
		break;

	case MBA_LIP_OCCURRED:		/* Loop Initialization Procedure */
456 457
		ql_log(ql_log_info, vha, 0x5009,
		    "LIP occurred (%x).\n", mb[1]);
L
Linus Torvalds 已提交
458

459 460 461 462
		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 已提交
463 464
		}

465 466 467
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
468 469
		}

470 471
		set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
		set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
472

473 474
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
L
Linus Torvalds 已提交
475 476 477 478 479
		break;

	case MBA_LOOP_UP:		/* Loop Up Event */
		if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
			link_speed = link_speeds[0];
480
			ha->link_data_rate = PORT_SPEED_1GB;
L
Linus Torvalds 已提交
481
		} else {
482
			link_speed = link_speeds[LS_UNKNOWN];
L
Linus Torvalds 已提交
483 484
			if (mb[1] < 5)
				link_speed = link_speeds[mb[1]];
485 486
			else if (mb[1] == 0x13)
				link_speed = link_speeds[5];
L
Linus Torvalds 已提交
487 488 489
			ha->link_data_rate = mb[1];
		}

490 491
		ql_log(ql_log_info, vha, 0x500a,
		    "LOOP UP detected (%s Gbps).\n", link_speed);
L
Linus Torvalds 已提交
492

493 494
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
L
Linus Torvalds 已提交
495 496 497
		break;

	case MBA_LOOP_DOWN:		/* Loop Down Event */
498
		mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox4) : 0;
499
		mbx = IS_QLA82XX(ha) ? RD_REG_WORD(&reg82->mailbox_out[4]) : mbx;
500 501 502
		ql_log(ql_log_info, vha, 0x500b,
		    "LOOP DOWN detected (%x %x %x %x).\n",
		    mb[1], mb[2], mb[3], mbx);
L
Linus Torvalds 已提交
503

504 505 506 507 508
		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 已提交
509 510
		}

511 512 513
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
514 515
		}

516
		vha->flags.management_server_logged_in = 0;
517
		ha->link_data_rate = PORT_SPEED_UNKNOWN;
518
		qla2x00_post_aen_work(vha, FCH_EVT_LINKDOWN, 0);
L
Linus Torvalds 已提交
519 520 521
		break;

	case MBA_LIP_RESET:		/* LIP reset occurred */
522
		ql_log(ql_log_info, vha, 0x500c,
523
		    "LIP reset occurred (%x).\n", mb[1]);
L
Linus Torvalds 已提交
524

525 526 527 528
		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 已提交
529 530
		}

531 532 533
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
534 535
		}

536
		set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
537 538

		ha->operating_mode = LOOP;
539 540
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
L
Linus Torvalds 已提交
541 542
		break;

543
	/* case MBA_DCBX_COMPLETE: */
L
Linus Torvalds 已提交
544 545 546 547
	case MBA_POINT_TO_POINT:	/* Point-to-Point */
		if (IS_QLA2100(ha))
			break;

548
		if (IS_QLA8XXX_TYPE(ha)) {
549 550 551
			ql_dbg(ql_dbg_async, vha, 0x500d,
			    "DCBX Completed -- %04x %04x %04x.\n",
			    mb[1], mb[2], mb[3]);
552 553 554 555
			if (ha->notify_dcbx_comp)
				complete(&ha->dcbx_comp);

		} else
556 557
			ql_dbg(ql_dbg_async, vha, 0x500e,
			    "Asynchronous P2P MODE received.\n");
L
Linus Torvalds 已提交
558 559 560 561 562

		/*
		 * Until there's a transition from loop down to loop up, treat
		 * this as loop down only.
		 */
563 564 565 566
		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 已提交
567
				    LOOP_DOWN_TIME);
568
			qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
569 570
		}

571 572 573
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
574 575
		}

576 577 578 579 580
		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);
581 582

		ha->flags.gpsc_supported = 1;
583
		vha->flags.management_server_logged_in = 0;
L
Linus Torvalds 已提交
584 585 586 587 588 589
		break;

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

590
		ql_log(ql_log_info, vha, 0x500f,
L
Linus Torvalds 已提交
591 592
		    "Configuration change detected: value=%x.\n", mb[1]);

593 594 595 596
		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 已提交
597
				    LOOP_DOWN_TIME);
598
			qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
599 600
		}

601 602 603
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
604 605
		}

606 607
		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
L
Linus Torvalds 已提交
608 609 610
		break;

	case MBA_PORT_UPDATE:		/* Port database update */
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
		/*
		 * 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
		 */
626 627 628 629
		if (IS_QLA2XXX_MIDTYPE(ha) &&
		    ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff) ||
			(mb[1] != 0xffff)) && vha->vp_idx != (mb[3] & 0xff))
			break;
630

631 632
		/* Global event -- port logout or port unavailable. */
		if (mb[1] == 0xffff && mb[2] == 0x7) {
633 634 635
			ql_dbg(ql_dbg_async, vha, 0x5010,
			    "Port unavailable %04x %04x %04x.\n",
			    mb[1], mb[2], mb[3]);
636 637 638 639 640 641 642 643 644 645 646 647 648

			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);
649
				qla2x00_mark_all_devices_lost(vha, 1);
650 651 652 653 654 655 656
			}

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

L
Linus Torvalds 已提交
657
		/*
658
		 * If PORT UPDATE is global (received LIP_OCCURRED/LIP_RESET
L
Linus Torvalds 已提交
659 660 661
		 * event etc. earlier indicating loop is down) then process
		 * it.  Otherwise ignore it and Wait for RSCN to come in.
		 */
662 663 664
		atomic_set(&vha->loop_down_timer, 0);
		if (atomic_read(&vha->loop_state) != LOOP_DOWN &&
		    atomic_read(&vha->loop_state) != LOOP_DEAD) {
665 666 667
			ql_dbg(ql_dbg_async, vha, 0x5011,
			    "Asynchronous PORT UPDATE ignored %04x/%04x/%04x.\n",
			    mb[1], mb[2], mb[3]);
L
Linus Torvalds 已提交
668 669 670
			break;
		}

671 672 673
		ql_dbg(ql_dbg_async, vha, 0x5012,
		    "Port database changed %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
L
Linus Torvalds 已提交
674 675 676 677

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

680
		qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
681

682
		vha->flags.rscn_queue_overflow = 1;
L
Linus Torvalds 已提交
683

684 685
		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
L
Linus Torvalds 已提交
686 687 688
		break;

	case MBA_RSCN_UPDATE:		/* State Change Registration */
689
		/* Check if the Vport has issued a SCR */
690
		if (vha->vp_idx && test_bit(VP_SCR_NEEDED, &vha->vp_flags))
691 692
			break;
		/* Only handle SCNs for our Vport index. */
693
		if (ha->flags.npiv_supported && vha->vp_idx != (mb[3] & 0xff))
694
			break;
695

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

700
		rscn_entry = ((mb[1] & 0xff) << 16) | mb[2];
701 702
		host_pid = (vha->d_id.b.domain << 16) | (vha->d_id.b.area << 8)
				| vha->d_id.b.al_pa;
L
Linus Torvalds 已提交
703
		if (rscn_entry == host_pid) {
704 705 706
			ql_dbg(ql_dbg_async, vha, 0x5014,
			    "Ignoring RSCN update to local host "
			    "port ID (%06x).\n", host_pid);
L
Linus Torvalds 已提交
707 708 709
			break;
		}

710 711
		/* Ignore reserved bits from RSCN-payload. */
		rscn_entry = ((mb[1] & 0x3ff) << 16) | mb[2];
712
		rscn_queue_index = vha->rscn_in_ptr + 1;
L
Linus Torvalds 已提交
713 714
		if (rscn_queue_index == MAX_RSCN_COUNT)
			rscn_queue_index = 0;
715 716 717
		if (rscn_queue_index != vha->rscn_out_ptr) {
			vha->rscn_queue[vha->rscn_in_ptr] = rscn_entry;
			vha->rscn_in_ptr = rscn_queue_index;
L
Linus Torvalds 已提交
718
		} else {
719
			vha->flags.rscn_queue_overflow = 1;
L
Linus Torvalds 已提交
720 721
		}

722 723
		atomic_set(&vha->loop_down_timer, 0);
		vha->flags.management_server_logged_in = 0;
L
Linus Torvalds 已提交
724

725 726 727
		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 已提交
728 729 730 731
		break;

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

735
		if (IS_FWI2_CAPABLE(ha))
736
			qla24xx_process_response_queue(vha, rsp);
737
		else
738
			qla2x00_process_response_queue(rsp);
L
Linus Torvalds 已提交
739
		break;
740 741

	case MBA_DISCARD_RND_FRAME:
742 743 744
		ql_dbg(ql_dbg_async, vha, 0x5016,
		    "Discard RND Frame -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
745
		break;
746 747

	case MBA_TRACE_NOTIFICATION:
748 749
		ql_dbg(ql_dbg_async, vha, 0x5017,
		    "Trace Notification -- %04x %04x.\n", mb[1], mb[2]);
750
		break;
751 752

	case MBA_ISP84XX_ALERT:
753 754 755
		ql_dbg(ql_dbg_async, vha, 0x5018,
		    "ISP84XX Alert Notification -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
756 757 758 759

		spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
		switch (mb[1]) {
		case A84_PANIC_RECOVERY:
760 761 762
			ql_log(ql_log_info, vha, 0x5019,
			    "Alert 84XX: panic recovery %04x %04x.\n",
			    mb[2], mb[3]);
763 764 765
			break;
		case A84_OP_LOGIN_COMPLETE:
			ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
766 767 768
			ql_log(ql_log_info, vha, 0x501a,
			    "Alert 84XX: firmware version %x.\n",
			    ha->cs84xx->op_fw_version);
769 770 771
			break;
		case A84_DIAG_LOGIN_COMPLETE:
			ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
772 773 774
			ql_log(ql_log_info, vha, 0x501b,
			    "Alert 84XX: diagnostic firmware version %x.\n",
			    ha->cs84xx->diag_fw_version);
775 776 777 778
			break;
		case A84_GOLD_LOGIN_COMPLETE:
			ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
			ha->cs84xx->fw_update = 1;
779 780 781
			ql_log(ql_log_info, vha, 0x501c,
			    "Alert 84XX: gold firmware version %x.\n",
			    ha->cs84xx->gold_fw_version);
782 783
			break;
		default:
784 785
			ql_log(ql_log_warn, vha, 0x501d,
			    "Alert 84xx: Invalid Alert %04x %04x %04x.\n",
786 787 788 789
			    mb[1], mb[2], mb[3]);
		}
		spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
		break;
790
	case MBA_DCBX_START:
791 792 793
		ql_dbg(ql_dbg_async, vha, 0x501e,
		    "DCBX Started -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
794 795
		break;
	case MBA_DCBX_PARAM_UPDATE:
796 797 798
		ql_dbg(ql_dbg_async, vha, 0x501f,
		    "DCBX Parameters Updated -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
799 800
		break;
	case MBA_FCF_CONF_ERR:
801 802 803
		ql_dbg(ql_dbg_async, vha, 0x5020,
		    "FCF Configuration Error -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
804 805 806 807
		break;
	case MBA_IDC_COMPLETE:
	case MBA_IDC_NOTIFY:
	case MBA_IDC_TIME_EXT:
808
		qla81xx_idc_event(vha, mb[0], mb[1]);
809
		break;
L
Linus Torvalds 已提交
810
	}
811

812
	if (!vha->vp_idx && ha->num_vhosts)
813
		qla2x00_alert_all_vps(rsp, mb);
L
Linus Torvalds 已提交
814 815 816 817 818 819 820 821
}

/**
 * qla2x00_process_completed_request() - Process a Fast Post response.
 * @ha: SCSI driver HA context
 * @index: SRB index
 */
static void
822 823
qla2x00_process_completed_request(struct scsi_qla_host *vha,
				struct req_que *req, uint32_t index)
L
Linus Torvalds 已提交
824 825
{
	srb_t *sp;
826
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
827 828 829

	/* Validate handle. */
	if (index >= MAX_OUTSTANDING_COMMANDS) {
830 831
		ql_log(ql_log_warn, vha, 0x3014,
		    "Invalid SCSI command index (%x).\n", index);
L
Linus Torvalds 已提交
832

833 834 835 836
		if (IS_QLA82XX(ha))
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
837 838 839
		return;
	}

840
	sp = req->outstanding_cmds[index];
L
Linus Torvalds 已提交
841 842
	if (sp) {
		/* Free outstanding command slot. */
843
		req->outstanding_cmds[index] = NULL;
L
Linus Torvalds 已提交
844 845 846

		/* Save ISP completion status */
		sp->cmd->result = DID_OK << 16;
847
		qla2x00_sp_compl(ha, sp);
L
Linus Torvalds 已提交
848
	} else {
849
		ql_log(ql_log_warn, vha, 0x3016, "Invalid SCSI SRB.\n");
L
Linus Torvalds 已提交
850

851 852 853 854
		if (IS_QLA82XX(ha))
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
855 856 857
	}
}

858 859 860 861 862 863 864 865 866 867 868
static srb_t *
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);
	if (index >= MAX_OUTSTANDING_COMMANDS) {
869 870
		ql_log(ql_log_warn, vha, 0x5031,
		    "Invalid command index (%x).\n", index);
871 872 873 874
		if (IS_QLA82XX(ha))
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
875 876 877 878
		goto done;
	}
	sp = req->outstanding_cmds[index];
	if (!sp) {
879 880
		ql_log(ql_log_warn, vha, 0x5032,
		    "Invalid completion handle (%x) -- timed-out.\n", index);
881 882 883
		return sp;
	}
	if (sp->handle != index) {
884 885
		ql_log(ql_log_warn, vha, 0x5033,
		    "SRB handle (%x) mismatch %x.\n", sp->handle, index);
886 887
		return NULL;
	}
888

889
	req->outstanding_cmds[index] = NULL;
890

891 892 893 894 895 896 897 898 899 900 901 902
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;
903 904
	struct srb_iocb *lio;
	struct srb_ctx *ctx;
905
	uint16_t *data;
906
	uint16_t status;
907 908 909 910 911

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

912 913 914
	ctx = sp->ctx;
	lio = ctx->u.iocb_cmd;
	type = ctx->name;
915
	fcport = sp->fcport;
916
	data = lio->u.logio.data;
917

918
	data[0] = MBS_COMMAND_ERROR;
919
	data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
920
	    QLA_LOGIO_LOGIN_RETRIED : 0;
921
	if (mbx->entry_status) {
922 923
		ql_dbg(ql_dbg_async, vha, 0x5043,
		    "Async-%s error entry - portid=%02x%02x%02x "
924 925
		    "entry-status=%x status=%x state-flag=%x "
		    "status-flags=%x.\n",
926
		    type, fcport->d_id.b.domain, fcport->d_id.b.area,
927 928
		    fcport->d_id.b.al_pa, mbx->entry_status,
		    le16_to_cpu(mbx->status), le16_to_cpu(mbx->state_flags),
929
		    le16_to_cpu(mbx->status_flags));
930

931 932
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5057,
		    (uint8_t *)mbx, sizeof(*mbx));
933

934
		goto logio_done;
935 936
	}

937
	status = le16_to_cpu(mbx->status);
938
	if (status == 0x30 && ctx->type == SRB_LOGIN_CMD &&
939 940 941
	    le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
		status = 0;
	if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
942 943 944 945
		ql_dbg(ql_dbg_async, vha, 0x5045,
		    "Async-%s complete - portid=%02x%02x%02x mbx1=%x.\n",
		    type, fcport->d_id.b.domain, fcport->d_id.b.area,
		    fcport->d_id.b.al_pa, le16_to_cpu(mbx->mb1));
946 947

		data[0] = MBS_COMMAND_COMPLETE;
948
		if (ctx->type == SRB_LOGIN_CMD) {
949 950 951
			fcport->port_type = FCT_TARGET;
			if (le16_to_cpu(mbx->mb1) & BIT_0)
				fcport->port_type = FCT_INITIATOR;
952
			else if (le16_to_cpu(mbx->mb1) & BIT_1)
953
				fcport->flags |= FCF_FCP2_DEVICE;
954
		}
955
		goto logio_done;
956 957 958 959 960 961 962 963 964 965 966 967 968 969
	}

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

970 971
	ql_log(ql_log_warn, vha, 0x5046,
	    "Async-%s failed - portid=%02x%02x%02x status=%x "
972
	    "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n",
973
	    type, fcport->d_id.b.domain,
974
	    fcport->d_id.b.area, fcport->d_id.b.al_pa, status,
975 976
	    le16_to_cpu(mbx->mb0), le16_to_cpu(mbx->mb1),
	    le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
977
	    le16_to_cpu(mbx->mb7));
978

979
logio_done:
980
	lio->done(sp);
981 982
}

983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
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;
	struct qla_hw_data *ha = vha->hw;
	srb_t *sp;
	struct srb_ctx *sp_bsg;
	struct fc_bsg_job *bsg_job;
	uint16_t comp_status;

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

	sp_bsg = sp->ctx;
	bsg_job = sp_bsg->u.bsg_job;

	type = NULL;
	switch (sp_bsg->type) {
	case SRB_CT_CMD:
		type = "ct pass-through";
		break;
	default:
1008 1009
		ql_log(ql_log_warn, vha, 0x5047,
		    "Unrecognized SRB: (%p) type=%d.\n", sp, sp_bsg->type);
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
		return;
	}

	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) {
			bsg_job->reply->result = DID_OK << 16;
			bsg_job->reply->reply_payload_rcv_len =
			    le16_to_cpu(((sts_entry_t *)pkt)->rsp_info_len);

1027 1028
			ql_log(ql_log_warn, vha, 0x5048,
			    "CT pass-through-%s error "
1029
			    "comp_status-status=0x%x total_byte = 0x%x.\n",
1030 1031
			    type, comp_status,
			    bsg_job->reply->reply_payload_rcv_len);
1032
		} else {
1033 1034 1035
			ql_log(ql_log_warn, vha, 0x5049,
			    "CT pass-through-%s error "
			    "comp_status-status=0x%x.\n", type, comp_status);
1036 1037 1038
			bsg_job->reply->result = DID_ERROR << 16;
			bsg_job->reply->reply_payload_rcv_len = 0;
		}
1039 1040
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5058,
		    (uint8_t *)pkt, sizeof(*pkt));
1041
	} else {
1042
		bsg_job->reply->result =  DID_OK << 16;
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
		bsg_job->reply->reply_payload_rcv_len =
		    bsg_job->reply_payload.payload_len;
		bsg_job->reply_len = 0;
	}

	dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
	    bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);

	dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
	    bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);

	if (sp_bsg->type == SRB_ELS_CMD_HST || sp_bsg->type == SRB_CT_CMD)
		kfree(sp->fcport);

	kfree(sp->ctx);
	mempool_free(sp, ha->srb_mempool);
	bsg_job->job_done(bsg_job);
}

1062 1063 1064 1065 1066 1067 1068 1069
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;
	struct qla_hw_data *ha = vha->hw;
	srb_t *sp;
1070
	struct srb_ctx *sp_bsg;
1071 1072 1073 1074 1075 1076 1077 1078
	struct fc_bsg_job *bsg_job;
	uint16_t comp_status;
	uint32_t fw_status[3];
	uint8_t* fw_sts_ptr;

	sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
	if (!sp)
		return;
1079 1080
	sp_bsg = sp->ctx;
	bsg_job = sp_bsg->u.bsg_job;
1081 1082

	type = NULL;
1083
	switch (sp_bsg->type) {
1084 1085 1086 1087 1088 1089 1090 1091
	case SRB_ELS_CMD_RPT:
	case SRB_ELS_CMD_HST:
		type = "els";
		break;
	case SRB_CT_CMD:
		type = "ct pass-through";
		break;
	default:
1092 1093
		ql_log(ql_log_warn, vha, 0x503e,
		    "Unrecognized SRB: (%p) type=%d.\n", sp, sp_bsg->type);
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
		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) {
			bsg_job->reply->result = DID_OK << 16;
			bsg_job->reply->reply_payload_rcv_len =
				le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count);

1113 1114
			ql_log(ql_log_info, vha, 0x503f,
			    "ELS-CT pass-through-%s error comp_status-status=0x%x "
1115
			    "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
1116 1117 1118
			    type, comp_status, fw_status[1], fw_status[2],
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				pkt)->total_byte_count));
1119 1120 1121 1122
			fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
			memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
		}
		else {
1123 1124
			ql_log(ql_log_info, vha, 0x5040,
			    "ELS-CT pass-through-%s error comp_status-status=0x%x "
1125
			    "error subcode 1=0x%x error subcode 2=0x%x.\n",
1126 1127 1128 1129 1130
			    type, comp_status,
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				pkt)->error_subcode_1),
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				    pkt)->error_subcode_2));
1131 1132 1133 1134 1135
			bsg_job->reply->result = DID_ERROR << 16;
			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));
		}
1136 1137
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5056,
				(uint8_t *)pkt, sizeof(*pkt));
1138 1139
	}
	else {
1140
		bsg_job->reply->result =  DID_OK << 16;
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
		bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
		bsg_job->reply_len = 0;
	}

	dma_unmap_sg(&ha->pdev->dev,
	    bsg_job->request_payload.sg_list,
	    bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
	dma_unmap_sg(&ha->pdev->dev,
	    bsg_job->reply_payload.sg_list,
	    bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
1151 1152
	if ((sp_bsg->type == SRB_ELS_CMD_HST) ||
	    (sp_bsg->type == SRB_CT_CMD))
1153 1154 1155 1156 1157 1158
		kfree(sp->fcport);
	kfree(sp->ctx);
	mempool_free(sp, ha->srb_mempool);
	bsg_job->job_done(bsg_job);
}

1159 1160 1161 1162 1163 1164 1165 1166
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;
1167 1168
	struct srb_iocb *lio;
	struct srb_ctx *ctx;
1169
	uint16_t *data;
1170 1171 1172 1173 1174 1175
	uint32_t iop[2];

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

1176 1177 1178
	ctx = sp->ctx;
	lio = ctx->u.iocb_cmd;
	type = ctx->name;
1179
	fcport = sp->fcport;
1180
	data = lio->u.logio.data;
1181

1182
	data[0] = MBS_COMMAND_ERROR;
1183
	data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
1184
		QLA_LOGIO_LOGIN_RETRIED : 0;
1185
	if (logio->entry_status) {
1186 1187
		ql_log(ql_log_warn, vha, 0x5034,
		    "Async-%s error entry - "
1188
		    "portid=%02x%02x%02x entry-status=%x.\n",
1189 1190 1191 1192
		    type, 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, 0x5059,
		    (uint8_t *)logio, sizeof(*logio));
1193

1194
		goto logio_done;
1195 1196 1197
	}

	if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
1198 1199
		ql_dbg(ql_dbg_async, vha, 0x5036,
		    "Async-%s complete - portid=%02x%02x%02x "
1200
		    "iop0=%x.\n",
1201
		    type, fcport->d_id.b.domain, fcport->d_id.b.area,
1202
		    fcport->d_id.b.al_pa,
1203
		    le32_to_cpu(logio->io_parameter[0]));
1204 1205

		data[0] = MBS_COMMAND_COMPLETE;
1206
		if (ctx->type != SRB_LOGIN_CMD)
1207
			goto logio_done;
1208 1209 1210 1211 1212

		iop[0] = le32_to_cpu(logio->io_parameter[0]);
		if (iop[0] & BIT_4) {
			fcport->port_type = FCT_TARGET;
			if (iop[0] & BIT_8)
1213
				fcport->flags |= FCF_FCP2_DEVICE;
1214
		} else if (iop[0] & BIT_5)
1215
			fcport->port_type = FCT_INITIATOR;
1216

1217 1218 1219 1220 1221
		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;

1222
		goto logio_done;
1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
	}

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

1240 1241
	ql_dbg(ql_dbg_async, vha, 0x5037,
	    "Async-%s failed - portid=%02x%02x%02x comp=%x "
1242
	    "iop0=%x iop1=%x.\n",
1243
	    type, fcport->d_id.b.domain,
1244
	    fcport->d_id.b.area, fcport->d_id.b.al_pa,
1245 1246
	    le16_to_cpu(logio->comp_status),
	    le32_to_cpu(logio->io_parameter[0]),
1247
	    le32_to_cpu(logio->io_parameter[1]));
1248

1249
logio_done:
1250
	lio->done(sp);
1251 1252
}

1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275
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 srb_ctx *ctx;
	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;

	ctx = sp->ctx;
	iocb = ctx->u.iocb_cmd;
	type = ctx->name;
	fcport = sp->fcport;

	if (sts->entry_status) {
1276 1277 1278
		ql_log(ql_log_warn, vha, 0x5038,
		    "Async-%s error - entry-status(%x).\n",
		    type, sts->entry_status);
1279
	} else if (sts->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1280 1281 1282
		ql_log(ql_log_warn, vha, 0x5039,
		    "Async-%s error - completion status(%x).\n",
		    type, sts->comp_status);
1283 1284
	} else if (!(le16_to_cpu(sts->scsi_status) &
	    SS_RESPONSE_INFO_LEN_VALID)) {
1285 1286 1287
		ql_log(ql_log_warn, vha, 0x503a,
		    "Async-%s error - no response info(%x).\n",
		    type, sts->scsi_status);
1288
	} else if (le32_to_cpu(sts->rsp_data_len) < 4) {
1289 1290 1291
		ql_log(ql_log_warn, vha, 0x503b,
		    "Async-%s error - not enough response(%d).\n",
		    type, sts->rsp_data_len);
1292
	} else if (sts->data[3]) {
1293 1294 1295
		ql_log(ql_log_warn, vha, 0x503c,
		    "Async-%s error - response(%x).\n",
		    type, sts->data[3]);
1296 1297 1298 1299 1300 1301
	} else {
		error = 0;
	}

	if (error) {
		iocb->u.tmf.data = error;
1302 1303
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5055,
		    (uint8_t *)sts, sizeof(*sts));
1304 1305 1306 1307 1308
	}

	iocb->done(sp);
}

L
Linus Torvalds 已提交
1309 1310 1311 1312 1313
/**
 * qla2x00_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
void
1314
qla2x00_process_response_queue(struct rsp_que *rsp)
L
Linus Torvalds 已提交
1315
{
1316 1317
	struct scsi_qla_host *vha;
	struct qla_hw_data *ha = rsp->hw;
1318
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
1319 1320 1321
	sts_entry_t	*pkt;
	uint16_t        handle_cnt;
	uint16_t        cnt;
1322

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

1325
	if (!vha->flags.online)
L
Linus Torvalds 已提交
1326 1327
		return;

1328 1329
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (sts_entry_t *)rsp->ring_ptr;
L
Linus Torvalds 已提交
1330

1331 1332 1333 1334
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
L
Linus Torvalds 已提交
1335
		} else {
1336
			rsp->ring_ptr++;
L
Linus Torvalds 已提交
1337 1338 1339
		}

		if (pkt->entry_status != 0) {
1340 1341
			ql_log(ql_log_warn, vha, 0x5035,
			    "Process error entry.\n");
L
Linus Torvalds 已提交
1342

1343
			qla2x00_error_entry(vha, rsp, pkt);
L
Linus Torvalds 已提交
1344 1345 1346 1347 1348 1349 1350
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

		switch (pkt->entry_type) {
		case STATUS_TYPE:
1351
			qla2x00_status_entry(vha, rsp, pkt);
L
Linus Torvalds 已提交
1352 1353 1354 1355
			break;
		case STATUS_TYPE_21:
			handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
			for (cnt = 0; cnt < handle_cnt; cnt++) {
1356
				qla2x00_process_completed_request(vha, rsp->req,
L
Linus Torvalds 已提交
1357 1358 1359 1360 1361 1362
				    ((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++) {
1363
				qla2x00_process_completed_request(vha, rsp->req,
L
Linus Torvalds 已提交
1364 1365 1366 1367
				    ((sts22_entry_t *)pkt)->handle[cnt]);
			}
			break;
		case STATUS_CONT_TYPE:
1368
			qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
L
Linus Torvalds 已提交
1369
			break;
1370 1371 1372
		case MBX_IOCB_TYPE:
			qla2x00_mbx_iocb_entry(vha, rsp->req,
			    (struct mbx_entry *)pkt);
1373
			break;
1374 1375 1376
		case CT_IOCB_TYPE:
			qla2x00_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
			break;
L
Linus Torvalds 已提交
1377 1378
		default:
			/* Type Not Supported. */
1379 1380
			ql_log(ql_log_warn, vha, 0x504a,
			    "Received unknown response pkt type %x "
L
Linus Torvalds 已提交
1381
			    "entry status=%x.\n",
1382
			    pkt->entry_type, pkt->entry_status);
L
Linus Torvalds 已提交
1383 1384 1385 1386 1387 1388 1389
			break;
		}
		((response_t *)pkt)->signature = RESPONSE_PROCESSED;
		wmb();
	}

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

1393
static inline void
1394 1395 1396

qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
    uint32_t sense_len, struct rsp_que *rsp)
1397
{
1398
	struct scsi_qla_host *vha = sp->fcport->vha;
1399 1400 1401 1402 1403 1404 1405
	struct scsi_cmnd *cp = sp->cmd;

	if (sense_len >= SCSI_SENSE_BUFFERSIZE)
		sense_len = SCSI_SENSE_BUFFERSIZE;

	sp->request_sense_length = sense_len;
	sp->request_sense_ptr = cp->sense_buffer;
1406 1407
	if (sp->request_sense_length > par_sense_len)
		sense_len = par_sense_len;
1408 1409 1410 1411 1412 1413

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

	sp->request_sense_ptr += sense_len;
	sp->request_sense_length -= sense_len;
	if (sp->request_sense_length != 0)
1414
		rsp->status_srb = sp;
1415

1416 1417 1418 1419
	ql_dbg(ql_dbg_io, vha, 0x301c,
	    "Check condition Sense data, scsi(%ld:%d:%d:%d) cmd=%p.\n",
	    sp->fcport->vha->host_no, cp->device->channel, cp->device->id,
	    cp->device->lun, cp);
1420
	if (sense_len)
1421 1422
		ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
		    cp->sense_buffer, sense_len);
1423 1424
}

1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
struct scsi_dif_tuple {
	__be16 guard;       /* Checksum */
	__be16 app_tag;         /* APPL identifer */
	__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.
 */
1437
static inline int
1438 1439
qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
{
1440
	struct scsi_qla_host *vha = sp->fcport->vha;
1441
	struct scsi_cmnd *cmd = sp->cmd;
1442 1443
	uint8_t		*ap = &sts24->data[12];
	uint8_t		*ep = &sts24->data[20];
1444 1445 1446 1447
	uint32_t	e_ref_tag, a_ref_tag;
	uint16_t	e_app_tag, a_app_tag;
	uint16_t	e_guard, a_guard;

1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
	/*
	 * 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));
1458

1459 1460
	ql_dbg(ql_dbg_io, vha, 0x3023,
	    "iocb(s) %p Returned STATUS.\n", sts24);
1461

1462 1463
	ql_dbg(ql_dbg_io, vha, 0x3024,
	    "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
1464
	    " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
1465
	    " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
1466
	    cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
1467
	    a_app_tag, e_app_tag, a_guard, e_guard);
1468

1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
	/*
	 * 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) {
				qla_printk(KERN_WARNING, sp->fcport->vha->hw,
1510 1511
				    "unexpected tag values tag:lba=%x:%llx)\n",
				    e_ref_tag, (unsigned long long)lba_s);
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
				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;
	}

1526 1527 1528 1529 1530 1531 1532
	/* 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;
1533
		return 1;
1534 1535
	}

1536 1537
	/* check ref tag */
	if (e_ref_tag != a_ref_tag) {
1538
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1539
		    0x10, 0x3);
1540 1541 1542
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1543
		return 1;
1544 1545
	}

1546 1547
	/* check appl tag */
	if (e_app_tag != a_app_tag) {
1548
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1549
		    0x10, 0x2);
1550 1551 1552
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1553
		return 1;
1554
	}
1555

1556
	return 1;
1557 1558
}

L
Linus Torvalds 已提交
1559 1560 1561 1562 1563 1564
/**
 * qla2x00_status_entry() - Process a Status IOCB entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
1565
qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
L
Linus Torvalds 已提交
1566 1567 1568 1569
{
	srb_t		*sp;
	fc_port_t	*fcport;
	struct scsi_cmnd *cp;
1570 1571
	sts_entry_t *sts;
	struct sts_entry_24xx *sts24;
L
Linus Torvalds 已提交
1572 1573
	uint16_t	comp_status;
	uint16_t	scsi_status;
1574
	uint16_t	ox_id;
L
Linus Torvalds 已提交
1575 1576
	uint8_t		lscsi_status;
	int32_t		resid;
1577 1578
	uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
	    fw_resid_len;
1579
	uint8_t		*rsp_info, *sense_data;
1580
	struct qla_hw_data *ha = vha->hw;
1581 1582 1583
	uint32_t handle;
	uint16_t que;
	struct req_que *req;
1584
	int logit = 1;
1585 1586 1587

	sts = (sts_entry_t *) pkt;
	sts24 = (struct sts_entry_24xx *) pkt;
1588
	if (IS_FWI2_CAPABLE(ha)) {
1589 1590 1591 1592 1593 1594
		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;
	}
1595 1596 1597
	handle = (uint32_t) LSW(sts->handle);
	que = MSW(sts->handle);
	req = ha->req_q_map[que];
1598

L
Linus Torvalds 已提交
1599
	/* Fast path completion. */
1600
	if (comp_status == CS_COMPLETE && scsi_status == 0) {
1601
		qla2x00_process_completed_request(vha, req, handle);
L
Linus Torvalds 已提交
1602 1603 1604 1605 1606

		return;
	}

	/* Validate handle. */
1607 1608 1609
	if (handle < MAX_OUTSTANDING_COMMANDS) {
		sp = req->outstanding_cmds[handle];
		req->outstanding_cmds[handle] = NULL;
L
Linus Torvalds 已提交
1610 1611 1612 1613
	} else
		sp = NULL;

	if (sp == NULL) {
1614 1615
		ql_log(ql_log_warn, vha, 0x3017,
		    "Invalid status handle (0x%x).\n", sts->handle);
L
Linus Torvalds 已提交
1616

1617 1618 1619 1620
		if (IS_QLA82XX(ha))
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1621
		qla2xxx_wake_dpc(vha);
L
Linus Torvalds 已提交
1622 1623 1624 1625
		return;
	}
	cp = sp->cmd;
	if (cp == NULL) {
1626 1627 1628
		ql_log(ql_log_warn, vha, 0x3018,
		    "Command already returned (0x%x/%p).\n",
		    sts->handle, sp);
L
Linus Torvalds 已提交
1629 1630 1631 1632

		return;
	}

1633
  	lscsi_status = scsi_status & STATUS_MASK;
L
Linus Torvalds 已提交
1634

1635
	fcport = sp->fcport;
L
Linus Torvalds 已提交
1636

1637
	ox_id = 0;
1638 1639
	sense_len = par_sense_len = rsp_info_len = resid_len =
	    fw_resid_len = 0;
1640
	if (IS_FWI2_CAPABLE(ha)) {
1641 1642 1643 1644 1645 1646 1647 1648
		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);
1649 1650 1651
		rsp_info = sts24->data;
		sense_data = sts24->data;
		host_to_fcp_swap(sts24->data, sizeof(sts24->data));
1652
		ox_id = le16_to_cpu(sts24->ox_id);
1653
		par_sense_len = sizeof(sts24->data);
1654
	} else {
1655 1656 1657 1658
		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);
1659 1660 1661
		resid_len = le32_to_cpu(sts->residual_length);
		rsp_info = sts->rsp_info;
		sense_data = sts->req_sense_data;
1662
		par_sense_len = sizeof(sts->req_sense_data);
1663 1664
	}

L
Linus Torvalds 已提交
1665 1666
	/* Check for any FCP transport errors. */
	if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
1667
		/* Sense data lies beyond any FCP RESPONSE data. */
1668
		if (IS_FWI2_CAPABLE(ha)) {
1669
			sense_data += rsp_info_len;
1670 1671
			par_sense_len -= rsp_info_len;
		}
1672
		if (rsp_info_len > 3 && rsp_info[3]) {
1673 1674 1675
			ql_log(ql_log_warn, vha, 0x3019,
			    "FCP I/O protocol failure (0x%x/0x%x).\n",
			    rsp_info_len, rsp_info[3]);
L
Linus Torvalds 已提交
1676 1677

			cp->result = DID_BUS_BUSY << 16;
1678
			goto out;
L
Linus Torvalds 已提交
1679 1680 1681
		}
	}

1682 1683 1684 1685 1686
	/* 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 已提交
1687 1688 1689 1690 1691
	/*
	 * Based on Host and scsi status generate status code for Linux
	 */
	switch (comp_status) {
	case CS_COMPLETE:
1692
	case CS_QUEUE_FULL:
L
Linus Torvalds 已提交
1693 1694 1695 1696 1697
		if (scsi_status == 0) {
			cp->result = DID_OK << 16;
			break;
		}
		if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
1698
			resid = resid_len;
1699
			scsi_set_resid(cp, resid);
1700 1701

			if (!lscsi_status &&
1702
			    ((unsigned)(scsi_bufflen(cp) - resid) <
1703
			     cp->underflow)) {
1704 1705
				ql_log(ql_log_warn, vha, 0x301a,
				    "Mid-layer underflow "
1706
				    "detected (0x%x of 0x%x bytes).\n",
1707
				    resid, scsi_bufflen(cp));
1708 1709 1710 1711

				cp->result = DID_ERROR << 16;
				break;
			}
L
Linus Torvalds 已提交
1712 1713 1714
		}
		cp->result = DID_OK << 16 | lscsi_status;

1715
		if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1716 1717
			ql_log(ql_log_warn, vha, 0x301b,
			    "QUEUE FULL detected.\n");
1718 1719
			break;
		}
1720
		logit = 0;
L
Linus Torvalds 已提交
1721 1722 1723
		if (lscsi_status != SS_CHECK_CONDITION)
			break;

1724
		memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
1725 1726 1727
		if (!(scsi_status & SS_SENSE_LEN_VALID))
			break;

1728 1729
		qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
		    rsp);
L
Linus Torvalds 已提交
1730 1731 1732
		break;

	case CS_DATA_UNDERRUN:
1733
		/* Use F/W calculated residual length. */
1734 1735 1736 1737
		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) {
1738 1739 1740 1741
				ql_log(ql_log_warn, vha, 0x301d,
				    "Dropped frame(s) detected "
				    "(0x%x of 0x%x bytes).\n",
				    resid, scsi_bufflen(cp));
1742 1743

				cp->result = DID_ERROR << 16 | lscsi_status;
1744
				goto check_scsi_status;
1745
			}
1746

1747 1748 1749
			if (!lscsi_status &&
			    ((unsigned)(scsi_bufflen(cp) - resid) <
			    cp->underflow)) {
1750 1751
				ql_log(ql_log_warn, vha, 0x301e,
				    "Mid-layer underflow "
1752
				    "detected (0x%x of 0x%x bytes).\n",
1753
				    resid, scsi_bufflen(cp));
1754

1755 1756 1757
				cp->result = DID_ERROR << 16;
				break;
			}
1758
		} else {
1759 1760 1761
			ql_log(ql_log_warn, vha, 0x301f,
			    "Dropped frame(s) detected (0x%x "
			    "of 0x%x bytes).\n", resid, scsi_bufflen(cp));
1762

1763 1764
			cp->result = DID_ERROR << 16 | lscsi_status;
			goto check_scsi_status;
L
Linus Torvalds 已提交
1765 1766
		}

1767
		cp->result = DID_OK << 16 | lscsi_status;
1768
		logit = 0;
1769

1770
check_scsi_status:
L
Linus Torvalds 已提交
1771
		/*
A
Andrew Vasquez 已提交
1772
		 * Check to see if SCSI Status is non zero. If so report SCSI
L
Linus Torvalds 已提交
1773 1774 1775
		 * Status.
		 */
		if (lscsi_status != 0) {
1776
			if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1777 1778
				ql_log(ql_log_warn, vha, 0x3020,
				    "QUEUE FULL detected.\n");
1779
				logit = 1;
1780 1781
				break;
			}
L
Linus Torvalds 已提交
1782 1783 1784
			if (lscsi_status != SS_CHECK_CONDITION)
				break;

1785
			memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
1786 1787 1788
			if (!(scsi_status & SS_SENSE_LEN_VALID))
				break;

1789 1790
			qla2x00_handle_sense(sp, sense_data, par_sense_len,
			    sense_len, rsp);
L
Linus Torvalds 已提交
1791 1792 1793 1794 1795 1796 1797 1798
		}
		break;

	case CS_PORT_LOGGED_OUT:
	case CS_PORT_CONFIG_CHG:
	case CS_PORT_BUSY:
	case CS_INCOMPLETE:
	case CS_PORT_UNAVAILABLE:
1799
	case CS_TIMEOUT:
1800 1801
	case CS_RESET:

1802 1803 1804 1805 1806 1807
		/*
		 * 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.
		 */
		cp->result = DID_TRANSPORT_DISRUPTED << 16;
1808 1809 1810 1811 1812 1813 1814 1815 1816

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

1817 1818 1819
		ql_dbg(ql_dbg_io, vha, 0x3021,
		    "Port down status: port-state=0x%x.\n",
		    atomic_read(&fcport->state));
1820

1821
		if (atomic_read(&fcport->state) == FCS_ONLINE)
1822
			qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
L
Linus Torvalds 已提交
1823 1824 1825 1826 1827
		break;

	case CS_ABORTED:
		cp->result = DID_RESET << 16;
		break;
1828 1829

	case CS_DIF_ERROR:
1830
		logit = qla2x00_handle_dif_error(sp, sts24);
1831
		break;
L
Linus Torvalds 已提交
1832 1833 1834 1835 1836
	default:
		cp->result = DID_ERROR << 16;
		break;
	}

1837 1838
out:
	if (logit)
1839 1840 1841 1842 1843 1844 1845
		ql_dbg(ql_dbg_io, vha, 0x3022,
		    "FCP command status: 0x%x-0x%x (0x%x) "
		    "oxid=0x%x cdb=%02x%02x%02x len=0x%x "
		    "rsp_info=0x%x resid=0x%x fw_resid=0x%x.\n",
		    comp_status, scsi_status, cp->result, ox_id, cp->cmnd[0],
		    cp->cmnd[1], cp->cmnd[2], scsi_bufflen(cp), rsp_info_len,
		    resid_len, fw_resid_len);
1846

1847
	if (rsp->status_srb == NULL)
1848
		qla2x00_sp_compl(ha, sp);
L
Linus Torvalds 已提交
1849 1850 1851 1852 1853 1854 1855 1856 1857 1858
}

/**
 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 *
 * Extended sense data.
 */
static void
1859
qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
L
Linus Torvalds 已提交
1860 1861
{
	uint8_t		sense_sz = 0;
1862
	struct qla_hw_data *ha = rsp->hw;
1863
	struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
1864
	srb_t		*sp = rsp->status_srb;
L
Linus Torvalds 已提交
1865 1866 1867 1868 1869
	struct scsi_cmnd *cp;

	if (sp != NULL && sp->request_sense_length != 0) {
		cp = sp->cmd;
		if (cp == NULL) {
1870 1871
			ql_log(ql_log_warn, vha, 0x3025,
			    "cmd is NULL: already returned to OS (sp=%p).\n",
A
Andrew Vasquez 已提交
1872
			    sp);
L
Linus Torvalds 已提交
1873

1874
			rsp->status_srb = NULL;
L
Linus Torvalds 已提交
1875 1876 1877 1878 1879 1880 1881 1882 1883 1884
			return;
		}

		if (sp->request_sense_length > sizeof(pkt->data)) {
			sense_sz = sizeof(pkt->data);
		} else {
			sense_sz = sp->request_sense_length;
		}

		/* Move sense data. */
1885
		if (IS_FWI2_CAPABLE(ha))
1886
			host_to_fcp_swap(pkt->data, sizeof(pkt->data));
L
Linus Torvalds 已提交
1887
		memcpy(sp->request_sense_ptr, pkt->data, sense_sz);
1888 1889
		ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302c,
			sp->request_sense_ptr, sense_sz);
L
Linus Torvalds 已提交
1890 1891 1892 1893 1894 1895

		sp->request_sense_ptr += sense_sz;
		sp->request_sense_length -= sense_sz;

		/* Place command on done queue. */
		if (sp->request_sense_length == 0) {
1896
			rsp->status_srb = NULL;
1897
			qla2x00_sp_compl(ha, sp);
L
Linus Torvalds 已提交
1898 1899 1900 1901 1902 1903 1904 1905 1906 1907
		}
	}
}

/**
 * qla2x00_error_entry() - Process an error entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
1908
qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
L
Linus Torvalds 已提交
1909 1910
{
	srb_t *sp;
1911
	struct qla_hw_data *ha = vha->hw;
1912 1913 1914
	uint32_t handle = LSW(pkt->handle);
	uint16_t que = MSW(pkt->handle);
	struct req_que *req = ha->req_q_map[que];
1915

L
Linus Torvalds 已提交
1916
	if (pkt->entry_status & RF_INV_E_ORDER)
1917 1918
		ql_dbg(ql_dbg_async, vha, 0x502a,
		    "Invalid Entry Order.\n");
L
Linus Torvalds 已提交
1919
	else if (pkt->entry_status & RF_INV_E_COUNT)
1920 1921
		ql_dbg(ql_dbg_async, vha, 0x502b,
		    "Invalid Entry Count.\n");
L
Linus Torvalds 已提交
1922
	else if (pkt->entry_status & RF_INV_E_PARAM)
1923 1924
		ql_dbg(ql_dbg_async, vha, 0x502c,
		    "Invalid Entry Parameter.\n");
L
Linus Torvalds 已提交
1925
	else if (pkt->entry_status & RF_INV_E_TYPE)
1926 1927
		ql_dbg(ql_dbg_async, vha, 0x502d,
		    "Invalid Entry Type.\n");
L
Linus Torvalds 已提交
1928
	else if (pkt->entry_status & RF_BUSY)
1929 1930
		ql_dbg(ql_dbg_async, vha, 0x502e,
		    "Busy.\n");
L
Linus Torvalds 已提交
1931
	else
1932 1933
		ql_dbg(ql_dbg_async, vha, 0x502f,
		    "UNKNOWN flag error.\n");
L
Linus Torvalds 已提交
1934 1935

	/* Validate handle. */
1936 1937
	if (handle < MAX_OUTSTANDING_COMMANDS)
		sp = req->outstanding_cmds[handle];
L
Linus Torvalds 已提交
1938 1939 1940 1941 1942
	else
		sp = NULL;

	if (sp) {
		/* Free outstanding command slot. */
1943
		req->outstanding_cmds[handle] = NULL;
1944

L
Linus Torvalds 已提交
1945 1946 1947 1948 1949 1950 1951 1952 1953 1954
		/* Bad payload or header */
		if (pkt->entry_status &
		    (RF_INV_E_ORDER | RF_INV_E_COUNT |
		     RF_INV_E_PARAM | RF_INV_E_TYPE)) {
			sp->cmd->result = DID_ERROR << 16;
		} else if (pkt->entry_status & RF_BUSY) {
			sp->cmd->result = DID_BUS_BUSY << 16;
		} else {
			sp->cmd->result = DID_ERROR << 16;
		}
1955
		qla2x00_sp_compl(ha, sp);
L
Linus Torvalds 已提交
1956

1957
	} else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type ==
1958 1959
		COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7
		|| pkt->entry_type == COMMAND_TYPE_6) {
1960 1961
		ql_log(ql_log_warn, vha, 0x5030,
		    "Error entry - invalid handle.\n");
L
Linus Torvalds 已提交
1962

1963 1964 1965 1966
		if (IS_QLA82XX(ha))
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1967
		qla2xxx_wake_dpc(vha);
L
Linus Torvalds 已提交
1968 1969 1970
	}
}

1971 1972 1973 1974 1975 1976
/**
 * qla24xx_mbx_completion() - Process mailbox command completions.
 * @ha: SCSI driver HA context
 * @mb0: Mailbox0 register
 */
static void
1977
qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
1978 1979 1980
{
	uint16_t	cnt;
	uint16_t __iomem *wptr;
1981
	struct qla_hw_data *ha = vha->hw;
1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

	/* Load return mailbox registers. */
	ha->flags.mbox_int = 1;
	ha->mailbox_out[0] = mb0;
	wptr = (uint16_t __iomem *)&reg->mailbox1;

	for (cnt = 1; cnt < ha->mbx_count; cnt++) {
		ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
		wptr++;
	}

	if (ha->mcp) {
1995 1996
		ql_dbg(ql_dbg_async, vha, 0x504d,
		    "Got mailbox completion. cmd=%x.\n", ha->mcp->mb[0]);
1997
	} else {
1998 1999
		ql_dbg(ql_dbg_async, vha, 0x504e,
		    "MBX pointer ERROR.\n");
2000 2001 2002 2003 2004 2005 2006
	}
}

/**
 * qla24xx_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
2007 2008
void qla24xx_process_response_queue(struct scsi_qla_host *vha,
	struct rsp_que *rsp)
2009 2010
{
	struct sts_entry_24xx *pkt;
2011
	struct qla_hw_data *ha = vha->hw;
2012

2013
	if (!vha->flags.online)
2014 2015
		return;

2016 2017
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
2018

2019 2020 2021 2022
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
2023
		} else {
2024
			rsp->ring_ptr++;
2025 2026 2027
		}

		if (pkt->entry_status != 0) {
2028 2029
			ql_dbg(ql_dbg_async, vha, 0x5029,
			    "Process error entry.\n");
2030

2031
			qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
2032 2033 2034 2035 2036 2037 2038
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

		switch (pkt->entry_type) {
		case STATUS_TYPE:
2039
			qla2x00_status_entry(vha, rsp, pkt);
2040 2041
			break;
		case STATUS_CONT_TYPE:
2042
			qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
2043
			break;
2044
		case VP_RPT_ID_IOCB_TYPE:
2045
			qla24xx_report_id_acquisition(vha,
2046 2047
			    (struct vp_rpt_id_entry_24xx *)pkt);
			break;
2048 2049 2050 2051
		case LOGINOUT_PORT_IOCB_TYPE:
			qla24xx_logio_entry(vha, rsp->req,
			    (struct logio_entry_24xx *)pkt);
			break;
2052 2053 2054 2055
		case TSK_MGMT_IOCB_TYPE:
			qla24xx_tm_iocb_entry(vha, rsp->req,
			    (struct tsk_mgmt_entry *)pkt);
			break;
2056 2057 2058 2059 2060 2061 2062
                case CT_IOCB_TYPE:
			qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
			clear_bit(MBX_INTERRUPT, &vha->hw->mbx_cmd_flags);
			break;
                case ELS_IOCB_TYPE:
			qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
			break;
2063 2064 2065 2066 2067
		case MARKER_TYPE:
			/* Do nothing in this case, this check is to prevent it
			 * from falling into default case
			 */
			break;
2068 2069
		default:
			/* Type Not Supported. */
2070 2071
			ql_dbg(ql_dbg_async, vha, 0x5042,
			    "Received unknown response pkt type %x "
2072
			    "entry status=%x.\n",
2073
			    pkt->entry_type, pkt->entry_status);
2074 2075 2076 2077 2078 2079 2080
			break;
		}
		((response_t *)pkt)->signature = RESPONSE_PROCESSED;
		wmb();
	}

	/* Adjust ring index */
2081 2082 2083 2084 2085
	if (IS_QLA82XX(ha)) {
		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);
2086 2087
}

2088
static void
2089
qla2xxx_check_risc_status(scsi_qla_host_t *vha)
2090 2091 2092
{
	int rval;
	uint32_t cnt;
2093
	struct qla_hw_data *ha = vha->hw;
2094 2095
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

2096
	if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha))
2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127
		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;

	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)
2128 2129
		ql_log(ql_log_info, vha, 0x504c,
		    "Additional code -- 0x55AA.\n");
2130 2131 2132 2133 2134 2135

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

2136 2137 2138 2139 2140 2141 2142 2143 2144 2145
/**
 * qla24xx_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
2146
qla24xx_intr_handler(int irq, void *dev_id)
2147
{
2148 2149
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
2150 2151 2152 2153 2154 2155
	struct device_reg_24xx __iomem *reg;
	int		status;
	unsigned long	iter;
	uint32_t	stat;
	uint32_t	hccr;
	uint16_t	mb[4];
2156
	struct rsp_que *rsp;
2157
	unsigned long	flags;
2158

2159 2160
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2161
		printk(KERN_INFO
2162
		    "%s(): NULL response queue pointer.\n", __func__);
2163 2164 2165
		return IRQ_NONE;
	}

2166
	ha = rsp->hw;
2167 2168 2169
	reg = &ha->iobase->isp24;
	status = 0;

2170 2171 2172
	if (unlikely(pci_channel_offline(ha->pdev)))
		return IRQ_HANDLED;

2173
	spin_lock_irqsave(&ha->hardware_lock, flags);
2174
	vha = pci_get_drvdata(ha->pdev);
2175 2176 2177
	for (iter = 50; iter--; ) {
		stat = RD_REG_DWORD(&reg->host_status);
		if (stat & HSRX_RISC_PAUSED) {
2178
			if (unlikely(pci_channel_offline(ha->pdev)))
2179 2180
				break;

2181 2182
			hccr = RD_REG_DWORD(&reg->hccr);

2183 2184 2185
			ql_log(ql_log_warn, vha, 0x504b,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2186

2187
			qla2xxx_check_risc_status(vha);
2188

2189 2190
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2191 2192 2193 2194 2195 2196 2197 2198 2199
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
		case 0x1:
		case 0x2:
		case 0x10:
		case 0x11:
2200
			qla24xx_mbx_completion(vha, MSW(stat));
2201 2202 2203 2204 2205 2206 2207 2208
			status |= MBX_INTERRUPT;

			break;
		case 0x12:
			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);
2209
			qla2x00_async_event(vha, rsp, mb);
2210 2211
			break;
		case 0x13:
2212
		case 0x14:
2213
			qla24xx_process_response_queue(vha, rsp);
2214 2215
			break;
		default:
2216 2217
			ql_dbg(ql_dbg_async, vha, 0x504f,
			    "Unrecognized interrupt type (%d).\n", stat * 0xff);
2218 2219 2220 2221 2222
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
	}
2223
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2224 2225 2226 2227

	if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
	    (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
		set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
2228
		complete(&ha->mbx_intr_comp);
2229 2230 2231 2232 2233
	}

	return IRQ_HANDLED;
}

2234 2235 2236
static irqreturn_t
qla24xx_msix_rsp_q(int irq, void *dev_id)
{
2237 2238
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2239
	struct device_reg_24xx __iomem *reg;
2240
	struct scsi_qla_host *vha;
2241
	unsigned long flags;
2242

2243 2244 2245
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
		printk(KERN_INFO
2246
		"%s(): NULL response queue pointer.\n", __func__);
2247 2248 2249
		return IRQ_NONE;
	}
	ha = rsp->hw;
2250 2251
	reg = &ha->iobase->isp24;

2252
	spin_lock_irqsave(&ha->hardware_lock, flags);
2253

2254
	vha = pci_get_drvdata(ha->pdev);
2255
	qla24xx_process_response_queue(vha, rsp);
2256
	if (!ha->flags.disable_msix_handshake) {
2257 2258 2259
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
	}
2260
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2261 2262 2263 2264

	return IRQ_HANDLED;
}

2265 2266 2267 2268 2269
static irqreturn_t
qla25xx_msix_rsp_q(int irq, void *dev_id)
{
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2270
	struct device_reg_24xx __iomem *reg;
2271
	unsigned long flags;
2272 2273 2274 2275

	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
		printk(KERN_INFO
2276
			"%s(): NULL response queue pointer.\n", __func__);
2277 2278 2279 2280
		return IRQ_NONE;
	}
	ha = rsp->hw;

2281
	/* Clear the interrupt, if enabled, for this response queue */
2282
	if (!ha->flags.disable_msix_handshake) {
2283
		reg = &ha->iobase->isp24;
2284
		spin_lock_irqsave(&ha->hardware_lock, flags);
2285 2286
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
2287
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
2288
	}
2289 2290 2291 2292 2293
	queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);

	return IRQ_HANDLED;
}

2294 2295 2296
static irqreturn_t
qla24xx_msix_default(int irq, void *dev_id)
{
2297 2298 2299
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2300 2301 2302 2303 2304
	struct device_reg_24xx __iomem *reg;
	int		status;
	uint32_t	stat;
	uint32_t	hccr;
	uint16_t	mb[4];
2305
	unsigned long flags;
2306

2307 2308
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2309 2310
		printk(KERN_INFO
			"%s(): NULL response queue pointer.\n", __func__);
2311 2312 2313
		return IRQ_NONE;
	}
	ha = rsp->hw;
2314 2315 2316
	reg = &ha->iobase->isp24;
	status = 0;

2317
	spin_lock_irqsave(&ha->hardware_lock, flags);
2318
	vha = pci_get_drvdata(ha->pdev);
2319
	do {
2320 2321
		stat = RD_REG_DWORD(&reg->host_status);
		if (stat & HSRX_RISC_PAUSED) {
2322
			if (unlikely(pci_channel_offline(ha->pdev)))
2323 2324
				break;

2325 2326
			hccr = RD_REG_DWORD(&reg->hccr);

2327 2328 2329
			ql_log(ql_log_info, vha, 0x5050,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2330

2331
			qla2xxx_check_risc_status(vha);
2332

2333 2334
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2335 2336 2337 2338 2339 2340 2341 2342 2343
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
		case 0x1:
		case 0x2:
		case 0x10:
		case 0x11:
2344
			qla24xx_mbx_completion(vha, MSW(stat));
2345 2346 2347 2348 2349 2350 2351 2352
			status |= MBX_INTERRUPT;

			break;
		case 0x12:
			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);
2353
			qla2x00_async_event(vha, rsp, mb);
2354 2355
			break;
		case 0x13:
2356
		case 0x14:
2357
			qla24xx_process_response_queue(vha, rsp);
2358 2359
			break;
		default:
2360 2361
			ql_dbg(ql_dbg_async, vha, 0x5051,
			    "Unrecognized interrupt type (%d).\n", stat & 0xff);
2362 2363 2364
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2365
	} while (0);
2366
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2367 2368 2369 2370

	if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
	    (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
		set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
2371
		complete(&ha->mbx_intr_comp);
2372 2373 2374 2375 2376 2377 2378 2379
	}
	return IRQ_HANDLED;
}

/* Interrupt handling helpers. */

struct qla_init_msix_entry {
	const char *name;
2380
	irq_handler_t handler;
2381 2382
};

2383
static struct qla_init_msix_entry msix_entries[3] = {
2384 2385
	{ "qla2xxx (default)", qla24xx_msix_default },
	{ "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
2386
	{ "qla2xxx (multiq)", qla25xx_msix_rsp_q },
2387 2388
};

2389 2390 2391 2392 2393
static struct qla_init_msix_entry qla82xx_msix_entries[2] = {
	{ "qla2xxx (default)", qla82xx_msix_default },
	{ "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
};

2394
static void
2395
qla24xx_disable_msix(struct qla_hw_data *ha)
2396 2397 2398
{
	int i;
	struct qla_msix_entry *qentry;
2399
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2400

2401 2402
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
2403
		if (qentry->have_irq)
2404
			free_irq(qentry->vector, qentry->rsp);
2405 2406
	}
	pci_disable_msix(ha->pdev);
2407 2408 2409
	kfree(ha->msix_entries);
	ha->msix_entries = NULL;
	ha->flags.msix_enabled = 0;
2410 2411
	ql_dbg(ql_dbg_init, vha, 0x0042,
	    "Disabled the MSI.\n");
2412 2413 2414
}

static int
2415
qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
2416
{
2417
#define MIN_MSIX_COUNT	2
2418
	int i, ret;
2419
	struct msix_entry *entries;
2420
	struct qla_msix_entry *qentry;
2421
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2422 2423

	entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
2424
			GFP_KERNEL);
2425 2426 2427
	if (!entries) {
		ql_log(ql_log_warn, vha, 0x00bc,
		    "Failed to allocate memory for msix_entry.\n");
2428
		return -ENOMEM;
2429
	}
2430

2431 2432
	for (i = 0; i < ha->msix_count; i++)
		entries[i].entry = i;
2433

2434
	ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
2435
	if (ret) {
2436 2437 2438
		if (ret < MIN_MSIX_COUNT)
			goto msix_failed;

2439 2440 2441 2442
		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);
2443 2444 2445
		ha->msix_count = ret;
		ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
		if (ret) {
2446
msix_failed:
2447 2448 2449 2450
			ql_log(ql_log_fatal, vha, 0x00c7,
			    "MSI-X: Failed to enable support, "
			    "giving   up -- %d/%d.\n",
			    ha->msix_count, ret);
2451 2452
			goto msix_out;
		}
2453
		ha->max_rsp_queues = ha->msix_count - 1;
2454 2455 2456 2457
	}
	ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
				ha->msix_count, GFP_KERNEL);
	if (!ha->msix_entries) {
2458 2459
		ql_log(ql_log_fatal, vha, 0x00c8,
		    "Failed to allocate memory for ha->msix_entries.\n");
2460
		ret = -ENOMEM;
2461 2462 2463 2464
		goto msix_out;
	}
	ha->flags.msix_enabled = 1;

2465 2466 2467 2468
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
		qentry->vector = entries[i].vector;
		qentry->entry = entries[i].entry;
2469
		qentry->have_irq = 0;
2470
		qentry->rsp = NULL;
2471 2472
	}

2473 2474 2475
	/* Enable MSI-X vectors for the base queue */
	for (i = 0; i < 2; i++) {
		qentry = &ha->msix_entries[i];
2476 2477 2478 2479 2480 2481 2482 2483 2484
		if (IS_QLA82XX(ha)) {
			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);
		}
2485
		if (ret) {
2486 2487 2488
			ql_log(ql_log_fatal, vha, 0x00cb,
			    "MSI-X: unable to register handler -- %x/%d.\n",
			    qentry->vector, ret);
2489 2490 2491 2492 2493 2494 2495
			qla24xx_disable_msix(ha);
			ha->mqenable = 0;
			goto msix_out;
		}
		qentry->have_irq = 1;
		qentry->rsp = rsp;
		rsp->msix = qentry;
2496 2497 2498
	}

	/* Enable MSI-X vector for response queue update for queue 0 */
2499
	if (ha->mqiobase &&  (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
2500
		ha->mqenable = 1;
2501 2502 2503 2504 2505 2506
	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);
2507

2508
msix_out:
2509
	kfree(entries);
2510 2511 2512 2513
	return ret;
}

int
2514
qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
2515 2516
{
	int ret;
2517
	device_reg_t __iomem *reg = ha->iobase;
2518
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2519 2520

	/* If possible, enable MSI-X. */
2521
	if (!IS_QLA2432(ha) && !IS_QLA2532(ha) &&
2522
		!IS_QLA8432(ha) && !IS_QLA8XXX_TYPE(ha))
2523 2524 2525 2526 2527 2528
		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)) {
2529 2530
		ql_log(ql_log_warn, vha, 0x0034,
		    "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
2531
			ha->pdev->subsystem_vendor,
2532
			ha->pdev->subsystem_device);
2533 2534
		goto skip_msi;
	}
2535

2536
	if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
2537 2538
		ql_log(ql_log_warn, vha, 0x0035,
		    "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
2539
		    ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
2540 2541 2542
		goto skip_msix;
	}

2543
	ret = qla24xx_enable_msix(ha, rsp);
2544
	if (!ret) {
2545 2546 2547
		ql_dbg(ql_dbg_init, vha, 0x0036,
		    "MSI-X: Enabled (0x%X, 0x%X).\n",
		    ha->chip_revision, ha->fw_attributes);
2548
		goto clear_risc_ints;
2549
	}
2550 2551
	ql_log(ql_log_info, vha, 0x0037,
	    "MSI-X Falling back-to MSI mode -%d.\n", ret);
2552
skip_msix:
2553

2554 2555
	if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
	    !IS_QLA8001(ha))
2556 2557 2558 2559
		goto skip_msi;

	ret = pci_enable_msi(ha->pdev);
	if (!ret) {
2560 2561
		ql_dbg(ql_dbg_init, vha, 0x0038,
		    "MSI: Enabled.\n");
2562
		ha->flags.msi_enabled = 1;
2563
	} else
2564 2565
		ql_log(ql_log_warn, vha, 0x0039,
		    "MSI-X; Falling back-to INTa mode -- %d.\n", ret);
2566 2567
skip_msi:

2568
	ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
2569 2570
	    ha->flags.msi_enabled ? 0 : IRQF_SHARED,
	    QLA2XXX_DRIVER_NAME, rsp);
2571
	if (ret) {
2572
		ql_log(ql_log_warn, vha, 0x003a,
2573 2574
		    "Failed to reserve interrupt %d already in use.\n",
		    ha->pdev->irq);
2575 2576
		goto fail;
	}
2577

2578 2579
clear_risc_ints:

2580 2581 2582 2583
	/*
	 * FIXME: Noted that 8014s were being dropped during NK testing.
	 * Timing deltas during MSI-X/INTa transitions?
	 */
2584
	if (IS_QLA81XX(ha) || IS_QLA82XX(ha))
2585
		goto fail;
2586
	spin_lock_irq(&ha->hardware_lock);
2587 2588 2589 2590 2591 2592 2593
	if (IS_FWI2_CAPABLE(ha)) {
		WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_HOST_INT);
		WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_CLR_RISC_INT);
	} else {
		WRT_REG_WORD(&reg->isp.semaphore, 0);
		WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_RISC_INT);
		WRT_REG_WORD(&reg->isp.hccr, HCCR_CLR_HOST_INT);
2594
	}
2595
	spin_unlock_irq(&ha->hardware_lock);
2596

2597
fail:
2598 2599 2600 2601
	return ret;
}

void
2602
qla2x00_free_irqs(scsi_qla_host_t *vha)
2603
{
2604
	struct qla_hw_data *ha = vha->hw;
2605
	struct rsp_que *rsp = ha->rsp_q_map[0];
2606 2607 2608

	if (ha->flags.msix_enabled)
		qla24xx_disable_msix(ha);
2609
	else if (ha->flags.msi_enabled) {
2610
		free_irq(ha->pdev->irq, rsp);
2611
		pci_disable_msi(ha->pdev);
2612 2613
	} else
		free_irq(ha->pdev->irq, rsp);
2614
}
2615

2616 2617 2618 2619

int qla25xx_request_irq(struct rsp_que *rsp)
{
	struct qla_hw_data *ha = rsp->hw;
2620
	struct qla_init_msix_entry *intr = &msix_entries[2];
2621
	struct qla_msix_entry *msix = rsp->msix;
2622
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2623 2624 2625 2626
	int ret;

	ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
	if (ret) {
2627 2628 2629
		ql_log(ql_log_fatal, vha, 0x00e6,
		    "MSI-X: Unable to register handler -- %x/%d.\n",
		    msix->vector, ret);
2630 2631 2632 2633 2634 2635
		return ret;
	}
	msix->have_irq = 1;
	msix->rsp = rsp;
	return ret;
}