qla_mbx.c 90.5 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
A
Andrew Vasquez 已提交
2
 * QLogic Fibre Channel HBA Driver
3
 * Copyright (c)  2003-2008 QLogic Corporation
L
Linus Torvalds 已提交
4
 *
A
Andrew Vasquez 已提交
5
 * See LICENSE.qla2xxx for copyright and licensing details.
L
Linus Torvalds 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 */
#include "qla_def.h"

#include <linux/delay.h>


/*
 * qla2x00_mailbox_command
 *	Issue mailbox command and waits for completion.
 *
 * Input:
 *	ha = adapter block pointer.
 *	mcp = driver internal mbx struct pointer.
 *
 * Output:
 *	mb[MAX_MAILBOX_REGISTER_COUNT] = returned mailbox data.
 *
 * Returns:
 *	0 : QLA_SUCCESS = cmd performed success
 *	1 : QLA_FUNCTION_FAILED   (error encountered)
 *	6 : QLA_FUNCTION_TIMEOUT (timeout condition encountered)
 *
 * Context:
 *	Kernel context.
 */
static int
32
qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
L
Linus Torvalds 已提交
33 34 35
{
	int		rval;
	unsigned long    flags = 0;
36
	device_reg_t __iomem *reg;
37
	uint8_t		abort_active;
38
	uint8_t		io_lock_on;
L
Linus Torvalds 已提交
39 40 41 42 43 44
	uint16_t	command;
	uint16_t	*iptr;
	uint16_t __iomem *optr;
	uint32_t	cnt;
	uint32_t	mboxes;
	unsigned long	wait_time;
45 46
	struct qla_hw_data *ha = vha->hw;
	scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
47

48 49 50
	if (ha->pdev->error_state > pci_channel_io_frozen)
		return QLA_FUNCTION_TIMEOUT;

51
	reg = ha->iobase;
52
	io_lock_on = base_vha->flags.init_done;
L
Linus Torvalds 已提交
53 54

	rval = QLA_SUCCESS;
55
	abort_active = test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
56

57
	DEBUG11(printk("%s(%ld): entered.\n", __func__, base_vha->host_no));
L
Linus Torvalds 已提交
58 59

	/*
60 61 62
	 * Wait for active mailbox commands to finish by waiting at most tov
	 * seconds. This is to serialize actual issuing of mailbox cmds during
	 * non ISP abort time.
L
Linus Torvalds 已提交
63
	 */
64 65 66 67 68
	if (!wait_for_completion_timeout(&ha->mbx_cmd_comp, mcp->tov * HZ)) {
		/* Timeout occurred. Return error. */
		DEBUG2_3_11(printk("%s(%ld): cmd access timeout. "
		    "Exiting.\n", __func__, base_vha->host_no));
		return QLA_FUNCTION_TIMEOUT;
L
Linus Torvalds 已提交
69 70 71 72 73 74
	}

	ha->flags.mbox_busy = 1;
	/* Save mailbox command for debug */
	ha->mcp = mcp;

75
	DEBUG11(printk("scsi(%ld): prepare to issue mbox cmd=0x%x.\n",
76
	    base_vha->host_no, mcp->mb[0]));
L
Linus Torvalds 已提交
77 78 79 80

	spin_lock_irqsave(&ha->hardware_lock, flags);

	/* Load mailbox registers. */
81
	if (IS_FWI2_CAPABLE(ha))
82 83 84
		optr = (uint16_t __iomem *)&reg->isp24.mailbox0;
	else
		optr = (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 0);
L
Linus Torvalds 已提交
85 86 87 88 89 90 91

	iptr = mcp->mb;
	command = mcp->mb[0];
	mboxes = mcp->out_mb;

	for (cnt = 0; cnt < ha->mbx_count; cnt++) {
		if (IS_QLA2200(ha) && cnt == 8)
92 93
			optr =
			    (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 8);
L
Linus Torvalds 已提交
94 95 96 97 98 99 100 101 102
		if (mboxes & BIT_0)
			WRT_REG_WORD(optr, *iptr);

		mboxes >>= 1;
		optr++;
		iptr++;
	}

#if defined(QL_DEBUG_LEVEL_1)
103
	printk("%s(%ld): Loaded MBX registers (displayed in bytes) = \n",
104
	    __func__, base_vha->host_no);
L
Linus Torvalds 已提交
105 106 107 108 109 110
	qla2x00_dump_buffer((uint8_t *)mcp->mb, 16);
	printk("\n");
	qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x10), 16);
	printk("\n");
	qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x20), 8);
	printk("\n");
111 112 113
	printk("%s(%ld): I/O address = %p.\n", __func__, base_vha->host_no,
		optr);
	qla2x00_dump_regs(base_vha);
L
Linus Torvalds 已提交
114 115 116 117 118 119 120
#endif

	/* Issue set host interrupt command to send cmd out. */
	ha->flags.mbox_int = 0;
	clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);

	/* Unlock mbx registers and wait for interrupt */
121
	DEBUG11(printk("%s(%ld): going to unlock irq & waiting for interrupt. "
122
	    "jiffies=%lx.\n", __func__, base_vha->host_no, jiffies));
L
Linus Torvalds 已提交
123 124 125

	/* Wait for mbx cmd completion until timeout */

126
	if ((!abort_active && io_lock_on) || IS_NOPOLLING_TYPE(ha)) {
L
Linus Torvalds 已提交
127 128
		set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);

129
		if (IS_FWI2_CAPABLE(ha))
130 131 132
			WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
		else
			WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
L
Linus Torvalds 已提交
133 134
		spin_unlock_irqrestore(&ha->hardware_lock, flags);

135
		wait_for_completion_timeout(&ha->mbx_intr_comp, mcp->tov * HZ);
L
Linus Torvalds 已提交
136 137 138 139

		clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);

	} else {
140
		DEBUG3_11(printk("%s(%ld): cmd=%x POLLING MODE.\n", __func__,
141
		    base_vha->host_no, command));
L
Linus Torvalds 已提交
142

143
		if (IS_FWI2_CAPABLE(ha))
144 145 146
			WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
		else
			WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
L
Linus Torvalds 已提交
147 148 149 150 151 152 153 154
		spin_unlock_irqrestore(&ha->hardware_lock, flags);

		wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */
		while (!ha->flags.mbox_int) {
			if (time_after(jiffies, wait_time))
				break;

			/* Check for pending interrupts. */
155
			qla2x00_poll(ha->rsp_q_map[0]);
L
Linus Torvalds 已提交
156

157 158 159
			if (command != MBC_LOAD_RISC_RAM_EXTENDED &&
			    !ha->flags.mbox_int)
				msleep(10);
L
Linus Torvalds 已提交
160 161 162 163 164 165 166
		} /* while */
	}

	/* Check whether we timed out */
	if (ha->flags.mbox_int) {
		uint16_t *iptr2;

167
		DEBUG3_11(printk("%s(%ld): cmd %x completed.\n", __func__,
168
		    base_vha->host_no, command));
L
Linus Torvalds 已提交
169 170 171 172 173

		/* Got interrupt. Clear the flag. */
		ha->flags.mbox_int = 0;
		clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);

174
		if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE)
L
Linus Torvalds 已提交
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
			rval = QLA_FUNCTION_FAILED;

		/* Load return mailbox registers. */
		iptr2 = mcp->mb;
		iptr = (uint16_t *)&ha->mailbox_out[0];
		mboxes = mcp->in_mb;
		for (cnt = 0; cnt < ha->mbx_count; cnt++) {
			if (mboxes & BIT_0)
				*iptr2 = *iptr;

			mboxes >>= 1;
			iptr2++;
			iptr++;
		}
	} else {

#if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3) || \
		defined(QL_DEBUG_LEVEL_11)
193 194 195
		uint16_t mb0;
		uint32_t ictrl;

196
		if (IS_FWI2_CAPABLE(ha)) {
197 198 199
			mb0 = RD_REG_WORD(&reg->isp24.mailbox0);
			ictrl = RD_REG_DWORD(&reg->isp24.ictrl);
		} else {
200
			mb0 = RD_MAILBOX_REG(ha, &reg->isp, 0);
201 202 203
			ictrl = RD_REG_WORD(&reg->isp.ictrl);
		}
		printk("%s(%ld): **** MB Command Timeout for cmd %x ****\n",
204
		    __func__, base_vha->host_no, command);
205
		printk("%s(%ld): icontrol=%x jiffies=%lx\n", __func__,
206
		    base_vha->host_no, ictrl, jiffies);
207
		printk("%s(%ld): *** mailbox[0] = 0x%x ***\n", __func__,
208 209
		    base_vha->host_no, mb0);
		qla2x00_dump_regs(base_vha);
L
Linus Torvalds 已提交
210 211 212 213 214 215 216 217 218 219
#endif

		rval = QLA_FUNCTION_TIMEOUT;
	}

	ha->flags.mbox_busy = 0;

	/* Clean up */
	ha->mcp = NULL;

220
	if ((abort_active || !io_lock_on) && !IS_NOPOLLING_TYPE(ha)) {
221
		DEBUG11(printk("%s(%ld): checking for additional resp "
222
		    "interrupt.\n", __func__, base_vha->host_no));
L
Linus Torvalds 已提交
223 224

		/* polling mode for non isp_abort commands. */
225
		qla2x00_poll(ha->rsp_q_map[0]);
L
Linus Torvalds 已提交
226 227
	}

228 229
	if (rval == QLA_FUNCTION_TIMEOUT &&
	    mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) {
L
Linus Torvalds 已提交
230 231
		if (!io_lock_on || (mcp->flags & IOCTL_CMD)) {
			/* not in dpc. schedule it for dpc to take over. */
232
			DEBUG(printk("%s(%ld): timeout schedule "
233 234
			"isp_abort_needed.\n", __func__,
			base_vha->host_no));
235
			DEBUG2_3_11(printk("%s(%ld): timeout schedule "
236 237
			"isp_abort_needed.\n", __func__,
			base_vha->host_no));
L
Linus Torvalds 已提交
238
			qla_printk(KERN_WARNING, ha,
239
			    "Mailbox command timeout occurred. Scheduling ISP "
L
Linus Torvalds 已提交
240
			    "abort.\n");
241 242
			set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);
			qla2xxx_wake_dpc(vha);
L
Linus Torvalds 已提交
243 244
		} else if (!abort_active) {
			/* call abort directly since we are in the DPC thread */
245
			DEBUG(printk("%s(%ld): timeout calling abort_isp\n",
246
			    __func__, base_vha->host_no));
247
			DEBUG2_3_11(printk("%s(%ld): timeout calling "
248
			    "abort_isp\n", __func__, base_vha->host_no));
L
Linus Torvalds 已提交
249
			qla_printk(KERN_WARNING, ha,
250
			    "Mailbox command timeout occurred. Issuing ISP "
L
Linus Torvalds 已提交
251 252
			    "abort.\n");

253 254 255
			set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
			clear_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);
			if (qla2x00_abort_isp(base_vha)) {
256
				/* Failed. retry later. */
257
				set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);
L
Linus Torvalds 已提交
258
			}
259
			clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
260
			DEBUG(printk("%s(%ld): finished abort_isp\n", __func__,
261
			    base_vha->host_no));
262
			DEBUG2_3_11(printk("%s(%ld): finished abort_isp\n",
263
			    __func__, base_vha->host_no));
L
Linus Torvalds 已提交
264 265 266 267
		}
	}

	/* Allow next mbx cmd to come in. */
268
	complete(&ha->mbx_cmd_comp);
L
Linus Torvalds 已提交
269 270

	if (rval) {
271
		DEBUG2_3_11(printk("%s(%ld): **** FAILED. mbx0=%x, mbx1=%x, "
272
		    "mbx2=%x, cmd=%x ****\n", __func__, base_vha->host_no,
273
		    mcp->mb[0], mcp->mb[1], mcp->mb[2], command));
L
Linus Torvalds 已提交
274
	} else {
275 276
		DEBUG11(printk("%s(%ld): done.\n", __func__,
		base_vha->host_no));
L
Linus Torvalds 已提交
277 278 279 280 281 282
	}

	return rval;
}

int
283
qla2x00_load_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t risc_addr,
284
    uint32_t risc_code_size)
L
Linus Torvalds 已提交
285 286
{
	int rval;
287
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
288 289 290
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

291
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
292

293
	if (MSW(risc_addr) || IS_FWI2_CAPABLE(ha)) {
294 295 296
		mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
		mcp->mb[8] = MSW(risc_addr);
		mcp->out_mb = MBX_8|MBX_0;
L
Linus Torvalds 已提交
297
	} else {
298 299
		mcp->mb[0] = MBC_LOAD_RISC_RAM;
		mcp->out_mb = MBX_0;
L
Linus Torvalds 已提交
300 301 302 303 304 305
	}
	mcp->mb[1] = LSW(risc_addr);
	mcp->mb[2] = MSW(req_dma);
	mcp->mb[3] = LSW(req_dma);
	mcp->mb[6] = MSW(MSD(req_dma));
	mcp->mb[7] = LSW(MSD(req_dma));
306
	mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
307
	if (IS_FWI2_CAPABLE(ha)) {
308 309 310 311 312 313 314 315
		mcp->mb[4] = MSW(risc_code_size);
		mcp->mb[5] = LSW(risc_code_size);
		mcp->out_mb |= MBX_5|MBX_4;
	} else {
		mcp->mb[4] = LSW(risc_code_size);
		mcp->out_mb |= MBX_4;
	}

L
Linus Torvalds 已提交
316
	mcp->in_mb = MBX_0;
317
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
318
	mcp->flags = 0;
319
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
320 321

	if (rval != QLA_SUCCESS) {
322
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
323
		    vha->host_no, rval, mcp->mb[0]));
L
Linus Torvalds 已提交
324
	} else {
325
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
326 327 328 329 330 331 332
	}

	return rval;
}

/*
 * qla2x00_execute_fw
333
 *     Start adapter firmware.
L
Linus Torvalds 已提交
334 335
 *
 * Input:
336 337 338
 *     ha = adapter block pointer.
 *     TARGET_QUEUE_LOCK must be released.
 *     ADAPTER_STATE_LOCK must be released.
L
Linus Torvalds 已提交
339 340
 *
 * Returns:
341
 *     qla2x00 local function return status code.
L
Linus Torvalds 已提交
342 343
 *
 * Context:
344
 *     Kernel context.
L
Linus Torvalds 已提交
345 346
 */
int
347
qla2x00_execute_fw(scsi_qla_host_t *vha, uint32_t risc_addr)
L
Linus Torvalds 已提交
348 349
{
	int rval;
350
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
351 352 353
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

354
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
355 356

	mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
357 358
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0;
359
	if (IS_FWI2_CAPABLE(ha)) {
360 361 362
		mcp->mb[1] = MSW(risc_addr);
		mcp->mb[2] = LSW(risc_addr);
		mcp->mb[3] = 0;
363 364
		mcp->mb[4] = 0;
		mcp->out_mb |= MBX_4|MBX_3|MBX_2|MBX_1;
365 366 367 368 369 370 371 372
		mcp->in_mb |= MBX_1;
	} else {
		mcp->mb[1] = LSW(risc_addr);
		mcp->out_mb |= MBX_1;
		if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
			mcp->mb[2] = 0;
			mcp->out_mb |= MBX_2;
		}
L
Linus Torvalds 已提交
373 374
	}

375
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
376
	mcp->flags = 0;
377
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
378

379 380
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
381
		    vha->host_no, rval, mcp->mb[0]));
382
	} else {
383
		if (IS_FWI2_CAPABLE(ha)) {
384
			DEBUG11(printk("%s(%ld): done exchanges=%x.\n",
385
			    __func__, vha->host_no, mcp->mb[1]));
386 387
		} else {
			DEBUG11(printk("%s(%ld): done.\n", __func__,
388
			    vha->host_no));
389 390
		}
	}
L
Linus Torvalds 已提交
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410

	return rval;
}

/*
 * qla2x00_get_fw_version
 *	Get firmware version.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	major:		pointer for major number.
 *	minor:		pointer for minor number.
 *	subminor:	pointer for subminor number.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
411
int
412
qla2x00_get_fw_version(scsi_qla_host_t *vha, uint16_t *major, uint16_t *minor,
413
    uint16_t *subminor, uint16_t *attributes, uint32_t *memory, uint8_t *mpi,
414
    uint32_t *mpi_caps, uint8_t *phy)
L
Linus Torvalds 已提交
415 416 417 418 419
{
	int		rval;
	mbx_cmd_t	mc;
	mbx_cmd_t	*mcp = &mc;

420
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
421 422 423 424

	mcp->mb[0] = MBC_GET_FIRMWARE_VERSION;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
425
	if (IS_QLA81XX(vha->hw))
426
		mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8;
L
Linus Torvalds 已提交
427
	mcp->flags = 0;
428
	mcp->tov = MBX_TOV_SECONDS;
429
	rval = qla2x00_mailbox_command(vha, mcp);
430 431
	if (rval != QLA_SUCCESS)
		goto failed;
L
Linus Torvalds 已提交
432 433 434 435 436 437

	/* Return mailbox data. */
	*major = mcp->mb[1];
	*minor = mcp->mb[2];
	*subminor = mcp->mb[3];
	*attributes = mcp->mb[6];
438
	if (IS_QLA2100(vha->hw) || IS_QLA2200(vha->hw))
L
Linus Torvalds 已提交
439 440 441
		*memory = 0x1FFFF;			/* Defaults to 128KB. */
	else
		*memory = (mcp->mb[5] << 16) | mcp->mb[4];
442
	if (IS_QLA81XX(vha->hw)) {
443 444 445
		mpi[0] = mcp->mb[10] & 0xff;
		mpi[1] = mcp->mb[11] >> 8;
		mpi[2] = mcp->mb[11] & 0xff;
446
		*mpi_caps = (mcp->mb[12] << 16) | mcp->mb[13];
447 448 449
		phy[0] = mcp->mb[8] & 0xff;
		phy[1] = mcp->mb[9] >> 8;
		phy[2] = mcp->mb[9] & 0xff;
450
	}
451
failed:
L
Linus Torvalds 已提交
452 453 454
	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
455
		    vha->host_no, rval));
L
Linus Torvalds 已提交
456 457
	} else {
		/*EMPTY*/
458
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
459
	}
460
	return rval;
L
Linus Torvalds 已提交
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
}

/*
 * qla2x00_get_fw_options
 *	Set firmware options.
 *
 * Input:
 *	ha = adapter block pointer.
 *	fwopt = pointer for firmware options.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
478
qla2x00_get_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
L
Linus Torvalds 已提交
479 480 481 482 483
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

484
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
485 486 487 488

	mcp->mb[0] = MBC_GET_FIRMWARE_OPTION;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
489
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
490
	mcp->flags = 0;
491
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
492 493 494 495

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
496
		    vha->host_no, rval));
L
Linus Torvalds 已提交
497
	} else {
498
		fwopts[0] = mcp->mb[0];
L
Linus Torvalds 已提交
499 500 501 502
		fwopts[1] = mcp->mb[1];
		fwopts[2] = mcp->mb[2];
		fwopts[3] = mcp->mb[3];

503
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
	}

	return rval;
}


/*
 * qla2x00_set_fw_options
 *	Set firmware options.
 *
 * Input:
 *	ha = adapter block pointer.
 *	fwopt = pointer for firmware options.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
525
qla2x00_set_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
L
Linus Torvalds 已提交
526 527 528 529 530
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

531
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
532 533 534 535 536

	mcp->mb[0] = MBC_SET_FIRMWARE_OPTION;
	mcp->mb[1] = fwopts[1];
	mcp->mb[2] = fwopts[2];
	mcp->mb[3] = fwopts[3];
537
	mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
L
Linus Torvalds 已提交
538
	mcp->in_mb = MBX_0;
539
	if (IS_FWI2_CAPABLE(vha->hw)) {
540 541 542 543 544 545 546
		mcp->in_mb |= MBX_1;
	} else {
		mcp->mb[10] = fwopts[10];
		mcp->mb[11] = fwopts[11];
		mcp->mb[12] = 0;	/* Undocumented, but used */
		mcp->out_mb |= MBX_12|MBX_11|MBX_10;
	}
547
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
548
	mcp->flags = 0;
549
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
550

551 552
	fwopts[0] = mcp->mb[0];

L
Linus Torvalds 已提交
553 554
	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
555
		DEBUG2_3_11(printk("%s(%ld): failed=%x (%x/%x).\n", __func__,
556
		    vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
L
Linus Torvalds 已提交
557 558
	} else {
		/*EMPTY*/
559
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
	}

	return rval;
}

/*
 * qla2x00_mbx_reg_test
 *	Mailbox register wrap test.
 *
 * Input:
 *	ha = adapter block pointer.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
581
qla2x00_mbx_reg_test(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
582 583 584 585 586
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

587
	DEBUG11(printk("qla2x00_mbx_reg_test(%ld): entered.\n", vha->host_no));
L
Linus Torvalds 已提交
588 589 590 591 592 593 594 595 596 597 598

	mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
	mcp->mb[1] = 0xAAAA;
	mcp->mb[2] = 0x5555;
	mcp->mb[3] = 0xAA55;
	mcp->mb[4] = 0x55AA;
	mcp->mb[5] = 0xA5A5;
	mcp->mb[6] = 0x5A5A;
	mcp->mb[7] = 0x2525;
	mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
599
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
600
	mcp->flags = 0;
601
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
602 603 604 605 606 607 608 609 610 611 612 613 614

	if (rval == QLA_SUCCESS) {
		if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
		    mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA)
			rval = QLA_FUNCTION_FAILED;
		if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
		    mcp->mb[7] != 0x2525)
			rval = QLA_FUNCTION_FAILED;
	}

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("qla2x00_mbx_reg_test(%ld): failed=%x.\n",
615
		    vha->host_no, rval));
L
Linus Torvalds 已提交
616 617 618
	} else {
		/*EMPTY*/
		DEBUG11(printk("qla2x00_mbx_reg_test(%ld): done.\n",
619
		    vha->host_no));
L
Linus Torvalds 已提交
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
	}

	return rval;
}

/*
 * qla2x00_verify_checksum
 *	Verify firmware checksum.
 *
 * Input:
 *	ha = adapter block pointer.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
641
qla2x00_verify_checksum(scsi_qla_host_t *vha, uint32_t risc_addr)
L
Linus Torvalds 已提交
642 643 644 645 646
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

647
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
648 649

	mcp->mb[0] = MBC_VERIFY_CHECKSUM;
650 651
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0;
652
	if (IS_FWI2_CAPABLE(vha->hw)) {
653 654 655 656 657 658 659 660 661 662
		mcp->mb[1] = MSW(risc_addr);
		mcp->mb[2] = LSW(risc_addr);
		mcp->out_mb |= MBX_2|MBX_1;
		mcp->in_mb |= MBX_2|MBX_1;
	} else {
		mcp->mb[1] = LSW(risc_addr);
		mcp->out_mb |= MBX_1;
		mcp->in_mb |= MBX_1;
	}

663
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
664
	mcp->flags = 0;
665
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
666 667

	if (rval != QLA_SUCCESS) {
668
		DEBUG2_3_11(printk("%s(%ld): failed=%x chk sum=%x.\n", __func__,
669
		    vha->host_no, rval, IS_FWI2_CAPABLE(vha->hw) ?
670
		    (mcp->mb[2] << 16) | mcp->mb[1]: mcp->mb[1]));
L
Linus Torvalds 已提交
671
	} else {
672
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
	}

	return rval;
}

/*
 * qla2x00_issue_iocb
 *	Issue IOCB using mailbox command
 *
 * Input:
 *	ha = adapter state pointer.
 *	buffer = buffer pointer.
 *	phys_addr = physical address of buffer.
 *	size = size of buffer.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
696
static int
697
qla2x00_issue_iocb_timeout(scsi_qla_host_t *vha, void *buffer,
698
    dma_addr_t phys_addr, size_t size, uint32_t tov)
L
Linus Torvalds 已提交
699 700 701 702 703 704 705 706 707 708 709 710 711
{
	int		rval;
	mbx_cmd_t	mc;
	mbx_cmd_t	*mcp = &mc;

	mcp->mb[0] = MBC_IOCB_COMMAND_A64;
	mcp->mb[1] = 0;
	mcp->mb[2] = MSW(phys_addr);
	mcp->mb[3] = LSW(phys_addr);
	mcp->mb[6] = MSW(MSD(phys_addr));
	mcp->mb[7] = LSW(MSD(phys_addr));
	mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_2|MBX_0;
712
	mcp->tov = tov;
L
Linus Torvalds 已提交
713
	mcp->flags = 0;
714
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
715 716 717

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
718
		DEBUG(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n",
719
		    vha->host_no, rval));
L
Linus Torvalds 已提交
720
	} else {
721 722 723 724
		sts_entry_t *sts_entry = (sts_entry_t *) buffer;

		/* Mask reserved bits. */
		sts_entry->entry_status &=
725
		    IS_FWI2_CAPABLE(vha->hw) ? RF_MASK_24XX : RF_MASK;
L
Linus Torvalds 已提交
726 727 728 729 730
	}

	return rval;
}

731
int
732
qla2x00_issue_iocb(scsi_qla_host_t *vha, void *buffer, dma_addr_t phys_addr,
733 734
    size_t size)
{
735
	return qla2x00_issue_iocb_timeout(vha, buffer, phys_addr, size,
736 737 738
	    MBX_TOV_SECONDS);
}

L
Linus Torvalds 已提交
739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
/*
 * qla2x00_abort_command
 *	Abort command aborts a specified IOCB.
 *
 * Input:
 *	ha = adapter block pointer.
 *	sp = SB structure pointer.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
754
qla2x00_abort_command(srb_t *sp)
L
Linus Torvalds 已提交
755 756 757
{
	unsigned long   flags = 0;
	int		rval;
758
	uint32_t	handle = 0;
L
Linus Torvalds 已提交
759 760
	mbx_cmd_t	mc;
	mbx_cmd_t	*mcp = &mc;
761 762
	fc_port_t	*fcport = sp->fcport;
	scsi_qla_host_t *vha = fcport->vha;
763
	struct qla_hw_data *ha = vha->hw;
764
	struct req_que *req = vha->req;
L
Linus Torvalds 已提交
765

766
	DEBUG11(printk("qla2x00_abort_command(%ld): entered.\n", vha->host_no));
L
Linus Torvalds 已提交
767

768
	spin_lock_irqsave(&ha->hardware_lock, flags);
L
Linus Torvalds 已提交
769
	for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
770
		if (req->outstanding_cmds[handle] == sp)
L
Linus Torvalds 已提交
771 772
			break;
	}
773
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
L
Linus Torvalds 已提交
774 775 776 777 778 779 780 781 782 783 784 785 786

	if (handle == MAX_OUTSTANDING_COMMANDS) {
		/* command not found */
		return QLA_FUNCTION_FAILED;
	}

	mcp->mb[0] = MBC_ABORT_COMMAND;
	if (HAS_EXTENDED_IDS(ha))
		mcp->mb[1] = fcport->loop_id;
	else
		mcp->mb[1] = fcport->loop_id << 8;
	mcp->mb[2] = (uint16_t)handle;
	mcp->mb[3] = (uint16_t)(handle >> 16);
787
	mcp->mb[6] = (uint16_t)sp->cmd->device->lun;
L
Linus Torvalds 已提交
788 789
	mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
790
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
791
	mcp->flags = 0;
792
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
793 794 795

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("qla2x00_abort_command(%ld): failed=%x.\n",
796
		    vha->host_no, rval));
L
Linus Torvalds 已提交
797 798
	} else {
		DEBUG11(printk("qla2x00_abort_command(%ld): done.\n",
799
		    vha->host_no));
L
Linus Torvalds 已提交
800 801 802 803 804 805
	}

	return rval;
}

int
806
qla2x00_abort_target(struct fc_port *fcport, unsigned int l, int tag)
L
Linus Torvalds 已提交
807
{
808
	int rval, rval2;
L
Linus Torvalds 已提交
809 810
	mbx_cmd_t  mc;
	mbx_cmd_t  *mcp = &mc;
811
	scsi_qla_host_t *vha;
812 813
	struct req_que *req;
	struct rsp_que *rsp;
L
Linus Torvalds 已提交
814

815
	DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->vha->host_no));
816

817
	l = l;
818
	vha = fcport->vha;
819 820
	req = vha->hw->req_q_map[tag];
	rsp = vha->hw->rsp_q_map[tag];
L
Linus Torvalds 已提交
821
	mcp->mb[0] = MBC_ABORT_TARGET;
822
	mcp->out_mb = MBX_9|MBX_2|MBX_1|MBX_0;
823
	if (HAS_EXTENDED_IDS(vha->hw)) {
L
Linus Torvalds 已提交
824 825 826 827 828 829
		mcp->mb[1] = fcport->loop_id;
		mcp->mb[10] = 0;
		mcp->out_mb |= MBX_10;
	} else {
		mcp->mb[1] = fcport->loop_id << 8;
	}
830 831
	mcp->mb[2] = vha->hw->loop_reset_delay;
	mcp->mb[9] = vha->vp_idx;
L
Linus Torvalds 已提交
832 833

	mcp->in_mb = MBX_0;
834
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
835
	mcp->flags = 0;
836
	rval = qla2x00_mailbox_command(vha, mcp);
837 838
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
839
		    vha->host_no, rval));
840 841 842
	}

	/* Issue marker IOCB. */
843 844
	rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, 0,
							MK_SYNC_ID);
845 846
	if (rval2 != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
847
		    "(%x).\n", __func__, vha->host_no, rval2));
848
	} else {
849
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
850 851 852 853 854 855
	}

	return rval;
}

int
856
qla2x00_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
857 858 859 860
{
	int rval, rval2;
	mbx_cmd_t  mc;
	mbx_cmd_t  *mcp = &mc;
861
	scsi_qla_host_t *vha;
862 863
	struct req_que *req;
	struct rsp_que *rsp;
864

865
	DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->vha->host_no));
L
Linus Torvalds 已提交
866

867
	vha = fcport->vha;
868 869
	req = vha->hw->req_q_map[tag];
	rsp = vha->hw->rsp_q_map[tag];
870 871
	mcp->mb[0] = MBC_LUN_RESET;
	mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
872
	if (HAS_EXTENDED_IDS(vha->hw))
873 874 875 876 877
		mcp->mb[1] = fcport->loop_id;
	else
		mcp->mb[1] = fcport->loop_id << 8;
	mcp->mb[2] = l;
	mcp->mb[3] = 0;
878
	mcp->mb[9] = vha->vp_idx;
L
Linus Torvalds 已提交
879

880
	mcp->in_mb = MBX_0;
881
	mcp->tov = MBX_TOV_SECONDS;
882
	mcp->flags = 0;
883
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
884
	if (rval != QLA_SUCCESS) {
885
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
886
		    vha->host_no, rval));
887 888 889
	}

	/* Issue marker IOCB. */
890 891
	rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
								MK_SYNC_ID_LUN);
892 893
	if (rval2 != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
894
		    "(%x).\n", __func__, vha->host_no, rval2));
L
Linus Torvalds 已提交
895
	} else {
896
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922
	}

	return rval;
}

/*
 * qla2x00_get_adapter_id
 *	Get adapter ID and topology.
 *
 * Input:
 *	ha = adapter block pointer.
 *	id = pointer for loop ID.
 *	al_pa = pointer for AL_PA.
 *	area = pointer for area.
 *	domain = pointer for domain.
 *	top = pointer for topology.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
923
qla2x00_get_adapter_id(scsi_qla_host_t *vha, uint16_t *id, uint8_t *al_pa,
924
    uint8_t *area, uint8_t *domain, uint16_t *top, uint16_t *sw_cap)
L
Linus Torvalds 已提交
925 926 927 928 929 930
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("qla2x00_get_adapter_id(%ld): entered.\n",
931
	    vha->host_no));
L
Linus Torvalds 已提交
932 933

	mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
934
	mcp->mb[9] = vha->vp_idx;
935
	mcp->out_mb = MBX_9|MBX_0;
936
	mcp->in_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
937 938
	if (IS_QLA81XX(vha->hw))
		mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10;
939
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
940
	mcp->flags = 0;
941
	rval = qla2x00_mailbox_command(vha, mcp);
942 943
	if (mcp->mb[0] == MBS_COMMAND_ERROR)
		rval = QLA_COMMAND_ERROR;
944 945
	else if (mcp->mb[0] == MBS_INVALID_COMMAND)
		rval = QLA_INVALID_COMMAND;
L
Linus Torvalds 已提交
946 947 948 949 950 951 952

	/* Return data. */
	*id = mcp->mb[1];
	*al_pa = LSB(mcp->mb[2]);
	*area = MSB(mcp->mb[2]);
	*domain	= LSB(mcp->mb[3]);
	*top = mcp->mb[6];
953
	*sw_cap = mcp->mb[7];
L
Linus Torvalds 已提交
954 955 956 957

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("qla2x00_get_adapter_id(%ld): failed=%x.\n",
958
		    vha->host_no, rval));
L
Linus Torvalds 已提交
959 960
	} else {
		DEBUG11(printk("qla2x00_get_adapter_id(%ld): done.\n",
961
		    vha->host_no));
962 963 964 965 966 967 968 969 970 971 972

		if (IS_QLA81XX(vha->hw)) {
			vha->fcoe_vlan_id = mcp->mb[9] & 0xfff;
			vha->fcoe_fcf_idx = mcp->mb[10];
			vha->fcoe_vn_port_mac[5] = mcp->mb[11] >> 8;
			vha->fcoe_vn_port_mac[4] = mcp->mb[11] & 0xff;
			vha->fcoe_vn_port_mac[3] = mcp->mb[12] >> 8;
			vha->fcoe_vn_port_mac[2] = mcp->mb[12] & 0xff;
			vha->fcoe_vn_port_mac[1] = mcp->mb[13] >> 8;
			vha->fcoe_vn_port_mac[0] = mcp->mb[13] & 0xff;
		}
L
Linus Torvalds 已提交
973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
	}

	return rval;
}

/*
 * qla2x00_get_retry_cnt
 *	Get current firmware login retry count and delay.
 *
 * Input:
 *	ha = adapter block pointer.
 *	retry_cnt = pointer to login retry count.
 *	tov = pointer to login timeout value.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
994
qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
L
Linus Torvalds 已提交
995 996 997 998 999 1000 1001 1002
    uint16_t *r_a_tov)
{
	int rval;
	uint16_t ratov;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("qla2x00_get_retry_cnt(%ld): entered.\n",
1003
			vha->host_no));
L
Linus Torvalds 已提交
1004 1005 1006 1007

	mcp->mb[0] = MBC_GET_RETRY_COUNT;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1008
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
1009
	mcp->flags = 0;
1010
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1011 1012 1013 1014

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("qla2x00_get_retry_cnt(%ld): failed = %x.\n",
1015
		    vha->host_no, mcp->mb[0]));
L
Linus Torvalds 已提交
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
	} else {
		/* Convert returned data and check our values. */
		*r_a_tov = mcp->mb[3] / 2;
		ratov = (mcp->mb[3]/2) / 10;  /* mb[3] value is in 100ms */
		if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) {
			/* Update to the larger values */
			*retry_cnt = (uint8_t)mcp->mb[1];
			*tov = ratov;
		}

		DEBUG11(printk("qla2x00_get_retry_cnt(%ld): done. mb3=%d "
1027
		    "ratov=%d.\n", vha->host_no, mcp->mb[3], ratov));
L
Linus Torvalds 已提交
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
	}

	return rval;
}

/*
 * qla2x00_init_firmware
 *	Initialize adapter firmware.
 *
 * Input:
 *	ha = adapter block pointer.
 *	dptr = Initialization control block pointer.
 *	size = size of initialization control block.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
1051
qla2x00_init_firmware(scsi_qla_host_t *vha, uint16_t size)
L
Linus Torvalds 已提交
1052 1053 1054 1055
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
1056
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1057 1058

	DEBUG11(printk("qla2x00_init_firmware(%ld): entered.\n",
1059
	    vha->host_no));
L
Linus Torvalds 已提交
1060

1061
	if (ha->flags.npiv_supported)
1062 1063 1064 1065
		mcp->mb[0] = MBC_MID_INITIALIZE_FIRMWARE;
	else
		mcp->mb[0] = MBC_INITIALIZE_FIRMWARE;

1066
	mcp->mb[1] = 0;
L
Linus Torvalds 已提交
1067 1068 1069 1070
	mcp->mb[2] = MSW(ha->init_cb_dma);
	mcp->mb[3] = LSW(ha->init_cb_dma);
	mcp->mb[6] = MSW(MSD(ha->init_cb_dma));
	mcp->mb[7] = LSW(MSD(ha->init_cb_dma));
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
	mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	if (IS_QLA81XX(ha) && ha->ex_init_cb->ex_version) {
		mcp->mb[1] = BIT_0;
		mcp->mb[10] = MSW(ha->ex_init_cb_dma);
		mcp->mb[11] = LSW(ha->ex_init_cb_dma);
		mcp->mb[12] = MSW(MSD(ha->ex_init_cb_dma));
		mcp->mb[13] = LSW(MSD(ha->ex_init_cb_dma));
		mcp->mb[14] = sizeof(*ha->ex_init_cb);
		mcp->out_mb |= MBX_14|MBX_13|MBX_12|MBX_11|MBX_10;
	}
	mcp->in_mb = MBX_0;
L
Linus Torvalds 已提交
1082 1083
	mcp->buf_size = size;
	mcp->flags = MBX_DMA_OUT;
1084
	mcp->tov = MBX_TOV_SECONDS;
1085
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1086 1087 1088 1089 1090

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("qla2x00_init_firmware(%ld): failed=%x "
		    "mb0=%x.\n",
1091
		    vha->host_no, rval, mcp->mb[0]));
L
Linus Torvalds 已提交
1092 1093 1094
	} else {
		/*EMPTY*/
		DEBUG11(printk("qla2x00_init_firmware(%ld): done.\n",
1095
		    vha->host_no));
L
Linus Torvalds 已提交
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
	}

	return rval;
}

/*
 * qla2x00_get_port_database
 *	Issue normal/enhanced get port database mailbox command
 *	and copy device name as necessary.
 *
 * Input:
 *	ha = adapter state pointer.
 *	dev = structure pointer.
 *	opt = enhanced cmd option byte.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
1118
qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
L
Linus Torvalds 已提交
1119 1120 1121 1122 1123
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
	port_database_t *pd;
1124
	struct port_database_24xx *pd24;
L
Linus Torvalds 已提交
1125
	dma_addr_t pd_dma;
1126
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1127

1128
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
1129

1130 1131
	pd24 = NULL;
	pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
L
Linus Torvalds 已提交
1132
	if (pd  == NULL) {
1133
		DEBUG2_3(printk("%s(%ld): failed to allocate Port Database "
1134
		    "structure.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
1135 1136
		return QLA_MEMORY_ALLOC_FAILED;
	}
1137
	memset(pd, 0, max(PORT_DATABASE_SIZE, PORT_DATABASE_24XX_SIZE));
L
Linus Torvalds 已提交
1138

1139
	mcp->mb[0] = MBC_GET_PORT_DATABASE;
1140
	if (opt != 0 && !IS_FWI2_CAPABLE(ha))
L
Linus Torvalds 已提交
1141 1142 1143 1144 1145
		mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE;
	mcp->mb[2] = MSW(pd_dma);
	mcp->mb[3] = LSW(pd_dma);
	mcp->mb[6] = MSW(MSD(pd_dma));
	mcp->mb[7] = LSW(MSD(pd_dma));
1146
	mcp->mb[9] = vha->vp_idx;
1147
	mcp->out_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
L
Linus Torvalds 已提交
1148
	mcp->in_mb = MBX_0;
1149
	if (IS_FWI2_CAPABLE(ha)) {
1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
		mcp->mb[1] = fcport->loop_id;
		mcp->mb[10] = opt;
		mcp->out_mb |= MBX_10|MBX_1;
		mcp->in_mb |= MBX_1;
	} else if (HAS_EXTENDED_IDS(ha)) {
		mcp->mb[1] = fcport->loop_id;
		mcp->mb[10] = opt;
		mcp->out_mb |= MBX_10|MBX_1;
	} else {
		mcp->mb[1] = fcport->loop_id << 8 | opt;
		mcp->out_mb |= MBX_1;
	}
1162 1163
	mcp->buf_size = IS_FWI2_CAPABLE(ha) ?
	    PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE;
L
Linus Torvalds 已提交
1164 1165
	mcp->flags = MBX_DMA_IN;
	mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
1166
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1167 1168 1169
	if (rval != QLA_SUCCESS)
		goto gpd_error_out;

1170
	if (IS_FWI2_CAPABLE(ha)) {
1171 1172 1173 1174 1175 1176 1177
		pd24 = (struct port_database_24xx *) pd;

		/* Check for logged in state. */
		if (pd24->current_login_state != PDS_PRLI_COMPLETE &&
		    pd24->last_login_state != PDS_PRLI_COMPLETE) {
			DEBUG2(printk("%s(%ld): Unable to verify "
			    "login-state (%x/%x) for loop_id %x\n",
1178
			    __func__, vha->host_no,
1179 1180 1181 1182 1183
			    pd24->current_login_state,
			    pd24->last_login_state, fcport->loop_id));
			rval = QLA_FUNCTION_FAILED;
			goto gpd_error_out;
		}
L
Linus Torvalds 已提交
1184

1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
		/* Names are little-endian. */
		memcpy(fcport->node_name, pd24->node_name, WWN_SIZE);
		memcpy(fcport->port_name, pd24->port_name, WWN_SIZE);

		/* Get port_id of device. */
		fcport->d_id.b.domain = pd24->port_id[0];
		fcport->d_id.b.area = pd24->port_id[1];
		fcport->d_id.b.al_pa = pd24->port_id[2];
		fcport->d_id.b.rsvd_1 = 0;

		/* If not target must be initiator or unknown type. */
		if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0)
			fcport->port_type = FCT_INITIATOR;
		else
			fcport->port_type = FCT_TARGET;
	} else {
		/* Check for logged in state. */
		if (pd->master_state != PD_STATE_PORT_LOGGED_IN &&
		    pd->slave_state != PD_STATE_PORT_LOGGED_IN) {
			rval = QLA_FUNCTION_FAILED;
			goto gpd_error_out;
		}
L
Linus Torvalds 已提交
1207

1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
		/* Names are little-endian. */
		memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
		memcpy(fcport->port_name, pd->port_name, WWN_SIZE);

		/* Get port_id of device. */
		fcport->d_id.b.domain = pd->port_id[0];
		fcport->d_id.b.area = pd->port_id[3];
		fcport->d_id.b.al_pa = pd->port_id[2];
		fcport->d_id.b.rsvd_1 = 0;

		/* If not target must be initiator or unknown type. */
		if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
			fcport->port_type = FCT_INITIATOR;
		else
			fcport->port_type = FCT_TARGET;
1223 1224 1225 1226

		/* Passback COS information. */
		fcport->supported_classes = (pd->options & BIT_4) ?
		    FC_COS_CLASS2: FC_COS_CLASS3;
1227
	}
L
Linus Torvalds 已提交
1228 1229 1230 1231 1232

gpd_error_out:
	dma_pool_free(ha->s_dma_pool, pd, pd_dma);

	if (rval != QLA_SUCCESS) {
1233
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
1234
		    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
L
Linus Torvalds 已提交
1235
	} else {
1236
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
	}

	return rval;
}

/*
 * qla2x00_get_firmware_state
 *	Get adapter firmware state.
 *
 * Input:
 *	ha = adapter block pointer.
 *	dptr = pointer for firmware state.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
1259
qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
L
Linus Torvalds 已提交
1260 1261 1262 1263 1264 1265
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("qla2x00_get_firmware_state(%ld): entered.\n",
1266
	    vha->host_no));
L
Linus Torvalds 已提交
1267 1268 1269

	mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
	mcp->out_mb = MBX_0;
1270 1271 1272 1273
	if (IS_FWI2_CAPABLE(vha->hw))
		mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	else
		mcp->in_mb = MBX_1|MBX_0;
1274
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
1275
	mcp->flags = 0;
1276
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1277

1278 1279
	/* Return firmware states. */
	states[0] = mcp->mb[1];
1280 1281 1282 1283 1284 1285
	if (IS_FWI2_CAPABLE(vha->hw)) {
		states[1] = mcp->mb[2];
		states[2] = mcp->mb[3];
		states[3] = mcp->mb[4];
		states[4] = mcp->mb[5];
	}
L
Linus Torvalds 已提交
1286 1287 1288 1289

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("qla2x00_get_firmware_state(%ld): "
1290
		    "failed=%x.\n", vha->host_no, rval));
L
Linus Torvalds 已提交
1291 1292 1293
	} else {
		/*EMPTY*/
		DEBUG11(printk("qla2x00_get_firmware_state(%ld): done.\n",
1294
		    vha->host_no));
L
Linus Torvalds 已提交
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
	}

	return rval;
}

/*
 * qla2x00_get_port_name
 *	Issue get port name mailbox command.
 *	Returned name is in big endian format.
 *
 * Input:
 *	ha = adapter block pointer.
 *	loop_id = loop ID of device.
 *	name = pointer for name.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
1319
qla2x00_get_port_name(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t *name,
L
Linus Torvalds 已提交
1320 1321 1322 1323 1324 1325 1326
    uint8_t opt)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("qla2x00_get_port_name(%ld): entered.\n",
1327
	    vha->host_no));
L
Linus Torvalds 已提交
1328 1329

	mcp->mb[0] = MBC_GET_PORT_NAME;
1330
	mcp->mb[9] = vha->vp_idx;
1331
	mcp->out_mb = MBX_9|MBX_1|MBX_0;
1332
	if (HAS_EXTENDED_IDS(vha->hw)) {
L
Linus Torvalds 已提交
1333 1334 1335 1336 1337 1338 1339 1340
		mcp->mb[1] = loop_id;
		mcp->mb[10] = opt;
		mcp->out_mb |= MBX_10;
	} else {
		mcp->mb[1] = loop_id << 8 | opt;
	}

	mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
1341
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
1342
	mcp->flags = 0;
1343
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1344 1345 1346 1347

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("qla2x00_get_port_name(%ld): failed=%x.\n",
1348
		    vha->host_no, rval));
L
Linus Torvalds 已提交
1349 1350 1351
	} else {
		if (name != NULL) {
			/* This function returns name in big endian. */
1352 1353 1354 1355 1356 1357 1358 1359
			name[0] = MSB(mcp->mb[2]);
			name[1] = LSB(mcp->mb[2]);
			name[2] = MSB(mcp->mb[3]);
			name[3] = LSB(mcp->mb[3]);
			name[4] = MSB(mcp->mb[6]);
			name[5] = LSB(mcp->mb[6]);
			name[6] = MSB(mcp->mb[7]);
			name[7] = LSB(mcp->mb[7]);
L
Linus Torvalds 已提交
1360 1361 1362
		}

		DEBUG11(printk("qla2x00_get_port_name(%ld): done.\n",
1363
		    vha->host_no));
L
Linus Torvalds 已提交
1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
	}

	return rval;
}

/*
 * qla2x00_lip_reset
 *	Issue LIP reset mailbox command.
 *
 * Input:
 *	ha = adapter block pointer.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
1385
qla2x00_lip_reset(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1386 1387 1388 1389 1390
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

1391
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
1392

1393 1394 1395 1396 1397 1398 1399
	if (IS_QLA81XX(vha->hw)) {
		/* Logout across all FCFs. */
		mcp->mb[0] = MBC_LIP_FULL_LOGIN;
		mcp->mb[1] = BIT_1;
		mcp->mb[2] = 0;
		mcp->out_mb = MBX_2|MBX_1|MBX_0;
	} else if (IS_FWI2_CAPABLE(vha->hw)) {
1400
		mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1401 1402
		mcp->mb[1] = BIT_6;
		mcp->mb[2] = 0;
1403
		mcp->mb[3] = vha->hw->loop_reset_delay;
1404
		mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
L
Linus Torvalds 已提交
1405
	} else {
1406 1407
		mcp->mb[0] = MBC_LIP_RESET;
		mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
1408
		if (HAS_EXTENDED_IDS(vha->hw)) {
1409 1410 1411 1412 1413 1414
			mcp->mb[1] = 0x00ff;
			mcp->mb[10] = 0;
			mcp->out_mb |= MBX_10;
		} else {
			mcp->mb[1] = 0xff00;
		}
1415
		mcp->mb[2] = vha->hw->loop_reset_delay;
1416
		mcp->mb[3] = 0;
L
Linus Torvalds 已提交
1417 1418
	}
	mcp->in_mb = MBX_0;
1419
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
1420
	mcp->flags = 0;
1421
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1422 1423 1424

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
1425
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n",
1426
		    __func__, vha->host_no, rval));
L
Linus Torvalds 已提交
1427 1428
	} else {
		/*EMPTY*/
1429
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
	}

	return rval;
}

/*
 * qla2x00_send_sns
 *	Send SNS command.
 *
 * Input:
 *	ha = adapter block pointer.
 *	sns = pointer for command.
 *	cmd_size = command size.
 *	buf_size = response/command size.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
1454
qla2x00_send_sns(scsi_qla_host_t *vha, dma_addr_t sns_phys_address,
L
Linus Torvalds 已提交
1455 1456 1457 1458 1459 1460 1461
    uint16_t cmd_size, size_t buf_size)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("qla2x00_send_sns(%ld): entered.\n",
1462
	    vha->host_no));
L
Linus Torvalds 已提交
1463 1464

	DEBUG11(printk("qla2x00_send_sns: retry cnt=%d ratov=%d total "
1465 1466
		"tov=%d.\n", vha->hw->retry_count, vha->hw->login_timeout,
		mcp->tov));
L
Linus Torvalds 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477

	mcp->mb[0] = MBC_SEND_SNS_COMMAND;
	mcp->mb[1] = cmd_size;
	mcp->mb[2] = MSW(sns_phys_address);
	mcp->mb[3] = LSW(sns_phys_address);
	mcp->mb[6] = MSW(MSD(sns_phys_address));
	mcp->mb[7] = LSW(MSD(sns_phys_address));
	mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0|MBX_1;
	mcp->buf_size = buf_size;
	mcp->flags = MBX_DMA_OUT|MBX_DMA_IN;
1478 1479
	mcp->tov = (vha->hw->login_timeout * 2) + (vha->hw->login_timeout / 2);
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1480 1481 1482 1483

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
1484
		    "mb[1]=%x.\n", vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
L
Linus Torvalds 已提交
1485
		DEBUG2_3_11(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
1486
		    "mb[1]=%x.\n", vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
L
Linus Torvalds 已提交
1487 1488
	} else {
		/*EMPTY*/
1489
		DEBUG11(printk("qla2x00_send_sns(%ld): done.\n", vha->host_no));
L
Linus Torvalds 已提交
1490 1491 1492 1493 1494
	}

	return rval;
}

1495
int
1496
qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1497 1498 1499 1500 1501 1502 1503
    uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
{
	int		rval;

	struct logio_entry_24xx *lg;
	dma_addr_t	lg_dma;
	uint32_t	iop[2];
1504
	struct qla_hw_data *ha = vha->hw;
1505 1506
	struct req_que *req;
	struct rsp_que *rsp;
1507

1508
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
1509

1510 1511 1512 1513
	if (ql2xmultique_tag)
		req = ha->req_q_map[0];
	else
		req = vha->req;
1514 1515
	rsp = req->rsp;

1516 1517 1518
	lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
	if (lg == NULL) {
		DEBUG2_3(printk("%s(%ld): failed to allocate Login IOCB.\n",
1519
		    __func__, vha->host_no));
1520 1521 1522 1523 1524 1525
		return QLA_MEMORY_ALLOC_FAILED;
	}
	memset(lg, 0, sizeof(struct logio_entry_24xx));

	lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
	lg->entry_count = 1;
1526
	lg->handle = MAKE_HANDLE(req->id, lg->handle);
1527 1528 1529 1530
	lg->nport_handle = cpu_to_le16(loop_id);
	lg->control_flags = __constant_cpu_to_le16(LCF_COMMAND_PLOGI);
	if (opt & BIT_0)
		lg->control_flags |= __constant_cpu_to_le16(LCF_COND_PLOGI);
1531 1532
	if (opt & BIT_1)
		lg->control_flags |= __constant_cpu_to_le16(LCF_SKIP_PRLI);
1533 1534 1535
	lg->port_id[0] = al_pa;
	lg->port_id[1] = area;
	lg->port_id[2] = domain;
1536 1537
	lg->vp_index = vha->vp_idx;
	rval = qla2x00_issue_iocb(vha, lg, lg_dma, 0);
1538 1539
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed to issue Login IOCB "
1540
		    "(%x).\n", __func__, vha->host_no, rval));
1541 1542
	} else if (lg->entry_status != 0) {
		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1543
		    "-- error status (%x).\n", __func__, vha->host_no,
1544 1545 1546 1547 1548 1549 1550 1551
		    lg->entry_status));
		rval = QLA_FUNCTION_FAILED;
	} else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
		iop[0] = le32_to_cpu(lg->io_parameter[0]);
		iop[1] = le32_to_cpu(lg->io_parameter[1]);

		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
		    "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
1552
		    vha->host_no, le16_to_cpu(lg->comp_status), iop[0],
1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
		    iop[1]));

		switch (iop[0]) {
		case LSC_SCODE_PORTID_USED:
			mb[0] = MBS_PORT_ID_USED;
			mb[1] = LSW(iop[1]);
			break;
		case LSC_SCODE_NPORT_USED:
			mb[0] = MBS_LOOP_ID_USED;
			break;
		case LSC_SCODE_NOLINK:
		case LSC_SCODE_NOIOCB:
		case LSC_SCODE_NOXCB:
		case LSC_SCODE_CMD_FAILED:
		case LSC_SCODE_NOFABRIC:
		case LSC_SCODE_FW_NOT_READY:
		case LSC_SCODE_NOT_LOGGED_IN:
		case LSC_SCODE_NOPCB:
		case LSC_SCODE_ELS_REJECT:
		case LSC_SCODE_CMD_PARAM_ERR:
		case LSC_SCODE_NONPORT:
		case LSC_SCODE_LOGGED_IN:
		case LSC_SCODE_NOFLOGI_ACC:
		default:
			mb[0] = MBS_COMMAND_ERROR;
			break;
		}
	} else {
1581
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
1582 1583 1584 1585 1586 1587 1588 1589 1590 1591

		iop[0] = le32_to_cpu(lg->io_parameter[0]);

		mb[0] = MBS_COMMAND_COMPLETE;
		mb[1] = 0;
		if (iop[0] & BIT_4) {
			if (iop[0] & BIT_8)
				mb[1] |= BIT_1;
		} else
			mb[1] = BIT_0;
1592 1593 1594 1595 1596 1597 1598

		/* Passback COS information. */
		mb[10] = 0;
		if (lg->io_parameter[7] || lg->io_parameter[8])
			mb[10] |= BIT_0;	/* Class 2. */
		if (lg->io_parameter[9] || lg->io_parameter[10])
			mb[10] |= BIT_1;	/* Class 3. */
1599 1600 1601 1602 1603 1604 1605
	}

	dma_pool_free(ha->s_dma_pool, lg, lg_dma);

	return rval;
}

L
Linus Torvalds 已提交
1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
/*
 * qla2x00_login_fabric
 *	Issue login fabric port mailbox command.
 *
 * Input:
 *	ha = adapter block pointer.
 *	loop_id = device loop ID.
 *	domain = device domain.
 *	area = device area.
 *	al_pa = device AL_PA.
 *	status = pointer for return status.
 *	opt = command options.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
1628
qla2x00_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
L
Linus Torvalds 已提交
1629 1630 1631 1632 1633
    uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
1634
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1635

1636
	DEBUG11(printk("qla2x00_login_fabric(%ld): entered.\n", vha->host_no));
L
Linus Torvalds 已提交
1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652

	mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
	mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
	if (HAS_EXTENDED_IDS(ha)) {
		mcp->mb[1] = loop_id;
		mcp->mb[10] = opt;
		mcp->out_mb |= MBX_10;
	} else {
		mcp->mb[1] = (loop_id << 8) | opt;
	}
	mcp->mb[2] = domain;
	mcp->mb[3] = area << 8 | al_pa;

	mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
	mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
	mcp->flags = 0;
1653
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1654 1655 1656 1657 1658 1659 1660 1661

	/* Return mailbox statuses. */
	if (mb != NULL) {
		mb[0] = mcp->mb[0];
		mb[1] = mcp->mb[1];
		mb[2] = mcp->mb[2];
		mb[6] = mcp->mb[6];
		mb[7] = mcp->mb[7];
1662 1663
		/* COS retrieved from Get-Port-Database mailbox command. */
		mb[10] = 0;
L
Linus Torvalds 已提交
1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
	}

	if (rval != QLA_SUCCESS) {
		/* RLU tmp code: need to change main mailbox_command function to
		 * return ok even when the mailbox completion value is not
		 * SUCCESS. The caller needs to be responsible to interpret
		 * the return values of this mailbox command if we're not
		 * to change too much of the existing code.
		 */
		if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 ||
		    mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 ||
		    mcp->mb[0] == 0x4006)
			rval = QLA_SUCCESS;

		/*EMPTY*/
		DEBUG2_3_11(printk("qla2x00_login_fabric(%ld): failed=%x "
1680
		    "mb[0]=%x mb[1]=%x mb[2]=%x.\n", vha->host_no, rval,
1681
		    mcp->mb[0], mcp->mb[1], mcp->mb[2]));
L
Linus Torvalds 已提交
1682 1683 1684
	} else {
		/*EMPTY*/
		DEBUG11(printk("qla2x00_login_fabric(%ld): done.\n",
1685
		    vha->host_no));
L
Linus Torvalds 已提交
1686 1687 1688 1689 1690 1691 1692 1693
	}

	return rval;
}

/*
 * qla2x00_login_local_device
 *           Issue login loop port mailbox command.
A
Andrew Vasquez 已提交
1694
 *
L
Linus Torvalds 已提交
1695 1696 1697 1698
 * Input:
 *           ha = adapter block pointer.
 *           loop_id = device loop ID.
 *           opt = command options.
A
Andrew Vasquez 已提交
1699
 *
L
Linus Torvalds 已提交
1700 1701
 * Returns:
 *            Return status code.
A
Andrew Vasquez 已提交
1702
 *
L
Linus Torvalds 已提交
1703 1704
 * Context:
 *            Kernel context.
A
Andrew Vasquez 已提交
1705
 *
L
Linus Torvalds 已提交
1706 1707
 */
int
1708
qla2x00_login_local_device(scsi_qla_host_t *vha, fc_port_t *fcport,
L
Linus Torvalds 已提交
1709 1710 1711 1712 1713
    uint16_t *mb_ret, uint8_t opt)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
1714
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1715

1716
	if (IS_FWI2_CAPABLE(ha))
1717
		return qla24xx_login_fabric(vha, fcport->loop_id,
1718 1719 1720
		    fcport->d_id.b.domain, fcport->d_id.b.area,
		    fcport->d_id.b.al_pa, mb_ret, opt);

1721
	DEBUG3(printk("%s(%ld): entered.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
1722 1723 1724

	mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
	if (HAS_EXTENDED_IDS(ha))
1725
		mcp->mb[1] = fcport->loop_id;
L
Linus Torvalds 已提交
1726
	else
1727
		mcp->mb[1] = fcport->loop_id << 8;
L
Linus Torvalds 已提交
1728 1729 1730 1731 1732
	mcp->mb[2] = opt;
	mcp->out_mb = MBX_2|MBX_1|MBX_0;
 	mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0;
	mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
	mcp->flags = 0;
1733
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753

 	/* Return mailbox statuses. */
 	if (mb_ret != NULL) {
 		mb_ret[0] = mcp->mb[0];
 		mb_ret[1] = mcp->mb[1];
 		mb_ret[6] = mcp->mb[6];
 		mb_ret[7] = mcp->mb[7];
 	}

	if (rval != QLA_SUCCESS) {
 		/* AV tmp code: need to change main mailbox_command function to
 		 * return ok even when the mailbox completion value is not
 		 * SUCCESS. The caller needs to be responsible to interpret
 		 * the return values of this mailbox command if we're not
 		 * to change too much of the existing code.
 		 */
 		if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006)
 			rval = QLA_SUCCESS;

		DEBUG(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
1754
		    "mb[6]=%x mb[7]=%x.\n", __func__, vha->host_no, rval,
1755
		    mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]));
L
Linus Torvalds 已提交
1756
		DEBUG2_3(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
1757
		    "mb[6]=%x mb[7]=%x.\n", __func__, vha->host_no, rval,
1758
		    mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]));
L
Linus Torvalds 已提交
1759 1760
	} else {
		/*EMPTY*/
1761
		DEBUG3(printk("%s(%ld): done.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
1762 1763 1764 1765 1766
	}

	return (rval);
}

1767
int
1768
qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1769 1770 1771 1772 1773
    uint8_t area, uint8_t al_pa)
{
	int		rval;
	struct logio_entry_24xx *lg;
	dma_addr_t	lg_dma;
1774
	struct qla_hw_data *ha = vha->hw;
1775 1776
	struct req_que *req;
	struct rsp_que *rsp;
1777

1778
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
1779 1780 1781 1782

	lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
	if (lg == NULL) {
		DEBUG2_3(printk("%s(%ld): failed to allocate Logout IOCB.\n",
1783
		    __func__, vha->host_no));
1784 1785 1786 1787
		return QLA_MEMORY_ALLOC_FAILED;
	}
	memset(lg, 0, sizeof(struct logio_entry_24xx));

1788 1789 1790 1791 1792
	if (ql2xmaxqueues > 1)
		req = ha->req_q_map[0];
	else
		req = vha->req;
	rsp = req->rsp;
1793 1794
	lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
	lg->entry_count = 1;
1795
	lg->handle = MAKE_HANDLE(req->id, lg->handle);
1796 1797
	lg->nport_handle = cpu_to_le16(loop_id);
	lg->control_flags =
1798
	    __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO);
1799 1800 1801
	lg->port_id[0] = al_pa;
	lg->port_id[1] = area;
	lg->port_id[2] = domain;
1802
	lg->vp_index = vha->vp_idx;
1803

1804
	rval = qla2x00_issue_iocb(vha, lg, lg_dma, 0);
1805 1806
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed to issue Logout IOCB "
1807
		    "(%x).\n", __func__, vha->host_no, rval));
1808 1809
	} else if (lg->entry_status != 0) {
		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
1810
		    "-- error status (%x).\n", __func__, vha->host_no,
1811 1812 1813
		    lg->entry_status));
		rval = QLA_FUNCTION_FAILED;
	} else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
1814
		DEBUG2_3_11(printk("%s(%ld %d): failed to complete IOCB "
1815
		    "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
1816
		    vha->host_no, vha->vp_idx, le16_to_cpu(lg->comp_status),
1817
		    le32_to_cpu(lg->io_parameter[0]),
1818
		    le32_to_cpu(lg->io_parameter[1])));
1819 1820
	} else {
		/*EMPTY*/
1821
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
1822 1823 1824 1825 1826 1827 1828
	}

	dma_pool_free(ha->s_dma_pool, lg, lg_dma);

	return rval;
}

L
Linus Torvalds 已提交
1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
/*
 * qla2x00_fabric_logout
 *	Issue logout fabric port mailbox command.
 *
 * Input:
 *	ha = adapter block pointer.
 *	loop_id = device loop ID.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
1846
qla2x00_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
1847
    uint8_t area, uint8_t al_pa)
L
Linus Torvalds 已提交
1848 1849 1850 1851 1852 1853
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("qla2x00_fabric_logout(%ld): entered.\n",
1854
	    vha->host_no));
L
Linus Torvalds 已提交
1855 1856 1857

	mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
	mcp->out_mb = MBX_1|MBX_0;
1858
	if (HAS_EXTENDED_IDS(vha->hw)) {
L
Linus Torvalds 已提交
1859 1860 1861 1862 1863 1864 1865 1866
		mcp->mb[1] = loop_id;
		mcp->mb[10] = 0;
		mcp->out_mb |= MBX_10;
	} else {
		mcp->mb[1] = loop_id << 8;
	}

	mcp->in_mb = MBX_1|MBX_0;
1867
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
1868
	mcp->flags = 0;
1869
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1870 1871 1872 1873

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("qla2x00_fabric_logout(%ld): failed=%x "
1874
		    "mbx1=%x.\n", vha->host_no, rval, mcp->mb[1]));
L
Linus Torvalds 已提交
1875 1876 1877
	} else {
		/*EMPTY*/
		DEBUG11(printk("qla2x00_fabric_logout(%ld): done.\n",
1878
		    vha->host_no));
L
Linus Torvalds 已提交
1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899
	}

	return rval;
}

/*
 * qla2x00_full_login_lip
 *	Issue full login LIP mailbox command.
 *
 * Input:
 *	ha = adapter block pointer.
 *	TARGET_QUEUE_LOCK must be released.
 *	ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
1900
qla2x00_full_login_lip(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1901 1902 1903 1904 1905 1906
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("qla2x00_full_login_lip(%ld): entered.\n",
1907
	    vha->host_no));
L
Linus Torvalds 已提交
1908 1909

	mcp->mb[0] = MBC_LIP_FULL_LOGIN;
1910
	mcp->mb[1] = IS_FWI2_CAPABLE(vha->hw) ? BIT_3 : 0;
1911
	mcp->mb[2] = 0;
L
Linus Torvalds 已提交
1912 1913 1914
	mcp->mb[3] = 0;
	mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
1915
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
1916
	mcp->flags = 0;
1917
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1918 1919 1920 1921

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("qla2x00_full_login_lip(%ld): failed=%x.\n",
1922
		    vha->host_no, rval));
L
Linus Torvalds 已提交
1923 1924 1925
	} else {
		/*EMPTY*/
		DEBUG11(printk("qla2x00_full_login_lip(%ld): done.\n",
1926
		    vha->host_no));
L
Linus Torvalds 已提交
1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
	}

	return rval;
}

/*
 * qla2x00_get_id_list
 *
 * Input:
 *	ha = adapter block pointer.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
1945
qla2x00_get_id_list(scsi_qla_host_t *vha, void *id_list, dma_addr_t id_list_dma,
L
Linus Torvalds 已提交
1946 1947 1948 1949 1950 1951 1952
    uint16_t *entries)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("qla2x00_get_id_list(%ld): entered.\n",
1953
	    vha->host_no));
L
Linus Torvalds 已提交
1954 1955 1956 1957 1958

	if (id_list == NULL)
		return QLA_FUNCTION_FAILED;

	mcp->mb[0] = MBC_GET_ID_LIST;
1959
	mcp->out_mb = MBX_0;
1960
	if (IS_FWI2_CAPABLE(vha->hw)) {
1961 1962 1963 1964
		mcp->mb[2] = MSW(id_list_dma);
		mcp->mb[3] = LSW(id_list_dma);
		mcp->mb[6] = MSW(MSD(id_list_dma));
		mcp->mb[7] = LSW(MSD(id_list_dma));
1965
		mcp->mb[8] = 0;
1966
		mcp->mb[9] = vha->vp_idx;
1967
		mcp->out_mb |= MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2;
1968 1969 1970 1971 1972 1973 1974
	} else {
		mcp->mb[1] = MSW(id_list_dma);
		mcp->mb[2] = LSW(id_list_dma);
		mcp->mb[3] = MSW(MSD(id_list_dma));
		mcp->mb[6] = LSW(MSD(id_list_dma));
		mcp->out_mb |= MBX_6|MBX_3|MBX_2|MBX_1;
	}
L
Linus Torvalds 已提交
1975
	mcp->in_mb = MBX_1|MBX_0;
1976
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
1977
	mcp->flags = 0;
1978
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
1979 1980 1981 1982

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("qla2x00_get_id_list(%ld): failed=%x.\n",
1983
		    vha->host_no, rval));
L
Linus Torvalds 已提交
1984 1985 1986
	} else {
		*entries = mcp->mb[1];
		DEBUG11(printk("qla2x00_get_id_list(%ld): done.\n",
1987
		    vha->host_no));
L
Linus Torvalds 已提交
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
	}

	return rval;
}

/*
 * qla2x00_get_resource_cnts
 *	Get current firmware resource counts.
 *
 * Input:
 *	ha = adapter block pointer.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
2007
qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
2008 2009
    uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt,
    uint16_t *orig_iocb_cnt, uint16_t *max_npiv_vports)
L
Linus Torvalds 已提交
2010 2011 2012 2013 2014
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

2015
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
2016 2017 2018

	mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
	mcp->out_mb = MBX_0;
2019
	mcp->in_mb = MBX_11|MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
2020
	mcp->tov = MBX_TOV_SECONDS;
L
Linus Torvalds 已提交
2021
	mcp->flags = 0;
2022
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
2023 2024 2025 2026

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("%s(%ld): failed = %x.\n", __func__,
2027
		    vha->host_no, mcp->mb[0]));
L
Linus Torvalds 已提交
2028 2029
	} else {
		DEBUG11(printk("%s(%ld): done. mb1=%x mb2=%x mb3=%x mb6=%x "
2030
		    "mb7=%x mb10=%x mb11=%x.\n", __func__, vha->host_no,
A
Andrew Vasquez 已提交
2031
		    mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[6], mcp->mb[7],
2032
		    mcp->mb[10], mcp->mb[11]));
L
Linus Torvalds 已提交
2033 2034 2035 2036 2037 2038 2039 2040 2041

		if (cur_xchg_cnt)
			*cur_xchg_cnt = mcp->mb[3];
		if (orig_xchg_cnt)
			*orig_xchg_cnt = mcp->mb[6];
		if (cur_iocb_cnt)
			*cur_iocb_cnt = mcp->mb[7];
		if (orig_iocb_cnt)
			*orig_iocb_cnt = mcp->mb[10];
2042
		if (vha->hw->flags.npiv_supported && max_npiv_vports)
2043
			*max_npiv_vports = mcp->mb[11];
L
Linus Torvalds 已提交
2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064
	}

	return (rval);
}

#if defined(QL_DEBUG_LEVEL_3)
/*
 * qla2x00_get_fcal_position_map
 *	Get FCAL (LILP) position map using mailbox command
 *
 * Input:
 *	ha = adapter state pointer.
 *	pos_map = buffer pointer (can be NULL).
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
2065
qla2x00_get_fcal_position_map(scsi_qla_host_t *vha, char *pos_map)
L
Linus Torvalds 已提交
2066 2067 2068 2069 2070 2071
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
	char *pmap;
	dma_addr_t pmap_dma;
2072
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
2073

2074
	pmap = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pmap_dma);
L
Linus Torvalds 已提交
2075 2076
	if (pmap  == NULL) {
		DEBUG2_3_11(printk("%s(%ld): **** Mem Alloc Failed ****",
2077
		    __func__, vha->host_no));
L
Linus Torvalds 已提交
2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091
		return QLA_MEMORY_ALLOC_FAILED;
	}
	memset(pmap, 0, FCAL_MAP_SIZE);

	mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP;
	mcp->mb[2] = MSW(pmap_dma);
	mcp->mb[3] = LSW(pmap_dma);
	mcp->mb[6] = MSW(MSD(pmap_dma));
	mcp->mb[7] = LSW(MSD(pmap_dma));
	mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
	mcp->buf_size = FCAL_MAP_SIZE;
	mcp->flags = MBX_DMA_IN;
	mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
2092
	rval = qla2x00_mailbox_command(vha, mcp);
L
Linus Torvalds 已提交
2093 2094 2095

	if (rval == QLA_SUCCESS) {
		DEBUG11(printk("%s(%ld): (mb0=%x/mb1=%x) FC/AL Position Map "
2096
		    "size (%x)\n", __func__, vha->host_no, mcp->mb[0],
L
Linus Torvalds 已提交
2097 2098 2099 2100 2101 2102 2103 2104 2105 2106
		    mcp->mb[1], (unsigned)pmap[0]));
		DEBUG11(qla2x00_dump_buffer(pmap, pmap[0] + 1));

		if (pos_map)
			memcpy(pos_map, pmap, FCAL_MAP_SIZE);
	}
	dma_pool_free(ha->s_dma_pool, pmap, pmap_dma);

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2107
		    vha->host_no, rval));
L
Linus Torvalds 已提交
2108
	} else {
2109
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
L
Linus Torvalds 已提交
2110 2111 2112 2113
	}

	return rval;
}
2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
#endif

/*
 * qla2x00_get_link_status
 *
 * Input:
 *	ha = adapter block pointer.
 *	loop_id = device loop ID.
 *	ret_buf = pointer to link status return buffer.
 *
 * Returns:
 *	0 = success.
 *	BIT_0 = mem alloc error.
 *	BIT_1 = mailbox error.
 */
int
2130
qla2x00_get_link_status(scsi_qla_host_t *vha, uint16_t loop_id,
2131
    struct link_statistics *stats, dma_addr_t stats_dma)
2132 2133 2134 2135
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
2136
	uint32_t *siter, *diter, dwords;
2137
	struct qla_hw_data *ha = vha->hw;
2138

2139
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2140 2141

	mcp->mb[0] = MBC_GET_LINK_STATUS;
2142 2143 2144 2145
	mcp->mb[2] = MSW(stats_dma);
	mcp->mb[3] = LSW(stats_dma);
	mcp->mb[6] = MSW(MSD(stats_dma));
	mcp->mb[7] = LSW(MSD(stats_dma));
2146 2147
	mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
	mcp->in_mb = MBX_0;
2148
	if (IS_FWI2_CAPABLE(ha)) {
2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161
		mcp->mb[1] = loop_id;
		mcp->mb[4] = 0;
		mcp->mb[10] = 0;
		mcp->out_mb |= MBX_10|MBX_4|MBX_1;
		mcp->in_mb |= MBX_1;
	} else if (HAS_EXTENDED_IDS(ha)) {
		mcp->mb[1] = loop_id;
		mcp->mb[10] = 0;
		mcp->out_mb |= MBX_10|MBX_1;
	} else {
		mcp->mb[1] = loop_id << 8;
		mcp->out_mb |= MBX_1;
	}
2162
	mcp->tov = MBX_TOV_SECONDS;
2163
	mcp->flags = IOCTL_CMD;
2164
	rval = qla2x00_mailbox_command(vha, mcp);
2165 2166 2167 2168

	if (rval == QLA_SUCCESS) {
		if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
			DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
2169
			    __func__, vha->host_no, mcp->mb[0]));
2170
			rval = QLA_FUNCTION_FAILED;
2171
		} else {
2172 2173 2174 2175 2176
			/* Copy over data -- firmware data is LE. */
			dwords = offsetof(struct link_statistics, unused1) / 4;
			siter = diter = &stats->link_fail_cnt;
			while (dwords--)
				*diter++ = le32_to_cpu(*siter++);
2177 2178 2179 2180
		}
	} else {
		/* Failed. */
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2181
		    vha->host_no, rval));
2182 2183 2184 2185 2186 2187
	}

	return rval;
}

int
2188
qla24xx_get_isp_stats(scsi_qla_host_t *vha, struct link_statistics *stats,
2189
    dma_addr_t stats_dma)
2190 2191 2192 2193
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
2194
	uint32_t *siter, *diter, dwords;
2195

2196
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2197 2198

	mcp->mb[0] = MBC_GET_LINK_PRIV_STATS;
2199 2200 2201 2202 2203
	mcp->mb[2] = MSW(stats_dma);
	mcp->mb[3] = LSW(stats_dma);
	mcp->mb[6] = MSW(MSD(stats_dma));
	mcp->mb[7] = LSW(MSD(stats_dma));
	mcp->mb[8] = sizeof(struct link_statistics) / 4;
2204
	mcp->mb[9] = vha->vp_idx;
2205
	mcp->mb[10] = 0;
2206
	mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
2207
	mcp->in_mb = MBX_2|MBX_1|MBX_0;
2208
	mcp->tov = MBX_TOV_SECONDS;
2209
	mcp->flags = IOCTL_CMD;
2210
	rval = qla2x00_mailbox_command(vha, mcp);
2211 2212 2213 2214

	if (rval == QLA_SUCCESS) {
		if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
			DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
2215
			    __func__, vha->host_no, mcp->mb[0]));
2216
			rval = QLA_FUNCTION_FAILED;
2217 2218
		} else {
			/* Copy over data -- firmware data is LE. */
2219 2220
			dwords = sizeof(struct link_statistics) / 4;
			siter = diter = &stats->link_fail_cnt;
2221
			while (dwords--)
2222
				*diter++ = le32_to_cpu(*siter++);
2223 2224 2225 2226
		}
	} else {
		/* Failed. */
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2227
		    vha->host_no, rval));
2228 2229 2230 2231 2232 2233
	}

	return rval;
}

int
2234
qla24xx_abort_command(srb_t *sp)
2235 2236 2237 2238 2239 2240 2241
{
	int		rval;
	unsigned long   flags = 0;

	struct abort_entry_24xx *abt;
	dma_addr_t	abt_dma;
	uint32_t	handle;
2242 2243
	fc_port_t	*fcport = sp->fcport;
	struct scsi_qla_host *vha = fcport->vha;
2244
	struct qla_hw_data *ha = vha->hw;
2245
	struct req_que *req = vha->req;
2246

2247
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2248

2249
	spin_lock_irqsave(&ha->hardware_lock, flags);
2250
	for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
2251
		if (req->outstanding_cmds[handle] == sp)
2252 2253
			break;
	}
2254
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
2255 2256 2257 2258 2259 2260 2261 2262
	if (handle == MAX_OUTSTANDING_COMMANDS) {
		/* Command not found. */
		return QLA_FUNCTION_FAILED;
	}

	abt = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma);
	if (abt == NULL) {
		DEBUG2_3(printk("%s(%ld): failed to allocate Abort IOCB.\n",
2263
		    __func__, vha->host_no));
2264 2265 2266 2267 2268 2269
		return QLA_MEMORY_ALLOC_FAILED;
	}
	memset(abt, 0, sizeof(struct abort_entry_24xx));

	abt->entry_type = ABORT_IOCB_TYPE;
	abt->entry_count = 1;
2270
	abt->handle = MAKE_HANDLE(req->id, abt->handle);
2271 2272 2273 2274 2275
	abt->nport_handle = cpu_to_le16(fcport->loop_id);
	abt->handle_to_abort = handle;
	abt->port_id[0] = fcport->d_id.b.al_pa;
	abt->port_id[1] = fcport->d_id.b.area;
	abt->port_id[2] = fcport->d_id.b.domain;
2276
	abt->vp_index = fcport->vp_idx;
2277 2278 2279

	abt->req_que_no = cpu_to_le16(req->id);

2280
	rval = qla2x00_issue_iocb(vha, abt, abt_dma, 0);
2281 2282
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed to issue IOCB (%x).\n",
2283
		    __func__, vha->host_no, rval));
2284 2285
	} else if (abt->entry_status != 0) {
		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2286
		    "-- error status (%x).\n", __func__, vha->host_no,
2287 2288 2289 2290
		    abt->entry_status));
		rval = QLA_FUNCTION_FAILED;
	} else if (abt->nport_handle != __constant_cpu_to_le16(0)) {
		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2291
		    "-- completion status (%x).\n", __func__, vha->host_no,
2292
		    le16_to_cpu(abt->nport_handle)));
2293 2294
		rval = QLA_FUNCTION_FAILED;
	} else {
2295
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309
	}

	dma_pool_free(ha->s_dma_pool, abt, abt_dma);

	return rval;
}

struct tsk_mgmt_cmd {
	union {
		struct tsk_mgmt_entry tsk;
		struct sts_entry_24xx sts;
	} p;
};

2310 2311
static int
__qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
2312
    unsigned int l, int tag)
2313
{
2314
	int		rval, rval2;
2315 2316
	struct tsk_mgmt_cmd *tsk;
	dma_addr_t	tsk_dma;
2317 2318
	scsi_qla_host_t *vha;
	struct qla_hw_data *ha;
2319 2320
	struct req_que *req;
	struct rsp_que *rsp;
2321

2322
	DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->vha->host_no));
2323

2324 2325
	vha = fcport->vha;
	ha = vha->hw;
2326
	req = vha->req;
2327 2328 2329 2330
	if (ql2xmultique_tag)
		rsp = ha->rsp_q_map[tag + 1];
	else
		rsp = req->rsp;
2331
	tsk = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma);
2332 2333
	if (tsk == NULL) {
		DEBUG2_3(printk("%s(%ld): failed to allocate Task Management "
2334
		    "IOCB.\n", __func__, vha->host_no));
2335 2336 2337 2338 2339 2340
		return QLA_MEMORY_ALLOC_FAILED;
	}
	memset(tsk, 0, sizeof(struct tsk_mgmt_cmd));

	tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE;
	tsk->p.tsk.entry_count = 1;
2341
	tsk->p.tsk.handle = MAKE_HANDLE(req->id, tsk->p.tsk.handle);
2342
	tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id);
2343
	tsk->p.tsk.timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
2344
	tsk->p.tsk.control_flags = cpu_to_le32(type);
2345 2346 2347
	tsk->p.tsk.port_id[0] = fcport->d_id.b.al_pa;
	tsk->p.tsk.port_id[1] = fcport->d_id.b.area;
	tsk->p.tsk.port_id[2] = fcport->d_id.b.domain;
2348
	tsk->p.tsk.vp_index = fcport->vp_idx;
2349 2350 2351 2352 2353
	if (type == TCF_LUN_RESET) {
		int_to_scsilun(l, &tsk->p.tsk.lun);
		host_to_fcp_swap((uint8_t *)&tsk->p.tsk.lun,
		    sizeof(tsk->p.tsk.lun));
	}
2354

2355
	rval = qla2x00_issue_iocb(vha, tsk, tsk_dma, 0);
2356
	if (rval != QLA_SUCCESS) {
2357
		DEBUG2_3_11(printk("%s(%ld): failed to issue %s Reset IOCB "
2358
		    "(%x).\n", __func__, vha->host_no, name, rval));
2359 2360
	} else if (tsk->p.sts.entry_status != 0) {
		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2361
		    "-- error status (%x).\n", __func__, vha->host_no,
2362 2363 2364 2365 2366 2367
		    tsk->p.sts.entry_status));
		rval = QLA_FUNCTION_FAILED;
	} else if (tsk->p.sts.comp_status !=
	    __constant_cpu_to_le16(CS_COMPLETE)) {
		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
		    "-- completion status (%x).\n", __func__,
2368
		    vha->host_no, le16_to_cpu(tsk->p.sts.comp_status)));
2369 2370 2371 2372
		rval = QLA_FUNCTION_FAILED;
	}

	/* Issue marker IOCB. */
2373
	rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
2374 2375
	    type == TCF_LUN_RESET ? MK_SYNC_ID_LUN: MK_SYNC_ID);
	if (rval2 != QLA_SUCCESS) {
2376
		DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
2377
		    "(%x).\n", __func__, vha->host_no, rval2));
2378
	} else {
2379
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2380 2381
	}

2382
	dma_pool_free(ha->s_dma_pool, tsk, tsk_dma);
2383 2384 2385 2386

	return rval;
}

2387
int
2388
qla24xx_abort_target(struct fc_port *fcport, unsigned int l, int tag)
2389
{
2390
	return __qla24xx_issue_tmf("Target", TCF_TARGET_RESET, fcport, l, tag);
2391 2392 2393
}

int
2394
qla24xx_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
2395
{
2396
	return __qla24xx_issue_tmf("Lun", TCF_LUN_RESET, fcport, l, tag);
2397 2398
}

2399
int
2400
qla2x00_system_error(scsi_qla_host_t *vha)
2401 2402 2403 2404
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
2405
	struct qla_hw_data *ha = vha->hw;
2406

2407
	if (!IS_QLA23XX(ha) && !IS_FWI2_CAPABLE(ha))
2408 2409
		return QLA_FUNCTION_FAILED;

2410
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2411 2412 2413 2414 2415 2416

	mcp->mb[0] = MBC_GEN_SYSTEM_ERROR;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0;
	mcp->tov = 5;
	mcp->flags = 0;
2417
	rval = qla2x00_mailbox_command(vha, mcp);
2418 2419 2420

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2421
		    vha->host_no, rval));
2422
	} else {
2423
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435
	}

	return rval;
}

/**
 * qla2x00_set_serdes_params() -
 * @ha: HA context
 *
 * Returns
 */
int
2436
qla2x00_set_serdes_params(scsi_qla_host_t *vha, uint16_t sw_em_1g,
2437 2438 2439 2440 2441 2442
    uint16_t sw_em_2g, uint16_t sw_em_4g)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

2443
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2444 2445 2446

	mcp->mb[0] = MBC_SERDES_PARAMS;
	mcp->mb[1] = BIT_0;
2447 2448 2449
	mcp->mb[2] = sw_em_1g | BIT_15;
	mcp->mb[3] = sw_em_2g | BIT_15;
	mcp->mb[4] = sw_em_4g | BIT_15;
2450 2451
	mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
2452
	mcp->tov = MBX_TOV_SECONDS;
2453
	mcp->flags = 0;
2454
	rval = qla2x00_mailbox_command(vha, mcp);
2455 2456 2457 2458

	if (rval != QLA_SUCCESS) {
		/*EMPTY*/
		DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
2459
		    vha->host_no, rval, mcp->mb[0]));
2460 2461
	} else {
		/*EMPTY*/
2462
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2463 2464 2465 2466
	}

	return rval;
}
2467 2468

int
2469
qla2x00_stop_firmware(scsi_qla_host_t *vha)
2470 2471 2472 2473 2474
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

2475
	if (!IS_FWI2_CAPABLE(vha->hw))
2476 2477
		return QLA_FUNCTION_FAILED;

2478
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2479 2480 2481 2482 2483 2484

	mcp->mb[0] = MBC_STOP_FIRMWARE;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0;
	mcp->tov = 5;
	mcp->flags = 0;
2485
	rval = qla2x00_mailbox_command(vha, mcp);
2486 2487 2488

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2489
		    vha->host_no, rval));
2490 2491
		if (mcp->mb[0] == MBS_INVALID_COMMAND)
			rval = QLA_INVALID_COMMAND;
2492
	} else {
2493
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2494 2495 2496 2497
	}

	return rval;
}
2498 2499

int
2500
qla2x00_enable_eft_trace(scsi_qla_host_t *vha, dma_addr_t eft_dma,
2501 2502 2503 2504 2505 2506
    uint16_t buffers)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

2507
	if (!IS_FWI2_CAPABLE(vha->hw))
2508 2509
		return QLA_FUNCTION_FAILED;

2510
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2511 2512

	mcp->mb[0] = MBC_TRACE_CONTROL;
2513 2514 2515 2516 2517 2518 2519 2520
	mcp->mb[1] = TC_EFT_ENABLE;
	mcp->mb[2] = LSW(eft_dma);
	mcp->mb[3] = MSW(eft_dma);
	mcp->mb[4] = LSW(MSD(eft_dma));
	mcp->mb[5] = MSW(MSD(eft_dma));
	mcp->mb[6] = buffers;
	mcp->mb[7] = TC_AEN_DISABLE;
	mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2521
	mcp->in_mb = MBX_1|MBX_0;
2522
	mcp->tov = MBX_TOV_SECONDS;
2523
	mcp->flags = 0;
2524
	rval = qla2x00_mailbox_command(vha, mcp);
2525 2526
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
2527
		    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
2528
	} else {
2529
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2530 2531 2532 2533
	}

	return rval;
}
2534

2535
int
2536
qla2x00_disable_eft_trace(scsi_qla_host_t *vha)
2537 2538 2539 2540 2541
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

2542
	if (!IS_FWI2_CAPABLE(vha->hw))
2543 2544
		return QLA_FUNCTION_FAILED;

2545
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2546 2547 2548 2549 2550

	mcp->mb[0] = MBC_TRACE_CONTROL;
	mcp->mb[1] = TC_EFT_DISABLE;
	mcp->out_mb = MBX_1|MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
2551
	mcp->tov = MBX_TOV_SECONDS;
2552
	mcp->flags = 0;
2553
	rval = qla2x00_mailbox_command(vha, mcp);
2554 2555
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
2556
		    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
2557
	} else {
2558
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2559 2560 2561 2562 2563
	}

	return rval;
}

2564
int
2565
qla2x00_enable_fce_trace(scsi_qla_host_t *vha, dma_addr_t fce_dma,
2566 2567 2568 2569 2570 2571
    uint16_t buffers, uint16_t *mb, uint32_t *dwords)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

2572
	if (!IS_QLA25XX(vha->hw) && !IS_QLA81XX(vha->hw))
2573 2574
		return QLA_FUNCTION_FAILED;

2575
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590

	mcp->mb[0] = MBC_TRACE_CONTROL;
	mcp->mb[1] = TC_FCE_ENABLE;
	mcp->mb[2] = LSW(fce_dma);
	mcp->mb[3] = MSW(fce_dma);
	mcp->mb[4] = LSW(MSD(fce_dma));
	mcp->mb[5] = MSW(MSD(fce_dma));
	mcp->mb[6] = buffers;
	mcp->mb[7] = TC_AEN_DISABLE;
	mcp->mb[8] = 0;
	mcp->mb[9] = TC_FCE_DEFAULT_RX_SIZE;
	mcp->mb[10] = TC_FCE_DEFAULT_TX_SIZE;
	mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
	    MBX_1|MBX_0;
	mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
2591
	mcp->tov = MBX_TOV_SECONDS;
2592
	mcp->flags = 0;
2593
	rval = qla2x00_mailbox_command(vha, mcp);
2594 2595
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
2596
		    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
2597
	} else {
2598
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2599 2600 2601 2602

		if (mb)
			memcpy(mb, mcp->mb, 8 * sizeof(*mb));
		if (dwords)
2603
			*dwords = buffers;
2604 2605 2606 2607 2608 2609
	}

	return rval;
}

int
2610
qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
2611 2612 2613 2614 2615
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

2616
	if (!IS_FWI2_CAPABLE(vha->hw))
2617 2618
		return QLA_FUNCTION_FAILED;

2619
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2620 2621 2622 2623 2624 2625 2626

	mcp->mb[0] = MBC_TRACE_CONTROL;
	mcp->mb[1] = TC_FCE_DISABLE;
	mcp->mb[2] = TC_FCE_DISABLE_TRACE;
	mcp->out_mb = MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
	    MBX_1|MBX_0;
2627
	mcp->tov = MBX_TOV_SECONDS;
2628
	mcp->flags = 0;
2629
	rval = qla2x00_mailbox_command(vha, mcp);
2630 2631
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
2632
		    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
2633
	} else {
2634
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650

		if (wr)
			*wr = (uint64_t) mcp->mb[5] << 48 |
			    (uint64_t) mcp->mb[4] << 32 |
			    (uint64_t) mcp->mb[3] << 16 |
			    (uint64_t) mcp->mb[2];
		if (rd)
			*rd = (uint64_t) mcp->mb[9] << 48 |
			    (uint64_t) mcp->mb[8] << 32 |
			    (uint64_t) mcp->mb[7] << 16 |
			    (uint64_t) mcp->mb[6];
	}

	return rval;
}

2651
int
2652
qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint16_t addr,
2653 2654 2655 2656 2657
    uint16_t off, uint16_t count)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
2658

2659
	if (!IS_FWI2_CAPABLE(vha->hw))
2660 2661
		return QLA_FUNCTION_FAILED;

2662
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674

	mcp->mb[0] = MBC_READ_SFP;
	mcp->mb[1] = addr;
	mcp->mb[2] = MSW(sfp_dma);
	mcp->mb[3] = LSW(sfp_dma);
	mcp->mb[6] = MSW(MSD(sfp_dma));
	mcp->mb[7] = LSW(MSD(sfp_dma));
	mcp->mb[8] = count;
	mcp->mb[9] = off;
	mcp->mb[10] = 0;
	mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
2675
	mcp->tov = MBX_TOV_SECONDS;
2676
	mcp->flags = 0;
2677
	rval = qla2x00_mailbox_command(vha, mcp);
2678 2679 2680

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
2681
		    vha->host_no, rval, mcp->mb[0]));
2682
	} else {
2683
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2684 2685 2686 2687
	}

	return rval;
}
2688 2689

int
2690
qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
2691 2692 2693 2694 2695 2696
    uint16_t port_speed, uint16_t *mb)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

2697
	if (!IS_IIDMA_CAPABLE(vha->hw))
2698 2699
		return QLA_FUNCTION_FAILED;

2700
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
2701 2702 2703 2704

	mcp->mb[0] = MBC_PORT_PARAMS;
	mcp->mb[1] = loop_id;
	mcp->mb[2] = BIT_0;
2705 2706 2707 2708 2709 2710 2711
	if (IS_QLA81XX(vha->hw))
		mcp->mb[3] = port_speed & (BIT_5|BIT_4|BIT_3|BIT_2|BIT_1|BIT_0);
	else
		mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0);
	mcp->mb[9] = vha->vp_idx;
	mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_3|MBX_1|MBX_0;
2712
	mcp->tov = MBX_TOV_SECONDS;
2713
	mcp->flags = 0;
2714
	rval = qla2x00_mailbox_command(vha, mcp);
2715 2716 2717 2718 2719 2720 2721 2722 2723 2724

	/* Return mailbox statuses. */
	if (mb != NULL) {
		mb[0] = mcp->mb[0];
		mb[1] = mcp->mb[1];
		mb[3] = mcp->mb[3];
	}

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
2725
		    vha->host_no, rval));
2726
	} else {
2727
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
2728 2729 2730 2731
	}

	return rval;
}
2732 2733

void
2734
qla24xx_report_id_acquisition(scsi_qla_host_t *vha,
2735 2736 2737
	struct vp_rpt_id_entry_24xx *rptid_entry)
{
	uint8_t vp_idx;
2738
	uint16_t stat = le16_to_cpu(rptid_entry->vp_idx);
2739 2740
	struct qla_hw_data *ha = vha->hw;
	scsi_qla_host_t *vp;
2741
	scsi_qla_host_t *tvp;
2742 2743 2744 2745 2746 2747

	if (rptid_entry->entry_status != 0)
		return;

	if (rptid_entry->format == 0) {
		DEBUG15(printk("%s:format 0 : scsi(%ld) number of VPs setup %d,"
2748
			" number of VPs acquired %d\n", __func__, vha->host_no,
2749 2750
			MSB(le16_to_cpu(rptid_entry->vp_count)),
			LSB(le16_to_cpu(rptid_entry->vp_count))));
2751 2752 2753 2754
		DEBUG15(printk("%s primary port id %02x%02x%02x\n", __func__,
			rptid_entry->port_id[2], rptid_entry->port_id[1],
			rptid_entry->port_id[0]));
	} else if (rptid_entry->format == 1) {
2755
		vp_idx = LSB(stat);
2756 2757
		DEBUG15(printk("%s:format 1: scsi(%ld): VP[%d] enabled "
		    "- status %d - "
2758
		    "with port id %02x%02x%02x\n", __func__, vha->host_no,
2759
		    vp_idx, MSB(stat),
2760 2761 2762 2763 2764
		    rptid_entry->port_id[2], rptid_entry->port_id[1],
		    rptid_entry->port_id[0]));
		if (vp_idx == 0)
			return;

2765 2766 2767
		if (MSB(stat) == 1) {
			DEBUG2(printk("scsi(%ld): Could not acquire ID for "
			    "VP[%d].\n", vha->host_no, vp_idx));
2768
			return;
2769
		}
2770

2771
		list_for_each_entry_safe(vp, tvp, &ha->vp_list, list)
2772
			if (vp_idx == vp->vp_idx)
2773
				break;
2774
		if (!vp)
2775 2776
			return;

2777 2778 2779
		vp->d_id.b.domain = rptid_entry->port_id[2];
		vp->d_id.b.area =  rptid_entry->port_id[1];
		vp->d_id.b.al_pa = rptid_entry->port_id[0];
2780 2781 2782 2783 2784

		/*
		 * Cannot configure here as we are still sitting on the
		 * response queue. Handle it in dpc context.
		 */
2785 2786
		set_bit(VP_IDX_ACQUIRED, &vp->vp_flags);
		set_bit(VP_DPC_NEEDED, &vha->dpc_flags);
2787

2788
		qla2xxx_wake_dpc(vha);
2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810
	}
}

/*
 * qla24xx_modify_vp_config
 *	Change VP configuration for vha
 *
 * Input:
 *	vha = adapter block pointer.
 *
 * Returns:
 *	qla2xxx local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
qla24xx_modify_vp_config(scsi_qla_host_t *vha)
{
	int		rval;
	struct vp_config_entry_24xx *vpmod;
	dma_addr_t	vpmod_dma;
2811 2812
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2813 2814 2815

	/* This can be called by the parent */

2816
	vpmod = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vpmod_dma);
2817 2818
	if (!vpmod) {
		DEBUG2_3(printk("%s(%ld): failed to allocate Modify VP "
2819
		    "IOCB.\n", __func__, vha->host_no));
2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833
		return QLA_MEMORY_ALLOC_FAILED;
	}

	memset(vpmod, 0, sizeof(struct vp_config_entry_24xx));
	vpmod->entry_type = VP_CONFIG_IOCB_TYPE;
	vpmod->entry_count = 1;
	vpmod->command = VCT_COMMAND_MOD_ENABLE_VPS;
	vpmod->vp_count = 1;
	vpmod->vp_index1 = vha->vp_idx;
	vpmod->options_idx1 = BIT_3|BIT_4|BIT_5;
	memcpy(vpmod->node_name_idx1, vha->node_name, WWN_SIZE);
	memcpy(vpmod->port_name_idx1, vha->port_name, WWN_SIZE);
	vpmod->entry_count = 1;

2834
	rval = qla2x00_issue_iocb(base_vha, vpmod, vpmod_dma, 0);
2835 2836
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed to issue VP config IOCB"
2837
			"(%x).\n", __func__, base_vha->host_no, rval));
2838 2839
	} else if (vpmod->comp_status != 0) {
		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2840
			"-- error status (%x).\n", __func__, base_vha->host_no,
2841 2842 2843 2844
			vpmod->comp_status));
		rval = QLA_FUNCTION_FAILED;
	} else if (vpmod->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2845
		    "-- completion status (%x).\n", __func__, base_vha->host_no,
2846 2847 2848 2849
		    le16_to_cpu(vpmod->comp_status)));
		rval = QLA_FUNCTION_FAILED;
	} else {
		/* EMPTY */
2850 2851
		DEBUG11(printk("%s(%ld): done.\n", __func__,
							base_vha->host_no));
2852 2853
		fc_vport_set_state(vha->fc_vport, FC_VPORT_INITIALIZING);
	}
2854
	dma_pool_free(ha->s_dma_pool, vpmod, vpmod_dma);
2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880

	return rval;
}

/*
 * qla24xx_control_vp
 *	Enable a virtual port for given host
 *
 * Input:
 *	ha = adapter block pointer.
 *	vhba = virtual adapter (unused)
 *	index = index number for enabled VP
 *
 * Returns:
 *	qla2xxx local function return status code.
 *
 * Context:
 *	Kernel context.
 */
int
qla24xx_control_vp(scsi_qla_host_t *vha, int cmd)
{
	int		rval;
	int		map, pos;
	struct vp_ctrl_entry_24xx   *vce;
	dma_addr_t	vce_dma;
2881
	struct qla_hw_data *ha = vha->hw;
2882
	int	vp_index = vha->vp_idx;
2883
	struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2884 2885

	DEBUG11(printk("%s(%ld): entered. Enabling index %d\n", __func__,
2886
	    vha->host_no, vp_index));
2887

2888
	if (vp_index == 0 || vp_index >= ha->max_npiv_vports)
2889 2890 2891 2892 2893 2894
		return QLA_PARAMETER_ERROR;

	vce = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vce_dma);
	if (!vce) {
		DEBUG2_3(printk("%s(%ld): "
		    "failed to allocate VP Control IOCB.\n", __func__,
2895
		    base_vha->host_no));
2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909
		return QLA_MEMORY_ALLOC_FAILED;
	}
	memset(vce, 0, sizeof(struct vp_ctrl_entry_24xx));

	vce->entry_type = VP_CTRL_IOCB_TYPE;
	vce->entry_count = 1;
	vce->command = cpu_to_le16(cmd);
	vce->vp_count = __constant_cpu_to_le16(1);

	/* index map in firmware starts with 1; decrement index
	 * this is ok as we never use index 0
	 */
	map = (vp_index - 1) / 8;
	pos = (vp_index - 1) & 7;
2910
	mutex_lock(&ha->vport_lock);
2911
	vce->vp_idx_map[map] |= 1 << pos;
2912
	mutex_unlock(&ha->vport_lock);
2913

2914
	rval = qla2x00_issue_iocb(base_vha, vce, vce_dma, 0);
2915 2916
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed to issue VP control IOCB"
2917
		    "(%x).\n", __func__, base_vha->host_no, rval));
2918
		printk("%s(%ld): failed to issue VP control IOCB"
2919
		    "(%x).\n", __func__, base_vha->host_no, rval);
2920 2921
	} else if (vce->entry_status != 0) {
		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2922
		    "-- error status (%x).\n", __func__, base_vha->host_no,
2923 2924
		    vce->entry_status));
		printk("%s(%ld): failed to complete IOCB "
2925
		    "-- error status (%x).\n", __func__, base_vha->host_no,
2926 2927 2928 2929
		    vce->entry_status);
		rval = QLA_FUNCTION_FAILED;
	} else if (vce->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
		DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
2930
		    "-- completion status (%x).\n", __func__, base_vha->host_no,
2931 2932
		    le16_to_cpu(vce->comp_status)));
		printk("%s(%ld): failed to complete IOCB "
2933
		    "-- completion status (%x).\n", __func__, base_vha->host_no,
2934 2935 2936
		    le16_to_cpu(vce->comp_status));
		rval = QLA_FUNCTION_FAILED;
	} else {
2937
		DEBUG2(printk("%s(%ld): done.\n", __func__, base_vha->host_no));
2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966
	}

	dma_pool_free(ha->s_dma_pool, vce, vce_dma);

	return rval;
}

/*
 * qla2x00_send_change_request
 *	Receive or disable RSCN request from fabric controller
 *
 * Input:
 *	ha = adapter block pointer
 *	format = registration format:
 *		0 - Reserved
 *		1 - Fabric detected registration
 *		2 - N_port detected registration
 *		3 - Full registration
 *		FF - clear registration
 *	vp_idx = Virtual port index
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel Context
 */

int
2967
qla2x00_send_change_request(scsi_qla_host_t *vha, uint16_t format,
2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987
			    uint16_t vp_idx)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	/*
	 * This command is implicitly executed by firmware during login for the
	 * physical hosts
	 */
	if (vp_idx == 0)
		return QLA_FUNCTION_FAILED;

	mcp->mb[0] = MBC_SEND_CHANGE_REQUEST;
	mcp->mb[1] = format;
	mcp->mb[9] = vp_idx;
	mcp->out_mb = MBX_9|MBX_1|MBX_0;
	mcp->in_mb = MBX_0|MBX_1;
	mcp->tov = MBX_TOV_SECONDS;
	mcp->flags = 0;
2988
	rval = qla2x00_mailbox_command(vha, mcp);
2989 2990 2991 2992 2993 2994 2995 2996 2997 2998

	if (rval == QLA_SUCCESS) {
		if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
			rval = BIT_1;
		}
	} else
		rval = BIT_1;

	return rval;
}
2999 3000

int
3001
qla2x00_dump_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
3002 3003 3004 3005 3006 3007
    uint32_t size)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

3008
	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3009

3010
	if (MSW(addr) || IS_FWI2_CAPABLE(vha->hw)) {
3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023
		mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
		mcp->mb[8] = MSW(addr);
		mcp->out_mb = MBX_8|MBX_0;
	} else {
		mcp->mb[0] = MBC_DUMP_RISC_RAM;
		mcp->out_mb = MBX_0;
	}
	mcp->mb[1] = LSW(addr);
	mcp->mb[2] = MSW(req_dma);
	mcp->mb[3] = LSW(req_dma);
	mcp->mb[6] = MSW(MSD(req_dma));
	mcp->mb[7] = LSW(MSD(req_dma));
	mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
3024
	if (IS_FWI2_CAPABLE(vha->hw)) {
3025 3026 3027 3028 3029 3030 3031 3032 3033
		mcp->mb[4] = MSW(size);
		mcp->mb[5] = LSW(size);
		mcp->out_mb |= MBX_5|MBX_4;
	} else {
		mcp->mb[4] = LSW(size);
		mcp->out_mb |= MBX_4;
	}

	mcp->in_mb = MBX_0;
3034
	mcp->tov = MBX_TOV_SECONDS;
3035
	mcp->flags = 0;
3036
	rval = qla2x00_mailbox_command(vha, mcp);
3037 3038 3039

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
3040
		    vha->host_no, rval, mcp->mb[0]));
3041
	} else {
3042
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3043 3044 3045 3046
	}

	return rval;
}
3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057

/* 84XX Support **************************************************************/

struct cs84xx_mgmt_cmd {
	union {
		struct verify_chip_entry_84xx req;
		struct verify_chip_rsp_84xx rsp;
	} p;
};

int
3058
qla84xx_verify_chip(struct scsi_qla_host *vha, uint16_t *status)
3059 3060 3061 3062 3063 3064
{
	int rval, retry;
	struct cs84xx_mgmt_cmd *mn;
	dma_addr_t mn_dma;
	uint16_t options;
	unsigned long flags;
3065
	struct qla_hw_data *ha = vha->hw;
3066

3067
	DEBUG16(printk("%s(%ld): entered.\n", __func__, vha->host_no));
3068 3069 3070 3071

	mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
	if (mn == NULL) {
		DEBUG2_3(printk("%s(%ld): failed to allocate Verify ISP84XX "
3072
		    "IOCB.\n", __func__, vha->host_no));
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083
		return QLA_MEMORY_ALLOC_FAILED;
	}

	/* Force Update? */
	options = ha->cs84xx->fw_update ? VCO_FORCE_UPDATE : 0;
	/* Diagnostic firmware? */
	/* options |= MENLO_DIAG_FW; */
	/* We update the firmware with only one data sequence. */
	options |= VCO_END_OF_DATA;

	do {
3084
		retry = 0;
3085 3086 3087 3088 3089 3090
		memset(mn, 0, sizeof(*mn));
		mn->p.req.entry_type = VERIFY_CHIP_IOCB_TYPE;
		mn->p.req.entry_count = 1;
		mn->p.req.options = cpu_to_le16(options);

		DEBUG16(printk("%s(%ld): Dump of Verify Request.\n", __func__,
3091
		    vha->host_no));
3092 3093 3094
		DEBUG16(qla2x00_dump_buffer((uint8_t *)mn,
		    sizeof(*mn)));

3095
		rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
3096 3097
		if (rval != QLA_SUCCESS) {
			DEBUG2_16(printk("%s(%ld): failed to issue Verify "
3098
			    "IOCB (%x).\n", __func__, vha->host_no, rval));
3099 3100 3101 3102
			goto verify_done;
		}

		DEBUG16(printk("%s(%ld): Dump of Verify Response.\n", __func__,
3103
		    vha->host_no));
3104 3105 3106 3107 3108 3109 3110
		DEBUG16(qla2x00_dump_buffer((uint8_t *)mn,
		    sizeof(*mn)));

		status[0] = le16_to_cpu(mn->p.rsp.comp_status);
		status[1] = status[0] == CS_VCS_CHIP_FAILURE ?
		    le16_to_cpu(mn->p.rsp.failure_code) : 0;
		DEBUG2_16(printk("%s(%ld): cs=%x fc=%x\n", __func__,
3111
		    vha->host_no, status[0], status[1]));
3112 3113 3114 3115 3116 3117

		if (status[0] != CS_COMPLETE) {
			rval = QLA_FUNCTION_FAILED;
			if (!(options & VCO_DONT_UPDATE_FW)) {
				DEBUG2_16(printk("%s(%ld): Firmware update "
				    "failed. Retrying without update "
3118
				    "firmware.\n", __func__, vha->host_no));
3119 3120 3121 3122 3123 3124
				options |= VCO_DONT_UPDATE_FW;
				options &= ~VCO_FORCE_UPDATE;
				retry = 1;
			}
		} else {
			DEBUG2_16(printk("%s(%ld): firmware updated to %x.\n",
3125
			    __func__, vha->host_no,
3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141
			    le32_to_cpu(mn->p.rsp.fw_ver)));

			/* NOTE: we only update OP firmware. */
			spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
			ha->cs84xx->op_fw_version =
			    le32_to_cpu(mn->p.rsp.fw_ver);
			spin_unlock_irqrestore(&ha->cs84xx->access_lock,
			    flags);
		}
	} while (retry);

verify_done:
	dma_pool_free(ha->s_dma_pool, mn, mn_dma);

	if (rval != QLA_SUCCESS) {
		DEBUG2_16(printk("%s(%ld): failed=%x.\n", __func__,
3142
		    vha->host_no, rval));
3143
	} else {
3144
		DEBUG16(printk("%s(%ld): done.\n", __func__, vha->host_no));
3145 3146 3147 3148
	}

	return rval;
}
3149 3150

int
3151
qla25xx_init_req_que(struct scsi_qla_host *vha, struct req_que *req)
3152 3153 3154 3155 3156 3157 3158 3159 3160
{
	int rval;
	unsigned long flags;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
	struct device_reg_25xxmq __iomem *reg;
	struct qla_hw_data *ha = vha->hw;

	mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
3161
	mcp->mb[1] = req->options;
3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187
	mcp->mb[2] = MSW(LSD(req->dma));
	mcp->mb[3] = LSW(LSD(req->dma));
	mcp->mb[6] = MSW(MSD(req->dma));
	mcp->mb[7] = LSW(MSD(req->dma));
	mcp->mb[5] = req->length;
	if (req->rsp)
		mcp->mb[10] = req->rsp->id;
	mcp->mb[12] = req->qos;
	mcp->mb[11] = req->vp_idx;
	mcp->mb[13] = req->rid;

	reg = (struct device_reg_25xxmq *)((void *)(ha->mqiobase) +
		QLA_QUE_PAGE * req->id);

	mcp->mb[4] = req->id;
	/* que in ptr index */
	mcp->mb[8] = 0;
	/* que out ptr index */
	mcp->mb[9] = 0;
	mcp->out_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|MBX_7|
			MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->flags = MBX_DMA_OUT;
	mcp->tov = 60;

	spin_lock_irqsave(&ha->hardware_lock, flags);
3188
	if (!(req->options & BIT_0)) {
3189 3190 3191
		WRT_REG_DWORD(&reg->req_q_in, 0);
		WRT_REG_DWORD(&reg->req_q_out, 0);
	}
3192 3193
	req->req_q_in = &reg->req_q_in;
	req->req_q_out = &reg->req_q_out;
3194 3195
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

3196
	rval = qla2x00_mailbox_command(vha, mcp);
3197 3198 3199 3200 3201 3202 3203
	if (rval != QLA_SUCCESS)
		DEBUG2_3_11(printk(KERN_WARNING "%s(%ld): failed=%x mb0=%x.\n",
			__func__, vha->host_no, rval, mcp->mb[0]));
	return rval;
}

int
3204
qla25xx_init_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
3205 3206 3207 3208 3209 3210 3211 3212 3213
{
	int rval;
	unsigned long flags;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;
	struct device_reg_25xxmq __iomem *reg;
	struct qla_hw_data *ha = vha->hw;

	mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
3214
	mcp->mb[1] = rsp->options;
3215 3216 3217 3218 3219
	mcp->mb[2] = MSW(LSD(rsp->dma));
	mcp->mb[3] = LSW(LSD(rsp->dma));
	mcp->mb[6] = MSW(MSD(rsp->dma));
	mcp->mb[7] = LSW(MSD(rsp->dma));
	mcp->mb[5] = rsp->length;
3220
	mcp->mb[14] = rsp->msix->entry;
3221 3222 3223 3224 3225 3226 3227 3228 3229 3230
	mcp->mb[13] = rsp->rid;

	reg = (struct device_reg_25xxmq *)((void *)(ha->mqiobase) +
		QLA_QUE_PAGE * rsp->id);

	mcp->mb[4] = rsp->id;
	/* que in ptr index */
	mcp->mb[8] = 0;
	/* que out ptr index */
	mcp->mb[9] = 0;
3231
	mcp->out_mb = MBX_14|MBX_13|MBX_9|MBX_8|MBX_7
3232 3233 3234 3235 3236 3237
			|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->flags = MBX_DMA_OUT;
	mcp->tov = 60;

	spin_lock_irqsave(&ha->hardware_lock, flags);
3238
	if (!(rsp->options & BIT_0)) {
3239 3240 3241 3242 3243 3244
		WRT_REG_DWORD(&reg->rsp_q_out, 0);
		WRT_REG_DWORD(&reg->rsp_q_in, 0);
	}

	spin_unlock_irqrestore(&ha->hardware_lock, flags);

3245
	rval = qla2x00_mailbox_command(vha, mcp);
3246 3247 3248 3249 3250 3251 3252
	if (rval != QLA_SUCCESS)
		DEBUG2_3_11(printk(KERN_WARNING "%s(%ld): failed=%x "
			"mb0=%x.\n", __func__,
			vha->host_no, rval, mcp->mb[0]));
	return rval;
}

3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278
int
qla81xx_idc_ack(scsi_qla_host_t *vha, uint16_t *mb)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	mcp->mb[0] = MBC_IDC_ACK;
	memcpy(&mcp->mb[1], mb, QLA_IDC_ACK_REGS * sizeof(uint16_t));
	mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->tov = MBX_TOV_SECONDS;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
		    vha->host_no, rval, mcp->mb[0]));
	} else {
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
	}

	return rval;
}
3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375

int
qla81xx_fac_get_sector_size(scsi_qla_host_t *vha, uint32_t *sector_size)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	if (!IS_QLA81XX(vha->hw))
		return QLA_FUNCTION_FAILED;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
	mcp->mb[1] = FAC_OPT_CMD_GET_SECTOR_SIZE;
	mcp->out_mb = MBX_1|MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
	mcp->tov = MBX_TOV_SECONDS;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
		    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
	} else {
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
		*sector_size = mcp->mb[1];
	}

	return rval;
}

int
qla81xx_fac_do_write_enable(scsi_qla_host_t *vha, int enable)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	if (!IS_QLA81XX(vha->hw))
		return QLA_FUNCTION_FAILED;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
	mcp->mb[1] = enable ? FAC_OPT_CMD_WRITE_ENABLE :
	    FAC_OPT_CMD_WRITE_PROTECT;
	mcp->out_mb = MBX_1|MBX_0;
	mcp->in_mb = MBX_1|MBX_0;
	mcp->tov = MBX_TOV_SECONDS;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
		    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
	} else {
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
	}

	return rval;
}

int
qla81xx_fac_erase_sector(scsi_qla_host_t *vha, uint32_t start, uint32_t finish)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	if (!IS_QLA81XX(vha->hw))
		return QLA_FUNCTION_FAILED;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
	mcp->mb[1] = FAC_OPT_CMD_ERASE_SECTOR;
	mcp->mb[2] = LSW(start);
	mcp->mb[3] = MSW(start);
	mcp->mb[4] = LSW(finish);
	mcp->mb[5] = MSW(finish);
	mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_2|MBX_1|MBX_0;
	mcp->tov = MBX_TOV_SECONDS;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
		    "mb[2]=%x.\n", __func__, vha->host_no, rval, mcp->mb[0],
		    mcp->mb[1], mcp->mb[2]));
	} else {
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
	}

	return rval;
}
3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401

int
qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
{
	int rval = 0;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	mcp->mb[0] = MBC_RESTART_MPI_FW;
	mcp->out_mb = MBX_0;
	mcp->in_mb = MBX_0|MBX_1;
	mcp->tov = MBX_TOV_SECONDS;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=0x%x mb[1]=0x%x.\n",
		    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
	} else {
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
	}

	return rval;
}
3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435

int
qla2x00_read_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
    dma_addr_t sfp_dma, uint8_t *sfp, uint16_t len, uint16_t opt)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	mcp->mb[0] = MBC_READ_SFP;
	mcp->mb[1] = dev;
	mcp->mb[2] = MSW(sfp_dma);
	mcp->mb[3] = LSW(sfp_dma);
	mcp->mb[6] = MSW(MSD(sfp_dma));
	mcp->mb[7] = LSW(MSD(sfp_dma));
	mcp->mb[8] = len;
	mcp->mb[9] = adr;
	mcp->mb[10] = opt;
	mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->tov = MBX_TOV_SECONDS;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);

	if (opt & BIT_0)
		if (sfp)
			*sfp = mcp->mb[8];

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
		    vha->host_no, rval, mcp->mb[0]));
	} else {
3436
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479
	}

	return rval;
}

int
qla2x00_write_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
    dma_addr_t sfp_dma, uint8_t *sfp, uint16_t len, uint16_t opt)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	if (opt & BIT_0)
		if (sfp)
			len = *sfp;

	mcp->mb[0] = MBC_WRITE_SFP;
	mcp->mb[1] = dev;
	mcp->mb[2] = MSW(sfp_dma);
	mcp->mb[3] = LSW(sfp_dma);
	mcp->mb[6] = MSW(MSD(sfp_dma));
	mcp->mb[7] = LSW(MSD(sfp_dma));
	mcp->mb[8] = len;
	mcp->mb[9] = adr;
	mcp->mb[10] = opt;
	mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->tov = MBX_TOV_SECONDS;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
		    vha->host_no, rval, mcp->mb[0]));
	} else {
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
	}

	return rval;
}
3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517

int
qla2x00_get_xgmac_stats(scsi_qla_host_t *vha, dma_addr_t stats_dma,
    uint16_t size_in_bytes, uint16_t *actual_size)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	if (!IS_QLA81XX(vha->hw))
		return QLA_FUNCTION_FAILED;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	mcp->mb[0] = MBC_GET_XGMAC_STATS;
	mcp->mb[2] = MSW(stats_dma);
	mcp->mb[3] = LSW(stats_dma);
	mcp->mb[6] = MSW(MSD(stats_dma));
	mcp->mb[7] = LSW(MSD(stats_dma));
	mcp->mb[8] = size_in_bytes >> 2;
	mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
	mcp->in_mb = MBX_2|MBX_1|MBX_0;
	mcp->tov = MBX_TOV_SECONDS;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=0x%x "
		    "mb[1]=0x%x mb[2]=0x%x.\n", __func__, vha->host_no, rval,
		    mcp->mb[0], mcp->mb[1], mcp->mb[2]));
	} else {
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));

		*actual_size = mcp->mb[2] << 2;
	}

	return rval;
}
3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554

int
qla2x00_get_dcbx_params(scsi_qla_host_t *vha, dma_addr_t tlv_dma,
    uint16_t size)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	if (!IS_QLA81XX(vha->hw))
		return QLA_FUNCTION_FAILED;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	mcp->mb[0] = MBC_GET_DCBX_PARAMS;
	mcp->mb[1] = 0;
	mcp->mb[2] = MSW(tlv_dma);
	mcp->mb[3] = LSW(tlv_dma);
	mcp->mb[6] = MSW(MSD(tlv_dma));
	mcp->mb[7] = LSW(MSD(tlv_dma));
	mcp->mb[8] = size;
	mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_2|MBX_1|MBX_0;
	mcp->tov = MBX_TOV_SECONDS;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);

	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=0x%x "
		    "mb[1]=0x%x mb[2]=0x%x.\n", __func__, vha->host_no, rval,
		    mcp->mb[0], mcp->mb[1], mcp->mb[2]));
	} else {
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
	}

	return rval;
}
3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617

int
qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	if (!IS_FWI2_CAPABLE(vha->hw))
		return QLA_FUNCTION_FAILED;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	mcp->mb[0] = MBC_READ_RAM_EXTENDED;
	mcp->mb[1] = LSW(risc_addr);
	mcp->mb[8] = MSW(risc_addr);
	mcp->out_mb = MBX_8|MBX_1|MBX_0;
	mcp->in_mb = MBX_3|MBX_2|MBX_0;
	mcp->tov = 30;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
		    vha->host_no, rval, mcp->mb[0]));
	} else {
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
		*data = mcp->mb[3] << 16 | mcp->mb[2];
	}

	return rval;
}

int
qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
{
	int rval;
	mbx_cmd_t mc;
	mbx_cmd_t *mcp = &mc;

	if (!IS_FWI2_CAPABLE(vha->hw))
                return QLA_FUNCTION_FAILED;

	DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));

	mcp->mb[0] = MBC_WRITE_RAM_WORD_EXTENDED;
	mcp->mb[1] = LSW(risc_addr);
	mcp->mb[2] = LSW(data);
	mcp->mb[3] = MSW(data);
	mcp->mb[8] = MSW(risc_addr);
	mcp->out_mb = MBX_8|MBX_3|MBX_2|MBX_1|MBX_0;
	mcp->in_mb = MBX_0;
	mcp->tov = 30;
	mcp->flags = 0;
	rval = qla2x00_mailbox_command(vha, mcp);
	if (rval != QLA_SUCCESS) {
		DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
		    vha->host_no, rval, mcp->mb[0]));
	} else {
		DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
	}

	return rval;
}