qla_isr.c 67.4 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) {
47 48
		ql_log(ql_log_info, NULL, 0x505d,
		    "%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) {
144 145
		ql_log(ql_log_info, NULL, 0x5058,
		    "%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
{
	uint16_t	cnt;
245
	uint32_t	mboxes;
L
Linus Torvalds 已提交
246
	uint16_t __iomem *wptr;
247
	struct qla_hw_data *ha = vha->hw;
248
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
249

250 251 252 253 254 255 256
	/* Read all mbox registers? */
	mboxes = (1 << ha->mbx_count) - 1;
	if (!ha->mcp)
		ql_dbg(ql_dbg_async, vha, 0x5001, "MBX pointer ERRROR.\n");
	else
		mboxes = ha->mcp->in_mb;

L
Linus Torvalds 已提交
257 258 259
	/* Load return mailbox registers. */
	ha->flags.mbox_int = 1;
	ha->mailbox_out[0] = mb0;
260
	mboxes >>= 1;
L
Linus Torvalds 已提交
261 262 263
	wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 1);

	for (cnt = 1; cnt < ha->mbx_count; cnt++) {
A
Andrew Vasquez 已提交
264
		if (IS_QLA2200(ha) && cnt == 8)
L
Linus Torvalds 已提交
265
			wptr = (uint16_t __iomem *)MAILBOX_REG(ha, reg, 8);
266
		if ((cnt == 4 || cnt == 5) && (mboxes & BIT_0))
L
Linus Torvalds 已提交
267
			ha->mailbox_out[cnt] = qla2x00_debounce_register(wptr);
268
		else if (mboxes & BIT_0)
L
Linus Torvalds 已提交
269
			ha->mailbox_out[cnt] = RD_REG_WORD(wptr);
A
Andrew Vasquez 已提交
270

L
Linus Torvalds 已提交
271
		wptr++;
272
		mboxes >>= 1;
L
Linus Torvalds 已提交
273 274 275
	}
}

276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
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);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

444
		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
445 446 447
		break;

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

451
		set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
452 453 454
		break;

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

	case MBA_LIP_OCCURRED:		/* Loop Initialization Procedure */
460
		ql_dbg(ql_dbg_async, vha, 0x5009,
461
		    "LIP occurred (%x).\n", mb[1]);
L
Linus Torvalds 已提交
462

463 464 465 466
		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 已提交
467 468
		}

469 470 471
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
472 473
		}

474 475
		set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
		set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
476

477 478
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LIP, mb[1]);
L
Linus Torvalds 已提交
479 480 481 482 483
		break;

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

494
		ql_dbg(ql_dbg_async, vha, 0x500a,
495
		    "LOOP UP detected (%s Gbps).\n", link_speed);
L
Linus Torvalds 已提交
496

497 498
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
L
Linus Torvalds 已提交
499 500 501
		break;

	case MBA_LOOP_DOWN:		/* Loop Down Event */
502 503
		mbx = (IS_QLA81XX(ha) || IS_QLA8031(ha))
			? RD_REG_WORD(&reg24->mailbox4) : 0;
504
		mbx = IS_QLA82XX(ha) ? RD_REG_WORD(&reg82->mailbox_out[4]) : mbx;
505
		ql_dbg(ql_dbg_async, vha, 0x500b,
506 507
		    "LOOP DOWN detected (%x %x %x %x).\n",
		    mb[1], mb[2], mb[3], mbx);
L
Linus Torvalds 已提交
508

509 510 511 512 513
		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 已提交
514 515
		}

516 517 518
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
519 520
		}

521
		vha->flags.management_server_logged_in = 0;
522
		ha->link_data_rate = PORT_SPEED_UNKNOWN;
523
		qla2x00_post_aen_work(vha, FCH_EVT_LINKDOWN, 0);
L
Linus Torvalds 已提交
524 525 526
		break;

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

530 531 532 533
		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 已提交
534 535
		}

536 537 538
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
539 540
		}

541
		set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
542 543

		ha->operating_mode = LOOP;
544 545
		vha->flags.management_server_logged_in = 0;
		qla2x00_post_aen_work(vha, FCH_EVT_LIPRESET, mb[1]);
L
Linus Torvalds 已提交
546 547
		break;

548
	/* case MBA_DCBX_COMPLETE: */
L
Linus Torvalds 已提交
549 550 551 552
	case MBA_POINT_TO_POINT:	/* Point-to-Point */
		if (IS_QLA2100(ha))
			break;

553
		if (IS_QLA81XX(ha) || IS_QLA82XX(ha) || IS_QLA8031(ha)) {
554 555 556
			ql_dbg(ql_dbg_async, vha, 0x500d,
			    "DCBX Completed -- %04x %04x %04x.\n",
			    mb[1], mb[2], mb[3]);
557 558 559 560
			if (ha->notify_dcbx_comp)
				complete(&ha->dcbx_comp);

		} else
561 562
			ql_dbg(ql_dbg_async, vha, 0x500e,
			    "Asynchronous P2P MODE received.\n");
L
Linus Torvalds 已提交
563 564 565 566 567

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

576 577 578
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
579 580
		}

581 582 583 584 585
		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);
586 587

		ha->flags.gpsc_supported = 1;
588
		vha->flags.management_server_logged_in = 0;
L
Linus Torvalds 已提交
589 590 591 592 593 594
		break;

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

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

598 599 600 601
		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 已提交
602
				    LOOP_DOWN_TIME);
603
			qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
604 605
		}

606 607 608
		if (vha->vp_idx) {
			atomic_set(&vha->vp_state, VP_FAILED);
			fc_vport_set_state(vha->fc_vport, FC_VPORT_FAILED);
609 610
		}

611 612
		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
L
Linus Torvalds 已提交
613 614 615
		break;

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

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

			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);
654
				qla2x00_mark_all_devices_lost(vha, 1);
655 656 657 658 659 660 661
			}

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

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

676 677 678
		ql_dbg(ql_dbg_async, vha, 0x5012,
		    "Port database changed %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
L
Linus Torvalds 已提交
679 680 681 682

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

685
		qla2x00_mark_all_devices_lost(vha, 1);
L
Linus Torvalds 已提交
686

687 688
		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
L
Linus Torvalds 已提交
689 690 691
		break;

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

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

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

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

716 717
		atomic_set(&vha->loop_down_timer, 0);
		vha->flags.management_server_logged_in = 0;
L
Linus Torvalds 已提交
718

719 720 721
		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 已提交
722 723 724 725
		break;

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

729
		if (IS_FWI2_CAPABLE(ha))
730
			qla24xx_process_response_queue(vha, rsp);
731
		else
732
			qla2x00_process_response_queue(rsp);
L
Linus Torvalds 已提交
733
		break;
734 735

	case MBA_DISCARD_RND_FRAME:
736 737 738
		ql_dbg(ql_dbg_async, vha, 0x5016,
		    "Discard RND Frame -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
739
		break;
740 741

	case MBA_TRACE_NOTIFICATION:
742 743
		ql_dbg(ql_dbg_async, vha, 0x5017,
		    "Trace Notification -- %04x %04x.\n", mb[1], mb[2]);
744
		break;
745 746

	case MBA_ISP84XX_ALERT:
747 748 749
		ql_dbg(ql_dbg_async, vha, 0x5018,
		    "ISP84XX Alert Notification -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
750 751 752 753

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

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

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

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

831 832 833 834
		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 已提交
835 836 837
		return;
	}

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

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

848 849 850 851
		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 已提交
852 853 854
	}
}

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

886
	req->outstanding_cmds[index] = NULL;
887

888 889 890 891 892 893 894 895 896 897 898 899
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;
900
	struct srb_iocb *lio;
901
	uint16_t *data;
902
	uint16_t status;
903 904 905 906 907

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

908 909
	lio = &sp->u.iocb_cmd;
	type = sp->name;
910
	fcport = sp->fcport;
911
	data = lio->u.logio.data;
912

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

926
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5029,
927
		    (uint8_t *)mbx, sizeof(*mbx));
928

929
		goto logio_done;
930 931
	}

932
	status = le16_to_cpu(mbx->status);
933
	if (status == 0x30 && sp->type == SRB_LOGIN_CMD &&
934 935 936
	    le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
		status = 0;
	if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
937
		ql_dbg(ql_dbg_async, vha, 0x5045,
938 939 940 941
		    "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));
942 943

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

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

966
	ql_log(ql_log_warn, vha, 0x5046,
967 968 969 970
	    "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),
971
	    le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
972
	    le16_to_cpu(mbx->mb7));
973

974
logio_done:
975
	sp->done(vha, sp, 0);
976 977
}

978 979 980 981 982 983 984 985 986
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;
987
	int res;
988 989 990 991 992

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

993
	bsg_job = sp->u.bsg_job;
994

995
	type = "ct pass-through";
996 997 998 999 1000 1001 1002 1003 1004 1005 1006

	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) {
1007
			res = DID_OK << 16;
1008 1009 1010
			bsg_job->reply->reply_payload_rcv_len =
			    le16_to_cpu(((sts_entry_t *)pkt)->rsp_info_len);

1011 1012
			ql_log(ql_log_warn, vha, 0x5048,
			    "CT pass-through-%s error "
1013
			    "comp_status-status=0x%x total_byte = 0x%x.\n",
1014 1015
			    type, comp_status,
			    bsg_job->reply->reply_payload_rcv_len);
1016
		} else {
1017 1018 1019
			ql_log(ql_log_warn, vha, 0x5049,
			    "CT pass-through-%s error "
			    "comp_status-status=0x%x.\n", type, comp_status);
1020
			res = DID_ERROR << 16;
1021 1022
			bsg_job->reply->reply_payload_rcv_len = 0;
		}
1023
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5035,
1024
		    (uint8_t *)pkt, sizeof(*pkt));
1025
	} else {
1026
		res = DID_OK << 16;
1027 1028 1029 1030 1031
		bsg_job->reply->reply_payload_rcv_len =
		    bsg_job->reply_payload.payload_len;
		bsg_job->reply_len = 0;
	}

1032
	sp->done(vha, sp, res);
1033 1034
}

1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
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;
1046
	int res;
1047 1048 1049 1050

	sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
	if (!sp)
		return;
1051
	bsg_job = sp->u.bsg_job;
1052 1053

	type = NULL;
1054
	switch (sp->type) {
1055 1056 1057 1058 1059 1060 1061 1062
	case SRB_ELS_CMD_RPT:
	case SRB_ELS_CMD_HST:
		type = "els";
		break;
	case SRB_CT_CMD:
		type = "ct pass-through";
		break;
	default:
1063
		ql_dbg(ql_dbg_user, vha, 0x503e,
1064
		    "Unrecognized SRB: (%p) type=%d.\n", sp, sp->type);
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
		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) {
1080
			res = DID_OK << 16;
1081
			bsg_job->reply->reply_payload_rcv_len =
1082
			    le16_to_cpu(((struct els_sts_entry_24xx *)pkt)->total_byte_count);
1083

1084
			ql_dbg(ql_dbg_user, vha, 0x503f,
1085
			    "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
1086
			    "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
1087
			    type, sp->handle, comp_status, fw_status[1], fw_status[2],
1088 1089
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				pkt)->total_byte_count));
1090 1091 1092 1093
			fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
			memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
		}
		else {
1094
			ql_dbg(ql_dbg_user, vha, 0x5040,
1095
			    "ELS-CT pass-through-%s error hdl=%x comp_status-status=0x%x "
1096
			    "error subcode 1=0x%x error subcode 2=0x%x.\n",
1097
			    type, sp->handle, comp_status,
1098 1099 1100 1101
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				pkt)->error_subcode_1),
			    le16_to_cpu(((struct els_sts_entry_24xx *)
				    pkt)->error_subcode_2));
1102
			res = DID_ERROR << 16;
1103 1104 1105 1106
			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));
		}
1107
		ql_dump_buffer(ql_dbg_user + ql_dbg_buffer, vha, 0x5056,
1108
				(uint8_t *)pkt, sizeof(*pkt));
1109 1110
	}
	else {
1111
		res =  DID_OK << 16;
1112 1113 1114 1115
		bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
		bsg_job->reply_len = 0;
	}

1116
	sp->done(vha, sp, res);
1117 1118
}

1119 1120 1121 1122 1123 1124 1125 1126
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;
1127
	struct srb_iocb *lio;
1128
	uint16_t *data;
1129 1130 1131 1132 1133 1134
	uint32_t iop[2];

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

1135 1136
	lio = &sp->u.iocb_cmd;
	type = sp->name;
1137
	fcport = sp->fcport;
1138
	data = lio->u.logio.data;
1139

1140
	data[0] = MBS_COMMAND_ERROR;
1141
	data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
1142
		QLA_LOGIO_LOGIN_RETRIED : 0;
1143
	if (logio->entry_status) {
1144
		ql_log(ql_log_warn, vha, 0x5034,
1145
		    "Async-%s error entry - hdl=%x"
1146
		    "portid=%02x%02x%02x entry-status=%x.\n",
1147 1148 1149 1150
		    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,
1151
		    (uint8_t *)logio, sizeof(*logio));
1152

1153
		goto logio_done;
1154 1155 1156
	}

	if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
1157
		ql_dbg(ql_dbg_async, vha, 0x5036,
1158 1159 1160
		    "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,
1161
		    le32_to_cpu(logio->io_parameter[0]));
1162 1163

		data[0] = MBS_COMMAND_COMPLETE;
1164
		if (sp->type != SRB_LOGIN_CMD)
1165
			goto logio_done;
1166 1167 1168 1169 1170

		iop[0] = le32_to_cpu(logio->io_parameter[0]);
		if (iop[0] & BIT_4) {
			fcport->port_type = FCT_TARGET;
			if (iop[0] & BIT_8)
1171
				fcport->flags |= FCF_FCP2_DEVICE;
1172
		} else if (iop[0] & BIT_5)
1173
			fcport->port_type = FCT_INITIATOR;
1174

1175 1176 1177 1178 1179
		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;

1180
		goto logio_done;
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
	}

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

1198
	ql_dbg(ql_dbg_async, vha, 0x5037,
1199 1200
	    "Async-%s failed - hdl=%x portid=%02x%02x%02x comp=%x "
	    "iop0=%x iop1=%x.\n", type, sp->handle, fcport->d_id.b.domain,
1201
	    fcport->d_id.b.area, fcport->d_id.b.al_pa,
1202 1203
	    le16_to_cpu(logio->comp_status),
	    le32_to_cpu(logio->io_parameter[0]),
1204
	    le32_to_cpu(logio->io_parameter[1]));
1205

1206
logio_done:
1207
	sp->done(vha, sp, 0);
1208 1209
}

1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
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;

1226 1227
	iocb = &sp->u.iocb_cmd;
	type = sp->name;
1228 1229 1230
	fcport = sp->fcport;

	if (sts->entry_status) {
1231
		ql_log(ql_log_warn, vha, 0x5038,
1232 1233
		    "Async-%s error - hdl=%x entry-status(%x).\n",
		    type, sp->handle, sts->entry_status);
1234
	} else if (sts->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1235
		ql_log(ql_log_warn, vha, 0x5039,
1236 1237
		    "Async-%s error - hdl=%x completion status(%x).\n",
		    type, sp->handle, sts->comp_status);
1238 1239
	} else if (!(le16_to_cpu(sts->scsi_status) &
	    SS_RESPONSE_INFO_LEN_VALID)) {
1240
		ql_log(ql_log_warn, vha, 0x503a,
1241 1242
		    "Async-%s error - hdl=%x no response info(%x).\n",
		    type, sp->handle, sts->scsi_status);
1243
	} else if (le32_to_cpu(sts->rsp_data_len) < 4) {
1244
		ql_log(ql_log_warn, vha, 0x503b,
1245 1246
		    "Async-%s error - hdl=%x not enough response(%d).\n",
		    type, sp->handle, sts->rsp_data_len);
1247
	} else if (sts->data[3]) {
1248
		ql_log(ql_log_warn, vha, 0x503c,
1249 1250
		    "Async-%s error - hdl=%x response(%x).\n",
		    type, sp->handle, sts->data[3]);
1251 1252 1253 1254 1255 1256
	} else {
		error = 0;
	}

	if (error) {
		iocb->u.tmf.data = error;
1257 1258
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5055,
		    (uint8_t *)sts, sizeof(*sts));
1259 1260
	}

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

L
Linus Torvalds 已提交
1264 1265 1266 1267 1268
/**
 * qla2x00_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
void
1269
qla2x00_process_response_queue(struct rsp_que *rsp)
L
Linus Torvalds 已提交
1270
{
1271 1272
	struct scsi_qla_host *vha;
	struct qla_hw_data *ha = rsp->hw;
1273
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
1274 1275 1276
	sts_entry_t	*pkt;
	uint16_t        handle_cnt;
	uint16_t        cnt;
1277

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

1280
	if (!vha->flags.online)
L
Linus Torvalds 已提交
1281 1282
		return;

1283 1284
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (sts_entry_t *)rsp->ring_ptr;
L
Linus Torvalds 已提交
1285

1286 1287 1288 1289
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
L
Linus Torvalds 已提交
1290
		} else {
1291
			rsp->ring_ptr++;
L
Linus Torvalds 已提交
1292 1293 1294
		}

		if (pkt->entry_status != 0) {
1295
			qla2x00_error_entry(vha, rsp, pkt);
L
Linus Torvalds 已提交
1296 1297 1298 1299 1300 1301 1302
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

		switch (pkt->entry_type) {
		case STATUS_TYPE:
1303
			qla2x00_status_entry(vha, rsp, pkt);
L
Linus Torvalds 已提交
1304 1305 1306 1307
			break;
		case STATUS_TYPE_21:
			handle_cnt = ((sts21_entry_t *)pkt)->handle_count;
			for (cnt = 0; cnt < handle_cnt; cnt++) {
1308
				qla2x00_process_completed_request(vha, rsp->req,
L
Linus Torvalds 已提交
1309 1310 1311 1312 1313 1314
				    ((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++) {
1315
				qla2x00_process_completed_request(vha, rsp->req,
L
Linus Torvalds 已提交
1316 1317 1318 1319
				    ((sts22_entry_t *)pkt)->handle[cnt]);
			}
			break;
		case STATUS_CONT_TYPE:
1320
			qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
L
Linus Torvalds 已提交
1321
			break;
1322 1323 1324
		case MBX_IOCB_TYPE:
			qla2x00_mbx_iocb_entry(vha, rsp->req,
			    (struct mbx_entry *)pkt);
1325
			break;
1326 1327 1328
		case CT_IOCB_TYPE:
			qla2x00_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
			break;
L
Linus Torvalds 已提交
1329 1330
		default:
			/* Type Not Supported. */
1331 1332
			ql_log(ql_log_warn, vha, 0x504a,
			    "Received unknown response pkt type %x "
L
Linus Torvalds 已提交
1333
			    "entry status=%x.\n",
1334
			    pkt->entry_type, pkt->entry_status);
L
Linus Torvalds 已提交
1335 1336 1337 1338 1339 1340 1341
			break;
		}
		((response_t *)pkt)->signature = RESPONSE_PROCESSED;
		wmb();
	}

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

1345
static inline void
1346
qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
1347
		     uint32_t sense_len, struct rsp_que *rsp, int res)
1348
{
1349
	struct scsi_qla_host *vha = sp->fcport->vha;
1350 1351
	struct scsi_cmnd *cp = GET_CMD_SP(sp);
	uint32_t track_sense_len;
1352 1353 1354 1355

	if (sense_len >= SCSI_SENSE_BUFFERSIZE)
		sense_len = SCSI_SENSE_BUFFERSIZE;

1356 1357 1358 1359 1360
	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)
1361
		sense_len = par_sense_len;
1362 1363 1364

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

1365 1366 1367 1368 1369
	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) {
1370
		rsp->status_srb = sp;
1371 1372
		cp->result = res;
	}
1373

1374 1375 1376 1377 1378
	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);
1379 1380
		ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
		    cp->sense_buffer, sense_len);
1381
	}
1382 1383
}

1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
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.
 */
1396
static inline int
1397 1398
qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
{
1399
	struct scsi_qla_host *vha = sp->fcport->vha;
1400
	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1401 1402
	uint8_t		*ap = &sts24->data[12];
	uint8_t		*ep = &sts24->data[20];
1403 1404 1405 1406
	uint32_t	e_ref_tag, a_ref_tag;
	uint16_t	e_app_tag, a_app_tag;
	uint16_t	e_guard, a_guard;

1407 1408 1409 1410 1411 1412 1413 1414 1415 1416
	/*
	 * 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));
1417

1418 1419
	ql_dbg(ql_dbg_io, vha, 0x3023,
	    "iocb(s) %p Returned STATUS.\n", sts24);
1420

1421 1422
	ql_dbg(ql_dbg_io, vha, 0x3024,
	    "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
1423
	    " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
1424
	    " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
1425
	    cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
1426
	    a_app_tag, e_app_tag, a_guard, e_guard);
1427

1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
	/*
	 * 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) {
1468
				ql_log(ql_log_warn, vha, 0x302f,
1469 1470
				    "unexpected tag values tag:lba=%x:%llx)\n",
				    e_ref_tag, (unsigned long long)lba_s);
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
				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;
	}

1485 1486 1487 1488 1489 1490 1491
	/* 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;
1492
		return 1;
1493 1494
	}

1495 1496
	/* check ref tag */
	if (e_ref_tag != a_ref_tag) {
1497
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1498
		    0x10, 0x3);
1499 1500 1501
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1502
		return 1;
1503 1504
	}

1505 1506
	/* check appl tag */
	if (e_app_tag != a_app_tag) {
1507
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1508
		    0x10, 0x2);
1509 1510 1511
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1512
		return 1;
1513
	}
1514

1515
	return 1;
1516 1517
}

L
Linus Torvalds 已提交
1518 1519 1520 1521 1522 1523
/**
 * qla2x00_status_entry() - Process a Status IOCB entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
1524
qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
L
Linus Torvalds 已提交
1525 1526 1527 1528
{
	srb_t		*sp;
	fc_port_t	*fcport;
	struct scsi_cmnd *cp;
1529 1530
	sts_entry_t *sts;
	struct sts_entry_24xx *sts24;
L
Linus Torvalds 已提交
1531 1532
	uint16_t	comp_status;
	uint16_t	scsi_status;
1533
	uint16_t	ox_id;
L
Linus Torvalds 已提交
1534 1535
	uint8_t		lscsi_status;
	int32_t		resid;
1536 1537
	uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
	    fw_resid_len;
1538
	uint8_t		*rsp_info, *sense_data;
1539
	struct qla_hw_data *ha = vha->hw;
1540 1541 1542
	uint32_t handle;
	uint16_t que;
	struct req_que *req;
1543
	int logit = 1;
1544
	int res = 0;
1545 1546 1547

	sts = (sts_entry_t *) pkt;
	sts24 = (struct sts_entry_24xx *) pkt;
1548
	if (IS_FWI2_CAPABLE(ha)) {
1549 1550 1551 1552 1553 1554
		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;
	}
1555 1556 1557
	handle = (uint32_t) LSW(sts->handle);
	que = MSW(sts->handle);
	req = ha->req_q_map[que];
1558

L
Linus Torvalds 已提交
1559
	/* Fast path completion. */
1560
	if (comp_status == CS_COMPLETE && scsi_status == 0) {
1561
		qla2x00_process_completed_request(vha, req, handle);
L
Linus Torvalds 已提交
1562 1563 1564 1565 1566

		return;
	}

	/* Validate handle. */
1567 1568 1569
	if (handle < MAX_OUTSTANDING_COMMANDS) {
		sp = req->outstanding_cmds[handle];
		req->outstanding_cmds[handle] = NULL;
L
Linus Torvalds 已提交
1570 1571 1572 1573
	} else
		sp = NULL;

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

1577 1578 1579 1580
		if (IS_QLA82XX(ha))
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1581
		qla2xxx_wake_dpc(vha);
L
Linus Torvalds 已提交
1582 1583
		return;
	}
1584
	cp = GET_CMD_SP(sp);
L
Linus Torvalds 已提交
1585
	if (cp == NULL) {
1586
		ql_dbg(ql_dbg_io, vha, 0x3018,
1587 1588
		    "Command already returned (0x%x/%p).\n",
		    sts->handle, sp);
L
Linus Torvalds 已提交
1589 1590 1591 1592

		return;
	}

1593
  	lscsi_status = scsi_status & STATUS_MASK;
L
Linus Torvalds 已提交
1594

1595
	fcport = sp->fcport;
L
Linus Torvalds 已提交
1596

1597
	ox_id = 0;
1598 1599
	sense_len = par_sense_len = rsp_info_len = resid_len =
	    fw_resid_len = 0;
1600
	if (IS_FWI2_CAPABLE(ha)) {
1601 1602 1603 1604 1605 1606 1607 1608
		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);
1609 1610 1611
		rsp_info = sts24->data;
		sense_data = sts24->data;
		host_to_fcp_swap(sts24->data, sizeof(sts24->data));
1612
		ox_id = le16_to_cpu(sts24->ox_id);
1613
		par_sense_len = sizeof(sts24->data);
1614
	} else {
1615 1616 1617 1618
		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);
1619 1620 1621
		resid_len = le32_to_cpu(sts->residual_length);
		rsp_info = sts->rsp_info;
		sense_data = sts->req_sense_data;
1622
		par_sense_len = sizeof(sts->req_sense_data);
1623 1624
	}

L
Linus Torvalds 已提交
1625 1626
	/* Check for any FCP transport errors. */
	if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
1627
		/* Sense data lies beyond any FCP RESPONSE data. */
1628
		if (IS_FWI2_CAPABLE(ha)) {
1629
			sense_data += rsp_info_len;
1630 1631
			par_sense_len -= rsp_info_len;
		}
1632
		if (rsp_info_len > 3 && rsp_info[3]) {
1633
			ql_dbg(ql_dbg_io, vha, 0x3019,
1634 1635
			    "FCP I/O protocol failure (0x%x/0x%x).\n",
			    rsp_info_len, rsp_info[3]);
L
Linus Torvalds 已提交
1636

1637
			res = DID_BUS_BUSY << 16;
1638
			goto out;
L
Linus Torvalds 已提交
1639 1640 1641
		}
	}

1642 1643 1644 1645 1646
	/* 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 已提交
1647 1648 1649 1650 1651
	/*
	 * Based on Host and scsi status generate status code for Linux
	 */
	switch (comp_status) {
	case CS_COMPLETE:
1652
	case CS_QUEUE_FULL:
L
Linus Torvalds 已提交
1653
		if (scsi_status == 0) {
1654
			res = DID_OK << 16;
L
Linus Torvalds 已提交
1655 1656 1657
			break;
		}
		if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
1658
			resid = resid_len;
1659
			scsi_set_resid(cp, resid);
1660 1661

			if (!lscsi_status &&
1662
			    ((unsigned)(scsi_bufflen(cp) - resid) <
1663
			     cp->underflow)) {
1664
				ql_dbg(ql_dbg_io, vha, 0x301a,
1665
				    "Mid-layer underflow "
1666
				    "detected (0x%x of 0x%x bytes).\n",
1667
				    resid, scsi_bufflen(cp));
1668

1669
				res = DID_ERROR << 16;
1670 1671
				break;
			}
L
Linus Torvalds 已提交
1672
		}
1673
		res = DID_OK << 16 | lscsi_status;
L
Linus Torvalds 已提交
1674

1675
		if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1676
			ql_dbg(ql_dbg_io, vha, 0x301b,
1677
			    "QUEUE FULL detected.\n");
1678 1679
			break;
		}
1680
		logit = 0;
L
Linus Torvalds 已提交
1681 1682 1683
		if (lscsi_status != SS_CHECK_CONDITION)
			break;

1684
		memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
1685 1686 1687
		if (!(scsi_status & SS_SENSE_LEN_VALID))
			break;

1688
		qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
1689
		    rsp, res);
L
Linus Torvalds 已提交
1690 1691 1692
		break;

	case CS_DATA_UNDERRUN:
1693
		/* Use F/W calculated residual length. */
1694 1695 1696 1697
		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) {
1698
				ql_dbg(ql_dbg_io, vha, 0x301d,
1699 1700 1701
				    "Dropped frame(s) detected "
				    "(0x%x of 0x%x bytes).\n",
				    resid, scsi_bufflen(cp));
1702

1703
				res = DID_ERROR << 16 | lscsi_status;
1704
				goto check_scsi_status;
1705
			}
1706

1707 1708 1709
			if (!lscsi_status &&
			    ((unsigned)(scsi_bufflen(cp) - resid) <
			    cp->underflow)) {
1710
				ql_dbg(ql_dbg_io, vha, 0x301e,
1711
				    "Mid-layer underflow "
1712
				    "detected (0x%x of 0x%x bytes).\n",
1713
				    resid, scsi_bufflen(cp));
1714

1715
				res = DID_ERROR << 16;
1716 1717
				break;
			}
1718
		} else {
1719
			ql_dbg(ql_dbg_io, vha, 0x301f,
1720 1721
			    "Dropped frame(s) detected (0x%x "
			    "of 0x%x bytes).\n", resid, scsi_bufflen(cp));
1722

1723
			res = DID_ERROR << 16 | lscsi_status;
1724
			goto check_scsi_status;
L
Linus Torvalds 已提交
1725 1726
		}

1727
		res = DID_OK << 16 | lscsi_status;
1728
		logit = 0;
1729

1730
check_scsi_status:
L
Linus Torvalds 已提交
1731
		/*
A
Andrew Vasquez 已提交
1732
		 * Check to see if SCSI Status is non zero. If so report SCSI
L
Linus Torvalds 已提交
1733 1734 1735
		 * Status.
		 */
		if (lscsi_status != 0) {
1736
			if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1737
				ql_dbg(ql_dbg_io, vha, 0x3020,
1738
				    "QUEUE FULL detected.\n");
1739
				logit = 1;
1740 1741
				break;
			}
L
Linus Torvalds 已提交
1742 1743 1744
			if (lscsi_status != SS_CHECK_CONDITION)
				break;

1745
			memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
1746 1747 1748
			if (!(scsi_status & SS_SENSE_LEN_VALID))
				break;

1749
			qla2x00_handle_sense(sp, sense_data, par_sense_len,
1750
			    sense_len, rsp, res);
L
Linus Torvalds 已提交
1751 1752 1753 1754 1755 1756 1757 1758
		}
		break;

	case CS_PORT_LOGGED_OUT:
	case CS_PORT_CONFIG_CHG:
	case CS_PORT_BUSY:
	case CS_INCOMPLETE:
	case CS_PORT_UNAVAILABLE:
1759
	case CS_TIMEOUT:
1760 1761
	case CS_RESET:

1762 1763 1764 1765 1766
		/*
		 * 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.
		 */
1767
		res = DID_TRANSPORT_DISRUPTED << 16;
1768 1769 1770 1771 1772 1773 1774 1775 1776

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

1777 1778 1779
		ql_dbg(ql_dbg_io, vha, 0x3021,
		    "Port down status: port-state=0x%x.\n",
		    atomic_read(&fcport->state));
1780

1781
		if (atomic_read(&fcport->state) == FCS_ONLINE)
1782
			qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
L
Linus Torvalds 已提交
1783 1784 1785
		break;

	case CS_ABORTED:
1786
		res = DID_RESET << 16;
L
Linus Torvalds 已提交
1787
		break;
1788 1789

	case CS_DIF_ERROR:
1790
		logit = qla2x00_handle_dif_error(sp, sts24);
1791
		break;
L
Linus Torvalds 已提交
1792
	default:
1793
		res = DID_ERROR << 16;
L
Linus Torvalds 已提交
1794 1795 1796
		break;
	}

1797 1798
out:
	if (logit)
1799 1800
		ql_dbg(ql_dbg_io, vha, 0x3022,
		    "FCP command status: 0x%x-0x%x (0x%x) "
1801 1802
		    "nexus=%ld:%d:%d portid=%02x%02x%02x oxid=0x%x "
		    "cdb=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x len=0x%x "
1803
		    "rsp_info=0x%x resid=0x%x fw_resid=0x%x.\n",
1804
		    comp_status, scsi_status, res, vha->host_no,
1805 1806 1807 1808 1809
		    cp->device->id, cp->device->lun, fcport->d_id.b.domain,
		    fcport->d_id.b.area, fcport->d_id.b.al_pa, ox_id,
		    cp->cmnd[0], cp->cmnd[1], cp->cmnd[2], cp->cmnd[3],
		    cp->cmnd[4], cp->cmnd[5], cp->cmnd[6], cp->cmnd[7],
		    cp->cmnd[8], cp->cmnd[9], scsi_bufflen(cp), rsp_info_len,
1810
		    resid_len, fw_resid_len);
1811

1812
	if (rsp->status_srb == NULL)
1813
		sp->done(ha, sp, res);
L
Linus Torvalds 已提交
1814 1815 1816 1817 1818 1819 1820 1821 1822 1823
}

/**
 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 *
 * Extended sense data.
 */
static void
1824
qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
L
Linus Torvalds 已提交
1825
{
1826
	uint8_t	sense_sz = 0;
1827
	struct qla_hw_data *ha = rsp->hw;
1828
	struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
1829
	srb_t *sp = rsp->status_srb;
L
Linus Torvalds 已提交
1830
	struct scsi_cmnd *cp;
1831 1832
	uint32_t sense_len;
	uint8_t *sense_ptr;
L
Linus Torvalds 已提交
1833

1834 1835
	if (!sp || !GET_CMD_SENSE_LEN(sp))
		return;
L
Linus Torvalds 已提交
1836

1837 1838
	sense_len = GET_CMD_SENSE_LEN(sp);
	sense_ptr = GET_CMD_SENSE_PTR(sp);
L
Linus Torvalds 已提交
1839

1840 1841 1842 1843
	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 已提交
1844

1845 1846
		rsp->status_srb = NULL;
		return;
L
Linus Torvalds 已提交
1847 1848
	}

1849 1850 1851 1852
	if (sense_len > sizeof(pkt->data))
		sense_sz = sizeof(pkt->data);
	else
		sense_sz = sense_len;
1853

1854 1855 1856 1857 1858 1859
	/* 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);
1860

1861 1862
	sense_len -= sense_sz;
	sense_ptr += sense_sz;
1863

1864 1865 1866 1867 1868 1869 1870
	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);
1871 1872 1873
	}
}

L
Linus Torvalds 已提交
1874 1875 1876 1877 1878 1879
/**
 * qla2x00_error_entry() - Process an error entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
1880
qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
L
Linus Torvalds 已提交
1881 1882
{
	srb_t *sp;
1883
	struct qla_hw_data *ha = vha->hw;
1884
	const char func[] = "ERROR-IOCB";
1885 1886
	uint16_t que = MSW(pkt->handle);
	struct req_que *req = ha->req_q_map[que];
1887
	int res = DID_ERROR << 16;
1888

1889 1890 1891 1892 1893
	ql_dbg(ql_dbg_async, vha, 0x502a,
	    "type of error status in response: 0x%x\n", pkt->entry_status);

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

1895
	sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
1896 1897 1898
	if (sp)
		sp->done(ha, sp, res);
	else {
1899 1900
		ql_log(ql_log_warn, vha, 0x5030,
		    "Error entry - invalid handle.\n");
L
Linus Torvalds 已提交
1901

1902 1903 1904 1905
		if (IS_QLA82XX(ha))
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1906
		qla2xxx_wake_dpc(vha);
L
Linus Torvalds 已提交
1907 1908 1909
	}
}

1910 1911 1912 1913 1914 1915
/**
 * qla24xx_mbx_completion() - Process mailbox command completions.
 * @ha: SCSI driver HA context
 * @mb0: Mailbox0 register
 */
static void
1916
qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
1917 1918
{
	uint16_t	cnt;
1919
	uint32_t	mboxes;
1920
	uint16_t __iomem *wptr;
1921
	struct qla_hw_data *ha = vha->hw;
1922 1923
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

1924 1925 1926 1927 1928 1929 1930
	/* Read all mbox registers? */
	mboxes = (1 << ha->mbx_count) - 1;
	if (!ha->mcp)
		ql_dbg(ql_dbg_async, vha, 0x504e, "MBX pointer ERRROR.\n");
	else
		mboxes = ha->mcp->in_mb;

1931 1932 1933
	/* Load return mailbox registers. */
	ha->flags.mbox_int = 1;
	ha->mailbox_out[0] = mb0;
1934
	mboxes >>= 1;
1935 1936 1937
	wptr = (uint16_t __iomem *)&reg->mailbox1;

	for (cnt = 1; cnt < ha->mbx_count; cnt++) {
1938 1939 1940 1941
		if (mboxes & BIT_0)
			ha->mailbox_out[cnt] = RD_REG_WORD(wptr);

		mboxes >>= 1;
1942 1943 1944 1945 1946 1947 1948 1949
		wptr++;
	}
}

/**
 * qla24xx_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
1950 1951
void qla24xx_process_response_queue(struct scsi_qla_host *vha,
	struct rsp_que *rsp)
1952 1953
{
	struct sts_entry_24xx *pkt;
1954
	struct qla_hw_data *ha = vha->hw;
1955

1956
	if (!vha->flags.online)
1957 1958
		return;

1959 1960
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
1961

1962 1963 1964 1965
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
1966
		} else {
1967
			rsp->ring_ptr++;
1968 1969 1970
		}

		if (pkt->entry_status != 0) {
1971
			qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
1972 1973 1974 1975 1976 1977 1978
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

		switch (pkt->entry_type) {
		case STATUS_TYPE:
1979
			qla2x00_status_entry(vha, rsp, pkt);
1980 1981
			break;
		case STATUS_CONT_TYPE:
1982
			qla2x00_status_cont_entry(rsp, (sts_cont_entry_t *)pkt);
1983
			break;
1984
		case VP_RPT_ID_IOCB_TYPE:
1985
			qla24xx_report_id_acquisition(vha,
1986 1987
			    (struct vp_rpt_id_entry_24xx *)pkt);
			break;
1988 1989 1990 1991
		case LOGINOUT_PORT_IOCB_TYPE:
			qla24xx_logio_entry(vha, rsp->req,
			    (struct logio_entry_24xx *)pkt);
			break;
1992 1993 1994 1995
		case TSK_MGMT_IOCB_TYPE:
			qla24xx_tm_iocb_entry(vha, rsp->req,
			    (struct tsk_mgmt_entry *)pkt);
			break;
1996 1997 1998 1999 2000 2001
                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;
2002 2003 2004 2005 2006
		case MARKER_TYPE:
			/* Do nothing in this case, this check is to prevent it
			 * from falling into default case
			 */
			break;
2007 2008
		default:
			/* Type Not Supported. */
2009 2010
			ql_dbg(ql_dbg_async, vha, 0x5042,
			    "Received unknown response pkt type %x "
2011
			    "entry status=%x.\n",
2012
			    pkt->entry_type, pkt->entry_status);
2013 2014 2015 2016 2017 2018 2019
			break;
		}
		((response_t *)pkt)->signature = RESPONSE_PROCESSED;
		wmb();
	}

	/* Adjust ring index */
2020 2021 2022 2023 2024
	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);
2025 2026
}

2027
static void
2028
qla2xxx_check_risc_status(scsi_qla_host_t *vha)
2029 2030 2031
{
	int rval;
	uint32_t cnt;
2032
	struct qla_hw_data *ha = vha->hw;
2033 2034
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

2035
	if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha))
2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066
		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)
2067 2068
		ql_log(ql_log_info, vha, 0x504c,
		    "Additional code -- 0x55AA.\n");
2069 2070 2071 2072 2073 2074

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

2075
/**
2076
 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP24xx.
2077 2078 2079 2080 2081 2082 2083 2084
 * @irq:
 * @dev_id: SCSI driver HA context
 *
 * Called by system whenever the host adapter generates an interrupt.
 *
 * Returns handled flag.
 */
irqreturn_t
2085
qla24xx_intr_handler(int irq, void *dev_id)
2086
{
2087 2088
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
2089 2090 2091 2092 2093 2094
	struct device_reg_24xx __iomem *reg;
	int		status;
	unsigned long	iter;
	uint32_t	stat;
	uint32_t	hccr;
	uint16_t	mb[4];
2095
	struct rsp_que *rsp;
2096
	unsigned long	flags;
2097

2098 2099
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2100 2101
		ql_log(ql_log_info, NULL, 0x5059,
		    "%s: NULL response queue pointer.\n", __func__);
2102 2103 2104
		return IRQ_NONE;
	}

2105
	ha = rsp->hw;
2106 2107 2108
	reg = &ha->iobase->isp24;
	status = 0;

2109 2110 2111
	if (unlikely(pci_channel_offline(ha->pdev)))
		return IRQ_HANDLED;

2112
	spin_lock_irqsave(&ha->hardware_lock, flags);
2113
	vha = pci_get_drvdata(ha->pdev);
2114 2115 2116
	for (iter = 50; iter--; ) {
		stat = RD_REG_DWORD(&reg->host_status);
		if (stat & HSRX_RISC_PAUSED) {
2117
			if (unlikely(pci_channel_offline(ha->pdev)))
2118 2119
				break;

2120 2121
			hccr = RD_REG_DWORD(&reg->hccr);

2122 2123 2124
			ql_log(ql_log_warn, vha, 0x504b,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2125

2126
			qla2xxx_check_risc_status(vha);
2127

2128 2129
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2130 2131 2132 2133 2134 2135 2136 2137 2138
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
		case 0x1:
		case 0x2:
		case 0x10:
		case 0x11:
2139
			qla24xx_mbx_completion(vha, MSW(stat));
2140 2141 2142 2143 2144 2145 2146 2147
			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);
2148
			qla2x00_async_event(vha, rsp, mb);
2149 2150
			break;
		case 0x13:
2151
		case 0x14:
2152
			qla24xx_process_response_queue(vha, rsp);
2153 2154
			break;
		default:
2155 2156
			ql_dbg(ql_dbg_async, vha, 0x504f,
			    "Unrecognized interrupt type (%d).\n", stat * 0xff);
2157 2158 2159 2160 2161
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
	}
2162
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2163 2164 2165 2166

	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);
2167
		complete(&ha->mbx_intr_comp);
2168 2169 2170 2171 2172
	}

	return IRQ_HANDLED;
}

2173 2174 2175
static irqreturn_t
qla24xx_msix_rsp_q(int irq, void *dev_id)
{
2176 2177
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2178
	struct device_reg_24xx __iomem *reg;
2179
	struct scsi_qla_host *vha;
2180
	unsigned long flags;
2181

2182 2183
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2184 2185
		ql_log(ql_log_info, NULL, 0x505a,
		    "%s: NULL response queue pointer.\n", __func__);
2186 2187 2188
		return IRQ_NONE;
	}
	ha = rsp->hw;
2189 2190
	reg = &ha->iobase->isp24;

2191
	spin_lock_irqsave(&ha->hardware_lock, flags);
2192

2193
	vha = pci_get_drvdata(ha->pdev);
2194
	qla24xx_process_response_queue(vha, rsp);
2195
	if (!ha->flags.disable_msix_handshake) {
2196 2197 2198
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
	}
2199
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2200 2201 2202 2203

	return IRQ_HANDLED;
}

2204 2205 2206 2207 2208
static irqreturn_t
qla25xx_msix_rsp_q(int irq, void *dev_id)
{
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2209
	struct device_reg_24xx __iomem *reg;
2210
	unsigned long flags;
2211 2212 2213

	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2214 2215
		ql_log(ql_log_info, NULL, 0x505b,
		    "%s: NULL response queue pointer.\n", __func__);
2216 2217 2218 2219
		return IRQ_NONE;
	}
	ha = rsp->hw;

2220
	/* Clear the interrupt, if enabled, for this response queue */
2221
	if (!ha->flags.disable_msix_handshake) {
2222
		reg = &ha->iobase->isp24;
2223
		spin_lock_irqsave(&ha->hardware_lock, flags);
2224 2225
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
2226
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
2227
	}
2228 2229 2230 2231 2232
	queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);

	return IRQ_HANDLED;
}

2233 2234 2235
static irqreturn_t
qla24xx_msix_default(int irq, void *dev_id)
{
2236 2237 2238
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2239 2240 2241 2242 2243
	struct device_reg_24xx __iomem *reg;
	int		status;
	uint32_t	stat;
	uint32_t	hccr;
	uint16_t	mb[4];
2244
	unsigned long flags;
2245

2246 2247
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2248 2249
		ql_log(ql_log_info, NULL, 0x505c,
		    "%s: NULL response queue pointer.\n", __func__);
2250 2251 2252
		return IRQ_NONE;
	}
	ha = rsp->hw;
2253 2254 2255
	reg = &ha->iobase->isp24;
	status = 0;

2256
	spin_lock_irqsave(&ha->hardware_lock, flags);
2257
	vha = pci_get_drvdata(ha->pdev);
2258
	do {
2259 2260
		stat = RD_REG_DWORD(&reg->host_status);
		if (stat & HSRX_RISC_PAUSED) {
2261
			if (unlikely(pci_channel_offline(ha->pdev)))
2262 2263
				break;

2264 2265
			hccr = RD_REG_DWORD(&reg->hccr);

2266 2267 2268
			ql_log(ql_log_info, vha, 0x5050,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2269

2270
			qla2xxx_check_risc_status(vha);
2271

2272 2273
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2274 2275 2276 2277 2278 2279 2280 2281 2282
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
		case 0x1:
		case 0x2:
		case 0x10:
		case 0x11:
2283
			qla24xx_mbx_completion(vha, MSW(stat));
2284 2285 2286 2287 2288 2289 2290 2291
			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);
2292
			qla2x00_async_event(vha, rsp, mb);
2293 2294
			break;
		case 0x13:
2295
		case 0x14:
2296
			qla24xx_process_response_queue(vha, rsp);
2297 2298
			break;
		default:
2299 2300
			ql_dbg(ql_dbg_async, vha, 0x5051,
			    "Unrecognized interrupt type (%d).\n", stat & 0xff);
2301 2302 2303
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2304
	} while (0);
2305
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2306 2307 2308 2309

	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);
2310
		complete(&ha->mbx_intr_comp);
2311 2312 2313 2314 2315 2316 2317 2318
	}
	return IRQ_HANDLED;
}

/* Interrupt handling helpers. */

struct qla_init_msix_entry {
	const char *name;
2319
	irq_handler_t handler;
2320 2321
};

2322
static struct qla_init_msix_entry msix_entries[3] = {
2323 2324
	{ "qla2xxx (default)", qla24xx_msix_default },
	{ "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
2325
	{ "qla2xxx (multiq)", qla25xx_msix_rsp_q },
2326 2327
};

2328 2329 2330 2331 2332
static struct qla_init_msix_entry qla82xx_msix_entries[2] = {
	{ "qla2xxx (default)", qla82xx_msix_default },
	{ "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
};

2333
static void
2334
qla24xx_disable_msix(struct qla_hw_data *ha)
2335 2336 2337
{
	int i;
	struct qla_msix_entry *qentry;
2338
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2339

2340 2341
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
2342
		if (qentry->have_irq)
2343
			free_irq(qentry->vector, qentry->rsp);
2344 2345
	}
	pci_disable_msix(ha->pdev);
2346 2347 2348
	kfree(ha->msix_entries);
	ha->msix_entries = NULL;
	ha->flags.msix_enabled = 0;
2349 2350
	ql_dbg(ql_dbg_init, vha, 0x0042,
	    "Disabled the MSI.\n");
2351 2352 2353
}

static int
2354
qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
2355
{
2356
#define MIN_MSIX_COUNT	2
2357
	int i, ret;
2358
	struct msix_entry *entries;
2359
	struct qla_msix_entry *qentry;
2360
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2361 2362

	entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
2363
			GFP_KERNEL);
2364 2365 2366
	if (!entries) {
		ql_log(ql_log_warn, vha, 0x00bc,
		    "Failed to allocate memory for msix_entry.\n");
2367
		return -ENOMEM;
2368
	}
2369

2370 2371
	for (i = 0; i < ha->msix_count; i++)
		entries[i].entry = i;
2372

2373
	ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
2374
	if (ret) {
2375 2376 2377
		if (ret < MIN_MSIX_COUNT)
			goto msix_failed;

2378 2379 2380 2381
		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);
2382 2383 2384
		ha->msix_count = ret;
		ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
		if (ret) {
2385
msix_failed:
2386 2387 2388 2389
			ql_log(ql_log_fatal, vha, 0x00c7,
			    "MSI-X: Failed to enable support, "
			    "giving   up -- %d/%d.\n",
			    ha->msix_count, ret);
2390 2391
			goto msix_out;
		}
2392
		ha->max_rsp_queues = ha->msix_count - 1;
2393 2394 2395 2396
	}
	ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
				ha->msix_count, GFP_KERNEL);
	if (!ha->msix_entries) {
2397 2398
		ql_log(ql_log_fatal, vha, 0x00c8,
		    "Failed to allocate memory for ha->msix_entries.\n");
2399
		ret = -ENOMEM;
2400 2401 2402 2403
		goto msix_out;
	}
	ha->flags.msix_enabled = 1;

2404 2405 2406 2407
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
		qentry->vector = entries[i].vector;
		qentry->entry = entries[i].entry;
2408
		qentry->have_irq = 0;
2409
		qentry->rsp = NULL;
2410 2411
	}

2412 2413 2414
	/* Enable MSI-X vectors for the base queue */
	for (i = 0; i < 2; i++) {
		qentry = &ha->msix_entries[i];
2415 2416 2417 2418 2419 2420 2421 2422 2423
		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);
		}
2424
		if (ret) {
2425 2426 2427
			ql_log(ql_log_fatal, vha, 0x00cb,
			    "MSI-X: unable to register handler -- %x/%d.\n",
			    qentry->vector, ret);
2428 2429 2430 2431 2432 2433 2434
			qla24xx_disable_msix(ha);
			ha->mqenable = 0;
			goto msix_out;
		}
		qentry->have_irq = 1;
		qentry->rsp = rsp;
		rsp->msix = qentry;
2435 2436 2437
	}

	/* Enable MSI-X vector for response queue update for queue 0 */
2438 2439 2440 2441 2442 2443 2444 2445
	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;
2446 2447 2448 2449 2450 2451
	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);
2452

2453
msix_out:
2454
	kfree(entries);
2455 2456 2457 2458
	return ret;
}

int
2459
qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
2460 2461
{
	int ret;
2462
	device_reg_t __iomem *reg = ha->iobase;
2463
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2464 2465

	/* If possible, enable MSI-X. */
2466 2467
	if (!IS_QLA2432(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
		!IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha))
2468 2469 2470 2471 2472 2473
		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)) {
2474 2475
		ql_log(ql_log_warn, vha, 0x0034,
		    "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
2476
			ha->pdev->subsystem_vendor,
2477
			ha->pdev->subsystem_device);
2478 2479
		goto skip_msi;
	}
2480

2481
	if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
2482 2483
		ql_log(ql_log_warn, vha, 0x0035,
		    "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
2484
		    ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
2485 2486 2487
		goto skip_msix;
	}

2488
	ret = qla24xx_enable_msix(ha, rsp);
2489
	if (!ret) {
2490 2491 2492
		ql_dbg(ql_dbg_init, vha, 0x0036,
		    "MSI-X: Enabled (0x%X, 0x%X).\n",
		    ha->chip_revision, ha->fw_attributes);
2493
		goto clear_risc_ints;
2494
	}
2495 2496
	ql_log(ql_log_info, vha, 0x0037,
	    "MSI-X Falling back-to MSI mode -%d.\n", ret);
2497
skip_msix:
2498

2499 2500
	if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
	    !IS_QLA8001(ha))
2501 2502 2503 2504
		goto skip_msi;

	ret = pci_enable_msi(ha->pdev);
	if (!ret) {
2505 2506
		ql_dbg(ql_dbg_init, vha, 0x0038,
		    "MSI: Enabled.\n");
2507
		ha->flags.msi_enabled = 1;
2508
	} else
2509 2510
		ql_log(ql_log_warn, vha, 0x0039,
		    "MSI-X; Falling back-to INTa mode -- %d.\n", ret);
2511 2512
skip_msi:

2513
	ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
2514 2515
	    ha->flags.msi_enabled ? 0 : IRQF_SHARED,
	    QLA2XXX_DRIVER_NAME, rsp);
2516
	if (ret) {
2517
		ql_log(ql_log_warn, vha, 0x003a,
2518 2519
		    "Failed to reserve interrupt %d already in use.\n",
		    ha->pdev->irq);
2520 2521
		goto fail;
	}
2522

2523 2524
clear_risc_ints:

2525 2526 2527 2528
	/*
	 * FIXME: Noted that 8014s were being dropped during NK testing.
	 * Timing deltas during MSI-X/INTa transitions?
	 */
2529
	if (IS_QLA81XX(ha) || IS_QLA82XX(ha) || IS_QLA83XX(ha))
2530
		goto fail;
2531
	spin_lock_irq(&ha->hardware_lock);
2532 2533 2534 2535 2536 2537 2538
	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);
2539
	}
2540
	spin_unlock_irq(&ha->hardware_lock);
2541

2542
fail:
2543 2544 2545 2546
	return ret;
}

void
2547
qla2x00_free_irqs(scsi_qla_host_t *vha)
2548
{
2549
	struct qla_hw_data *ha = vha->hw;
2550
	struct rsp_que *rsp = ha->rsp_q_map[0];
2551 2552 2553

	if (ha->flags.msix_enabled)
		qla24xx_disable_msix(ha);
2554
	else if (ha->flags.msi_enabled) {
2555
		free_irq(ha->pdev->irq, rsp);
2556
		pci_disable_msi(ha->pdev);
2557 2558
	} else
		free_irq(ha->pdev->irq, rsp);
2559
}
2560

2561 2562 2563 2564

int qla25xx_request_irq(struct rsp_que *rsp)
{
	struct qla_hw_data *ha = rsp->hw;
2565
	struct qla_init_msix_entry *intr = &msix_entries[2];
2566
	struct qla_msix_entry *msix = rsp->msix;
2567
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2568 2569 2570 2571
	int ret;

	ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
	if (ret) {
2572 2573 2574
		ql_log(ql_log_fatal, vha, 0x00e6,
		    "MSI-X: Unable to register handler -- %x/%d.\n",
		    msix->vector, ret);
2575 2576 2577 2578 2579 2580
		return ret;
	}
	msix->have_irq = 1;
	msix->rsp = rsp;
	return ret;
}