qla_isr.c 67.7 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
{
	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 331
	uint32_t	rscn_entry, host_pid;
	uint8_t		rscn_queue_index;
332
	unsigned long	flags;
L
Linus Torvalds 已提交
333 334 335

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

688
		vha->flags.rscn_queue_overflow = 1;
L
Linus Torvalds 已提交
689

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

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

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

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

716 717
		/* Ignore reserved bits from RSCN-payload. */
		rscn_entry = ((mb[1] & 0x3ff) << 16) | mb[2];
718
		rscn_queue_index = vha->rscn_in_ptr + 1;
L
Linus Torvalds 已提交
719 720
		if (rscn_queue_index == MAX_RSCN_COUNT)
			rscn_queue_index = 0;
721 722 723
		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 已提交
724
		} else {
725
			vha->flags.rscn_queue_overflow = 1;
L
Linus Torvalds 已提交
726 727
		}

728 729
		atomic_set(&vha->loop_down_timer, 0);
		vha->flags.management_server_logged_in = 0;
L
Linus Torvalds 已提交
730

731 732 733
		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 已提交
734 735 736 737
		break;

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

741
		if (IS_FWI2_CAPABLE(ha))
742
			qla24xx_process_response_queue(vha, rsp);
743
		else
744
			qla2x00_process_response_queue(rsp);
L
Linus Torvalds 已提交
745
		break;
746 747

	case MBA_DISCARD_RND_FRAME:
748 749 750
		ql_dbg(ql_dbg_async, vha, 0x5016,
		    "Discard RND Frame -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
751
		break;
752 753

	case MBA_TRACE_NOTIFICATION:
754 755
		ql_dbg(ql_dbg_async, vha, 0x5017,
		    "Trace Notification -- %04x %04x.\n", mb[1], mb[2]);
756
		break;
757 758

	case MBA_ISP84XX_ALERT:
759 760 761
		ql_dbg(ql_dbg_async, vha, 0x5018,
		    "ISP84XX Alert Notification -- %04x %04x %04x.\n",
		    mb[1], mb[2], mb[3]);
762 763 764 765

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

822
	if (!vha->vp_idx && ha->num_vhosts)
823
		qla2x00_alert_all_vps(rsp, mb);
L
Linus Torvalds 已提交
824 825 826 827 828 829 830 831
}

/**
 * qla2x00_process_completed_request() - Process a Fast Post response.
 * @ha: SCSI driver HA context
 * @index: SRB index
 */
static void
832 833
qla2x00_process_completed_request(struct scsi_qla_host *vha,
				struct req_que *req, uint32_t index)
L
Linus Torvalds 已提交
834 835
{
	srb_t *sp;
836
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
837 838 839

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

843 844 845 846
		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 已提交
847 848 849
		return;
	}

850
	sp = req->outstanding_cmds[index];
L
Linus Torvalds 已提交
851 852
	if (sp) {
		/* Free outstanding command slot. */
853
		req->outstanding_cmds[index] = NULL;
L
Linus Torvalds 已提交
854 855

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

860 861 862 863
		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 已提交
864 865 866
	}
}

867 868 869 870 871 872 873 874 875 876 877
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) {
878 879
		ql_log(ql_log_warn, vha, 0x5031,
		    "Invalid command index (%x).\n", index);
880 881 882 883
		if (IS_QLA82XX(ha))
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
884 885 886 887
		goto done;
	}
	sp = req->outstanding_cmds[index];
	if (!sp) {
888 889
		ql_log(ql_log_warn, vha, 0x5032,
		    "Invalid completion handle (%x) -- timed-out.\n", index);
890 891 892
		return sp;
	}
	if (sp->handle != index) {
893 894
		ql_log(ql_log_warn, vha, 0x5033,
		    "SRB handle (%x) mismatch %x.\n", sp->handle, index);
895 896
		return NULL;
	}
897

898
	req->outstanding_cmds[index] = NULL;
899

900 901 902 903 904 905 906 907 908 909 910 911
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;
912
	struct srb_iocb *lio;
913
	uint16_t *data;
914
	uint16_t status;
915 916 917 918 919

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

920 921
	lio = &sp->u.iocb_cmd;
	type = sp->name;
922
	fcport = sp->fcport;
923
	data = lio->u.logio.data;
924

925
	data[0] = MBS_COMMAND_ERROR;
926
	data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
927
	    QLA_LOGIO_LOGIN_RETRIED : 0;
928
	if (mbx->entry_status) {
929
		ql_dbg(ql_dbg_async, vha, 0x5043,
930
		    "Async-%s error entry - hdl=%x portid=%02x%02x%02x "
931
		    "entry-status=%x status=%x state-flag=%x "
932 933
		    "status-flags=%x.\n", type, sp->handle,
		    fcport->d_id.b.domain, fcport->d_id.b.area,
934 935
		    fcport->d_id.b.al_pa, mbx->entry_status,
		    le16_to_cpu(mbx->status), le16_to_cpu(mbx->state_flags),
936
		    le16_to_cpu(mbx->status_flags));
937

938
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5029,
939
		    (uint8_t *)mbx, sizeof(*mbx));
940

941
		goto logio_done;
942 943
	}

944
	status = le16_to_cpu(mbx->status);
945
	if (status == 0x30 && sp->type == SRB_LOGIN_CMD &&
946 947 948
	    le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
		status = 0;
	if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
949
		ql_dbg(ql_dbg_async, vha, 0x5045,
950 951 952 953
		    "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));
954 955

		data[0] = MBS_COMMAND_COMPLETE;
956
		if (sp->type == SRB_LOGIN_CMD) {
957 958 959
			fcport->port_type = FCT_TARGET;
			if (le16_to_cpu(mbx->mb1) & BIT_0)
				fcport->port_type = FCT_INITIATOR;
960
			else if (le16_to_cpu(mbx->mb1) & BIT_1)
961
				fcport->flags |= FCF_FCP2_DEVICE;
962
		}
963
		goto logio_done;
964 965 966 967 968 969 970 971 972 973 974 975 976 977
	}

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

978
	ql_log(ql_log_warn, vha, 0x5046,
979 980 981 982
	    "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),
983
	    le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
984
	    le16_to_cpu(mbx->mb7));
985

986
logio_done:
987
	sp->done(vha, sp, 0);
988 989
}

990 991 992 993 994 995 996 997 998
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;
999
	int res;
1000 1001 1002 1003 1004

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

1005
	bsg_job = sp->u.bsg_job;
1006

1007
	type = "ct pass-through";
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018

	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) {
1019
			res = DID_OK << 16;
1020 1021 1022
			bsg_job->reply->reply_payload_rcv_len =
			    le16_to_cpu(((sts_entry_t *)pkt)->rsp_info_len);

1023 1024
			ql_log(ql_log_warn, vha, 0x5048,
			    "CT pass-through-%s error "
1025
			    "comp_status-status=0x%x total_byte = 0x%x.\n",
1026 1027
			    type, comp_status,
			    bsg_job->reply->reply_payload_rcv_len);
1028
		} else {
1029 1030 1031
			ql_log(ql_log_warn, vha, 0x5049,
			    "CT pass-through-%s error "
			    "comp_status-status=0x%x.\n", type, comp_status);
1032
			res = DID_ERROR << 16;
1033 1034
			bsg_job->reply->reply_payload_rcv_len = 0;
		}
1035
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5035,
1036
		    (uint8_t *)pkt, sizeof(*pkt));
1037
	} else {
1038
		res = DID_OK << 16;
1039 1040 1041 1042 1043
		bsg_job->reply->reply_payload_rcv_len =
		    bsg_job->reply_payload.payload_len;
		bsg_job->reply_len = 0;
	}

1044
	sp->done(vha, sp, res);
1045 1046
}

1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
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;
1058
	int res;
1059 1060 1061 1062

	sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
	if (!sp)
		return;
1063
	bsg_job = sp->u.bsg_job;
1064 1065

	type = NULL;
1066
	switch (sp->type) {
1067 1068 1069 1070 1071 1072 1073 1074
	case SRB_ELS_CMD_RPT:
	case SRB_ELS_CMD_HST:
		type = "els";
		break;
	case SRB_CT_CMD:
		type = "ct pass-through";
		break;
	default:
1075
		ql_dbg(ql_dbg_user, vha, 0x503e,
1076
		    "Unrecognized SRB: (%p) type=%d.\n", sp, sp->type);
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
		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) {
1092
			res = DID_OK << 16;
1093
			bsg_job->reply->reply_payload_rcv_len =
1094
			    le16_to_cpu(((struct els_sts_entry_24xx *)pkt)->total_byte_count);
1095

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

1128
	sp->done(vha, sp, res);
1129 1130
}

1131 1132 1133 1134 1135 1136 1137 1138
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;
1139
	struct srb_iocb *lio;
1140
	uint16_t *data;
1141 1142 1143 1144 1145 1146
	uint32_t iop[2];

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

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

1152
	data[0] = MBS_COMMAND_ERROR;
1153
	data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
1154
		QLA_LOGIO_LOGIN_RETRIED : 0;
1155
	if (logio->entry_status) {
1156
		ql_log(ql_log_warn, vha, 0x5034,
1157
		    "Async-%s error entry - hdl=%x"
1158
		    "portid=%02x%02x%02x entry-status=%x.\n",
1159 1160 1161 1162
		    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,
1163
		    (uint8_t *)logio, sizeof(*logio));
1164

1165
		goto logio_done;
1166 1167 1168
	}

	if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
1169
		ql_dbg(ql_dbg_async, vha, 0x5036,
1170 1171 1172
		    "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,
1173
		    le32_to_cpu(logio->io_parameter[0]));
1174 1175

		data[0] = MBS_COMMAND_COMPLETE;
1176
		if (sp->type != SRB_LOGIN_CMD)
1177
			goto logio_done;
1178 1179 1180 1181 1182

		iop[0] = le32_to_cpu(logio->io_parameter[0]);
		if (iop[0] & BIT_4) {
			fcport->port_type = FCT_TARGET;
			if (iop[0] & BIT_8)
1183
				fcport->flags |= FCF_FCP2_DEVICE;
1184
		} else if (iop[0] & BIT_5)
1185
			fcport->port_type = FCT_INITIATOR;
1186

1187 1188 1189 1190 1191
		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;

1192
		goto logio_done;
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
	}

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

1210
	ql_dbg(ql_dbg_async, vha, 0x5037,
1211 1212
	    "Async-%s failed - hdl=%x portid=%02x%02x%02x comp=%x "
	    "iop0=%x iop1=%x.\n", type, sp->handle, fcport->d_id.b.domain,
1213
	    fcport->d_id.b.area, fcport->d_id.b.al_pa,
1214 1215
	    le16_to_cpu(logio->comp_status),
	    le32_to_cpu(logio->io_parameter[0]),
1216
	    le32_to_cpu(logio->io_parameter[1]));
1217

1218
logio_done:
1219
	sp->done(vha, sp, 0);
1220 1221
}

1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
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;

1238 1239
	iocb = &sp->u.iocb_cmd;
	type = sp->name;
1240 1241 1242
	fcport = sp->fcport;

	if (sts->entry_status) {
1243
		ql_log(ql_log_warn, vha, 0x5038,
1244 1245
		    "Async-%s error - hdl=%x entry-status(%x).\n",
		    type, sp->handle, sts->entry_status);
1246
	} else if (sts->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1247
		ql_log(ql_log_warn, vha, 0x5039,
1248 1249
		    "Async-%s error - hdl=%x completion status(%x).\n",
		    type, sp->handle, sts->comp_status);
1250 1251
	} else if (!(le16_to_cpu(sts->scsi_status) &
	    SS_RESPONSE_INFO_LEN_VALID)) {
1252
		ql_log(ql_log_warn, vha, 0x503a,
1253 1254
		    "Async-%s error - hdl=%x no response info(%x).\n",
		    type, sp->handle, sts->scsi_status);
1255
	} else if (le32_to_cpu(sts->rsp_data_len) < 4) {
1256
		ql_log(ql_log_warn, vha, 0x503b,
1257 1258
		    "Async-%s error - hdl=%x not enough response(%d).\n",
		    type, sp->handle, sts->rsp_data_len);
1259
	} else if (sts->data[3]) {
1260
		ql_log(ql_log_warn, vha, 0x503c,
1261 1262
		    "Async-%s error - hdl=%x response(%x).\n",
		    type, sp->handle, sts->data[3]);
1263 1264 1265 1266 1267 1268
	} else {
		error = 0;
	}

	if (error) {
		iocb->u.tmf.data = error;
1269 1270
		ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5055,
		    (uint8_t *)sts, sizeof(*sts));
1271 1272
	}

1273
	sp->done(vha, sp, 0);
1274 1275
}

L
Linus Torvalds 已提交
1276 1277 1278 1279 1280
/**
 * qla2x00_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
void
1281
qla2x00_process_response_queue(struct rsp_que *rsp)
L
Linus Torvalds 已提交
1282
{
1283 1284
	struct scsi_qla_host *vha;
	struct qla_hw_data *ha = rsp->hw;
1285
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
1286 1287 1288
	sts_entry_t	*pkt;
	uint16_t        handle_cnt;
	uint16_t        cnt;
1289

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

1292
	if (!vha->flags.online)
L
Linus Torvalds 已提交
1293 1294
		return;

1295 1296
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (sts_entry_t *)rsp->ring_ptr;
L
Linus Torvalds 已提交
1297

1298 1299 1300 1301
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
L
Linus Torvalds 已提交
1302
		} else {
1303
			rsp->ring_ptr++;
L
Linus Torvalds 已提交
1304 1305 1306
		}

		if (pkt->entry_status != 0) {
1307
			qla2x00_error_entry(vha, rsp, pkt);
L
Linus Torvalds 已提交
1308 1309 1310 1311 1312 1313 1314
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

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

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

1357
static inline void
1358
qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
1359
		     uint32_t sense_len, struct rsp_que *rsp, int res)
1360
{
1361
	struct scsi_qla_host *vha = sp->fcport->vha;
1362 1363
	struct scsi_cmnd *cp = GET_CMD_SP(sp);
	uint32_t track_sense_len;
1364 1365 1366 1367

	if (sense_len >= SCSI_SENSE_BUFFERSIZE)
		sense_len = SCSI_SENSE_BUFFERSIZE;

1368 1369 1370 1371 1372
	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)
1373
		sense_len = par_sense_len;
1374 1375 1376

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

1377 1378 1379 1380 1381
	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) {
1382
		rsp->status_srb = sp;
1383 1384
		cp->result = res;
	}
1385

1386 1387 1388 1389 1390
	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);
1391 1392
		ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
		    cp->sense_buffer, sense_len);
1393
	}
1394 1395
}

1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
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.
 */
1408
static inline int
1409 1410
qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
{
1411
	struct scsi_qla_host *vha = sp->fcport->vha;
1412
	struct scsi_cmnd *cmd = GET_CMD_SP(sp);
1413 1414
	uint8_t		*ap = &sts24->data[12];
	uint8_t		*ep = &sts24->data[20];
1415 1416 1417 1418
	uint32_t	e_ref_tag, a_ref_tag;
	uint16_t	e_app_tag, a_app_tag;
	uint16_t	e_guard, a_guard;

1419 1420 1421 1422 1423 1424 1425 1426 1427 1428
	/*
	 * 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));
1429

1430 1431
	ql_dbg(ql_dbg_io, vha, 0x3023,
	    "iocb(s) %p Returned STATUS.\n", sts24);
1432

1433 1434
	ql_dbg(ql_dbg_io, vha, 0x3024,
	    "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
1435
	    " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
1436
	    " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
1437
	    cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
1438
	    a_app_tag, e_app_tag, a_guard, e_guard);
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 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
	/*
	 * 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) {
1480
				ql_log(ql_log_warn, vha, 0x302f,
1481 1482
				    "unexpected tag values tag:lba=%x:%llx)\n",
				    e_ref_tag, (unsigned long long)lba_s);
1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
				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;
	}

1497 1498 1499 1500 1501 1502 1503
	/* 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;
1504
		return 1;
1505 1506
	}

1507 1508
	/* check ref tag */
	if (e_ref_tag != a_ref_tag) {
1509
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1510
		    0x10, 0x3);
1511 1512 1513
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1514
		return 1;
1515 1516
	}

1517 1518
	/* check appl tag */
	if (e_app_tag != a_app_tag) {
1519
		scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
1520
		    0x10, 0x2);
1521 1522 1523
		set_driver_byte(cmd, DRIVER_SENSE);
		set_host_byte(cmd, DID_ABORT);
		cmd->result |= SAM_STAT_CHECK_CONDITION << 1;
1524
		return 1;
1525
	}
1526

1527
	return 1;
1528 1529
}

L
Linus Torvalds 已提交
1530 1531 1532 1533 1534 1535
/**
 * qla2x00_status_entry() - Process a Status IOCB entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
1536
qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
L
Linus Torvalds 已提交
1537 1538 1539 1540
{
	srb_t		*sp;
	fc_port_t	*fcport;
	struct scsi_cmnd *cp;
1541 1542
	sts_entry_t *sts;
	struct sts_entry_24xx *sts24;
L
Linus Torvalds 已提交
1543 1544
	uint16_t	comp_status;
	uint16_t	scsi_status;
1545
	uint16_t	ox_id;
L
Linus Torvalds 已提交
1546 1547
	uint8_t		lscsi_status;
	int32_t		resid;
1548 1549
	uint32_t sense_len, par_sense_len, rsp_info_len, resid_len,
	    fw_resid_len;
1550
	uint8_t		*rsp_info, *sense_data;
1551
	struct qla_hw_data *ha = vha->hw;
1552 1553 1554
	uint32_t handle;
	uint16_t que;
	struct req_que *req;
1555
	int logit = 1;
1556
	int res = 0;
1557 1558 1559

	sts = (sts_entry_t *) pkt;
	sts24 = (struct sts_entry_24xx *) pkt;
1560
	if (IS_FWI2_CAPABLE(ha)) {
1561 1562 1563 1564 1565 1566
		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;
	}
1567 1568 1569
	handle = (uint32_t) LSW(sts->handle);
	que = MSW(sts->handle);
	req = ha->req_q_map[que];
1570

L
Linus Torvalds 已提交
1571
	/* Fast path completion. */
1572
	if (comp_status == CS_COMPLETE && scsi_status == 0) {
1573
		qla2x00_process_completed_request(vha, req, handle);
L
Linus Torvalds 已提交
1574 1575 1576 1577 1578

		return;
	}

	/* Validate handle. */
1579 1580 1581
	if (handle < MAX_OUTSTANDING_COMMANDS) {
		sp = req->outstanding_cmds[handle];
		req->outstanding_cmds[handle] = NULL;
L
Linus Torvalds 已提交
1582 1583 1584 1585
	} else
		sp = NULL;

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

1589 1590 1591 1592
		if (IS_QLA82XX(ha))
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1593
		qla2xxx_wake_dpc(vha);
L
Linus Torvalds 已提交
1594 1595
		return;
	}
1596
	cp = GET_CMD_SP(sp);
L
Linus Torvalds 已提交
1597
	if (cp == NULL) {
1598
		ql_dbg(ql_dbg_io, vha, 0x3018,
1599 1600
		    "Command already returned (0x%x/%p).\n",
		    sts->handle, sp);
L
Linus Torvalds 已提交
1601 1602 1603 1604

		return;
	}

1605
  	lscsi_status = scsi_status & STATUS_MASK;
L
Linus Torvalds 已提交
1606

1607
	fcport = sp->fcport;
L
Linus Torvalds 已提交
1608

1609
	ox_id = 0;
1610 1611
	sense_len = par_sense_len = rsp_info_len = resid_len =
	    fw_resid_len = 0;
1612
	if (IS_FWI2_CAPABLE(ha)) {
1613 1614 1615 1616 1617 1618 1619 1620
		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);
1621 1622 1623
		rsp_info = sts24->data;
		sense_data = sts24->data;
		host_to_fcp_swap(sts24->data, sizeof(sts24->data));
1624
		ox_id = le16_to_cpu(sts24->ox_id);
1625
		par_sense_len = sizeof(sts24->data);
1626
	} else {
1627 1628 1629 1630
		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);
1631 1632 1633
		resid_len = le32_to_cpu(sts->residual_length);
		rsp_info = sts->rsp_info;
		sense_data = sts->req_sense_data;
1634
		par_sense_len = sizeof(sts->req_sense_data);
1635 1636
	}

L
Linus Torvalds 已提交
1637 1638
	/* Check for any FCP transport errors. */
	if (scsi_status & SS_RESPONSE_INFO_LEN_VALID) {
1639
		/* Sense data lies beyond any FCP RESPONSE data. */
1640
		if (IS_FWI2_CAPABLE(ha)) {
1641
			sense_data += rsp_info_len;
1642 1643
			par_sense_len -= rsp_info_len;
		}
1644
		if (rsp_info_len > 3 && rsp_info[3]) {
1645
			ql_dbg(ql_dbg_io, vha, 0x3019,
1646 1647
			    "FCP I/O protocol failure (0x%x/0x%x).\n",
			    rsp_info_len, rsp_info[3]);
L
Linus Torvalds 已提交
1648

1649
			res = DID_BUS_BUSY << 16;
1650
			goto out;
L
Linus Torvalds 已提交
1651 1652 1653
		}
	}

1654 1655 1656 1657 1658
	/* 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 已提交
1659 1660 1661 1662 1663
	/*
	 * Based on Host and scsi status generate status code for Linux
	 */
	switch (comp_status) {
	case CS_COMPLETE:
1664
	case CS_QUEUE_FULL:
L
Linus Torvalds 已提交
1665
		if (scsi_status == 0) {
1666
			res = DID_OK << 16;
L
Linus Torvalds 已提交
1667 1668 1669
			break;
		}
		if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER)) {
1670
			resid = resid_len;
1671
			scsi_set_resid(cp, resid);
1672 1673

			if (!lscsi_status &&
1674
			    ((unsigned)(scsi_bufflen(cp) - resid) <
1675
			     cp->underflow)) {
1676
				ql_dbg(ql_dbg_io, vha, 0x301a,
1677
				    "Mid-layer underflow "
1678
				    "detected (0x%x of 0x%x bytes).\n",
1679
				    resid, scsi_bufflen(cp));
1680

1681
				res = DID_ERROR << 16;
1682 1683
				break;
			}
L
Linus Torvalds 已提交
1684
		}
1685
		res = DID_OK << 16 | lscsi_status;
L
Linus Torvalds 已提交
1686

1687
		if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1688
			ql_dbg(ql_dbg_io, vha, 0x301b,
1689
			    "QUEUE FULL detected.\n");
1690 1691
			break;
		}
1692
		logit = 0;
L
Linus Torvalds 已提交
1693 1694 1695
		if (lscsi_status != SS_CHECK_CONDITION)
			break;

1696
		memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
1697 1698 1699
		if (!(scsi_status & SS_SENSE_LEN_VALID))
			break;

1700
		qla2x00_handle_sense(sp, sense_data, par_sense_len, sense_len,
1701
		    rsp, res);
L
Linus Torvalds 已提交
1702 1703 1704
		break;

	case CS_DATA_UNDERRUN:
1705
		/* Use F/W calculated residual length. */
1706 1707 1708 1709
		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) {
1710
				ql_dbg(ql_dbg_io, vha, 0x301d,
1711 1712 1713
				    "Dropped frame(s) detected "
				    "(0x%x of 0x%x bytes).\n",
				    resid, scsi_bufflen(cp));
1714

1715
				res = DID_ERROR << 16 | lscsi_status;
1716
				goto check_scsi_status;
1717
			}
1718

1719 1720 1721
			if (!lscsi_status &&
			    ((unsigned)(scsi_bufflen(cp) - resid) <
			    cp->underflow)) {
1722
				ql_dbg(ql_dbg_io, vha, 0x301e,
1723
				    "Mid-layer underflow "
1724
				    "detected (0x%x of 0x%x bytes).\n",
1725
				    resid, scsi_bufflen(cp));
1726

1727
				res = DID_ERROR << 16;
1728 1729
				break;
			}
1730
		} else {
1731
			ql_dbg(ql_dbg_io, vha, 0x301f,
1732 1733
			    "Dropped frame(s) detected (0x%x "
			    "of 0x%x bytes).\n", resid, scsi_bufflen(cp));
1734

1735
			res = DID_ERROR << 16 | lscsi_status;
1736
			goto check_scsi_status;
L
Linus Torvalds 已提交
1737 1738
		}

1739
		res = DID_OK << 16 | lscsi_status;
1740
		logit = 0;
1741

1742
check_scsi_status:
L
Linus Torvalds 已提交
1743
		/*
A
Andrew Vasquez 已提交
1744
		 * Check to see if SCSI Status is non zero. If so report SCSI
L
Linus Torvalds 已提交
1745 1746 1747
		 * Status.
		 */
		if (lscsi_status != 0) {
1748
			if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
1749
				ql_dbg(ql_dbg_io, vha, 0x3020,
1750
				    "QUEUE FULL detected.\n");
1751
				logit = 1;
1752 1753
				break;
			}
L
Linus Torvalds 已提交
1754 1755 1756
			if (lscsi_status != SS_CHECK_CONDITION)
				break;

1757
			memset(cp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
L
Linus Torvalds 已提交
1758 1759 1760
			if (!(scsi_status & SS_SENSE_LEN_VALID))
				break;

1761
			qla2x00_handle_sense(sp, sense_data, par_sense_len,
1762
			    sense_len, rsp, res);
L
Linus Torvalds 已提交
1763 1764 1765 1766 1767 1768 1769 1770
		}
		break;

	case CS_PORT_LOGGED_OUT:
	case CS_PORT_CONFIG_CHG:
	case CS_PORT_BUSY:
	case CS_INCOMPLETE:
	case CS_PORT_UNAVAILABLE:
1771
	case CS_TIMEOUT:
1772 1773
	case CS_RESET:

1774 1775 1776 1777 1778
		/*
		 * 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.
		 */
1779
		res = DID_TRANSPORT_DISRUPTED << 16;
1780 1781 1782 1783 1784 1785 1786 1787 1788

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

1789 1790 1791
		ql_dbg(ql_dbg_io, vha, 0x3021,
		    "Port down status: port-state=0x%x.\n",
		    atomic_read(&fcport->state));
1792

1793
		if (atomic_read(&fcport->state) == FCS_ONLINE)
1794
			qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
L
Linus Torvalds 已提交
1795 1796 1797
		break;

	case CS_ABORTED:
1798
		res = DID_RESET << 16;
L
Linus Torvalds 已提交
1799
		break;
1800 1801

	case CS_DIF_ERROR:
1802
		logit = qla2x00_handle_dif_error(sp, sts24);
1803
		break;
L
Linus Torvalds 已提交
1804
	default:
1805
		res = DID_ERROR << 16;
L
Linus Torvalds 已提交
1806 1807 1808
		break;
	}

1809 1810
out:
	if (logit)
1811 1812
		ql_dbg(ql_dbg_io, vha, 0x3022,
		    "FCP command status: 0x%x-0x%x (0x%x) "
1813 1814
		    "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 "
1815
		    "rsp_info=0x%x resid=0x%x fw_resid=0x%x.\n",
1816
		    comp_status, scsi_status, res, vha->host_no,
1817 1818 1819 1820 1821
		    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,
1822
		    resid_len, fw_resid_len);
1823

1824
	if (rsp->status_srb == NULL)
1825
		sp->done(ha, sp, res);
L
Linus Torvalds 已提交
1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
}

/**
 * qla2x00_status_cont_entry() - Process a Status Continuations entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 *
 * Extended sense data.
 */
static void
1836
qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
L
Linus Torvalds 已提交
1837
{
1838
	uint8_t	sense_sz = 0;
1839
	struct qla_hw_data *ha = rsp->hw;
1840
	struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
1841
	srb_t *sp = rsp->status_srb;
L
Linus Torvalds 已提交
1842
	struct scsi_cmnd *cp;
1843 1844
	uint32_t sense_len;
	uint8_t *sense_ptr;
L
Linus Torvalds 已提交
1845

1846 1847
	if (!sp || !GET_CMD_SENSE_LEN(sp))
		return;
L
Linus Torvalds 已提交
1848

1849 1850
	sense_len = GET_CMD_SENSE_LEN(sp);
	sense_ptr = GET_CMD_SENSE_PTR(sp);
L
Linus Torvalds 已提交
1851

1852 1853 1854 1855
	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 已提交
1856

1857 1858
		rsp->status_srb = NULL;
		return;
L
Linus Torvalds 已提交
1859 1860
	}

1861 1862 1863 1864
	if (sense_len > sizeof(pkt->data))
		sense_sz = sizeof(pkt->data);
	else
		sense_sz = sense_len;
1865

1866 1867 1868 1869 1870 1871
	/* 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);
1872

1873 1874
	sense_len -= sense_sz;
	sense_ptr += sense_sz;
1875

1876 1877 1878 1879 1880 1881 1882
	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);
1883 1884 1885
	}
}

L
Linus Torvalds 已提交
1886 1887 1888 1889 1890 1891
/**
 * qla2x00_error_entry() - Process an error entry.
 * @ha: SCSI driver HA context
 * @pkt: Entry pointer
 */
static void
1892
qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
L
Linus Torvalds 已提交
1893 1894
{
	srb_t *sp;
1895
	struct qla_hw_data *ha = vha->hw;
1896
	const char func[] = "ERROR-IOCB";
1897 1898
	uint16_t que = MSW(pkt->handle);
	struct req_que *req = ha->req_q_map[que];
1899
	int res = DID_ERROR << 16;
1900

1901 1902 1903 1904 1905
	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 已提交
1906

1907
	sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
1908 1909 1910
	if (sp)
		sp->done(ha, sp, res);
	else {
1911 1912
		ql_log(ql_log_warn, vha, 0x5030,
		    "Error entry - invalid handle.\n");
L
Linus Torvalds 已提交
1913

1914 1915 1916 1917
		if (IS_QLA82XX(ha))
			set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
		else
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1918
		qla2xxx_wake_dpc(vha);
L
Linus Torvalds 已提交
1919 1920 1921
	}
}

1922 1923 1924 1925 1926 1927
/**
 * qla24xx_mbx_completion() - Process mailbox command completions.
 * @ha: SCSI driver HA context
 * @mb0: Mailbox0 register
 */
static void
1928
qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
1929 1930
{
	uint16_t	cnt;
1931
	uint32_t	mboxes;
1932
	uint16_t __iomem *wptr;
1933
	struct qla_hw_data *ha = vha->hw;
1934 1935
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

1936 1937 1938 1939 1940 1941 1942
	/* 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;

1943 1944 1945
	/* Load return mailbox registers. */
	ha->flags.mbox_int = 1;
	ha->mailbox_out[0] = mb0;
1946
	mboxes >>= 1;
1947 1948 1949
	wptr = (uint16_t __iomem *)&reg->mailbox1;

	for (cnt = 1; cnt < ha->mbx_count; cnt++) {
1950 1951 1952 1953
		if (mboxes & BIT_0)
			ha->mailbox_out[cnt] = RD_REG_WORD(wptr);

		mboxes >>= 1;
1954 1955 1956 1957 1958 1959 1960 1961
		wptr++;
	}
}

/**
 * qla24xx_process_response_queue() - Process response queue entries.
 * @ha: SCSI driver HA context
 */
1962 1963
void qla24xx_process_response_queue(struct scsi_qla_host *vha,
	struct rsp_que *rsp)
1964 1965
{
	struct sts_entry_24xx *pkt;
1966
	struct qla_hw_data *ha = vha->hw;
1967

1968
	if (!vha->flags.online)
1969 1970
		return;

1971 1972
	while (rsp->ring_ptr->signature != RESPONSE_PROCESSED) {
		pkt = (struct sts_entry_24xx *)rsp->ring_ptr;
1973

1974 1975 1976 1977
		rsp->ring_index++;
		if (rsp->ring_index == rsp->length) {
			rsp->ring_index = 0;
			rsp->ring_ptr = rsp->ring;
1978
		} else {
1979
			rsp->ring_ptr++;
1980 1981 1982
		}

		if (pkt->entry_status != 0) {
1983
			qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
1984 1985 1986 1987 1988 1989 1990
			((response_t *)pkt)->signature = RESPONSE_PROCESSED;
			wmb();
			continue;
		}

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

	/* Adjust ring index */
2032 2033 2034 2035 2036
	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);
2037 2038
}

2039
static void
2040
qla2xxx_check_risc_status(scsi_qla_host_t *vha)
2041 2042 2043
{
	int rval;
	uint32_t cnt;
2044
	struct qla_hw_data *ha = vha->hw;
2045 2046
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

2047
	if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha))
2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078
		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)
2079 2080
		ql_log(ql_log_info, vha, 0x504c,
		    "Additional code -- 0x55AA.\n");
2081 2082 2083 2084 2085 2086

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

2087
/**
2088
 * qla24xx_intr_handler() - Process interrupts for the ISP23xx and ISP24xx.
2089 2090 2091 2092 2093 2094 2095 2096
 * @irq:
 * @dev_id: SCSI driver HA context
 *
 * Called by system whenever the host adapter generates an interrupt.
 *
 * Returns handled flag.
 */
irqreturn_t
2097
qla24xx_intr_handler(int irq, void *dev_id)
2098
{
2099 2100
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
2101 2102 2103 2104 2105 2106
	struct device_reg_24xx __iomem *reg;
	int		status;
	unsigned long	iter;
	uint32_t	stat;
	uint32_t	hccr;
	uint16_t	mb[4];
2107
	struct rsp_que *rsp;
2108
	unsigned long	flags;
2109

2110 2111
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2112
		printk(KERN_INFO
2113
		    "%s(): NULL response queue pointer.\n", __func__);
2114 2115 2116
		return IRQ_NONE;
	}

2117
	ha = rsp->hw;
2118 2119 2120
	reg = &ha->iobase->isp24;
	status = 0;

2121 2122 2123
	if (unlikely(pci_channel_offline(ha->pdev)))
		return IRQ_HANDLED;

2124
	spin_lock_irqsave(&ha->hardware_lock, flags);
2125
	vha = pci_get_drvdata(ha->pdev);
2126 2127 2128
	for (iter = 50; iter--; ) {
		stat = RD_REG_DWORD(&reg->host_status);
		if (stat & HSRX_RISC_PAUSED) {
2129
			if (unlikely(pci_channel_offline(ha->pdev)))
2130 2131
				break;

2132 2133
			hccr = RD_REG_DWORD(&reg->hccr);

2134 2135 2136
			ql_log(ql_log_warn, vha, 0x504b,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2137

2138
			qla2xxx_check_risc_status(vha);
2139

2140 2141
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2142 2143 2144 2145 2146 2147 2148 2149 2150
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
		case 0x1:
		case 0x2:
		case 0x10:
		case 0x11:
2151
			qla24xx_mbx_completion(vha, MSW(stat));
2152 2153 2154 2155 2156 2157 2158 2159
			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);
2160
			qla2x00_async_event(vha, rsp, mb);
2161 2162
			break;
		case 0x13:
2163
		case 0x14:
2164
			qla24xx_process_response_queue(vha, rsp);
2165 2166
			break;
		default:
2167 2168
			ql_dbg(ql_dbg_async, vha, 0x504f,
			    "Unrecognized interrupt type (%d).\n", stat * 0xff);
2169 2170 2171 2172 2173
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
	}
2174
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2175 2176 2177 2178

	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);
2179
		complete(&ha->mbx_intr_comp);
2180 2181 2182 2183 2184
	}

	return IRQ_HANDLED;
}

2185 2186 2187
static irqreturn_t
qla24xx_msix_rsp_q(int irq, void *dev_id)
{
2188 2189
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2190
	struct device_reg_24xx __iomem *reg;
2191
	struct scsi_qla_host *vha;
2192
	unsigned long flags;
2193

2194 2195 2196
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
		printk(KERN_INFO
2197
		"%s(): NULL response queue pointer.\n", __func__);
2198 2199 2200
		return IRQ_NONE;
	}
	ha = rsp->hw;
2201 2202
	reg = &ha->iobase->isp24;

2203
	spin_lock_irqsave(&ha->hardware_lock, flags);
2204

2205
	vha = pci_get_drvdata(ha->pdev);
2206
	qla24xx_process_response_queue(vha, rsp);
2207
	if (!ha->flags.disable_msix_handshake) {
2208 2209 2210
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
	}
2211
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2212 2213 2214 2215

	return IRQ_HANDLED;
}

2216 2217 2218 2219 2220
static irqreturn_t
qla25xx_msix_rsp_q(int irq, void *dev_id)
{
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2221
	struct device_reg_24xx __iomem *reg;
2222
	unsigned long flags;
2223 2224 2225 2226

	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
		printk(KERN_INFO
2227
			"%s(): NULL response queue pointer.\n", __func__);
2228 2229 2230 2231
		return IRQ_NONE;
	}
	ha = rsp->hw;

2232
	/* Clear the interrupt, if enabled, for this response queue */
2233
	if (!ha->flags.disable_msix_handshake) {
2234
		reg = &ha->iobase->isp24;
2235
		spin_lock_irqsave(&ha->hardware_lock, flags);
2236 2237
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
		RD_REG_DWORD_RELAXED(&reg->hccr);
2238
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
2239
	}
2240 2241 2242 2243 2244
	queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);

	return IRQ_HANDLED;
}

2245 2246 2247
static irqreturn_t
qla24xx_msix_default(int irq, void *dev_id)
{
2248 2249 2250
	scsi_qla_host_t	*vha;
	struct qla_hw_data *ha;
	struct rsp_que *rsp;
2251 2252 2253 2254 2255
	struct device_reg_24xx __iomem *reg;
	int		status;
	uint32_t	stat;
	uint32_t	hccr;
	uint16_t	mb[4];
2256
	unsigned long flags;
2257

2258 2259
	rsp = (struct rsp_que *) dev_id;
	if (!rsp) {
2260 2261
		printk(KERN_INFO
			"%s(): NULL response queue pointer.\n", __func__);
2262 2263 2264
		return IRQ_NONE;
	}
	ha = rsp->hw;
2265 2266 2267
	reg = &ha->iobase->isp24;
	status = 0;

2268
	spin_lock_irqsave(&ha->hardware_lock, flags);
2269
	vha = pci_get_drvdata(ha->pdev);
2270
	do {
2271 2272
		stat = RD_REG_DWORD(&reg->host_status);
		if (stat & HSRX_RISC_PAUSED) {
2273
			if (unlikely(pci_channel_offline(ha->pdev)))
2274 2275
				break;

2276 2277
			hccr = RD_REG_DWORD(&reg->hccr);

2278 2279 2280
			ql_log(ql_log_info, vha, 0x5050,
			    "RISC paused -- HCCR=%x, Dumping firmware.\n",
			    hccr);
2281

2282
			qla2xxx_check_risc_status(vha);
2283

2284 2285
			ha->isp_ops->fw_dump(vha, 1);
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2286 2287 2288 2289 2290 2291 2292 2293 2294
			break;
		} else if ((stat & HSRX_RISC_INT) == 0)
			break;

		switch (stat & 0xff) {
		case 0x1:
		case 0x2:
		case 0x10:
		case 0x11:
2295
			qla24xx_mbx_completion(vha, MSW(stat));
2296 2297 2298 2299 2300 2301 2302 2303
			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);
2304
			qla2x00_async_event(vha, rsp, mb);
2305 2306
			break;
		case 0x13:
2307
		case 0x14:
2308
			qla24xx_process_response_queue(vha, rsp);
2309 2310
			break;
		default:
2311 2312
			ql_dbg(ql_dbg_async, vha, 0x5051,
			    "Unrecognized interrupt type (%d).\n", stat & 0xff);
2313 2314 2315
			break;
		}
		WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
2316
	} while (0);
2317
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2318 2319 2320 2321

	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);
2322
		complete(&ha->mbx_intr_comp);
2323 2324 2325 2326 2327 2328 2329 2330
	}
	return IRQ_HANDLED;
}

/* Interrupt handling helpers. */

struct qla_init_msix_entry {
	const char *name;
2331
	irq_handler_t handler;
2332 2333
};

2334
static struct qla_init_msix_entry msix_entries[3] = {
2335 2336
	{ "qla2xxx (default)", qla24xx_msix_default },
	{ "qla2xxx (rsp_q)", qla24xx_msix_rsp_q },
2337
	{ "qla2xxx (multiq)", qla25xx_msix_rsp_q },
2338 2339
};

2340 2341 2342 2343 2344
static struct qla_init_msix_entry qla82xx_msix_entries[2] = {
	{ "qla2xxx (default)", qla82xx_msix_default },
	{ "qla2xxx (rsp_q)", qla82xx_msix_rsp_q },
};

2345
static void
2346
qla24xx_disable_msix(struct qla_hw_data *ha)
2347 2348 2349
{
	int i;
	struct qla_msix_entry *qentry;
2350
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2351

2352 2353
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
2354
		if (qentry->have_irq)
2355
			free_irq(qentry->vector, qentry->rsp);
2356 2357
	}
	pci_disable_msix(ha->pdev);
2358 2359 2360
	kfree(ha->msix_entries);
	ha->msix_entries = NULL;
	ha->flags.msix_enabled = 0;
2361 2362
	ql_dbg(ql_dbg_init, vha, 0x0042,
	    "Disabled the MSI.\n");
2363 2364 2365
}

static int
2366
qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
2367
{
2368
#define MIN_MSIX_COUNT	2
2369
	int i, ret;
2370
	struct msix_entry *entries;
2371
	struct qla_msix_entry *qentry;
2372
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2373 2374

	entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
2375
			GFP_KERNEL);
2376 2377 2378
	if (!entries) {
		ql_log(ql_log_warn, vha, 0x00bc,
		    "Failed to allocate memory for msix_entry.\n");
2379
		return -ENOMEM;
2380
	}
2381

2382 2383
	for (i = 0; i < ha->msix_count; i++)
		entries[i].entry = i;
2384

2385
	ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
2386
	if (ret) {
2387 2388 2389
		if (ret < MIN_MSIX_COUNT)
			goto msix_failed;

2390 2391 2392 2393
		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);
2394 2395 2396
		ha->msix_count = ret;
		ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
		if (ret) {
2397
msix_failed:
2398 2399 2400 2401
			ql_log(ql_log_fatal, vha, 0x00c7,
			    "MSI-X: Failed to enable support, "
			    "giving   up -- %d/%d.\n",
			    ha->msix_count, ret);
2402 2403
			goto msix_out;
		}
2404
		ha->max_rsp_queues = ha->msix_count - 1;
2405 2406 2407 2408
	}
	ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
				ha->msix_count, GFP_KERNEL);
	if (!ha->msix_entries) {
2409 2410
		ql_log(ql_log_fatal, vha, 0x00c8,
		    "Failed to allocate memory for ha->msix_entries.\n");
2411
		ret = -ENOMEM;
2412 2413 2414 2415
		goto msix_out;
	}
	ha->flags.msix_enabled = 1;

2416 2417 2418 2419
	for (i = 0; i < ha->msix_count; i++) {
		qentry = &ha->msix_entries[i];
		qentry->vector = entries[i].vector;
		qentry->entry = entries[i].entry;
2420
		qentry->have_irq = 0;
2421
		qentry->rsp = NULL;
2422 2423
	}

2424 2425 2426
	/* Enable MSI-X vectors for the base queue */
	for (i = 0; i < 2; i++) {
		qentry = &ha->msix_entries[i];
2427 2428 2429 2430 2431 2432 2433 2434 2435
		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);
		}
2436
		if (ret) {
2437 2438 2439
			ql_log(ql_log_fatal, vha, 0x00cb,
			    "MSI-X: unable to register handler -- %x/%d.\n",
			    qentry->vector, ret);
2440 2441 2442 2443 2444 2445 2446
			qla24xx_disable_msix(ha);
			ha->mqenable = 0;
			goto msix_out;
		}
		qentry->have_irq = 1;
		qentry->rsp = rsp;
		rsp->msix = qentry;
2447 2448 2449
	}

	/* Enable MSI-X vector for response queue update for queue 0 */
2450 2451 2452 2453 2454 2455 2456 2457
	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;
2458 2459 2460 2461 2462 2463
	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);
2464

2465
msix_out:
2466
	kfree(entries);
2467 2468 2469 2470
	return ret;
}

int
2471
qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
2472 2473
{
	int ret;
2474
	device_reg_t __iomem *reg = ha->iobase;
2475
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2476 2477

	/* If possible, enable MSI-X. */
2478 2479
	if (!IS_QLA2432(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
		!IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha))
2480 2481 2482 2483 2484 2485
		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)) {
2486 2487
		ql_log(ql_log_warn, vha, 0x0034,
		    "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
2488
			ha->pdev->subsystem_vendor,
2489
			ha->pdev->subsystem_device);
2490 2491
		goto skip_msi;
	}
2492

2493
	if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX)) {
2494 2495
		ql_log(ql_log_warn, vha, 0x0035,
		    "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
2496
		    ha->pdev->revision, QLA_MSIX_CHIP_REV_24XX);
2497 2498 2499
		goto skip_msix;
	}

2500
	ret = qla24xx_enable_msix(ha, rsp);
2501
	if (!ret) {
2502 2503 2504
		ql_dbg(ql_dbg_init, vha, 0x0036,
		    "MSI-X: Enabled (0x%X, 0x%X).\n",
		    ha->chip_revision, ha->fw_attributes);
2505
		goto clear_risc_ints;
2506
	}
2507 2508
	ql_log(ql_log_info, vha, 0x0037,
	    "MSI-X Falling back-to MSI mode -%d.\n", ret);
2509
skip_msix:
2510

2511 2512
	if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
	    !IS_QLA8001(ha))
2513 2514 2515 2516
		goto skip_msi;

	ret = pci_enable_msi(ha->pdev);
	if (!ret) {
2517 2518
		ql_dbg(ql_dbg_init, vha, 0x0038,
		    "MSI: Enabled.\n");
2519
		ha->flags.msi_enabled = 1;
2520
	} else
2521 2522
		ql_log(ql_log_warn, vha, 0x0039,
		    "MSI-X; Falling back-to INTa mode -- %d.\n", ret);
2523 2524
skip_msi:

2525
	ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
2526 2527
	    ha->flags.msi_enabled ? 0 : IRQF_SHARED,
	    QLA2XXX_DRIVER_NAME, rsp);
2528
	if (ret) {
2529
		ql_log(ql_log_warn, vha, 0x003a,
2530 2531
		    "Failed to reserve interrupt %d already in use.\n",
		    ha->pdev->irq);
2532 2533
		goto fail;
	}
2534

2535 2536
clear_risc_ints:

2537 2538 2539 2540
	/*
	 * FIXME: Noted that 8014s were being dropped during NK testing.
	 * Timing deltas during MSI-X/INTa transitions?
	 */
2541
	if (IS_QLA81XX(ha) || IS_QLA82XX(ha) || IS_QLA83XX(ha))
2542
		goto fail;
2543
	spin_lock_irq(&ha->hardware_lock);
2544 2545 2546 2547 2548 2549 2550
	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);
2551
	}
2552
	spin_unlock_irq(&ha->hardware_lock);
2553

2554
fail:
2555 2556 2557 2558
	return ret;
}

void
2559
qla2x00_free_irqs(scsi_qla_host_t *vha)
2560
{
2561
	struct qla_hw_data *ha = vha->hw;
2562
	struct rsp_que *rsp = ha->rsp_q_map[0];
2563 2564 2565

	if (ha->flags.msix_enabled)
		qla24xx_disable_msix(ha);
2566
	else if (ha->flags.msi_enabled) {
2567
		free_irq(ha->pdev->irq, rsp);
2568
		pci_disable_msi(ha->pdev);
2569 2570
	} else
		free_irq(ha->pdev->irq, rsp);
2571
}
2572

2573 2574 2575 2576

int qla25xx_request_irq(struct rsp_que *rsp)
{
	struct qla_hw_data *ha = rsp->hw;
2577
	struct qla_init_msix_entry *intr = &msix_entries[2];
2578
	struct qla_msix_entry *msix = rsp->msix;
2579
	scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
2580 2581 2582 2583
	int ret;

	ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
	if (ret) {
2584 2585 2586
		ql_log(ql_log_fatal, vha, 0x00e6,
		    "MSI-X: Unable to register handler -- %x/%d.\n",
		    msix->vector, ret);
2587 2588 2589 2590 2591 2592
		return ret;
	}
	msix->have_irq = 1;
	msix->rsp = rsp;
	return ret;
}