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

#include <linux/delay.h>
11
#include <linux/slab.h>
12
#include <linux/vmalloc.h>
L
Linus Torvalds 已提交
13 14 15

#include "qla_devtbl.h"

16 17 18 19
#ifdef CONFIG_SPARC
#include <asm/prom.h>
#endif

L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
/*
*  QLogic ISP2x00 Hardware Support Function Prototypes.
*/
static int qla2x00_isp_firmware(scsi_qla_host_t *);
static int qla2x00_setup_chip(scsi_qla_host_t *);
static int qla2x00_init_rings(scsi_qla_host_t *);
static int qla2x00_fw_ready(scsi_qla_host_t *);
static int qla2x00_configure_hba(scsi_qla_host_t *);
static int qla2x00_configure_loop(scsi_qla_host_t *);
static int qla2x00_configure_local_loop(scsi_qla_host_t *);
static int qla2x00_configure_fabric(scsi_qla_host_t *);
static int qla2x00_find_all_fabric_devs(scsi_qla_host_t *, struct list_head *);
static int qla2x00_device_resync(scsi_qla_host_t *);
static int qla2x00_fabric_dev_login(scsi_qla_host_t *, fc_port_t *,
    uint16_t *);

static int qla2x00_restart_isp(scsi_qla_host_t *);

38 39
static struct qla_chip_state_84xx *qla84xx_get_chip(struct scsi_qla_host *);
static int qla84xx_init_chip(scsi_qla_host_t *);
40
static int qla25xx_init_queues(struct qla_hw_data *);
41

42 43 44 45 46 47 48
/* SRB Extensions ---------------------------------------------------------- */

static void
qla2x00_ctx_sp_timeout(unsigned long __data)
{
	srb_t *sp = (srb_t *)__data;
	struct srb_ctx *ctx;
49
	struct srb_iocb *iocb;
50 51 52 53 54 55 56 57 58
	fc_port_t *fcport = sp->fcport;
	struct qla_hw_data *ha = fcport->vha->hw;
	struct req_que *req;
	unsigned long flags;

	spin_lock_irqsave(&ha->hardware_lock, flags);
	req = ha->req_q_map[0];
	req->outstanding_cmds[sp->handle] = NULL;
	ctx = sp->ctx;
59 60 61
	iocb = ctx->u.iocb_cmd;
	iocb->timeout(sp);
	iocb->free(sp);
62
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
63 64
}

65
static void
66 67 68
qla2x00_ctx_sp_free(srb_t *sp)
{
	struct srb_ctx *ctx = sp->ctx;
69
	struct srb_iocb *iocb = ctx->u.iocb_cmd;
70
	struct scsi_qla_host *vha = sp->fcport->vha;
71

72
	del_timer(&iocb->timer);
73
	kfree(iocb);
74 75
	kfree(ctx);
	mempool_free(sp, sp->fcport->vha->hw->srb_mempool);
76 77

	QLA_VHA_MARK_NOT_BUSY(vha);
78 79 80 81 82 83
}

inline srb_t *
qla2x00_get_ctx_sp(scsi_qla_host_t *vha, fc_port_t *fcport, size_t size,
    unsigned long tmo)
{
84
	srb_t *sp = NULL;
85 86
	struct qla_hw_data *ha = vha->hw;
	struct srb_ctx *ctx;
87
	struct srb_iocb *iocb;
88 89 90 91 92
	uint8_t bail;

	QLA_VHA_MARK_BUSY(vha, bail);
	if (bail)
		return NULL;
93 94 95 96 97 98 99

	sp = mempool_alloc(ha->srb_mempool, GFP_KERNEL);
	if (!sp)
		goto done;
	ctx = kzalloc(size, GFP_KERNEL);
	if (!ctx) {
		mempool_free(sp, ha->srb_mempool);
100 101 102 103 104 105 106 107
		sp = NULL;
		goto done;
	}
	iocb = kzalloc(sizeof(struct srb_iocb), GFP_KERNEL);
	if (!iocb) {
		mempool_free(sp, ha->srb_mempool);
		sp = NULL;
		kfree(ctx);
108 109 110 111 112 113
		goto done;
	}

	memset(sp, 0, sizeof(*sp));
	sp->fcport = fcport;
	sp->ctx = ctx;
114
	ctx->iocbs = 1;
115 116
	ctx->u.iocb_cmd = iocb;
	iocb->free = qla2x00_ctx_sp_free;
117

118
	init_timer(&iocb->timer);
119 120
	if (!tmo)
		goto done;
121 122 123 124
	iocb->timer.expires = jiffies + tmo * HZ;
	iocb->timer.data = (unsigned long)sp;
	iocb->timer.function = qla2x00_ctx_sp_timeout;
	add_timer(&iocb->timer);
125
done:
126 127
	if (!sp)
		QLA_VHA_MARK_NOT_BUSY(vha);
128 129 130 131 132
	return sp;
}

/* Asynchronous Login/Logout Routines -------------------------------------- */

133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
static inline unsigned long
qla2x00_get_async_timeout(struct scsi_qla_host *vha)
{
	unsigned long tmo;
	struct qla_hw_data *ha = vha->hw;

	/* Firmware should use switch negotiated r_a_tov for timeout. */
	tmo = ha->r_a_tov / 10 * 2;
	if (!IS_FWI2_CAPABLE(ha)) {
		/*
		 * Except for earlier ISPs where the timeout is seeded from the
		 * initialization control block.
		 */
		tmo = ha->login_timeout;
	}
	return tmo;
}
150 151

static void
152
qla2x00_async_iocb_timeout(srb_t *sp)
153 154
{
	fc_port_t *fcport = sp->fcport;
155
	struct srb_ctx *ctx = sp->ctx;
156

157
	ql_dbg(ql_dbg_disc, fcport->vha, 0x2071,
158 159
	    "Async-%s timeout - hdl=%x portid=%02x%02x%02x.\n",
	    ctx->name, sp->handle, fcport->d_id.b.domain, fcport->d_id.b.area,
160
	    fcport->d_id.b.al_pa);
161

162
	fcport->flags &= ~FCF_ASYNC_SENT;
163 164
	if (ctx->type == SRB_LOGIN_CMD) {
		struct srb_iocb *lio = ctx->u.iocb_cmd;
165
		qla2x00_post_async_logout_work(fcport->vha, fcport, NULL);
166 167 168 169 170 171 172
		/* Retry as needed. */
		lio->u.logio.data[0] = MBS_COMMAND_ERROR;
		lio->u.logio.data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
			QLA_LOGIO_LOGIN_RETRIED : 0;
		qla2x00_post_async_login_done_work(fcport->vha, fcport,
			lio->u.logio.data);
	}
173 174
}

175 176 177
static void
qla2x00_async_login_ctx_done(srb_t *sp)
{
178 179
	struct srb_ctx *ctx = sp->ctx;
	struct srb_iocb *lio = ctx->u.iocb_cmd;
180 181

	qla2x00_post_async_login_done_work(sp->fcport->vha, sp->fcport,
182 183
		lio->u.logio.data);
	lio->free(sp);
184 185
}

186 187 188 189 190
int
qla2x00_async_login(struct scsi_qla_host *vha, fc_port_t *fcport,
    uint16_t *data)
{
	srb_t *sp;
191 192
	struct srb_ctx *ctx;
	struct srb_iocb *lio;
193 194 195
	int rval;

	rval = QLA_FUNCTION_FAILED;
196
	sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
197
	    qla2x00_get_async_timeout(vha) + 2);
198 199 200
	if (!sp)
		goto done;

201 202 203 204
	ctx = sp->ctx;
	ctx->type = SRB_LOGIN_CMD;
	ctx->name = "login";
	lio = ctx->u.iocb_cmd;
205
	lio->timeout = qla2x00_async_iocb_timeout;
206 207
	lio->done = qla2x00_async_login_ctx_done;
	lio->u.logio.flags |= SRB_LOGIN_COND_PLOGI;
208
	if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
209
		lio->u.logio.flags |= SRB_LOGIN_RETRIED;
210 211 212 213
	rval = qla2x00_start_sp(sp);
	if (rval != QLA_SUCCESS)
		goto done_free_sp;

214
	ql_dbg(ql_dbg_disc, vha, 0x2072,
215 216 217 218
	    "Async-login - hdl=%x, loopid=%x portid=%02x%02x%02x "
	    "retries=%d.\n", sp->handle, fcport->loop_id,
	    fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa,
	    fcport->login_retry);
219 220 221
	return rval;

done_free_sp:
222
	lio->free(sp);
223 224 225 226
done:
	return rval;
}

227 228 229
static void
qla2x00_async_logout_ctx_done(srb_t *sp)
{
230 231
	struct srb_ctx *ctx = sp->ctx;
	struct srb_iocb *lio = ctx->u.iocb_cmd;
232 233

	qla2x00_post_async_logout_done_work(sp->fcport->vha, sp->fcport,
234 235
	    lio->u.logio.data);
	lio->free(sp);
236 237
}

238 239 240 241
int
qla2x00_async_logout(struct scsi_qla_host *vha, fc_port_t *fcport)
{
	srb_t *sp;
242 243
	struct srb_ctx *ctx;
	struct srb_iocb *lio;
244 245 246
	int rval;

	rval = QLA_FUNCTION_FAILED;
247
	sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
248
	    qla2x00_get_async_timeout(vha) + 2);
249 250 251
	if (!sp)
		goto done;

252 253 254 255
	ctx = sp->ctx;
	ctx->type = SRB_LOGOUT_CMD;
	ctx->name = "logout";
	lio = ctx->u.iocb_cmd;
256
	lio->timeout = qla2x00_async_iocb_timeout;
257
	lio->done = qla2x00_async_logout_ctx_done;
258 259 260 261
	rval = qla2x00_start_sp(sp);
	if (rval != QLA_SUCCESS)
		goto done_free_sp;

262
	ql_dbg(ql_dbg_disc, vha, 0x2070,
263 264 265
	    "Async-logout - hdl=%x loop-id=%x portid=%02x%02x%02x.\n",
	    sp->handle, fcport->loop_id, fcport->d_id.b.domain,
	    fcport->d_id.b.area, fcport->d_id.b.al_pa);
266 267 268
	return rval;

done_free_sp:
269
	lio->free(sp);
270 271 272 273
done:
	return rval;
}

274 275 276
static void
qla2x00_async_adisc_ctx_done(srb_t *sp)
{
277 278
	struct srb_ctx *ctx = sp->ctx;
	struct srb_iocb *lio = ctx->u.iocb_cmd;
279 280

	qla2x00_post_async_adisc_done_work(sp->fcport->vha, sp->fcport,
281 282
	    lio->u.logio.data);
	lio->free(sp);
283 284 285 286 287 288 289
}

int
qla2x00_async_adisc(struct scsi_qla_host *vha, fc_port_t *fcport,
    uint16_t *data)
{
	srb_t *sp;
290 291
	struct srb_ctx *ctx;
	struct srb_iocb *lio;
292 293 294
	int rval;

	rval = QLA_FUNCTION_FAILED;
295
	sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
296
	    qla2x00_get_async_timeout(vha) + 2);
297 298 299
	if (!sp)
		goto done;

300 301 302 303
	ctx = sp->ctx;
	ctx->type = SRB_ADISC_CMD;
	ctx->name = "adisc";
	lio = ctx->u.iocb_cmd;
304
	lio->timeout = qla2x00_async_iocb_timeout;
305
	lio->done = qla2x00_async_adisc_ctx_done;
306
	if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
307
		lio->u.logio.flags |= SRB_LOGIN_RETRIED;
308 309 310 311
	rval = qla2x00_start_sp(sp);
	if (rval != QLA_SUCCESS)
		goto done_free_sp;

312
	ql_dbg(ql_dbg_disc, vha, 0x206f,
313 314 315
	    "Async-adisc - hdl=%x loopid=%x portid=%02x%02x%02x.\n",
	    sp->handle, fcport->loop_id, fcport->d_id.b.domain,
	    fcport->d_id.b.area, fcport->d_id.b.al_pa);
316 317 318
	return rval;

done_free_sp:
319
	lio->free(sp);
320 321 322 323
done:
	return rval;
}

324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
static void
qla2x00_async_tm_cmd_ctx_done(srb_t *sp)
{
	struct srb_ctx *ctx = sp->ctx;
	struct srb_iocb *iocb = (struct srb_iocb *)ctx->u.iocb_cmd;

	qla2x00_async_tm_cmd_done(sp->fcport->vha, sp->fcport, iocb);
	iocb->free(sp);
}

int
qla2x00_async_tm_cmd(fc_port_t *fcport, uint32_t flags, uint32_t lun,
	uint32_t tag)
{
	struct scsi_qla_host *vha = fcport->vha;
	srb_t *sp;
	struct srb_ctx *ctx;
	struct srb_iocb *tcf;
	int rval;

	rval = QLA_FUNCTION_FAILED;
	sp = qla2x00_get_ctx_sp(vha, fcport, sizeof(struct srb_ctx),
346
	    qla2x00_get_async_timeout(vha) + 2);
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
	if (!sp)
		goto done;

	ctx = sp->ctx;
	ctx->type = SRB_TM_CMD;
	ctx->name = "tmf";
	tcf = ctx->u.iocb_cmd;
	tcf->u.tmf.flags = flags;
	tcf->u.tmf.lun = lun;
	tcf->u.tmf.data = tag;
	tcf->timeout = qla2x00_async_iocb_timeout;
	tcf->done = qla2x00_async_tm_cmd_ctx_done;

	rval = qla2x00_start_sp(sp);
	if (rval != QLA_SUCCESS)
		goto done_free_sp;

364
	ql_dbg(ql_dbg_taskm, vha, 0x802f,
365 366 367
	    "Async-tmf hdl=%x loop-id=%x portid=%02x%02x%02x.\n",
	    sp->handle, fcport->loop_id, fcport->d_id.b.domain,
	    fcport->d_id.b.area, fcport->d_id.b.al_pa);
368 369 370 371 372 373 374 375
	return rval;

done_free_sp:
	tcf->free(sp);
done:
	return rval;
}

376
void
377 378 379 380 381 382 383
qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
    uint16_t *data)
{
	int rval;

	switch (data[0]) {
	case MBS_COMMAND_COMPLETE:
384 385 386 387 388 389 390 391 392 393 394
		/*
		 * Driver must validate login state - If PRLI not complete,
		 * force a relogin attempt via implicit LOGO, PLOGI, and PRLI
		 * requests.
		 */
		rval = qla2x00_get_port_database(vha, fcport, 0);
		if (rval != QLA_SUCCESS) {
			qla2x00_post_async_logout_work(vha, fcport, NULL);
			qla2x00_post_async_login_work(vha, fcport, NULL);
			break;
		}
395
		if (fcport->flags & FCF_FCP2_DEVICE) {
396 397
			qla2x00_post_async_adisc_work(vha, fcport, data);
			break;
398 399
		}
		qla2x00_update_fcport(vha, fcport);
400 401
		break;
	case MBS_COMMAND_ERROR:
402
		fcport->flags &= ~FCF_ASYNC_SENT;
403 404 405
		if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
			set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
		else
406
			qla2x00_mark_device_lost(vha, fcport, 1, 0);
407 408 409
		break;
	case MBS_PORT_ID_USED:
		fcport->loop_id = data[1];
410
		qla2x00_post_async_logout_work(vha, fcport, NULL);
411 412 413 414 415 416
		qla2x00_post_async_login_work(vha, fcport, NULL);
		break;
	case MBS_LOOP_ID_USED:
		fcport->loop_id++;
		rval = qla2x00_find_new_loop_id(vha, fcport);
		if (rval != QLA_SUCCESS) {
417
			fcport->flags &= ~FCF_ASYNC_SENT;
418
			qla2x00_mark_device_lost(vha, fcport, 1, 0);
419 420 421 422 423
			break;
		}
		qla2x00_post_async_login_work(vha, fcport, NULL);
		break;
	}
424
	return;
425 426
}

427
void
428 429 430 431
qla2x00_async_logout_done(struct scsi_qla_host *vha, fc_port_t *fcport,
    uint16_t *data)
{
	qla2x00_mark_device_lost(vha, fcport, 1, 0);
432
	return;
433 434
}

435
void
436 437 438 439 440 441
qla2x00_async_adisc_done(struct scsi_qla_host *vha, fc_port_t *fcport,
    uint16_t *data)
{
	if (data[0] == MBS_COMMAND_COMPLETE) {
		qla2x00_update_fcport(vha, fcport);

442
		return;
443 444 445 446 447 448 449
	}

	/* Retry login. */
	fcport->flags &= ~FCF_ASYNC_SENT;
	if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
		set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
	else
450
		qla2x00_mark_device_lost(vha, fcport, 1, 0);
451

452
	return;
453 454
}

455 456 457 458 459 460 461 462 463 464 465 466
void
qla2x00_async_tm_cmd_done(struct scsi_qla_host *vha, fc_port_t *fcport,
    struct srb_iocb *iocb)
{
	int rval;
	uint32_t flags;
	uint16_t lun;

	flags = iocb->u.tmf.flags;
	lun = (uint16_t)iocb->u.tmf.lun;

	/* Issue Marker IOCB */
467 468
	rval = qla2x00_marker(vha, vha->hw->req_q_map[0],
		vha->hw->rsp_q_map[0], fcport->loop_id, lun,
469 470 471
		flags == TCF_LUN_RESET ? MK_SYNC_ID_LUN : MK_SYNC_ID);

	if ((rval != QLA_SUCCESS) || iocb->u.tmf.data) {
472 473
		ql_dbg(ql_dbg_taskm, vha, 0x8030,
		    "TM IOCB failed (%x).\n", rval);
474 475 476 477 478
	}

	return;
}

L
Linus Torvalds 已提交
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
/****************************************************************************/
/*                QLogic ISP2x00 Hardware Support Functions.                */
/****************************************************************************/

/*
* qla2x00_initialize_adapter
*      Initialize board.
*
* Input:
*      ha = adapter block pointer.
*
* Returns:
*      0 = success
*/
int
494
qla2x00_initialize_adapter(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
495 496
{
	int	rval;
497
	struct qla_hw_data *ha = vha->hw;
498
	struct req_que *req = ha->req_q_map[0];
499

L
Linus Torvalds 已提交
500
	/* Clear adapter flags. */
501
	vha->flags.online = 0;
502
	ha->flags.chip_reset_done = 0;
503
	vha->flags.reset_active = 0;
504 505
	ha->flags.pci_channel_io_perm_failure = 0;
	ha->flags.eeh_busy = 0;
506
	ha->flags.thermal_supported = 1;
507 508 509 510 511 512
	atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
	atomic_set(&vha->loop_state, LOOP_DOWN);
	vha->device_flags = DFLG_NO_CABLE;
	vha->dpc_flags = 0;
	vha->flags.management_server_logged_in = 0;
	vha->marker_needed = 0;
L
Linus Torvalds 已提交
513 514 515
	ha->isp_abort_cnt = 0;
	ha->beacon_blink_led = 0;

516 517 518
	set_bit(0, ha->req_qid_map);
	set_bit(0, ha->rsp_qid_map);

519
	ql_dbg(ql_dbg_init, vha, 0x0040,
520
	    "Configuring PCI space...\n");
521
	rval = ha->isp_ops->pci_config(vha);
L
Linus Torvalds 已提交
522
	if (rval) {
523 524
		ql_log(ql_log_warn, vha, 0x0044,
		    "Unable to configure PCI space.\n");
L
Linus Torvalds 已提交
525 526 527
		return (rval);
	}

528
	ha->isp_ops->reset_chip(vha);
L
Linus Torvalds 已提交
529

530
	rval = qla2xxx_get_flash_info(vha);
531
	if (rval) {
532 533
		ql_log(ql_log_fatal, vha, 0x004f,
		    "Unable to validate FLASH data.\n");
534 535 536
		return (rval);
	}

537
	ha->isp_ops->get_flash_version(vha, req->ring);
538
	ql_dbg(ql_dbg_init, vha, 0x0061,
539
	    "Configure NVRAM parameters...\n");
540

541
	ha->isp_ops->nvram_config(vha);
L
Linus Torvalds 已提交
542

543 544
	if (ha->flags.disable_serdes) {
		/* Mask HBA via NVRAM settings? */
545 546
		ql_log(ql_log_info, vha, 0x0077,
		    "Masking HBA WWPN "
547
		    "%02x%02x%02x%02x%02x%02x%02x%02x (via NVRAM).\n",
548 549 550 551
		    vha->port_name[0], vha->port_name[1],
		    vha->port_name[2], vha->port_name[3],
		    vha->port_name[4], vha->port_name[5],
		    vha->port_name[6], vha->port_name[7]);
552 553 554
		return QLA_FUNCTION_FAILED;
	}

555
	ql_dbg(ql_dbg_init, vha, 0x0078,
556
	    "Verifying loaded RISC code...\n");
L
Linus Torvalds 已提交
557

558 559
	if (qla2x00_isp_firmware(vha) != QLA_SUCCESS) {
		rval = ha->isp_ops->chip_diag(vha);
560 561
		if (rval)
			return (rval);
562
		rval = qla2x00_setup_chip(vha);
563 564
		if (rval)
			return (rval);
L
Linus Torvalds 已提交
565
	}
566

567
	if (IS_QLA84XX(ha)) {
568
		ha->cs84xx = qla84xx_get_chip(vha);
569
		if (!ha->cs84xx) {
570
			ql_log(ql_log_warn, vha, 0x00d0,
571 572 573 574
			    "Unable to configure ISP84XX.\n");
			return QLA_FUNCTION_FAILED;
		}
	}
575
	rval = qla2x00_init_rings(vha);
576
	ha->flags.chip_reset_done = 1;
L
Linus Torvalds 已提交
577

578
	if (rval == QLA_SUCCESS && IS_QLA84XX(ha)) {
579
		/* Issue verify 84xx FW IOCB to complete 84xx initialization */
580 581
		rval = qla84xx_init_chip(vha);
		if (rval != QLA_SUCCESS) {
582 583
			ql_log(ql_log_warn, vha, 0x00d4,
			    "Unable to initialize ISP84XX.\n");
584 585 586 587
		qla84xx_put_chip(vha);
		}
	}

588 589
	if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha))
		qla24xx_read_fcp_prio_cfg(vha);
S
Sarang Radke 已提交
590

L
Linus Torvalds 已提交
591 592 593 594
	return (rval);
}

/**
595
 * qla2100_pci_config() - Setup ISP21xx PCI configuration registers.
L
Linus Torvalds 已提交
596 597 598 599
 * @ha: HA context
 *
 * Returns 0 on success.
 */
600
int
601
qla2100_pci_config(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
602
{
603
	uint16_t w;
604
	unsigned long flags;
605
	struct qla_hw_data *ha = vha->hw;
606
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
607 608

	pci_set_master(ha->pdev);
609
	pci_try_set_mwi(ha->pdev);
L
Linus Torvalds 已提交
610 611

	pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
612
	w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
613 614
	pci_write_config_word(ha->pdev, PCI_COMMAND, w);

615
	pci_disable_rom(ha->pdev);
L
Linus Torvalds 已提交
616 617 618

	/* Get PCI bus information. */
	spin_lock_irqsave(&ha->hardware_lock, flags);
619
	ha->pci_attr = RD_REG_WORD(&reg->ctrl_status);
L
Linus Torvalds 已提交
620 621
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

622 623
	return QLA_SUCCESS;
}
L
Linus Torvalds 已提交
624

625 626 627 628 629 630 631
/**
 * qla2300_pci_config() - Setup ISP23xx PCI configuration registers.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
int
632
qla2300_pci_config(scsi_qla_host_t *vha)
633
{
634
	uint16_t	w;
635 636
	unsigned long   flags = 0;
	uint32_t	cnt;
637
	struct qla_hw_data *ha = vha->hw;
638
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
639

640
	pci_set_master(ha->pdev);
641
	pci_try_set_mwi(ha->pdev);
L
Linus Torvalds 已提交
642

643
	pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
644
	w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
L
Linus Torvalds 已提交
645

646 647
	if (IS_QLA2322(ha) || IS_QLA6322(ha))
		w &= ~PCI_COMMAND_INTX_DISABLE;
648
	pci_write_config_word(ha->pdev, PCI_COMMAND, w);
L
Linus Torvalds 已提交
649

650 651 652 653 654 655 656 657 658
	/*
	 * If this is a 2300 card and not 2312, reset the
	 * COMMAND_INVALIDATE due to a bug in the 2300. Unfortunately,
	 * the 2310 also reports itself as a 2300 so we need to get the
	 * fb revision level -- a 6 indicates it really is a 2300 and
	 * not a 2310.
	 */
	if (IS_QLA2300(ha)) {
		spin_lock_irqsave(&ha->hardware_lock, flags);
L
Linus Torvalds 已提交
659

660
		/* Pause RISC. */
661
		WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
662
		for (cnt = 0; cnt < 30000; cnt++) {
663
			if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) != 0)
664
				break;
L
Linus Torvalds 已提交
665

666 667
			udelay(10);
		}
L
Linus Torvalds 已提交
668

669
		/* Select FPM registers. */
670 671
		WRT_REG_WORD(&reg->ctrl_status, 0x20);
		RD_REG_WORD(&reg->ctrl_status);
672 673

		/* Get the fb rev level */
674
		ha->fb_rev = RD_FB_CMD_REG(ha, reg);
675 676

		if (ha->fb_rev == FPM_2300)
677
			pci_clear_mwi(ha->pdev);
678 679

		/* Deselect FPM registers. */
680 681
		WRT_REG_WORD(&reg->ctrl_status, 0x0);
		RD_REG_WORD(&reg->ctrl_status);
682 683

		/* Release RISC module. */
684
		WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
685
		for (cnt = 0; cnt < 30000; cnt++) {
686
			if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0)
687 688 689
				break;

			udelay(10);
L
Linus Torvalds 已提交
690 691
		}

692 693
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
	}
L
Linus Torvalds 已提交
694

695 696
	pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);

697
	pci_disable_rom(ha->pdev);
L
Linus Torvalds 已提交
698

699 700
	/* Get PCI bus information. */
	spin_lock_irqsave(&ha->hardware_lock, flags);
701
	ha->pci_attr = RD_REG_WORD(&reg->ctrl_status);
702 703 704
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

	return QLA_SUCCESS;
L
Linus Torvalds 已提交
705 706
}

707 708 709 710 711 712 713
/**
 * qla24xx_pci_config() - Setup ISP24xx PCI configuration registers.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
int
714
qla24xx_pci_config(scsi_qla_host_t *vha)
715
{
716
	uint16_t w;
717
	unsigned long flags = 0;
718
	struct qla_hw_data *ha = vha->hw;
719 720 721
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

	pci_set_master(ha->pdev);
722
	pci_try_set_mwi(ha->pdev);
723 724

	pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
725
	w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
726 727 728 729 730 731
	w &= ~PCI_COMMAND_INTX_DISABLE;
	pci_write_config_word(ha->pdev, PCI_COMMAND, w);

	pci_write_config_byte(ha->pdev, PCI_LATENCY_TIMER, 0x80);

	/* PCI-X -- adjust Maximum Memory Read Byte Count (2048). */
732 733
	if (pci_find_capability(ha->pdev, PCI_CAP_ID_PCIX))
		pcix_set_mmrbc(ha->pdev, 2048);
734 735

	/* PCIe -- adjust Maximum Read Request Size (2048). */
736 737
	if (pci_find_capability(ha->pdev, PCI_CAP_ID_EXP))
		pcie_set_readrq(ha->pdev, 2048);
738

739
	pci_disable_rom(ha->pdev);
740

741
	ha->chip_revision = ha->pdev->revision;
742

743 744 745 746 747 748 749 750
	/* Get PCI bus information. */
	spin_lock_irqsave(&ha->hardware_lock, flags);
	ha->pci_attr = RD_REG_DWORD(&reg->ctrl_status);
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

	return QLA_SUCCESS;
}

751 752 753 754 755 756 757
/**
 * qla25xx_pci_config() - Setup ISP25xx PCI configuration registers.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
int
758
qla25xx_pci_config(scsi_qla_host_t *vha)
759 760
{
	uint16_t w;
761
	struct qla_hw_data *ha = vha->hw;
762 763 764 765 766 767 768 769 770 771 772 773 774

	pci_set_master(ha->pdev);
	pci_try_set_mwi(ha->pdev);

	pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
	w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
	w &= ~PCI_COMMAND_INTX_DISABLE;
	pci_write_config_word(ha->pdev, PCI_COMMAND, w);

	/* PCIe -- adjust Maximum Read Request Size (2048). */
	if (pci_find_capability(ha->pdev, PCI_CAP_ID_EXP))
		pcie_set_readrq(ha->pdev, 2048);

775
	pci_disable_rom(ha->pdev);
776 777 778 779 780 781

	ha->chip_revision = ha->pdev->revision;

	return QLA_SUCCESS;
}

L
Linus Torvalds 已提交
782 783 784 785 786 787 788
/**
 * qla2x00_isp_firmware() - Choose firmware image.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
static int
789
qla2x00_isp_firmware(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
790 791
{
	int  rval;
792 793
	uint16_t loop_id, topo, sw_cap;
	uint8_t domain, area, al_pa;
794
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
795 796

	/* Assume loading risc code */
A
Andrew Vasquez 已提交
797
	rval = QLA_FUNCTION_FAILED;
L
Linus Torvalds 已提交
798 799

	if (ha->flags.disable_risc_code_load) {
800
		ql_log(ql_log_info, vha, 0x0079, "RISC CODE NOT loaded.\n");
L
Linus Torvalds 已提交
801 802

		/* Verify checksum of loaded RISC code. */
803
		rval = qla2x00_verify_checksum(vha, ha->fw_srisc_address);
804 805
		if (rval == QLA_SUCCESS) {
			/* And, verify we are not in ROM code. */
806
			rval = qla2x00_get_adapter_id(vha, &loop_id, &al_pa,
807 808
			    &area, &domain, &topo, &sw_cap);
		}
L
Linus Torvalds 已提交
809 810
	}

811 812 813
	if (rval)
		ql_dbg(ql_dbg_init, vha, 0x007a,
		    "**** Load RISC code ****.\n");
L
Linus Torvalds 已提交
814 815 816 817 818 819 820 821 822 823

	return (rval);
}

/**
 * qla2x00_reset_chip() - Reset ISP chip.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
824
void
825
qla2x00_reset_chip(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
826 827
{
	unsigned long   flags = 0;
828
	struct qla_hw_data *ha = vha->hw;
829
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
830 831 832
	uint32_t	cnt;
	uint16_t	cmd;

833 834 835
	if (unlikely(pci_channel_offline(ha->pdev)))
		return;

836
	ha->isp_ops->disable_intrs(ha);
L
Linus Torvalds 已提交
837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 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 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940

	spin_lock_irqsave(&ha->hardware_lock, flags);

	/* Turn off master enable */
	cmd = 0;
	pci_read_config_word(ha->pdev, PCI_COMMAND, &cmd);
	cmd &= ~PCI_COMMAND_MASTER;
	pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);

	if (!IS_QLA2100(ha)) {
		/* Pause RISC. */
		WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
		if (IS_QLA2200(ha) || IS_QLA2300(ha)) {
			for (cnt = 0; cnt < 30000; cnt++) {
				if ((RD_REG_WORD(&reg->hccr) &
				    HCCR_RISC_PAUSE) != 0)
					break;
				udelay(100);
			}
		} else {
			RD_REG_WORD(&reg->hccr);	/* PCI Posting. */
			udelay(10);
		}

		/* Select FPM registers. */
		WRT_REG_WORD(&reg->ctrl_status, 0x20);
		RD_REG_WORD(&reg->ctrl_status);		/* PCI Posting. */

		/* FPM Soft Reset. */
		WRT_REG_WORD(&reg->fpm_diag_config, 0x100);
		RD_REG_WORD(&reg->fpm_diag_config);	/* PCI Posting. */

		/* Toggle Fpm Reset. */
		if (!IS_QLA2200(ha)) {
			WRT_REG_WORD(&reg->fpm_diag_config, 0x0);
			RD_REG_WORD(&reg->fpm_diag_config); /* PCI Posting. */
		}

		/* Select frame buffer registers. */
		WRT_REG_WORD(&reg->ctrl_status, 0x10);
		RD_REG_WORD(&reg->ctrl_status);		/* PCI Posting. */

		/* Reset frame buffer FIFOs. */
		if (IS_QLA2200(ha)) {
			WRT_FB_CMD_REG(ha, reg, 0xa000);
			RD_FB_CMD_REG(ha, reg);		/* PCI Posting. */
		} else {
			WRT_FB_CMD_REG(ha, reg, 0x00fc);

			/* Read back fb_cmd until zero or 3 seconds max */
			for (cnt = 0; cnt < 3000; cnt++) {
				if ((RD_FB_CMD_REG(ha, reg) & 0xff) == 0)
					break;
				udelay(100);
			}
		}

		/* Select RISC module registers. */
		WRT_REG_WORD(&reg->ctrl_status, 0);
		RD_REG_WORD(&reg->ctrl_status);		/* PCI Posting. */

		/* Reset RISC processor. */
		WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
		RD_REG_WORD(&reg->hccr);		/* PCI Posting. */

		/* Release RISC processor. */
		WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
		RD_REG_WORD(&reg->hccr);		/* PCI Posting. */
	}

	WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
	WRT_REG_WORD(&reg->hccr, HCCR_CLR_HOST_INT);

	/* Reset ISP chip. */
	WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);

	/* Wait for RISC to recover from reset. */
	if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
		/*
		 * It is necessary to for a delay here since the card doesn't
		 * respond to PCI reads during a reset. On some architectures
		 * this will result in an MCA.
		 */
		udelay(20);
		for (cnt = 30000; cnt; cnt--) {
			if ((RD_REG_WORD(&reg->ctrl_status) &
			    CSR_ISP_SOFT_RESET) == 0)
				break;
			udelay(100);
		}
	} else
		udelay(10);

	/* Reset RISC processor. */
	WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);

	WRT_REG_WORD(&reg->semaphore, 0);

	/* Release RISC processor. */
	WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
	RD_REG_WORD(&reg->hccr);			/* PCI Posting. */

	if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
		for (cnt = 0; cnt < 30000; cnt++) {
941
			if (RD_MAILBOX_REG(ha, reg, 0) != MBS_BUSY)
L
Linus Torvalds 已提交
942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961
				break;

			udelay(100);
		}
	} else
		udelay(100);

	/* Turn on master enable */
	cmd |= PCI_COMMAND_MASTER;
	pci_write_config_word(ha->pdev, PCI_COMMAND, cmd);

	/* Disable RISC pause on FPM parity error. */
	if (!IS_QLA2100(ha)) {
		WRT_REG_WORD(&reg->hccr, HCCR_DISABLE_PARITY_PAUSE);
		RD_REG_WORD(&reg->hccr);		/* PCI Posting. */
	}

	spin_unlock_irqrestore(&ha->hardware_lock, flags);
}

962 963 964 965 966 967 968 969 970 971
/**
 * qla81xx_reset_mpi() - Reset's MPI FW via Write MPI Register MBC.
 *
 * Returns 0 on success.
 */
int
qla81xx_reset_mpi(scsi_qla_host_t *vha)
{
	uint16_t mb[4] = {0x1010, 0, 1, 0};

972 973 974
	if (!IS_QLA81XX(vha->hw))
		return QLA_SUCCESS;

975 976 977
	return qla81xx_write_mpi_register(vha, mb);
}

978
/**
979
 * qla24xx_reset_risc() - Perform full reset of ISP24xx RISC.
980 981 982 983
 * @ha: HA context
 *
 * Returns 0 on success.
 */
984
static inline void
985
qla24xx_reset_risc(scsi_qla_host_t *vha)
986 987
{
	unsigned long flags = 0;
988
	struct qla_hw_data *ha = vha->hw;
989 990
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
	uint32_t cnt, d2;
991
	uint16_t wd;
992
	static int abts_cnt; /* ISP abort retry counts */
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006

	spin_lock_irqsave(&ha->hardware_lock, flags);

	/* Reset RISC. */
	WRT_REG_DWORD(&reg->ctrl_status, CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
	for (cnt = 0; cnt < 30000; cnt++) {
		if ((RD_REG_DWORD(&reg->ctrl_status) & CSRX_DMA_ACTIVE) == 0)
			break;

		udelay(10);
	}

	WRT_REG_DWORD(&reg->ctrl_status,
	    CSRX_ISP_SOFT_RESET|CSRX_DMA_SHUTDOWN|MWB_4096_BYTES);
1007
	pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
1008

1009
	udelay(100);
1010 1011 1012 1013 1014 1015 1016 1017
	/* Wait for firmware to complete NVRAM accesses. */
	d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
	for (cnt = 10000 ; cnt && d2; cnt--) {
		udelay(5);
		d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
		barrier();
	}

1018
	/* Wait for soft-reset to complete. */
1019 1020 1021 1022 1023 1024 1025
	d2 = RD_REG_DWORD(&reg->ctrl_status);
	for (cnt = 6000000 ; cnt && (d2 & CSRX_ISP_SOFT_RESET); cnt--) {
		udelay(5);
		d2 = RD_REG_DWORD(&reg->ctrl_status);
		barrier();
	}

1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
	/* If required, do an MPI FW reset now */
	if (test_and_clear_bit(MPI_RESET_NEEDED, &vha->dpc_flags)) {
		if (qla81xx_reset_mpi(vha) != QLA_SUCCESS) {
			if (++abts_cnt < 5) {
				set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
				set_bit(MPI_RESET_NEEDED, &vha->dpc_flags);
			} else {
				/*
				 * We exhausted the ISP abort retries. We have to
				 * set the board offline.
				 */
				abts_cnt = 0;
				vha->flags.online = 0;
			}
		}
	}

1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
	WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_RESET);
	RD_REG_DWORD(&reg->hccr);

	WRT_REG_DWORD(&reg->hccr, HCCRX_REL_RISC_PAUSE);
	RD_REG_DWORD(&reg->hccr);

	WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_RESET);
	RD_REG_DWORD(&reg->hccr);

	d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
	for (cnt = 6000000 ; cnt && d2; cnt--) {
		udelay(5);
		d2 = (uint32_t) RD_REG_WORD(&reg->mailbox0);
		barrier();
	}

	spin_unlock_irqrestore(&ha->hardware_lock, flags);
1060 1061 1062

	if (IS_NOPOLLING_TYPE(ha))
		ha->isp_ops->enable_intrs(ha);
1063 1064
}

1065 1066 1067 1068 1069 1070 1071
/**
 * qla24xx_reset_chip() - Reset ISP24xx chip.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
void
1072
qla24xx_reset_chip(scsi_qla_host_t *vha)
1073
{
1074
	struct qla_hw_data *ha = vha->hw;
1075 1076 1077 1078 1079 1080

	if (pci_channel_offline(ha->pdev) &&
	    ha->flags.pci_channel_io_perm_failure) {
		return;
	}

1081
	ha->isp_ops->disable_intrs(ha);
1082 1083

	/* Perform RISC reset. */
1084
	qla24xx_reset_risc(vha);
1085 1086
}

L
Linus Torvalds 已提交
1087 1088 1089 1090 1091 1092
/**
 * qla2x00_chip_diag() - Test chip for proper operation.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
1093
int
1094
qla2x00_chip_diag(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1095 1096
{
	int		rval;
1097
	struct qla_hw_data *ha = vha->hw;
1098
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
1099 1100 1101 1102
	unsigned long	flags = 0;
	uint16_t	data;
	uint32_t	cnt;
	uint16_t	mb[5];
1103
	struct req_que *req = ha->req_q_map[0];
L
Linus Torvalds 已提交
1104 1105 1106 1107

	/* Assume a failed state */
	rval = QLA_FUNCTION_FAILED;

1108 1109
	ql_dbg(ql_dbg_init, vha, 0x007b,
	    "Testing device at %lx.\n", (u_long)&reg->flash_address);
L
Linus Torvalds 已提交
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130

	spin_lock_irqsave(&ha->hardware_lock, flags);

	/* Reset ISP chip. */
	WRT_REG_WORD(&reg->ctrl_status, CSR_ISP_SOFT_RESET);

	/*
	 * We need to have a delay here since the card will not respond while
	 * in reset causing an MCA on some architectures.
	 */
	udelay(20);
	data = qla2x00_debounce_register(&reg->ctrl_status);
	for (cnt = 6000000 ; cnt && (data & CSR_ISP_SOFT_RESET); cnt--) {
		udelay(5);
		data = RD_REG_WORD(&reg->ctrl_status);
		barrier();
	}

	if (!cnt)
		goto chip_diag_failed;

1131 1132
	ql_dbg(ql_dbg_init, vha, 0x007c,
	    "Reset register cleared by chip reset.\n");
L
Linus Torvalds 已提交
1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143

	/* Reset RISC processor. */
	WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
	WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);

	/* Workaround for QLA2312 PCI parity error */
	if (IS_QLA2100(ha) || IS_QLA2200(ha) || IS_QLA2300(ha)) {
		data = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 0));
		for (cnt = 6000000; cnt && (data == MBS_BUSY); cnt--) {
			udelay(5);
			data = RD_MAILBOX_REG(ha, reg, 0);
A
Andrew Vasquez 已提交
1144
			barrier();
L
Linus Torvalds 已提交
1145 1146 1147 1148 1149 1150 1151 1152
		}
	} else
		udelay(10);

	if (!cnt)
		goto chip_diag_failed;

	/* Check product ID of chip */
1153
	ql_dbg(ql_dbg_init, vha, 0x007d, "Checking product Id of chip.\n");
L
Linus Torvalds 已提交
1154 1155 1156 1157 1158 1159 1160

	mb[1] = RD_MAILBOX_REG(ha, reg, 1);
	mb[2] = RD_MAILBOX_REG(ha, reg, 2);
	mb[3] = RD_MAILBOX_REG(ha, reg, 3);
	mb[4] = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 4));
	if (mb[1] != PROD_ID_1 || (mb[2] != PROD_ID_2 && mb[2] != PROD_ID_2a) ||
	    mb[3] != PROD_ID_3) {
1161 1162 1163
		ql_log(ql_log_warn, vha, 0x0062,
		    "Wrong product ID = 0x%x,0x%x,0x%x.\n",
		    mb[1], mb[2], mb[3]);
L
Linus Torvalds 已提交
1164 1165 1166 1167 1168 1169 1170 1171 1172

		goto chip_diag_failed;
	}
	ha->product_id[0] = mb[1];
	ha->product_id[1] = mb[2];
	ha->product_id[2] = mb[3];
	ha->product_id[3] = mb[4];

	/* Adjust fw RISC transfer size */
1173
	if (req->length > 1024)
L
Linus Torvalds 已提交
1174 1175 1176
		ha->fw_transfer_size = REQUEST_ENTRY_SIZE * 1024;
	else
		ha->fw_transfer_size = REQUEST_ENTRY_SIZE *
1177
		    req->length;
L
Linus Torvalds 已提交
1178 1179 1180 1181

	if (IS_QLA2200(ha) &&
	    RD_MAILBOX_REG(ha, reg, 7) == QLA2200A_RISC_ROM_VER) {
		/* Limit firmware transfer size with a 2200A */
1182
		ql_dbg(ql_dbg_init, vha, 0x007e, "Found QLA2200A Chip.\n");
L
Linus Torvalds 已提交
1183

1184
		ha->device_type |= DT_ISP2200A;
L
Linus Torvalds 已提交
1185 1186 1187 1188 1189 1190
		ha->fw_transfer_size = 128;
	}

	/* Wrap Incoming Mailboxes Test. */
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

1191
	ql_dbg(ql_dbg_init, vha, 0x007f, "Checking mailboxes.\n");
1192
	rval = qla2x00_mbx_reg_test(vha);
1193 1194 1195 1196
	if (rval)
		ql_log(ql_log_warn, vha, 0x0080,
		    "Failed mailbox send register test.\n");
	else
L
Linus Torvalds 已提交
1197 1198 1199 1200 1201 1202
		/* Flag a successful rval */
		rval = QLA_SUCCESS;
	spin_lock_irqsave(&ha->hardware_lock, flags);

chip_diag_failed:
	if (rval)
1203 1204
		ql_log(ql_log_info, vha, 0x0081,
		    "Chip diagnostics **** FAILED ****.\n");
L
Linus Torvalds 已提交
1205 1206 1207 1208 1209 1210

	spin_unlock_irqrestore(&ha->hardware_lock, flags);

	return (rval);
}

1211 1212 1213 1214 1215 1216 1217
/**
 * qla24xx_chip_diag() - Test ISP24xx for proper operation.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
int
1218
qla24xx_chip_diag(scsi_qla_host_t *vha)
1219 1220
{
	int rval;
1221
	struct qla_hw_data *ha = vha->hw;
1222
	struct req_que *req = ha->req_q_map[0];
1223

1224 1225 1226
	if (IS_QLA82XX(ha))
		return QLA_SUCCESS;

1227
	ha->fw_transfer_size = REQUEST_ENTRY_SIZE * req->length;
1228

1229
	rval = qla2x00_mbx_reg_test(vha);
1230
	if (rval) {
1231 1232
		ql_log(ql_log_warn, vha, 0x0082,
		    "Failed mailbox send register test.\n");
1233 1234 1235 1236 1237 1238 1239 1240
	} else {
		/* Flag a successful rval */
		rval = QLA_SUCCESS;
	}

	return rval;
}

1241
void
1242
qla2x00_alloc_fw_dump(scsi_qla_host_t *vha)
1243
{
1244 1245
	int rval;
	uint32_t dump_size, fixed_size, mem_size, req_q_size, rsp_q_size,
1246
	    eft_size, fce_size, mq_size;
1247 1248
	dma_addr_t tc_dma;
	void *tc;
1249
	struct qla_hw_data *ha = vha->hw;
1250 1251
	struct req_que *req = ha->req_q_map[0];
	struct rsp_que *rsp = ha->rsp_q_map[0];
1252 1253

	if (ha->fw_dump) {
1254 1255
		ql_dbg(ql_dbg_init, vha, 0x00bd,
		    "Firmware dump already allocated.\n");
1256 1257
		return;
	}
1258

1259
	ha->fw_dumped = 0;
1260
	fixed_size = mem_size = eft_size = fce_size = mq_size = 0;
1261
	if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
1262
		fixed_size = sizeof(struct qla2100_fw_dump);
1263
	} else if (IS_QLA23XX(ha)) {
1264 1265 1266
		fixed_size = offsetof(struct qla2300_fw_dump, data_ram);
		mem_size = (ha->fw_memory_size - 0x11000 + 1) *
		    sizeof(uint16_t);
1267
	} else if (IS_FWI2_CAPABLE(ha)) {
1268 1269 1270
		if (IS_QLA83XX(ha))
			fixed_size = offsetof(struct qla83xx_fw_dump, ext_mem);
		else if (IS_QLA81XX(ha))
1271 1272 1273 1274 1275
			fixed_size = offsetof(struct qla81xx_fw_dump, ext_mem);
		else if (IS_QLA25XX(ha))
			fixed_size = offsetof(struct qla25xx_fw_dump, ext_mem);
		else
			fixed_size = offsetof(struct qla24xx_fw_dump, ext_mem);
1276 1277
		mem_size = (ha->fw_memory_size - 0x100000 + 1) *
		    sizeof(uint32_t);
1278
		if (ha->mqenable) {
1279 1280
			if (!IS_QLA83XX(ha))
				mq_size = sizeof(struct qla2xxx_mq_chain);
1281 1282 1283 1284 1285 1286 1287 1288 1289
			/*
			 * Allocate maximum buffer size for all queues.
			 * Resizing must be done at end-of-dump processing.
			 */
			mq_size += ha->max_req_queues *
			    (req->length * sizeof(request_t));
			mq_size += ha->max_rsp_queues *
			    (rsp->length * sizeof(response_t));
		}
1290
		/* Allocate memory for Fibre Channel Event Buffer. */
1291
		if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha))
1292
			goto try_eft;
1293 1294 1295 1296

		tc = dma_alloc_coherent(&ha->pdev->dev, FCE_SIZE, &tc_dma,
		    GFP_KERNEL);
		if (!tc) {
1297 1298 1299
			ql_log(ql_log_warn, vha, 0x00be,
			    "Unable to allocate (%d KB) for FCE.\n",
			    FCE_SIZE / 1024);
1300
			goto try_eft;
1301 1302 1303
		}

		memset(tc, 0, FCE_SIZE);
1304
		rval = qla2x00_enable_fce_trace(vha, tc_dma, FCE_NUM_BUFFERS,
1305 1306
		    ha->fce_mb, &ha->fce_bufs);
		if (rval) {
1307 1308
			ql_log(ql_log_warn, vha, 0x00bf,
			    "Unable to initialize FCE (%d).\n", rval);
1309 1310 1311
			dma_free_coherent(&ha->pdev->dev, FCE_SIZE, tc,
			    tc_dma);
			ha->flags.fce_enabled = 0;
1312
			goto try_eft;
1313
		}
1314
		ql_dbg(ql_dbg_init, vha, 0x00c0,
1315
		    "Allocate (%d KB) for FCE...\n", FCE_SIZE / 1024);
1316

1317
		fce_size = sizeof(struct qla2xxx_fce_chain) + FCE_SIZE;
1318 1319 1320
		ha->flags.fce_enabled = 1;
		ha->fce_dma = tc_dma;
		ha->fce = tc;
1321 1322 1323 1324 1325
try_eft:
		/* Allocate memory for Extended Trace Buffer. */
		tc = dma_alloc_coherent(&ha->pdev->dev, EFT_SIZE, &tc_dma,
		    GFP_KERNEL);
		if (!tc) {
1326 1327 1328
			ql_log(ql_log_warn, vha, 0x00c1,
			    "Unable to allocate (%d KB) for EFT.\n",
			    EFT_SIZE / 1024);
1329 1330 1331 1332
			goto cont_alloc;
		}

		memset(tc, 0, EFT_SIZE);
1333
		rval = qla2x00_enable_eft_trace(vha, tc_dma, EFT_NUM_BUFFERS);
1334
		if (rval) {
1335 1336
			ql_log(ql_log_warn, vha, 0x00c2,
			    "Unable to initialize EFT (%d).\n", rval);
1337 1338 1339 1340
			dma_free_coherent(&ha->pdev->dev, EFT_SIZE, tc,
			    tc_dma);
			goto cont_alloc;
		}
1341
		ql_dbg(ql_dbg_init, vha, 0x00c3,
1342
		    "Allocated (%d KB) EFT ...\n", EFT_SIZE / 1024);
1343 1344 1345 1346

		eft_size = EFT_SIZE;
		ha->eft_dma = tc_dma;
		ha->eft = tc;
1347
	}
1348
cont_alloc:
1349 1350
	req_q_size = req->length * sizeof(request_t);
	rsp_q_size = rsp->length * sizeof(response_t);
1351 1352

	dump_size = offsetof(struct qla2xxx_fw_dump, isp);
1353
	dump_size += fixed_size + mem_size + req_q_size + rsp_q_size + eft_size;
1354 1355
	ha->chain_offset = dump_size;
	dump_size += mq_size + fce_size;
1356 1357

	ha->fw_dump = vmalloc(dump_size);
1358
	if (!ha->fw_dump) {
1359 1360 1361
		ql_log(ql_log_warn, vha, 0x00c4,
		    "Unable to allocate (%d KB) for firmware dump.\n",
		    dump_size / 1024);
1362

1363 1364 1365 1366 1367 1368 1369
		if (ha->fce) {
			dma_free_coherent(&ha->pdev->dev, FCE_SIZE, ha->fce,
			    ha->fce_dma);
			ha->fce = NULL;
			ha->fce_dma = 0;
		}

1370 1371 1372 1373 1374 1375 1376 1377
		if (ha->eft) {
			dma_free_coherent(&ha->pdev->dev, eft_size, ha->eft,
			    ha->eft_dma);
			ha->eft = NULL;
			ha->eft_dma = 0;
		}
		return;
	}
1378
	ql_dbg(ql_dbg_init, vha, 0x00c5,
1379
	    "Allocated (%d KB) for firmware dump.\n", dump_size / 1024);
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398

	ha->fw_dump_len = dump_size;
	ha->fw_dump->signature[0] = 'Q';
	ha->fw_dump->signature[1] = 'L';
	ha->fw_dump->signature[2] = 'G';
	ha->fw_dump->signature[3] = 'C';
	ha->fw_dump->version = __constant_htonl(1);

	ha->fw_dump->fixed_size = htonl(fixed_size);
	ha->fw_dump->mem_size = htonl(mem_size);
	ha->fw_dump->req_q_size = htonl(req_q_size);
	ha->fw_dump->rsp_q_size = htonl(rsp_q_size);

	ha->fw_dump->eft_size = htonl(eft_size);
	ha->fw_dump->eft_addr_l = htonl(LSD(ha->eft_dma));
	ha->fw_dump->eft_addr_h = htonl(MSD(ha->eft_dma));

	ha->fw_dump->header_size =
	    htonl(offsetof(struct qla2xxx_fw_dump, isp));
1399 1400
}

1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
static int
qla81xx_mpi_sync(scsi_qla_host_t *vha)
{
#define MPS_MASK	0xe0
	int rval;
	uint16_t dc;
	uint32_t dw;

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

	rval = qla2x00_write_ram_word(vha, 0x7c00, 1);
	if (rval != QLA_SUCCESS) {
1414 1415
		ql_log(ql_log_warn, vha, 0x0105,
		    "Unable to acquire semaphore.\n");
1416 1417 1418 1419 1420 1421
		goto done;
	}

	pci_read_config_word(vha->hw->pdev, 0x54, &dc);
	rval = qla2x00_read_ram_word(vha, 0x7a15, &dw);
	if (rval != QLA_SUCCESS) {
1422
		ql_log(ql_log_warn, vha, 0x0067, "Unable to read sync.\n");
1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
		goto done_release;
	}

	dc &= MPS_MASK;
	if (dc == (dw & MPS_MASK))
		goto done_release;

	dw &= ~MPS_MASK;
	dw |= dc;
	rval = qla2x00_write_ram_word(vha, 0x7a15, dw);
	if (rval != QLA_SUCCESS) {
1434
		ql_log(ql_log_warn, vha, 0x0114, "Unable to gain sync.\n");
1435 1436 1437 1438 1439
	}

done_release:
	rval = qla2x00_write_ram_word(vha, 0x7c00, 0);
	if (rval != QLA_SUCCESS) {
1440 1441
		ql_log(ql_log_warn, vha, 0x006d,
		    "Unable to release semaphore.\n");
1442 1443 1444 1445 1446 1447
	}

done:
	return rval;
}

L
Linus Torvalds 已提交
1448 1449 1450 1451 1452 1453 1454
/**
 * qla2x00_setup_chip() - Load and start RISC firmware.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
static int
1455
qla2x00_setup_chip(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1456
{
1457 1458
	int rval;
	uint32_t srisc_address = 0;
1459
	struct qla_hw_data *ha = vha->hw;
1460 1461
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
	unsigned long flags;
1462
	uint16_t fw_major_version;
1463

1464 1465
	if (IS_QLA82XX(ha)) {
		rval = ha->isp_ops->load_risc(vha, &srisc_address);
1466 1467
		if (rval == QLA_SUCCESS) {
			qla2x00_stop_firmware(vha);
1468
			goto enable_82xx_npiv;
1469
		} else
1470
			goto failed;
1471 1472
	}

1473 1474 1475 1476 1477 1478 1479
	if (!IS_FWI2_CAPABLE(ha) && !IS_QLA2100(ha) && !IS_QLA2200(ha)) {
		/* Disable SRAM, Instruction RAM and GP RAM parity.  */
		spin_lock_irqsave(&ha->hardware_lock, flags);
		WRT_REG_WORD(&reg->hccr, (HCCR_ENABLE_PARITY + 0x0));
		RD_REG_WORD(&reg->hccr);
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
	}
L
Linus Torvalds 已提交
1480

1481 1482
	qla81xx_mpi_sync(vha);

L
Linus Torvalds 已提交
1483
	/* Load firmware sequences */
1484
	rval = ha->isp_ops->load_risc(vha, &srisc_address);
1485
	if (rval == QLA_SUCCESS) {
1486 1487
		ql_dbg(ql_dbg_init, vha, 0x00c9,
		    "Verifying Checksum of loaded RISC code.\n");
L
Linus Torvalds 已提交
1488

1489
		rval = qla2x00_verify_checksum(vha, srisc_address);
L
Linus Torvalds 已提交
1490 1491
		if (rval == QLA_SUCCESS) {
			/* Start firmware execution. */
1492 1493
			ql_dbg(ql_dbg_init, vha, 0x00ca,
			    "Starting firmware.\n");
L
Linus Torvalds 已提交
1494

1495
			rval = qla2x00_execute_fw(vha, srisc_address);
L
Linus Torvalds 已提交
1496
			/* Retrieve firmware information. */
1497
			if (rval == QLA_SUCCESS) {
1498
enable_82xx_npiv:
1499
				fw_major_version = ha->fw_major_version;
1500 1501
				if (IS_QLA82XX(ha))
					qla82xx_check_md_needed(vha);
1502 1503
				else
					rval = qla2x00_get_fw_version(vha);
1504 1505
				if (rval != QLA_SUCCESS)
					goto failed;
1506
				ha->flags.npiv_supported = 0;
1507
				if (IS_QLA2XXX_MIDTYPE(ha) &&
1508
					 (ha->fw_attributes & BIT_2)) {
1509
					ha->flags.npiv_supported = 1;
1510 1511
					if ((!ha->max_npiv_vports) ||
					    ((ha->max_npiv_vports + 1) %
1512
					    MIN_MULTI_ID_FABRIC))
1513
						ha->max_npiv_vports =
1514
						    MIN_MULTI_ID_FABRIC - 1;
1515
				}
1516 1517
				qla2x00_get_resource_cnts(vha, NULL,
				    &ha->fw_xcb_count, NULL, NULL,
1518
				    &ha->max_npiv_vports, NULL);
1519

1520 1521
				if (!fw_major_version && ql2xallocfwdump
				    && !IS_QLA82XX(ha))
1522
					qla2x00_alloc_fw_dump(vha);
L
Linus Torvalds 已提交
1523 1524
			}
		} else {
1525 1526 1527
			ql_log(ql_log_fatal, vha, 0x00cd,
			    "ISP Firmware failed checksum.\n");
			goto failed;
L
Linus Torvalds 已提交
1528 1529 1530
		}
	}

1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
	if (!IS_FWI2_CAPABLE(ha) && !IS_QLA2100(ha) && !IS_QLA2200(ha)) {
		/* Enable proper parity. */
		spin_lock_irqsave(&ha->hardware_lock, flags);
		if (IS_QLA2300(ha))
			/* SRAM parity */
			WRT_REG_WORD(&reg->hccr, HCCR_ENABLE_PARITY + 0x1);
		else
			/* SRAM, Instruction RAM and GP RAM parity */
			WRT_REG_WORD(&reg->hccr, HCCR_ENABLE_PARITY + 0x7);
		RD_REG_WORD(&reg->hccr);
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
	}

1544 1545 1546
	if (IS_QLA83XX(ha))
		goto skip_fac_check;

1547 1548 1549 1550 1551 1552 1553 1554
	if (rval == QLA_SUCCESS && IS_FAC_REQUIRED(ha)) {
		uint32_t size;

		rval = qla81xx_fac_get_sector_size(vha, &size);
		if (rval == QLA_SUCCESS) {
			ha->flags.fac_supported = 1;
			ha->fdt_block_size = size << 2;
		} else {
1555
			ql_log(ql_log_warn, vha, 0x00ce,
1556 1557 1558
			    "Unsupported FAC firmware (%d.%02d.%02d).\n",
			    ha->fw_major_version, ha->fw_minor_version,
			    ha->fw_subminor_version);
1559 1560 1561 1562 1563
skip_fac_check:
			if (IS_QLA83XX(ha)) {
				ha->flags.fac_supported = 0;
				rval = QLA_SUCCESS;
			}
1564 1565
		}
	}
1566
failed:
L
Linus Torvalds 已提交
1567
	if (rval) {
1568 1569
		ql_log(ql_log_fatal, vha, 0x00cf,
		    "Setup chip ****FAILED****.\n");
L
Linus Torvalds 已提交
1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
	}

	return (rval);
}

/**
 * qla2x00_init_response_q_entries() - Initializes response queue entries.
 * @ha: HA context
 *
 * Beginning of request ring has initialization control block already built
 * by nvram config routine.
 *
 * Returns 0 on success.
 */
1584 1585
void
qla2x00_init_response_q_entries(struct rsp_que *rsp)
L
Linus Torvalds 已提交
1586 1587 1588 1589
{
	uint16_t cnt;
	response_t *pkt;

1590 1591 1592
	rsp->ring_ptr = rsp->ring;
	rsp->ring_index    = 0;
	rsp->status_srb = NULL;
1593 1594
	pkt = rsp->ring_ptr;
	for (cnt = 0; cnt < rsp->length; cnt++) {
L
Linus Torvalds 已提交
1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605
		pkt->signature = RESPONSE_PROCESSED;
		pkt++;
	}
}

/**
 * qla2x00_update_fw_options() - Read and process firmware options.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
1606
void
1607
qla2x00_update_fw_options(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1608 1609
{
	uint16_t swing, emphasis, tx_sens, rx_sens;
1610
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1611 1612

	memset(ha->fw_options, 0, sizeof(ha->fw_options));
1613
	qla2x00_get_fw_options(vha, ha->fw_options);
L
Linus Torvalds 已提交
1614 1615 1616 1617 1618

	if (IS_QLA2100(ha) || IS_QLA2200(ha))
		return;

	/* Serial Link options. */
1619 1620 1621 1622 1623
	ql_dbg(ql_dbg_init + ql_dbg_buffer, vha, 0x0115,
	    "Serial link options.\n");
	ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x0109,
	    (uint8_t *)&ha->fw_seriallink_options,
	    sizeof(ha->fw_seriallink_options));
L
Linus Torvalds 已提交
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633

	ha->fw_options[1] &= ~FO1_SET_EMPHASIS_SWING;
	if (ha->fw_seriallink_options[3] & BIT_2) {
		ha->fw_options[1] |= FO1_SET_EMPHASIS_SWING;

		/*  1G settings */
		swing = ha->fw_seriallink_options[2] & (BIT_2 | BIT_1 | BIT_0);
		emphasis = (ha->fw_seriallink_options[2] &
		    (BIT_4 | BIT_3)) >> 3;
		tx_sens = ha->fw_seriallink_options[0] &
A
Andrew Vasquez 已提交
1634
		    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
L
Linus Torvalds 已提交
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
		rx_sens = (ha->fw_seriallink_options[0] &
		    (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
		ha->fw_options[10] = (emphasis << 14) | (swing << 8);
		if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
			if (rx_sens == 0x0)
				rx_sens = 0x3;
			ha->fw_options[10] |= (tx_sens << 4) | rx_sens;
		} else if (IS_QLA2322(ha) || IS_QLA6322(ha))
			ha->fw_options[10] |= BIT_5 |
			    ((rx_sens & (BIT_1 | BIT_0)) << 2) |
			    (tx_sens & (BIT_1 | BIT_0));

		/*  2G settings */
		swing = (ha->fw_seriallink_options[2] &
		    (BIT_7 | BIT_6 | BIT_5)) >> 5;
		emphasis = ha->fw_seriallink_options[3] & (BIT_1 | BIT_0);
		tx_sens = ha->fw_seriallink_options[1] &
A
Andrew Vasquez 已提交
1652
		    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
L
Linus Torvalds 已提交
1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
		rx_sens = (ha->fw_seriallink_options[1] &
		    (BIT_7 | BIT_6 | BIT_5 | BIT_4)) >> 4;
		ha->fw_options[11] = (emphasis << 14) | (swing << 8);
		if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) {
			if (rx_sens == 0x0)
				rx_sens = 0x3;
			ha->fw_options[11] |= (tx_sens << 4) | rx_sens;
		} else if (IS_QLA2322(ha) || IS_QLA6322(ha))
			ha->fw_options[11] |= BIT_5 |
			    ((rx_sens & (BIT_1 | BIT_0)) << 2) |
			    (tx_sens & (BIT_1 | BIT_0));
	}

	/* FCP2 options. */
	/*  Return command IOCBs without waiting for an ABTS to complete. */
	ha->fw_options[3] |= BIT_13;

	/* LED scheme. */
	if (ha->flags.enable_led_scheme)
		ha->fw_options[2] |= BIT_12;

1674 1675 1676 1677
	/* Detect ISP6312. */
	if (IS_QLA6312(ha))
		ha->fw_options[2] |= BIT_13;

L
Linus Torvalds 已提交
1678
	/* Update firmware options. */
1679
	qla2x00_set_fw_options(vha, ha->fw_options);
L
Linus Torvalds 已提交
1680 1681
}

1682
void
1683
qla24xx_update_fw_options(scsi_qla_host_t *vha)
1684 1685
{
	int rval;
1686
	struct qla_hw_data *ha = vha->hw;
1687

1688 1689 1690
	if (IS_QLA82XX(ha))
		return;

1691
	/* Update Serial Link options. */
1692
	if ((le16_to_cpu(ha->fw_seriallink_options24[0]) & BIT_0) == 0)
1693 1694
		return;

1695
	rval = qla2x00_set_serdes_params(vha,
1696 1697 1698
	    le16_to_cpu(ha->fw_seriallink_options24[1]),
	    le16_to_cpu(ha->fw_seriallink_options24[2]),
	    le16_to_cpu(ha->fw_seriallink_options24[3]));
1699
	if (rval != QLA_SUCCESS) {
1700
		ql_log(ql_log_warn, vha, 0x0104,
1701 1702 1703 1704
		    "Unable to update Serial Link options (%x).\n", rval);
	}
}

1705
void
1706
qla2x00_config_rings(struct scsi_qla_host *vha)
1707
{
1708
	struct qla_hw_data *ha = vha->hw;
1709
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1710 1711
	struct req_que *req = ha->req_q_map[0];
	struct rsp_que *rsp = ha->rsp_q_map[0];
1712 1713 1714 1715

	/* Setup ring parameters in initialization control block. */
	ha->init_cb->request_q_outpointer = __constant_cpu_to_le16(0);
	ha->init_cb->response_q_inpointer = __constant_cpu_to_le16(0);
1716 1717 1718 1719 1720 1721
	ha->init_cb->request_q_length = cpu_to_le16(req->length);
	ha->init_cb->response_q_length = cpu_to_le16(rsp->length);
	ha->init_cb->request_q_address[0] = cpu_to_le32(LSD(req->dma));
	ha->init_cb->request_q_address[1] = cpu_to_le32(MSD(req->dma));
	ha->init_cb->response_q_address[0] = cpu_to_le32(LSD(rsp->dma));
	ha->init_cb->response_q_address[1] = cpu_to_le32(MSD(rsp->dma));
1722 1723 1724 1725 1726 1727 1728 1729

	WRT_REG_WORD(ISP_REQ_Q_IN(ha, reg), 0);
	WRT_REG_WORD(ISP_REQ_Q_OUT(ha, reg), 0);
	WRT_REG_WORD(ISP_RSP_Q_IN(ha, reg), 0);
	WRT_REG_WORD(ISP_RSP_Q_OUT(ha, reg), 0);
	RD_REG_WORD(ISP_RSP_Q_OUT(ha, reg));		/* PCI Posting. */
}

1730
void
1731
qla24xx_config_rings(struct scsi_qla_host *vha)
1732
{
1733
	struct qla_hw_data *ha = vha->hw;
1734 1735 1736
	device_reg_t __iomem *reg = ISP_QUE_REG(ha, 0);
	struct device_reg_2xxx __iomem *ioreg = &ha->iobase->isp;
	struct qla_msix_entry *msix;
1737
	struct init_cb_24xx *icb;
1738 1739 1740
	uint16_t rid = 0;
	struct req_que *req = ha->req_q_map[0];
	struct rsp_que *rsp = ha->rsp_q_map[0];
1741

1742
	/* Setup ring parameters in initialization control block. */
1743 1744 1745
	icb = (struct init_cb_24xx *)ha->init_cb;
	icb->request_q_outpointer = __constant_cpu_to_le16(0);
	icb->response_q_inpointer = __constant_cpu_to_le16(0);
1746 1747 1748 1749 1750 1751
	icb->request_q_length = cpu_to_le16(req->length);
	icb->response_q_length = cpu_to_le16(rsp->length);
	icb->request_q_address[0] = cpu_to_le32(LSD(req->dma));
	icb->request_q_address[1] = cpu_to_le32(MSD(req->dma));
	icb->response_q_address[0] = cpu_to_le32(LSD(rsp->dma));
	icb->response_q_address[1] = cpu_to_le32(MSD(rsp->dma));
1752

1753
	if (ha->mqenable || IS_QLA83XX(ha)) {
1754 1755 1756 1757
		icb->qos = __constant_cpu_to_le16(QLA_DEFAULT_QUE_QOS);
		icb->rid = __constant_cpu_to_le16(rid);
		if (ha->flags.msix_enabled) {
			msix = &ha->msix_entries[1];
1758 1759 1760
			ql_dbg(ql_dbg_init, vha, 0x00fd,
			    "Registering vector 0x%x for base que.\n",
			    msix->entry);
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771
			icb->msix = cpu_to_le16(msix->entry);
		}
		/* Use alternate PCI bus number */
		if (MSB(rid))
			icb->firmware_options_2 |=
				__constant_cpu_to_le32(BIT_19);
		/* Use alternate PCI devfn */
		if (LSB(rid))
			icb->firmware_options_2 |=
				__constant_cpu_to_le32(BIT_18);

1772
		/* Use Disable MSIX Handshake mode for capable adapters */
1773 1774
		if ((ha->fw_attributes & BIT_6) && (IS_MSIX_NACK_CAPABLE(ha)) &&
		    (ha->flags.msix_enabled)) {
1775 1776 1777
			icb->firmware_options_2 &=
				__constant_cpu_to_le32(~BIT_22);
			ha->flags.disable_msix_handshake = 1;
1778 1779
			ql_dbg(ql_dbg_init, vha, 0x00fe,
			    "MSIX Handshake Disable Mode turned on.\n");
1780 1781 1782 1783
		} else {
			icb->firmware_options_2 |=
				__constant_cpu_to_le32(BIT_22);
		}
1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797
		icb->firmware_options_2 |= __constant_cpu_to_le32(BIT_23);

		WRT_REG_DWORD(&reg->isp25mq.req_q_in, 0);
		WRT_REG_DWORD(&reg->isp25mq.req_q_out, 0);
		WRT_REG_DWORD(&reg->isp25mq.rsp_q_in, 0);
		WRT_REG_DWORD(&reg->isp25mq.rsp_q_out, 0);
	} else {
		WRT_REG_DWORD(&reg->isp24.req_q_in, 0);
		WRT_REG_DWORD(&reg->isp24.req_q_out, 0);
		WRT_REG_DWORD(&reg->isp24.rsp_q_in, 0);
		WRT_REG_DWORD(&reg->isp24.rsp_q_out, 0);
	}
	/* PCI posting */
	RD_REG_DWORD(&ioreg->hccr);
1798 1799
}

L
Linus Torvalds 已提交
1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
/**
 * qla2x00_init_rings() - Initializes firmware.
 * @ha: HA context
 *
 * Beginning of request ring has initialization control block already built
 * by nvram config routine.
 *
 * Returns 0 on success.
 */
static int
1810
qla2x00_init_rings(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1811 1812 1813
{
	int	rval;
	unsigned long flags = 0;
1814
	int cnt, que;
1815
	struct qla_hw_data *ha = vha->hw;
1816 1817 1818
	struct req_que *req;
	struct rsp_que *rsp;
	struct scsi_qla_host *vp;
1819 1820
	struct mid_init_cb_24xx *mid_init_cb =
	    (struct mid_init_cb_24xx *) ha->init_cb;
L
Linus Torvalds 已提交
1821 1822 1823 1824

	spin_lock_irqsave(&ha->hardware_lock, flags);

	/* Clear outstanding commands array. */
1825
	for (que = 0; que < ha->max_req_queues; que++) {
1826 1827 1828
		req = ha->req_q_map[que];
		if (!req)
			continue;
1829
		for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++)
1830
			req->outstanding_cmds[cnt] = NULL;
L
Linus Torvalds 已提交
1831

1832
		req->current_outstanding_cmd = 1;
L
Linus Torvalds 已提交
1833

1834 1835 1836 1837 1838
		/* Initialize firmware. */
		req->ring_ptr  = req->ring;
		req->ring_index    = 0;
		req->cnt      = req->length;
	}
L
Linus Torvalds 已提交
1839

1840
	for (que = 0; que < ha->max_rsp_queues; que++) {
1841 1842 1843 1844 1845 1846
		rsp = ha->rsp_q_map[que];
		if (!rsp)
			continue;
		/* Initialize response queue entries */
		qla2x00_init_response_q_entries(rsp);
	}
L
Linus Torvalds 已提交
1847

1848
	spin_lock(&ha->vport_slock);
1849 1850 1851 1852 1853
	/* Clear RSCN queue. */
	list_for_each_entry(vp, &ha->vp_list, list) {
		vp->rscn_in_ptr = 0;
		vp->rscn_out_ptr = 0;
	}
1854

1855
	spin_unlock(&ha->vport_slock);
1856

1857
	ha->isp_ops->config_rings(vha);
L
Linus Torvalds 已提交
1858 1859 1860 1861

	spin_unlock_irqrestore(&ha->hardware_lock, flags);

	/* Update any ISP specific firmware options before initialization. */
1862
	ha->isp_ops->update_fw_options(vha);
L
Linus Torvalds 已提交
1863

1864
	ql_dbg(ql_dbg_init, vha, 0x00d1, "Issue init firmware.\n");
1865

1866 1867 1868
	if (ha->flags.npiv_supported) {
		if (ha->operating_mode == LOOP)
			ha->max_npiv_vports = MIN_MULTI_ID_FABRIC - 1;
1869
		mid_init_cb->count = cpu_to_le16(ha->max_npiv_vports);
1870 1871
	}

1872 1873 1874 1875 1876
	if (IS_FWI2_CAPABLE(ha)) {
		mid_init_cb->options = __constant_cpu_to_le16(BIT_1);
		mid_init_cb->init_cb.execution_throttle =
		    cpu_to_le16(ha->fw_xcb_count);
	}
1877

1878
	rval = qla2x00_init_firmware(vha, ha->init_cb_size);
L
Linus Torvalds 已提交
1879
	if (rval) {
1880 1881
		ql_log(ql_log_fatal, vha, 0x00d2,
		    "Init Firmware **** FAILED ****.\n");
L
Linus Torvalds 已提交
1882
	} else {
1883 1884
		ql_dbg(ql_dbg_init, vha, 0x00d3,
		    "Init Firmware -- success.\n");
L
Linus Torvalds 已提交
1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896
	}

	return (rval);
}

/**
 * qla2x00_fw_ready() - Waits for firmware ready.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
static int
1897
qla2x00_fw_ready(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1898 1899
{
	int		rval;
1900
	unsigned long	wtime, mtime, cs84xx_time;
L
Linus Torvalds 已提交
1901 1902
	uint16_t	min_wait;	/* Minimum wait time if loop is down */
	uint16_t	wait_time;	/* Wait time if loop is coming ready */
1903
	uint16_t	state[5];
1904
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1905 1906 1907 1908

	rval = QLA_SUCCESS;

	/* 20 seconds for loop down. */
A
Andrew Vasquez 已提交
1909
	min_wait = 20;
L
Linus Torvalds 已提交
1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925

	/*
	 * Firmware should take at most one RATOV to login, plus 5 seconds for
	 * our own processing.
	 */
	if ((wait_time = (ha->retry_count*ha->login_timeout) + 5) < min_wait) {
		wait_time = min_wait;
	}

	/* Min wait time if loop down */
	mtime = jiffies + (min_wait * HZ);

	/* wait time before firmware ready */
	wtime = jiffies + (wait_time * HZ);

	/* Wait for ISP to finish LIP */
1926
	if (!vha->flags.init_done)
1927 1928
		ql_log(ql_log_info, vha, 0x801e,
		    "Waiting for LIP to complete.\n");
L
Linus Torvalds 已提交
1929 1930

	do {
1931
		rval = qla2x00_get_firmware_state(vha, state);
L
Linus Torvalds 已提交
1932
		if (rval == QLA_SUCCESS) {
1933
			if (state[0] < FSTATE_LOSS_OF_SYNC) {
1934
				vha->device_flags &= ~DFLG_NO_CABLE;
L
Linus Torvalds 已提交
1935
			}
1936
			if (IS_QLA84XX(ha) && state[0] != FSTATE_READY) {
1937 1938 1939
				ql_dbg(ql_dbg_taskm, vha, 0x801f,
				    "fw_state=%x 84xx=%x.\n", state[0],
				    state[2]);
1940 1941
				if ((state[2] & FSTATE_LOGGED_IN) &&
				     (state[2] & FSTATE_WAITING_FOR_VERIFY)) {
1942 1943
					ql_dbg(ql_dbg_taskm, vha, 0x8028,
					    "Sending verify iocb.\n");
1944 1945

					cs84xx_time = jiffies;
1946
					rval = qla84xx_init_chip(vha);
1947 1948
					if (rval != QLA_SUCCESS) {
						ql_log(ql_log_warn,
1949
						    vha, 0x8007,
1950
						    "Init chip failed.\n");
1951
						break;
1952
					}
1953 1954 1955 1956 1957

					/* Add time taken to initialize. */
					cs84xx_time = jiffies - cs84xx_time;
					wtime += cs84xx_time;
					mtime += cs84xx_time;
1958
					ql_dbg(ql_dbg_taskm, vha, 0x8008,
1959 1960 1961
					    "Increasing wait time by %ld. "
					    "New time %ld.\n", cs84xx_time,
					    wtime);
1962 1963
				}
			} else if (state[0] == FSTATE_READY) {
1964 1965
				ql_dbg(ql_dbg_taskm, vha, 0x8037,
				    "F/W Ready - OK.\n");
L
Linus Torvalds 已提交
1966

1967
				qla2x00_get_retry_cnt(vha, &ha->retry_count,
L
Linus Torvalds 已提交
1968 1969 1970 1971 1972 1973 1974 1975
				    &ha->login_timeout, &ha->r_a_tov);

				rval = QLA_SUCCESS;
				break;
			}

			rval = QLA_FUNCTION_FAILED;

1976
			if (atomic_read(&vha->loop_down_timer) &&
1977
			    state[0] != FSTATE_READY) {
L
Linus Torvalds 已提交
1978
				/* Loop down. Timeout on min_wait for states
A
Andrew Vasquez 已提交
1979 1980
				 * other than Wait for Login.
				 */
L
Linus Torvalds 已提交
1981
				if (time_after_eq(jiffies, mtime)) {
1982
					ql_log(ql_log_info, vha, 0x8038,
L
Linus Torvalds 已提交
1983 1984
					    "Cable is unplugged...\n");

1985
					vha->device_flags |= DFLG_NO_CABLE;
L
Linus Torvalds 已提交
1986 1987 1988 1989 1990
					break;
				}
			}
		} else {
			/* Mailbox cmd failed. Timeout on min_wait. */
1991
			if (time_after_eq(jiffies, mtime) ||
1992
				ha->flags.isp82xx_fw_hung)
L
Linus Torvalds 已提交
1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
				break;
		}

		if (time_after_eq(jiffies, wtime))
			break;

		/* Delay for a while */
		msleep(500);
	} while (1);

2003 2004 2005
	ql_dbg(ql_dbg_taskm, vha, 0x803a,
	    "fw_state=%x (%x, %x, %x, %x) " "curr time=%lx.\n", state[0],
	    state[1], state[2], state[3], state[4], jiffies);
L
Linus Torvalds 已提交
2006

2007
	if (rval && !(vha->device_flags & DFLG_NO_CABLE)) {
2008 2009
		ql_log(ql_log_warn, vha, 0x803b,
		    "Firmware ready **** FAILED ****.\n");
L
Linus Torvalds 已提交
2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
	}

	return (rval);
}

/*
*  qla2x00_configure_hba
*      Setup adapter context.
*
* Input:
*      ha = adapter state pointer.
*
* Returns:
*      0 = success
*
* Context:
*      Kernel context.
*/
static int
2029
qla2x00_configure_hba(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
2030 2031 2032 2033
{
	int       rval;
	uint16_t      loop_id;
	uint16_t      topo;
2034
	uint16_t      sw_cap;
L
Linus Torvalds 已提交
2035 2036 2037 2038
	uint8_t       al_pa;
	uint8_t       area;
	uint8_t       domain;
	char		connect_type[22];
2039
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
2040 2041

	/* Get host addresses. */
2042
	rval = qla2x00_get_adapter_id(vha,
2043
	    &loop_id, &al_pa, &area, &domain, &topo, &sw_cap);
L
Linus Torvalds 已提交
2044
	if (rval != QLA_SUCCESS) {
2045
		if (LOOP_TRANSITION(vha) || atomic_read(&ha->loop_down_timer) ||
2046
		    IS_CNA_CAPABLE(ha) ||
2047
		    (rval == QLA_COMMAND_ERROR && loop_id == 0x7)) {
2048 2049
			ql_dbg(ql_dbg_disc, vha, 0x2008,
			    "Loop is in a transition state.\n");
2050
		} else {
2051 2052
			ql_log(ql_log_warn, vha, 0x2009,
			    "Unable to get host loop ID.\n");
2053
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2054
		}
L
Linus Torvalds 已提交
2055 2056 2057 2058
		return (rval);
	}

	if (topo == 4) {
2059 2060
		ql_log(ql_log_info, vha, 0x200a,
		    "Cannot get topology - retrying.\n");
L
Linus Torvalds 已提交
2061 2062 2063
		return (QLA_FUNCTION_FAILED);
	}

2064
	vha->loop_id = loop_id;
L
Linus Torvalds 已提交
2065 2066 2067 2068

	/* initialize */
	ha->min_external_loopid = SNS_FIRST_LOOP_ID;
	ha->operating_mode = LOOP;
2069
	ha->switch_cap = 0;
L
Linus Torvalds 已提交
2070 2071 2072

	switch (topo) {
	case 0:
2073
		ql_dbg(ql_dbg_disc, vha, 0x200b, "HBA in NL topology.\n");
L
Linus Torvalds 已提交
2074 2075 2076 2077 2078
		ha->current_topology = ISP_CFG_NL;
		strcpy(connect_type, "(Loop)");
		break;

	case 1:
2079
		ql_dbg(ql_dbg_disc, vha, 0x200c, "HBA in FL topology.\n");
2080
		ha->switch_cap = sw_cap;
L
Linus Torvalds 已提交
2081 2082 2083 2084 2085
		ha->current_topology = ISP_CFG_FL;
		strcpy(connect_type, "(FL_Port)");
		break;

	case 2:
2086
		ql_dbg(ql_dbg_disc, vha, 0x200d, "HBA in N P2P topology.\n");
L
Linus Torvalds 已提交
2087 2088 2089 2090 2091 2092
		ha->operating_mode = P2P;
		ha->current_topology = ISP_CFG_N;
		strcpy(connect_type, "(N_Port-to-N_Port)");
		break;

	case 3:
2093
		ql_dbg(ql_dbg_disc, vha, 0x200e, "HBA in F P2P topology.\n");
2094
		ha->switch_cap = sw_cap;
L
Linus Torvalds 已提交
2095 2096 2097 2098 2099 2100
		ha->operating_mode = P2P;
		ha->current_topology = ISP_CFG_F;
		strcpy(connect_type, "(F_Port)");
		break;

	default:
2101 2102
		ql_dbg(ql_dbg_disc, vha, 0x200f,
		    "HBA in unknown topology %x, using NL.\n", topo);
L
Linus Torvalds 已提交
2103 2104 2105 2106 2107 2108 2109
		ha->current_topology = ISP_CFG_NL;
		strcpy(connect_type, "(Loop)");
		break;
	}

	/* Save Host port and loop ID. */
	/* byte order - Big Endian */
2110 2111 2112
	vha->d_id.b.domain = domain;
	vha->d_id.b.area = area;
	vha->d_id.b.al_pa = al_pa;
L
Linus Torvalds 已提交
2113

2114
	if (!vha->flags.init_done)
2115 2116
		ql_log(ql_log_info, vha, 0x2010,
		    "Topology - %s, Host Loop address 0x%x.\n",
2117
		    connect_type, vha->loop_id);
L
Linus Torvalds 已提交
2118 2119

	if (rval) {
2120 2121
		ql_log(ql_log_warn, vha, 0x2011,
		    "%s FAILED\n", __func__);
L
Linus Torvalds 已提交
2122
	} else {
2123 2124
		ql_dbg(ql_dbg_disc, vha, 0x2012,
		    "%s success\n", __func__);
L
Linus Torvalds 已提交
2125 2126 2127 2128 2129
	}

	return(rval);
}

2130
inline void
2131 2132
qla2x00_set_model_info(scsi_qla_host_t *vha, uint8_t *model, size_t len,
	char *def)
2133 2134 2135
{
	char *st, *en;
	uint16_t index;
2136
	struct qla_hw_data *ha = vha->hw;
2137
	int use_tbl = !IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha) &&
2138
	    !IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha);
2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150

	if (memcmp(model, BINZERO, len) != 0) {
		strncpy(ha->model_number, model, len);
		st = en = ha->model_number;
		en += len - 1;
		while (en > st) {
			if (*en != 0x20 && *en != 0x00)
				break;
			*en-- = '\0';
		}

		index = (ha->pdev->subsystem_device & 0xff);
2151 2152
		if (use_tbl &&
		    ha->pdev->subsystem_vendor == PCI_VENDOR_ID_QLOGIC &&
2153
		    index < QLA_MODEL_NAMES)
2154 2155 2156
			strncpy(ha->model_desc,
			    qla2x00_model_name[index * 2 + 1],
			    sizeof(ha->model_desc) - 1);
2157 2158
	} else {
		index = (ha->pdev->subsystem_device & 0xff);
2159 2160
		if (use_tbl &&
		    ha->pdev->subsystem_vendor == PCI_VENDOR_ID_QLOGIC &&
2161 2162 2163
		    index < QLA_MODEL_NAMES) {
			strcpy(ha->model_number,
			    qla2x00_model_name[index * 2]);
2164 2165 2166
			strncpy(ha->model_desc,
			    qla2x00_model_name[index * 2 + 1],
			    sizeof(ha->model_desc) - 1);
2167 2168 2169 2170
		} else {
			strcpy(ha->model_number, def);
		}
	}
2171
	if (IS_FWI2_CAPABLE(ha))
2172
		qla2xxx_get_vpd_field(vha, "\x82", ha->model_desc,
2173
		    sizeof(ha->model_desc));
2174 2175
}

2176 2177 2178
/* On sparc systems, obtain port and node WWN from firmware
 * properties.
 */
2179
static void qla2xxx_nvram_wwn_from_ofw(scsi_qla_host_t *vha, nvram_t *nv)
2180 2181
{
#ifdef CONFIG_SPARC
2182
	struct qla_hw_data *ha = vha->hw;
2183
	struct pci_dev *pdev = ha->pdev;
D
David S. Miller 已提交
2184 2185
	struct device_node *dp = pci_device_to_OF_node(pdev);
	const u8 *val;
2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197
	int len;

	val = of_get_property(dp, "port-wwn", &len);
	if (val && len >= WWN_SIZE)
		memcpy(nv->port_name, val, WWN_SIZE);

	val = of_get_property(dp, "node-wwn", &len);
	if (val && len >= WWN_SIZE)
		memcpy(nv->node_name, val, WWN_SIZE);
#endif
}

L
Linus Torvalds 已提交
2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210
/*
* NVRAM configuration for ISP 2xxx
*
* Input:
*      ha                = adapter block pointer.
*
* Output:
*      initialization control block in response_ring
*      host adapters parameters in host adapter block
*
* Returns:
*      0 = success.
*/
2211
int
2212
qla2x00_nvram_config(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
2213
{
2214
	int             rval;
2215 2216 2217
	uint8_t         chksum = 0;
	uint16_t        cnt;
	uint8_t         *dptr1, *dptr2;
2218
	struct qla_hw_data *ha = vha->hw;
2219
	init_cb_t       *icb = ha->init_cb;
2220 2221
	nvram_t         *nv = ha->nvram;
	uint8_t         *ptr = ha->nvram;
2222
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
2223

2224 2225
	rval = QLA_SUCCESS;

L
Linus Torvalds 已提交
2226
	/* Determine NVRAM starting address. */
2227
	ha->nvram_size = sizeof(nvram_t);
L
Linus Torvalds 已提交
2228 2229 2230 2231 2232 2233
	ha->nvram_base = 0;
	if (!IS_QLA2100(ha) && !IS_QLA2200(ha) && !IS_QLA2300(ha))
		if ((RD_REG_WORD(&reg->ctrl_status) >> 14) == 1)
			ha->nvram_base = 0x80;

	/* Get NVRAM data and calculate checksum. */
2234
	ha->isp_ops->read_nvram(vha, ptr, ha->nvram_base, ha->nvram_size);
2235 2236
	for (cnt = 0, chksum = 0; cnt < ha->nvram_size; cnt++)
		chksum += *ptr++;
L
Linus Torvalds 已提交
2237

2238 2239 2240 2241
	ql_dbg(ql_dbg_init + ql_dbg_buffer, vha, 0x010f,
	    "Contents of NVRAM.\n");
	ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x0110,
	    (uint8_t *)nv, ha->nvram_size);
L
Linus Torvalds 已提交
2242 2243 2244 2245 2246

	/* Bad NVRAM data, set defaults parameters. */
	if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' ||
	    nv->id[2] != 'P' || nv->id[3] != ' ' || nv->nvram_version < 1) {
		/* Reset NVRAM data. */
2247 2248 2249 2250 2251 2252 2253
		ql_log(ql_log_warn, vha, 0x0064,
		    "Inconisistent NVRAM "
		    "detected: checksum=0x%x id=%c version=0x%x.\n",
		    chksum, nv->id[0], nv->nvram_version);
		ql_log(ql_log_warn, vha, 0x0065,
		    "Falling back to "
		    "functioning (yet invalid -- WWPN) defaults.\n");
2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288

		/*
		 * Set default initialization control block.
		 */
		memset(nv, 0, ha->nvram_size);
		nv->parameter_block_version = ICB_VERSION;

		if (IS_QLA23XX(ha)) {
			nv->firmware_options[0] = BIT_2 | BIT_1;
			nv->firmware_options[1] = BIT_7 | BIT_5;
			nv->add_firmware_options[0] = BIT_5;
			nv->add_firmware_options[1] = BIT_5 | BIT_4;
			nv->frame_payload_size = __constant_cpu_to_le16(2048);
			nv->special_options[1] = BIT_7;
		} else if (IS_QLA2200(ha)) {
			nv->firmware_options[0] = BIT_2 | BIT_1;
			nv->firmware_options[1] = BIT_7 | BIT_5;
			nv->add_firmware_options[0] = BIT_5;
			nv->add_firmware_options[1] = BIT_5 | BIT_4;
			nv->frame_payload_size = __constant_cpu_to_le16(1024);
		} else if (IS_QLA2100(ha)) {
			nv->firmware_options[0] = BIT_3 | BIT_1;
			nv->firmware_options[1] = BIT_5;
			nv->frame_payload_size = __constant_cpu_to_le16(1024);
		}

		nv->max_iocb_allocation = __constant_cpu_to_le16(256);
		nv->execution_throttle = __constant_cpu_to_le16(16);
		nv->retry_count = 8;
		nv->retry_delay = 1;

		nv->port_name[0] = 33;
		nv->port_name[3] = 224;
		nv->port_name[4] = 139;

2289
		qla2xxx_nvram_wwn_from_ofw(vha, nv);
2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302

		nv->login_timeout = 4;

		/*
		 * Set default host adapter parameters
		 */
		nv->host_p[1] = BIT_2;
		nv->reset_delay = 5;
		nv->port_down_retry_count = 8;
		nv->max_luns_per_target = __constant_cpu_to_le16(8);
		nv->link_down_timeout = 60;

		rval = 1;
L
Linus Torvalds 已提交
2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319
	}

#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
	/*
	 * The SN2 does not provide BIOS emulation which means you can't change
	 * potentially bogus BIOS settings. Force the use of default settings
	 * for link rate and frame size.  Hope that the rest of the settings
	 * are valid.
	 */
	if (ia64_platform_is("sn2")) {
		nv->frame_payload_size = __constant_cpu_to_le16(2048);
		if (IS_QLA23XX(ha))
			nv->special_options[1] = BIT_7;
	}
#endif

	/* Reset Initialization control block */
2320
	memset(icb, 0, ha->init_cb_size);
L
Linus Torvalds 已提交
2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332

	/*
	 * Setup driver NVRAM options.
	 */
	nv->firmware_options[0] |= (BIT_6 | BIT_1);
	nv->firmware_options[0] &= ~(BIT_5 | BIT_4);
	nv->firmware_options[1] |= (BIT_5 | BIT_0);
	nv->firmware_options[1] &= ~BIT_4;

	if (IS_QLA23XX(ha)) {
		nv->firmware_options[0] |= BIT_2;
		nv->firmware_options[0] &= ~BIT_3;
2333
		nv->firmware_options[0] &= ~BIT_6;
2334
		nv->add_firmware_options[1] |= BIT_5 | BIT_4;
L
Linus Torvalds 已提交
2335 2336 2337 2338 2339 2340 2341 2342

		if (IS_QLA2300(ha)) {
			if (ha->fb_rev == FPM_2310) {
				strcpy(ha->model_number, "QLA2310");
			} else {
				strcpy(ha->model_number, "QLA2300");
			}
		} else {
2343
			qla2x00_set_model_info(vha, nv->model_number,
2344
			    sizeof(nv->model_number), "QLA23xx");
L
Linus Torvalds 已提交
2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377
		}
	} else if (IS_QLA2200(ha)) {
		nv->firmware_options[0] |= BIT_2;
		/*
		 * 'Point-to-point preferred, else loop' is not a safe
		 * connection mode setting.
		 */
		if ((nv->add_firmware_options[0] & (BIT_6 | BIT_5 | BIT_4)) ==
		    (BIT_5 | BIT_4)) {
			/* Force 'loop preferred, else point-to-point'. */
			nv->add_firmware_options[0] &= ~(BIT_6 | BIT_5 | BIT_4);
			nv->add_firmware_options[0] |= BIT_5;
		}
		strcpy(ha->model_number, "QLA22xx");
	} else /*if (IS_QLA2100(ha))*/ {
		strcpy(ha->model_number, "QLA2100");
	}

	/*
	 * Copy over NVRAM RISC parameter block to initialization control block.
	 */
	dptr1 = (uint8_t *)icb;
	dptr2 = (uint8_t *)&nv->parameter_block_version;
	cnt = (uint8_t *)&icb->request_q_outpointer - (uint8_t *)&icb->version;
	while (cnt--)
		*dptr1++ = *dptr2++;

	/* Copy 2nd half. */
	dptr1 = (uint8_t *)icb->add_firmware_options;
	cnt = (uint8_t *)icb->reserved_3 - (uint8_t *)icb->add_firmware_options;
	while (cnt--)
		*dptr1++ = *dptr2++;

2378 2379 2380 2381 2382 2383
	/* Use alternate WWN? */
	if (nv->host_p[1] & BIT_7) {
		memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
		memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
	}

L
Linus Torvalds 已提交
2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396
	/* Prepare nodename */
	if ((icb->firmware_options[1] & BIT_6) == 0) {
		/*
		 * Firmware will apply the following mask if the nodename was
		 * not provided.
		 */
		memcpy(icb->node_name, icb->port_name, WWN_SIZE);
		icb->node_name[0] &= 0xF0;
	}

	/*
	 * Set host adapter parameters.
	 */
2397 2398 2399 2400 2401

	/*
	 * BIT_7 in the host-parameters section allows for modification to
	 * internal driver logging.
	 */
2402
	if (nv->host_p[0] & BIT_7)
2403
		ql2xextended_error_logging = QL_DBG_DEFAULT1_MASK;
L
Linus Torvalds 已提交
2404 2405 2406 2407 2408 2409 2410
	ha->flags.disable_risc_code_load = ((nv->host_p[0] & BIT_4) ? 1 : 0);
	/* Always load RISC code on non ISP2[12]00 chips. */
	if (!IS_QLA2100(ha) && !IS_QLA2200(ha))
		ha->flags.disable_risc_code_load = 0;
	ha->flags.enable_lip_reset = ((nv->host_p[1] & BIT_1) ? 1 : 0);
	ha->flags.enable_lip_full_login = ((nv->host_p[1] & BIT_2) ? 1 : 0);
	ha->flags.enable_target_reset = ((nv->host_p[1] & BIT_3) ? 1 : 0);
2411
	ha->flags.enable_led_scheme = (nv->special_options[1] & BIT_4) ? 1 : 0;
2412
	ha->flags.disable_serdes = 0;
L
Linus Torvalds 已提交
2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423

	ha->operating_mode =
	    (icb->add_firmware_options[0] & (BIT_6 | BIT_5 | BIT_4)) >> 4;

	memcpy(ha->fw_seriallink_options, nv->seriallink_options,
	    sizeof(ha->fw_seriallink_options));

	/* save HBA serial number */
	ha->serial0 = icb->port_name[5];
	ha->serial1 = icb->port_name[6];
	ha->serial2 = icb->port_name[7];
2424 2425
	memcpy(vha->node_name, icb->node_name, WWN_SIZE);
	memcpy(vha->port_name, icb->port_name, WWN_SIZE);
L
Linus Torvalds 已提交
2426 2427 2428 2429 2430 2431

	icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);

	ha->retry_count = nv->retry_count;

	/* Set minimum login_timeout to 4 seconds. */
2432
	if (nv->login_timeout != ql2xlogintimeout)
L
Linus Torvalds 已提交
2433 2434 2435 2436 2437 2438
		nv->login_timeout = ql2xlogintimeout;
	if (nv->login_timeout < 4)
		nv->login_timeout = 4;
	ha->login_timeout = nv->login_timeout;
	icb->login_timeout = nv->login_timeout;

2439 2440
	/* Set minimum RATOV to 100 tenths of a second. */
	ha->r_a_tov = 100;
L
Linus Torvalds 已提交
2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452

	ha->loop_reset_delay = nv->reset_delay;

	/* Link Down Timeout = 0:
	 *
	 * 	When Port Down timer expires we will start returning
	 *	I/O's to OS with "DID_NO_CONNECT".
	 *
	 * Link Down Timeout != 0:
	 *
	 *	 The driver waits for the link to come up after link down
	 *	 before returning I/Os to OS with "DID_NO_CONNECT".
A
Andrew Vasquez 已提交
2453
	 */
L
Linus Torvalds 已提交
2454 2455
	if (nv->link_down_timeout == 0) {
		ha->loop_down_abort_time =
2456
		    (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
L
Linus Torvalds 已提交
2457 2458 2459 2460
	} else {
		ha->link_down_timeout =	 nv->link_down_timeout;
		ha->loop_down_abort_time =
		    (LOOP_DOWN_TIME - ha->link_down_timeout);
A
Andrew Vasquez 已提交
2461
	}
L
Linus Torvalds 已提交
2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492

	/*
	 * Need enough time to try and get the port back.
	 */
	ha->port_down_retry_count = nv->port_down_retry_count;
	if (qlport_down_retry)
		ha->port_down_retry_count = qlport_down_retry;
	/* Set login_retry_count */
	ha->login_retry_count  = nv->retry_count;
	if (ha->port_down_retry_count == nv->port_down_retry_count &&
	    ha->port_down_retry_count > 3)
		ha->login_retry_count = ha->port_down_retry_count;
	else if (ha->port_down_retry_count > (int)ha->login_retry_count)
		ha->login_retry_count = ha->port_down_retry_count;
	if (ql2xloginretrycount)
		ha->login_retry_count = ql2xloginretrycount;

	icb->lun_enables = __constant_cpu_to_le16(0);
	icb->command_resource_count = 0;
	icb->immediate_notify_resource_count = 0;
	icb->timeout = __constant_cpu_to_le16(0);

	if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
		/* Enable RIO */
		icb->firmware_options[0] &= ~BIT_3;
		icb->add_firmware_options[0] &=
		    ~(BIT_3 | BIT_2 | BIT_1 | BIT_0);
		icb->add_firmware_options[0] |= BIT_2;
		icb->response_accumulation_timer = 3;
		icb->interrupt_delay_timer = 5;

2493
		vha->flags.process_response_queue = 1;
L
Linus Torvalds 已提交
2494
	} else {
2495
		/* Enable ZIO. */
2496
		if (!vha->flags.init_done) {
2497 2498 2499 2500 2501
			ha->zio_mode = icb->add_firmware_options[0] &
			    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
			ha->zio_timer = icb->interrupt_delay_timer ?
			    icb->interrupt_delay_timer: 2;
		}
L
Linus Torvalds 已提交
2502 2503
		icb->add_firmware_options[0] &=
		    ~(BIT_3 | BIT_2 | BIT_1 | BIT_0);
2504
		vha->flags.process_response_queue = 0;
2505
		if (ha->zio_mode != QLA_ZIO_DISABLED) {
2506 2507
			ha->zio_mode = QLA_ZIO_MODE_6;

2508
			ql_log(ql_log_info, vha, 0x0068,
2509 2510
			    "ZIO mode %d enabled; timer delay (%d us).\n",
			    ha->zio_mode, ha->zio_timer * 100);
L
Linus Torvalds 已提交
2511

2512 2513
			icb->add_firmware_options[0] |= (uint8_t)ha->zio_mode;
			icb->interrupt_delay_timer = (uint8_t)ha->zio_timer;
2514
			vha->flags.process_response_queue = 1;
L
Linus Torvalds 已提交
2515 2516 2517
		}
	}

2518
	if (rval) {
2519 2520
		ql_log(ql_log_warn, vha, 0x0069,
		    "NVRAM configuration failed.\n");
2521 2522
	}
	return (rval);
L
Linus Torvalds 已提交
2523 2524
}

2525 2526 2527 2528
static void
qla2x00_rport_del(void *data)
{
	fc_port_t *fcport = data;
2529
	struct fc_rport *rport;
2530
	unsigned long flags;
2531

2532
	spin_lock_irqsave(fcport->vha->host->host_lock, flags);
2533
	rport = fcport->drport ? fcport->drport: fcport->rport;
2534
	fcport->drport = NULL;
2535
	spin_unlock_irqrestore(fcport->vha->host->host_lock, flags);
2536 2537
	if (rport)
		fc_remote_port_delete(rport);
2538 2539
}

L
Linus Torvalds 已提交
2540 2541 2542 2543 2544 2545 2546
/**
 * qla2x00_alloc_fcport() - Allocate a generic fcport.
 * @ha: HA context
 * @flags: allocation flags
 *
 * Returns a pointer to the allocated fcport, or NULL, if none available.
 */
2547
fc_port_t *
2548
qla2x00_alloc_fcport(scsi_qla_host_t *vha, gfp_t flags)
L
Linus Torvalds 已提交
2549 2550 2551
{
	fc_port_t *fcport;

2552 2553 2554
	fcport = kzalloc(sizeof(fc_port_t), flags);
	if (!fcport)
		return NULL;
L
Linus Torvalds 已提交
2555 2556

	/* Setup fcport template structure. */
2557 2558
	fcport->vha = vha;
	fcport->vp_idx = vha->vp_idx;
L
Linus Torvalds 已提交
2559 2560
	fcport->port_type = FCT_UNKNOWN;
	fcport->loop_id = FC_NO_LOOP_ID;
2561
	qla2x00_set_fcport_state(fcport, FCS_UNCONFIGURED);
2562
	fcport->supported_classes = FC_COS_UNSPECIFIED;
L
Linus Torvalds 已提交
2563

2564
	return fcport;
L
Linus Torvalds 已提交
2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579
}

/*
 * qla2x00_configure_loop
 *      Updates Fibre Channel Device Database with what is actually on loop.
 *
 * Input:
 *      ha                = adapter block pointer.
 *
 * Returns:
 *      0 = success.
 *      1 = error.
 *      2 = database was full and device was not configured.
 */
static int
2580
qla2x00_configure_loop(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
2581 2582 2583
{
	int  rval;
	unsigned long flags, save_flags;
2584
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
2585 2586 2587
	rval = QLA_SUCCESS;

	/* Get Initiator ID */
2588 2589
	if (test_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags)) {
		rval = qla2x00_configure_hba(vha);
L
Linus Torvalds 已提交
2590
		if (rval != QLA_SUCCESS) {
2591 2592
			ql_dbg(ql_dbg_disc, vha, 0x2013,
			    "Unable to configure HBA.\n");
L
Linus Torvalds 已提交
2593 2594 2595 2596
			return (rval);
		}
	}

2597
	save_flags = flags = vha->dpc_flags;
2598 2599
	ql_dbg(ql_dbg_disc, vha, 0x2014,
	    "Configure loop -- dpc flags = 0x%lx.\n", flags);
L
Linus Torvalds 已提交
2600 2601 2602 2603 2604

	/*
	 * If we have both an RSCN and PORT UPDATE pending then handle them
	 * both at the same time.
	 */
2605 2606
	clear_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
	clear_bit(RSCN_UPDATE, &vha->dpc_flags);
L
Linus Torvalds 已提交
2607

2608 2609
	qla2x00_get_data_rate(vha);

L
Linus Torvalds 已提交
2610 2611 2612 2613
	/* Determine what we need to do */
	if (ha->current_topology == ISP_CFG_FL &&
	    (test_bit(LOCAL_LOOP_UPDATE, &flags))) {

2614
		vha->flags.rscn_queue_overflow = 1;
L
Linus Torvalds 已提交
2615 2616 2617 2618 2619
		set_bit(RSCN_UPDATE, &flags);

	} else if (ha->current_topology == ISP_CFG_F &&
	    (test_bit(LOCAL_LOOP_UPDATE, &flags))) {

2620
		vha->flags.rscn_queue_overflow = 1;
L
Linus Torvalds 已提交
2621 2622
		set_bit(RSCN_UPDATE, &flags);
		clear_bit(LOCAL_LOOP_UPDATE, &flags);
2623 2624 2625

	} else if (ha->current_topology == ISP_CFG_N) {
		clear_bit(RSCN_UPDATE, &flags);
L
Linus Torvalds 已提交
2626

2627
	} else if (!vha->flags.online ||
L
Linus Torvalds 已提交
2628 2629
	    (test_bit(ABORT_ISP_ACTIVE, &flags))) {

2630
		vha->flags.rscn_queue_overflow = 1;
L
Linus Torvalds 已提交
2631 2632 2633 2634 2635
		set_bit(RSCN_UPDATE, &flags);
		set_bit(LOCAL_LOOP_UPDATE, &flags);
	}

	if (test_bit(LOCAL_LOOP_UPDATE, &flags)) {
2636 2637 2638
		if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
			ql_dbg(ql_dbg_disc, vha, 0x2015,
			    "Loop resync needed, failing.\n");
L
Linus Torvalds 已提交
2639
			rval = QLA_FUNCTION_FAILED;
2640
		}
2641 2642
		else
			rval = qla2x00_configure_local_loop(vha);
L
Linus Torvalds 已提交
2643 2644 2645
	}

	if (rval == QLA_SUCCESS && test_bit(RSCN_UPDATE, &flags)) {
2646 2647 2648
		if (LOOP_TRANSITION(vha)) {
			ql_dbg(ql_dbg_disc, vha, 0x201e,
			    "Needs RSCN update and loop transition.\n");
L
Linus Torvalds 已提交
2649
			rval = QLA_FUNCTION_FAILED;
2650
		}
2651 2652
		else
			rval = qla2x00_configure_fabric(vha);
L
Linus Torvalds 已提交
2653 2654 2655
	}

	if (rval == QLA_SUCCESS) {
2656 2657
		if (atomic_read(&vha->loop_down_timer) ||
		    test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
L
Linus Torvalds 已提交
2658 2659
			rval = QLA_FUNCTION_FAILED;
		} else {
2660
			atomic_set(&vha->loop_state, LOOP_READY);
2661 2662
			ql_dbg(ql_dbg_disc, vha, 0x2069,
			    "LOOP READY.\n");
L
Linus Torvalds 已提交
2663 2664 2665 2666
		}
	}

	if (rval) {
2667 2668
		ql_dbg(ql_dbg_disc, vha, 0x206a,
		    "%s *** FAILED ***.\n", __func__);
L
Linus Torvalds 已提交
2669
	} else {
2670 2671
		ql_dbg(ql_dbg_disc, vha, 0x206b,
		    "%s: exiting normally.\n", __func__);
L
Linus Torvalds 已提交
2672 2673
	}

2674
	/* Restore state if a resync event occurred during processing */
2675
	if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
L
Linus Torvalds 已提交
2676
		if (test_bit(LOCAL_LOOP_UPDATE, &save_flags))
2677
			set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
2678
		if (test_bit(RSCN_UPDATE, &save_flags)) {
2679
			set_bit(RSCN_UPDATE, &vha->dpc_flags);
2680 2681
			if (!IS_ALOGIO_CAPABLE(ha))
				vha->flags.rscn_queue_overflow = 1;
2682
		}
L
Linus Torvalds 已提交
2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700
	}

	return (rval);
}



/*
 * qla2x00_configure_local_loop
 *	Updates Fibre Channel Device Database with local loop devices.
 *
 * Input:
 *	ha = adapter block pointer.
 *
 * Returns:
 *	0 = success.
 */
static int
2701
qla2x00_configure_local_loop(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712
{
	int		rval, rval2;
	int		found_devs;
	int		found;
	fc_port_t	*fcport, *new_fcport;

	uint16_t	index;
	uint16_t	entries;
	char		*id_iter;
	uint16_t	loop_id;
	uint8_t		domain, area, al_pa;
2713
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
2714 2715 2716 2717 2718

	found_devs = 0;
	new_fcport = NULL;
	entries = MAX_FIBRE_DEVICES;

2719 2720 2721 2722
	ql_dbg(ql_dbg_disc, vha, 0x2016,
	    "Getting FCAL position map.\n");
	if (ql2xextended_error_logging & ql_dbg_disc)
		qla2x00_get_fcal_position_map(vha, NULL);
L
Linus Torvalds 已提交
2723 2724 2725

	/* Get list of logged in devices. */
	memset(ha->gid_list, 0, GID_LIST_SIZE);
2726
	rval = qla2x00_get_id_list(vha, ha->gid_list, ha->gid_list_dma,
L
Linus Torvalds 已提交
2727 2728 2729 2730
	    &entries);
	if (rval != QLA_SUCCESS)
		goto cleanup_allocation;

2731 2732 2733 2734 2735
	ql_dbg(ql_dbg_disc, vha, 0x2017,
	    "Entries in ID list (%d).\n", entries);
	ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2075,
	    (uint8_t *)ha->gid_list,
	    entries * sizeof(struct gid_list_info));
L
Linus Torvalds 已提交
2736 2737

	/* Allocate temporary fcport for any new fcports discovered. */
2738
	new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
L
Linus Torvalds 已提交
2739
	if (new_fcport == NULL) {
2740 2741
		ql_log(ql_log_warn, vha, 0x2018,
		    "Memory allocation failed for fcport.\n");
L
Linus Torvalds 已提交
2742 2743 2744 2745 2746 2747 2748 2749
		rval = QLA_MEMORY_ALLOC_FAILED;
		goto cleanup_allocation;
	}
	new_fcport->flags &= ~FCF_FABRIC_DEVICE;

	/*
	 * Mark local devices that were present with FCF_DEVICE_LOST for now.
	 */
2750
	list_for_each_entry(fcport, &vha->vp_fcports, list) {
L
Linus Torvalds 已提交
2751 2752 2753 2754
		if (atomic_read(&fcport->state) == FCS_ONLINE &&
		    fcport->port_type != FCT_BROADCAST &&
		    (fcport->flags & FCF_FABRIC_DEVICE) == 0) {

2755 2756 2757
			ql_dbg(ql_dbg_disc, vha, 0x2019,
			    "Marking port lost loop_id=0x%04x.\n",
			    fcport->loop_id);
L
Linus Torvalds 已提交
2758

2759
			qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
L
Linus Torvalds 已提交
2760 2761 2762 2763 2764 2765 2766 2767 2768
		}
	}

	/* Add devices to port list. */
	id_iter = (char *)ha->gid_list;
	for (index = 0; index < entries; index++) {
		domain = ((struct gid_list_info *)id_iter)->domain;
		area = ((struct gid_list_info *)id_iter)->area;
		al_pa = ((struct gid_list_info *)id_iter)->al_pa;
2769
		if (IS_QLA2100(ha) || IS_QLA2200(ha))
L
Linus Torvalds 已提交
2770 2771
			loop_id = (uint16_t)
			    ((struct gid_list_info *)id_iter)->loop_id_2100;
2772
		else
L
Linus Torvalds 已提交
2773 2774
			loop_id = le16_to_cpu(
			    ((struct gid_list_info *)id_iter)->loop_id);
2775
		id_iter += ha->gid_list_info_size;
L
Linus Torvalds 已提交
2776 2777 2778 2779 2780 2781

		/* Bypass reserved domain fields. */
		if ((domain & 0xf0) == 0xf0)
			continue;

		/* Bypass if not same domain and area of adapter. */
2782
		if (area && domain &&
2783
		    (area != vha->d_id.b.area || domain != vha->d_id.b.domain))
L
Linus Torvalds 已提交
2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794
			continue;

		/* Bypass invalid local loop ID. */
		if (loop_id > LAST_LOCAL_LOOP_ID)
			continue;

		/* Fill in member data. */
		new_fcport->d_id.b.domain = domain;
		new_fcport->d_id.b.area = area;
		new_fcport->d_id.b.al_pa = al_pa;
		new_fcport->loop_id = loop_id;
2795 2796
		new_fcport->vp_idx = vha->vp_idx;
		rval2 = qla2x00_get_port_database(vha, new_fcport, 0);
L
Linus Torvalds 已提交
2797
		if (rval2 != QLA_SUCCESS) {
2798 2799 2800 2801 2802 2803
			ql_dbg(ql_dbg_disc, vha, 0x201a,
			    "Failed to retrieve fcport information "
			    "-- get_port_database=%x, loop_id=0x%04x.\n",
			    rval2, new_fcport->loop_id);
			ql_dbg(ql_dbg_disc, vha, 0x201b,
			    "Scheduling resync.\n");
2804
			set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
2805 2806 2807 2808 2809 2810
			continue;
		}

		/* Check for matching device in port list. */
		found = 0;
		fcport = NULL;
2811
		list_for_each_entry(fcport, &vha->vp_fcports, list) {
L
Linus Torvalds 已提交
2812 2813 2814 2815
			if (memcmp(new_fcport->port_name, fcport->port_name,
			    WWN_SIZE))
				continue;

2816
			fcport->flags &= ~FCF_FABRIC_DEVICE;
L
Linus Torvalds 已提交
2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828
			fcport->loop_id = new_fcport->loop_id;
			fcport->port_type = new_fcport->port_type;
			fcport->d_id.b24 = new_fcport->d_id.b24;
			memcpy(fcport->node_name, new_fcport->node_name,
			    WWN_SIZE);

			found++;
			break;
		}

		if (!found) {
			/* New device, add to fcports list. */
2829 2830 2831
			if (vha->vp_idx) {
				new_fcport->vha = vha;
				new_fcport->vp_idx = vha->vp_idx;
2832
			}
2833
			list_add_tail(&new_fcport->list, &vha->vp_fcports);
L
Linus Torvalds 已提交
2834 2835 2836

			/* Allocate a new replacement fcport. */
			fcport = new_fcport;
2837
			new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
L
Linus Torvalds 已提交
2838
			if (new_fcport == NULL) {
2839 2840
				ql_log(ql_log_warn, vha, 0x201c,
				    "Failed to allocate memory for fcport.\n");
L
Linus Torvalds 已提交
2841 2842 2843 2844 2845 2846
				rval = QLA_MEMORY_ALLOC_FAILED;
				goto cleanup_allocation;
			}
			new_fcport->flags &= ~FCF_FABRIC_DEVICE;
		}

2847
		/* Base iIDMA settings on HBA port speed. */
2848
		fcport->fp_speed = ha->link_data_rate;
2849

2850
		qla2x00_update_fcport(vha, fcport);
L
Linus Torvalds 已提交
2851 2852 2853 2854 2855

		found_devs++;
	}

cleanup_allocation:
J
Jesper Juhl 已提交
2856
	kfree(new_fcport);
L
Linus Torvalds 已提交
2857 2858

	if (rval != QLA_SUCCESS) {
2859 2860
		ql_dbg(ql_dbg_disc, vha, 0x201d,
		    "Configure local loop error exit: rval=%x.\n", rval);
L
Linus Torvalds 已提交
2861 2862 2863 2864 2865
	}

	return (rval);
}

2866
static void
2867
qla2x00_iidma_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
2868 2869
{
#define LS_UNKNOWN      2
2870 2871
	static char *link_speeds[] = { "1", "2", "?", "4", "8", "10" };
	char *link_speed;
2872
	int rval;
2873
	uint16_t mb[4];
2874
	struct qla_hw_data *ha = vha->hw;
2875

2876
	if (!IS_IIDMA_CAPABLE(ha))
2877 2878
		return;

2879 2880 2881
	if (atomic_read(&fcport->state) != FCS_ONLINE)
		return;

2882 2883
	if (fcport->fp_speed == PORT_SPEED_UNKNOWN ||
	    fcport->fp_speed > ha->link_data_rate)
2884 2885
		return;

2886
	rval = qla2x00_set_idma_speed(vha, fcport->loop_id, fcport->fp_speed,
2887
	    mb);
2888
	if (rval != QLA_SUCCESS) {
2889 2890 2891 2892
		ql_dbg(ql_dbg_disc, vha, 0x2004,
		    "Unable to adjust iIDMA "
		    "%02x%02x%02x%02x%02x%02x%02x%02x -- %04x %x %04x "
		    "%04x.\n", fcport->port_name[0], fcport->port_name[1],
2893 2894 2895
		    fcport->port_name[2], fcport->port_name[3],
		    fcport->port_name[4], fcport->port_name[5],
		    fcport->port_name[6], fcport->port_name[7], rval,
2896
		    fcport->fp_speed, mb[0], mb[1]);
2897
	} else {
2898 2899 2900 2901 2902
		link_speed = link_speeds[LS_UNKNOWN];
		if (fcport->fp_speed < 5)
			link_speed = link_speeds[fcport->fp_speed];
		else if (fcport->fp_speed == 0x13)
			link_speed = link_speeds[5];
2903 2904 2905 2906 2907 2908 2909
		ql_dbg(ql_dbg_disc, vha, 0x2005,
		    "iIDMA adjusted to %s GB/s "
		    "on %02x%02x%02x%02x%02x%02x%02x%02x.\n", link_speed,
		    fcport->port_name[0], fcport->port_name[1],
		    fcport->port_name[2], fcport->port_name[3],
		    fcport->port_name[4], fcport->port_name[5],
		    fcport->port_name[6], fcport->port_name[7]);
2910 2911 2912
	}
}

2913
static void
2914
qla2x00_reg_remote_port(scsi_qla_host_t *vha, fc_port_t *fcport)
已提交
2915 2916
{
	struct fc_rport_identifiers rport_ids;
2917
	struct fc_rport *rport;
2918
	unsigned long flags;
已提交
2919

2920
	qla2x00_rport_del(fcport);
已提交
2921

2922 2923
	rport_ids.node_name = wwn_to_u64(fcport->node_name);
	rport_ids.port_name = wwn_to_u64(fcport->port_name);
已提交
2924 2925
	rport_ids.port_id = fcport->d_id.b.domain << 16 |
	    fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
2926
	rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
2927
	fcport->rport = rport = fc_remote_port_add(vha->host, 0, &rport_ids);
2928
	if (!rport) {
2929 2930
		ql_log(ql_log_warn, vha, 0x2006,
		    "Unable to allocate fc remote port.\n");
2931 2932
		return;
	}
2933
	spin_lock_irqsave(fcport->vha->host->host_lock, flags);
2934
	*((fc_port_t **)rport->dd_data) = fcport;
2935
	spin_unlock_irqrestore(fcport->vha->host->host_lock, flags);
2936

2937
	rport->supported_classes = fcport->supported_classes;
2938

已提交
2939 2940 2941 2942 2943
	rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
	if (fcport->port_type == FCT_INITIATOR)
		rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR;
	if (fcport->port_type == FCT_TARGET)
		rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
2944
	fc_remote_port_rolechg(rport, rport_ids.roles);
L
Linus Torvalds 已提交
2945 2946
}

2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962
/*
 * qla2x00_update_fcport
 *	Updates device on list.
 *
 * Input:
 *	ha = adapter block pointer.
 *	fcport = port structure pointer.
 *
 * Return:
 *	0  - Success
 *  BIT_0 - error
 *
 * Context:
 *	Kernel context.
 */
void
2963
qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
2964
{
2965
	fcport->vha = vha;
2966
	fcport->login_retry = 0;
2967
	fcport->flags &= ~(FCF_LOGIN_NEEDED | FCF_ASYNC_SENT);
2968

2969
	qla2x00_iidma_fcport(vha, fcport);
2970
	qla24xx_update_fcport_fcp_prio(vha, fcport);
2971
	qla2x00_reg_remote_port(vha, fcport);
2972
	qla2x00_set_fcport_state(fcport, FCS_ONLINE);
2973 2974
}

L
Linus Torvalds 已提交
2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986
/*
 * qla2x00_configure_fabric
 *      Setup SNS devices with loop ID's.
 *
 * Input:
 *      ha = adapter block pointer.
 *
 * Returns:
 *      0 = success.
 *      BIT_0 = error
 */
static int
2987
qla2x00_configure_fabric(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
2988 2989 2990 2991 2992
{
	int	rval, rval2;
	fc_port_t	*fcport, *fcptemp;
	uint16_t	next_loopid;
	uint16_t	mb[MAILBOX_REGISTER_COUNT];
2993
	uint16_t	loop_id;
L
Linus Torvalds 已提交
2994
	LIST_HEAD(new_fcports);
2995 2996
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
2997 2998

	/* If FL port exists, then SNS is present */
2999
	if (IS_FWI2_CAPABLE(ha))
3000 3001 3002
		loop_id = NPH_F_PORT;
	else
		loop_id = SNS_FL_PORT;
3003
	rval = qla2x00_get_port_name(vha, loop_id, vha->fabric_node_name, 1);
L
Linus Torvalds 已提交
3004
	if (rval != QLA_SUCCESS) {
3005 3006
		ql_dbg(ql_dbg_disc, vha, 0x201f,
		    "MBX_GET_PORT_NAME failed, No FL Port.\n");
L
Linus Torvalds 已提交
3007

3008
		vha->device_flags &= ~SWITCH_FOUND;
L
Linus Torvalds 已提交
3009 3010
		return (QLA_SUCCESS);
	}
3011
	vha->device_flags |= SWITCH_FOUND;
L
Linus Torvalds 已提交
3012 3013

	/* Mark devices that need re-synchronization. */
3014
	rval2 = qla2x00_device_resync(vha);
L
Linus Torvalds 已提交
3015 3016 3017 3018 3019
	if (rval2 == QLA_RSCNS_HANDLED) {
		/* No point doing the scan, just continue. */
		return (QLA_SUCCESS);
	}
	do {
3020 3021
		/* FDMI support. */
		if (ql2xfdmienable &&
3022 3023
		    test_and_clear_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags))
			qla2x00_fdmi_register(vha);
3024

L
Linus Torvalds 已提交
3025
		/* Ensure we are logged into the SNS. */
3026
		if (IS_FWI2_CAPABLE(ha))
3027 3028 3029
			loop_id = NPH_SNS;
		else
			loop_id = SIMPLE_NAME_SERVER;
3030
		ha->isp_ops->fabric_login(vha, loop_id, 0xff, 0xff,
3031
		    0xfc, mb, BIT_1 | BIT_0);
L
Linus Torvalds 已提交
3032
		if (mb[0] != MBS_COMMAND_COMPLETE) {
3033 3034 3035 3036
			ql_dbg(ql_dbg_disc, vha, 0x2042,
			    "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x mb[2]=%x "
			    "mb[6]=%x mb[7]=%x.\n", loop_id, mb[0], mb[1],
			    mb[2], mb[6], mb[7]);
L
Linus Torvalds 已提交
3037 3038 3039
			return (QLA_SUCCESS);
		}

3040 3041
		if (test_and_clear_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags)) {
			if (qla2x00_rft_id(vha)) {
L
Linus Torvalds 已提交
3042
				/* EMPTY */
3043 3044
				ql_dbg(ql_dbg_disc, vha, 0x2045,
				    "Register FC-4 TYPE failed.\n");
L
Linus Torvalds 已提交
3045
			}
3046
			if (qla2x00_rff_id(vha)) {
L
Linus Torvalds 已提交
3047
				/* EMPTY */
3048 3049
				ql_dbg(ql_dbg_disc, vha, 0x2049,
				    "Register FC-4 Features failed.\n");
L
Linus Torvalds 已提交
3050
			}
3051
			if (qla2x00_rnn_id(vha)) {
L
Linus Torvalds 已提交
3052
				/* EMPTY */
3053 3054
				ql_dbg(ql_dbg_disc, vha, 0x204f,
				    "Register Node Name failed.\n");
3055
			} else if (qla2x00_rsnn_nn(vha)) {
L
Linus Torvalds 已提交
3056
				/* EMPTY */
3057 3058
				ql_dbg(ql_dbg_disc, vha, 0x2053,
				    "Register Symobilic Node Name failed.\n");
L
Linus Torvalds 已提交
3059 3060 3061
			}
		}

3062
		rval = qla2x00_find_all_fabric_devs(vha, &new_fcports);
L
Linus Torvalds 已提交
3063 3064 3065 3066 3067
		if (rval != QLA_SUCCESS)
			break;

		/*
		 * Logout all previous fabric devices marked lost, except
3068
		 * FCP2 devices.
L
Linus Torvalds 已提交
3069
		 */
3070 3071
		list_for_each_entry(fcport, &vha->vp_fcports, list) {
			if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
L
Linus Torvalds 已提交
3072 3073 3074 3075 3076 3077
				break;

			if ((fcport->flags & FCF_FABRIC_DEVICE) == 0)
				continue;

			if (atomic_read(&fcport->state) == FCS_DEVICE_LOST) {
3078
				qla2x00_mark_device_lost(vha, fcport,
3079
				    ql2xplogiabsentdevice, 0);
L
Linus Torvalds 已提交
3080
				if (fcport->loop_id != FC_NO_LOOP_ID &&
3081
				    (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
L
Linus Torvalds 已提交
3082 3083
				    fcport->port_type != FCT_INITIATOR &&
				    fcport->port_type != FCT_BROADCAST) {
3084
					ha->isp_ops->fabric_logout(vha,
3085 3086 3087 3088
					    fcport->loop_id,
					    fcport->d_id.b.domain,
					    fcport->d_id.b.area,
					    fcport->d_id.b.al_pa);
L
Linus Torvalds 已提交
3089 3090 3091 3092 3093 3094
					fcport->loop_id = FC_NO_LOOP_ID;
				}
			}
		}

		/* Starting free loop ID. */
3095
		next_loopid = ha->min_external_loopid;
L
Linus Torvalds 已提交
3096 3097 3098 3099 3100

		/*
		 * Scan through our port list and login entries that need to be
		 * logged in.
		 */
3101 3102 3103
		list_for_each_entry(fcport, &vha->vp_fcports, list) {
			if (atomic_read(&vha->loop_down_timer) ||
			    test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
L
Linus Torvalds 已提交
3104 3105 3106 3107 3108 3109 3110 3111
				break;

			if ((fcport->flags & FCF_FABRIC_DEVICE) == 0 ||
			    (fcport->flags & FCF_LOGIN_NEEDED) == 0)
				continue;

			if (fcport->loop_id == FC_NO_LOOP_ID) {
				fcport->loop_id = next_loopid;
3112
				rval = qla2x00_find_new_loop_id(
3113
				    base_vha, fcport);
L
Linus Torvalds 已提交
3114 3115 3116 3117 3118 3119
				if (rval != QLA_SUCCESS) {
					/* Ran out of IDs to use */
					break;
				}
			}
			/* Login and update database */
3120
			qla2x00_fabric_dev_login(vha, fcport, &next_loopid);
L
Linus Torvalds 已提交
3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131
		}

		/* Exit if out of loop IDs. */
		if (rval != QLA_SUCCESS) {
			break;
		}

		/*
		 * Login and add the new devices to our port list.
		 */
		list_for_each_entry_safe(fcport, fcptemp, &new_fcports, list) {
3132 3133
			if (atomic_read(&vha->loop_down_timer) ||
			    test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
L
Linus Torvalds 已提交
3134 3135 3136 3137
				break;

			/* Find a new loop ID to use. */
			fcport->loop_id = next_loopid;
3138
			rval = qla2x00_find_new_loop_id(base_vha, fcport);
L
Linus Torvalds 已提交
3139 3140 3141 3142 3143
			if (rval != QLA_SUCCESS) {
				/* Ran out of IDs to use */
				break;
			}

3144
			/* Login and update database */
3145 3146 3147 3148 3149 3150 3151
			qla2x00_fabric_dev_login(vha, fcport, &next_loopid);

			if (vha->vp_idx) {
				fcport->vha = vha;
				fcport->vp_idx = vha->vp_idx;
			}
			list_move_tail(&fcport->list, &vha->vp_fcports);
L
Linus Torvalds 已提交
3152 3153 3154 3155 3156 3157 3158 3159 3160 3161
		}
	} while (0);

	/* Free all new device structures not processed. */
	list_for_each_entry_safe(fcport, fcptemp, &new_fcports, list) {
		list_del(&fcport->list);
		kfree(fcport);
	}

	if (rval) {
3162 3163
		ql_dbg(ql_dbg_disc, vha, 0x2068,
		    "Configure fabric error exit rval=%d.\n", rval);
L
Linus Torvalds 已提交
3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182
	}

	return (rval);
}

/*
 * qla2x00_find_all_fabric_devs
 *
 * Input:
 *	ha = adapter block pointer.
 *	dev = database device entry pointer.
 *
 * Returns:
 *	0 = success.
 *
 * Context:
 *	Kernel context.
 */
static int
3183 3184
qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
	struct list_head *new_fcports)
L
Linus Torvalds 已提交
3185 3186 3187 3188 3189 3190 3191 3192 3193
{
	int		rval;
	uint16_t	loop_id;
	fc_port_t	*fcport, *new_fcport, *fcptemp;
	int		found;

	sw_info_t	*swl;
	int		swl_idx;
	int		first_dev, last_dev;
3194
	port_id_t	wrap = {}, nxt_d_id;
3195 3196
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *vp, *base_vha = pci_get_drvdata(ha->pdev);
3197
	struct scsi_qla_host *tvp;
L
Linus Torvalds 已提交
3198 3199 3200 3201

	rval = QLA_SUCCESS;

	/* Try GID_PT to get device list, else GAN. */
3202
	swl = kcalloc(MAX_FIBRE_DEVICES, sizeof(sw_info_t), GFP_KERNEL);
3203
	if (!swl) {
L
Linus Torvalds 已提交
3204
		/*EMPTY*/
3205 3206
		ql_dbg(ql_dbg_disc, vha, 0x2054,
		    "GID_PT allocations failed, fallback on GA_NXT.\n");
L
Linus Torvalds 已提交
3207
	} else {
3208
		if (qla2x00_gid_pt(vha, swl) != QLA_SUCCESS) {
L
Linus Torvalds 已提交
3209 3210
			kfree(swl);
			swl = NULL;
3211
		} else if (qla2x00_gpn_id(vha, swl) != QLA_SUCCESS) {
L
Linus Torvalds 已提交
3212 3213
			kfree(swl);
			swl = NULL;
3214
		} else if (qla2x00_gnn_id(vha, swl) != QLA_SUCCESS) {
L
Linus Torvalds 已提交
3215 3216
			kfree(swl);
			swl = NULL;
3217
		} else if (ql2xiidmaenable &&
3218 3219
		    qla2x00_gfpn_id(vha, swl) == QLA_SUCCESS) {
			qla2x00_gpsc(vha, swl);
L
Linus Torvalds 已提交
3220
		}
3221 3222 3223 3224

		/* If other queries succeeded probe for FC-4 type */
		if (swl)
			qla2x00_gff_id(vha, swl);
L
Linus Torvalds 已提交
3225 3226 3227 3228
	}
	swl_idx = 0;

	/* Allocate temporary fcport for any new fcports discovered. */
3229
	new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
L
Linus Torvalds 已提交
3230
	if (new_fcport == NULL) {
3231 3232
		ql_log(ql_log_warn, vha, 0x205e,
		    "Failed to allocate memory for fcport.\n");
J
Jesper Juhl 已提交
3233
		kfree(swl);
L
Linus Torvalds 已提交
3234 3235 3236 3237 3238 3239 3240 3241
		return (QLA_MEMORY_ALLOC_FAILED);
	}
	new_fcport->flags |= (FCF_FABRIC_DEVICE | FCF_LOGIN_NEEDED);
	/* Set start port ID scan at adapter ID. */
	first_dev = 1;
	last_dev = 0;

	/* Starting free loop ID. */
3242 3243 3244
	loop_id = ha->min_external_loopid;
	for (; loop_id <= ha->max_loop_id; loop_id++) {
		if (qla2x00_is_reserved_id(vha, loop_id))
L
Linus Torvalds 已提交
3245 3246
			continue;

3247 3248 3249
		if (ha->current_topology == ISP_CFG_FL &&
		    (atomic_read(&vha->loop_down_timer) ||
		     LOOP_TRANSITION(vha))) {
3250 3251 3252
			atomic_set(&vha->loop_down_timer, 0);
			set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
			set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
L
Linus Torvalds 已提交
3253
			break;
3254
		}
L
Linus Torvalds 已提交
3255 3256 3257 3258 3259 3260 3261 3262 3263 3264

		if (swl != NULL) {
			if (last_dev) {
				wrap.b24 = new_fcport->d_id.b24;
			} else {
				new_fcport->d_id.b24 = swl[swl_idx].d_id.b24;
				memcpy(new_fcport->node_name,
				    swl[swl_idx].node_name, WWN_SIZE);
				memcpy(new_fcport->port_name,
				    swl[swl_idx].port_name, WWN_SIZE);
3265 3266 3267
				memcpy(new_fcport->fabric_port_name,
				    swl[swl_idx].fabric_port_name, WWN_SIZE);
				new_fcport->fp_speed = swl[swl_idx].fp_speed;
3268
				new_fcport->fc4_type = swl[swl_idx].fc4_type;
L
Linus Torvalds 已提交
3269 3270 3271 3272 3273 3274 3275 3276

				if (swl[swl_idx].d_id.b.rsvd_1 != 0) {
					last_dev = 1;
				}
				swl_idx++;
			}
		} else {
			/* Send GA_NXT to the switch */
3277
			rval = qla2x00_ga_nxt(vha, new_fcport);
L
Linus Torvalds 已提交
3278
			if (rval != QLA_SUCCESS) {
3279 3280 3281
				ql_log(ql_log_warn, vha, 0x2064,
				    "SNS scan failed -- assuming "
				    "zero-entry result.\n");
L
Linus Torvalds 已提交
3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296
				list_for_each_entry_safe(fcport, fcptemp,
				    new_fcports, list) {
					list_del(&fcport->list);
					kfree(fcport);
				}
				rval = QLA_SUCCESS;
				break;
			}
		}

		/* If wrap on switch device list, exit. */
		if (first_dev) {
			wrap.b24 = new_fcport->d_id.b24;
			first_dev = 0;
		} else if (new_fcport->d_id.b24 == wrap.b24) {
3297 3298 3299 3300 3301
			ql_dbg(ql_dbg_disc, vha, 0x2065,
			    "Device wrap (%02x%02x%02x).\n",
			    new_fcport->d_id.b.domain,
			    new_fcport->d_id.b.area,
			    new_fcport->d_id.b.al_pa);
L
Linus Torvalds 已提交
3302 3303 3304
			break;
		}

3305
		/* Bypass if same physical adapter. */
3306
		if (new_fcport->d_id.b24 == base_vha->d_id.b24)
L
Linus Torvalds 已提交
3307 3308
			continue;

3309
		/* Bypass virtual ports of the same host. */
3310 3311
		found = 0;
		if (ha->num_vhosts) {
3312 3313 3314
			unsigned long flags;

			spin_lock_irqsave(&ha->vport_slock, flags);
3315
			list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
3316 3317
				if (new_fcport->d_id.b24 == vp->d_id.b24) {
					found = 1;
3318
					break;
3319
				}
3320
			}
3321 3322
			spin_unlock_irqrestore(&ha->vport_slock, flags);

3323
			if (found)
3324 3325 3326
				continue;
		}

3327 3328
		/* Bypass if same domain and area of adapter. */
		if (((new_fcport->d_id.b24 & 0xffff00) ==
3329
		    (vha->d_id.b24 & 0xffff00)) && ha->current_topology ==
3330 3331 3332
			ISP_CFG_FL)
			    continue;

L
Linus Torvalds 已提交
3333 3334 3335 3336
		/* Bypass reserved domain fields. */
		if ((new_fcport->d_id.b.domain & 0xf0) == 0xf0)
			continue;

3337
		/* Bypass ports whose FCP-4 type is not FCP_SCSI */
3338 3339 3340
		if (ql2xgffidenable &&
		    (new_fcport->fc4_type != FC4_TYPE_FCP_SCSI &&
		    new_fcport->fc4_type != FC4_TYPE_UNKNOWN))
3341 3342
			continue;

L
Linus Torvalds 已提交
3343 3344
		/* Locate matching device in database. */
		found = 0;
3345
		list_for_each_entry(fcport, &vha->vp_fcports, list) {
L
Linus Torvalds 已提交
3346 3347 3348 3349 3350 3351
			if (memcmp(new_fcport->port_name, fcport->port_name,
			    WWN_SIZE))
				continue;

			found++;

3352 3353 3354 3355 3356
			/* Update port state. */
			memcpy(fcport->fabric_port_name,
			    new_fcport->fabric_port_name, WWN_SIZE);
			fcport->fp_speed = new_fcport->fp_speed;

L
Linus Torvalds 已提交
3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384
			/*
			 * If address the same and state FCS_ONLINE, nothing
			 * changed.
			 */
			if (fcport->d_id.b24 == new_fcport->d_id.b24 &&
			    atomic_read(&fcport->state) == FCS_ONLINE) {
				break;
			}

			/*
			 * If device was not a fabric device before.
			 */
			if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
				fcport->d_id.b24 = new_fcport->d_id.b24;
				fcport->loop_id = FC_NO_LOOP_ID;
				fcport->flags |= (FCF_FABRIC_DEVICE |
				    FCF_LOGIN_NEEDED);
				break;
			}

			/*
			 * Port ID changed or device was marked to be updated;
			 * Log it out if still logged in and mark it for
			 * relogin later.
			 */
			fcport->d_id.b24 = new_fcport->d_id.b24;
			fcport->flags |= FCF_LOGIN_NEEDED;
			if (fcport->loop_id != FC_NO_LOOP_ID &&
3385
			    (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
L
Linus Torvalds 已提交
3386 3387
			    fcport->port_type != FCT_INITIATOR &&
			    fcport->port_type != FCT_BROADCAST) {
3388
				ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3389 3390
				    fcport->d_id.b.domain, fcport->d_id.b.area,
				    fcport->d_id.b.al_pa);
L
Linus Torvalds 已提交
3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403
				fcport->loop_id = FC_NO_LOOP_ID;
			}

			break;
		}

		if (found)
			continue;
		/* If device was not in our fcports list, then add it. */
		list_add_tail(&new_fcport->list, new_fcports);

		/* Allocate a new replacement fcport. */
		nxt_d_id.b24 = new_fcport->d_id.b24;
3404
		new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
L
Linus Torvalds 已提交
3405
		if (new_fcport == NULL) {
3406 3407
			ql_log(ql_log_warn, vha, 0x2066,
			    "Memory allocation failed for fcport.\n");
J
Jesper Juhl 已提交
3408
			kfree(swl);
L
Linus Torvalds 已提交
3409 3410 3411 3412 3413 3414
			return (QLA_MEMORY_ALLOC_FAILED);
		}
		new_fcport->flags |= (FCF_FABRIC_DEVICE | FCF_LOGIN_NEEDED);
		new_fcport->d_id.b24 = nxt_d_id.b24;
	}

J
Jesper Juhl 已提交
3415 3416
	kfree(swl);
	kfree(new_fcport);
L
Linus Torvalds 已提交
3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434

	return (rval);
}

/*
 * qla2x00_find_new_loop_id
 *	Scan through our port list and find a new usable loop ID.
 *
 * Input:
 *	ha:	adapter state pointer.
 *	dev:	port structure pointer.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
3435
int
3436
qla2x00_find_new_loop_id(scsi_qla_host_t *vha, fc_port_t *dev)
L
Linus Torvalds 已提交
3437 3438 3439 3440 3441
{
	int	rval;
	int	found;
	fc_port_t *fcport;
	uint16_t first_loop_id;
3442 3443
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *vp;
3444
	struct scsi_qla_host *tvp;
3445
	unsigned long flags = 0;
L
Linus Torvalds 已提交
3446 3447 3448 3449 3450 3451 3452 3453

	rval = QLA_SUCCESS;

	/* Save starting loop ID. */
	first_loop_id = dev->loop_id;

	for (;;) {
		/* Skip loop ID if already used by adapter. */
3454
		if (dev->loop_id == vha->loop_id)
L
Linus Torvalds 已提交
3455 3456 3457
			dev->loop_id++;

		/* Skip reserved loop IDs. */
3458
		while (qla2x00_is_reserved_id(vha, dev->loop_id))
L
Linus Torvalds 已提交
3459 3460 3461
			dev->loop_id++;

		/* Reset loop ID if passed the end. */
3462
		if (dev->loop_id > ha->max_loop_id) {
L
Linus Torvalds 已提交
3463 3464 3465 3466 3467 3468 3469
			/* first loop ID. */
			dev->loop_id = ha->min_external_loopid;
		}

		/* Check for loop ID being already in use. */
		found = 0;
		fcport = NULL;
3470 3471

		spin_lock_irqsave(&ha->vport_slock, flags);
3472
		list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
3473 3474 3475 3476 3477 3478 3479
			list_for_each_entry(fcport, &vp->vp_fcports, list) {
				if (fcport->loop_id == dev->loop_id &&
								fcport != dev) {
					/* ID possibly in use */
					found++;
					break;
				}
L
Linus Torvalds 已提交
3480
			}
3481 3482
			if (found)
				break;
L
Linus Torvalds 已提交
3483
		}
3484
		spin_unlock_irqrestore(&ha->vport_slock, flags);
L
Linus Torvalds 已提交
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

		/* If not in use then it is free to use. */
		if (!found) {
			break;
		}

		/* ID in use. Try next value. */
		dev->loop_id++;

		/* If wrap around. No free ID to use. */
		if (dev->loop_id == first_loop_id) {
			dev->loop_id = FC_NO_LOOP_ID;
			rval = QLA_FUNCTION_FAILED;
			break;
		}
	}

	return (rval);
}

/*
 * qla2x00_device_resync
 *	Marks devices in the database that needs resynchronization.
 *
 * Input:
 *	ha = adapter block pointer.
 *
 * Context:
 *	Kernel context.
 */
static int
3516
qla2x00_device_resync(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
3517 3518 3519 3520 3521 3522 3523
{
	int	rval;
	uint32_t mask;
	fc_port_t *fcport;
	uint32_t rscn_entry;
	uint8_t rscn_out_iter;
	uint8_t format;
3524
	port_id_t d_id = {};
L
Linus Torvalds 已提交
3525 3526 3527

	rval = QLA_RSCNS_HANDLED;

3528 3529
	while (vha->rscn_out_ptr != vha->rscn_in_ptr ||
	    vha->flags.rscn_queue_overflow) {
L
Linus Torvalds 已提交
3530

3531
		rscn_entry = vha->rscn_queue[vha->rscn_out_ptr];
L
Linus Torvalds 已提交
3532 3533 3534 3535 3536
		format = MSB(MSW(rscn_entry));
		d_id.b.domain = LSB(MSW(rscn_entry));
		d_id.b.area = MSB(LSW(rscn_entry));
		d_id.b.al_pa = LSB(LSW(rscn_entry));

3537 3538 3539 3540
		ql_dbg(ql_dbg_disc, vha, 0x2020,
		    "RSCN queue entry[%d] = [%02x/%02x%02x%02x].\n",
		    vha->rscn_out_ptr, format, d_id.b.domain, d_id.b.area,
		    d_id.b.al_pa);
L
Linus Torvalds 已提交
3541

3542 3543 3544
		vha->rscn_out_ptr++;
		if (vha->rscn_out_ptr == MAX_RSCN_COUNT)
			vha->rscn_out_ptr = 0;
L
Linus Torvalds 已提交
3545 3546

		/* Skip duplicate entries. */
3547 3548 3549
		for (rscn_out_iter = vha->rscn_out_ptr;
		    !vha->flags.rscn_queue_overflow &&
		    rscn_out_iter != vha->rscn_in_ptr;
L
Linus Torvalds 已提交
3550 3551 3552
		    rscn_out_iter = (rscn_out_iter ==
			(MAX_RSCN_COUNT - 1)) ? 0: rscn_out_iter + 1) {

3553
			if (rscn_entry != vha->rscn_queue[rscn_out_iter])
L
Linus Torvalds 已提交
3554 3555
				break;

3556 3557 3558
			ql_dbg(ql_dbg_disc, vha, 0x2021,
			    "Skipping duplicate RSCN queue entry found at "
			    "[%d].\n", rscn_out_iter);
L
Linus Torvalds 已提交
3559

3560
			vha->rscn_out_ptr = rscn_out_iter;
L
Linus Torvalds 已提交
3561 3562 3563
		}

		/* Queue overflow, set switch default case. */
3564
		if (vha->flags.rscn_queue_overflow) {
3565 3566
			ql_dbg(ql_dbg_disc, vha, 0x2022,
			    "device_resync: rscn overflow.\n");
L
Linus Torvalds 已提交
3567 3568

			format = 3;
3569
			vha->flags.rscn_queue_overflow = 0;
L
Linus Torvalds 已提交
3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584
		}

		switch (format) {
		case 0:
			mask = 0xffffff;
			break;
		case 1:
			mask = 0xffff00;
			break;
		case 2:
			mask = 0xff0000;
			break;
		default:
			mask = 0x0;
			d_id.b24 = 0;
3585
			vha->rscn_out_ptr = vha->rscn_in_ptr;
L
Linus Torvalds 已提交
3586 3587 3588 3589 3590
			break;
		}

		rval = QLA_SUCCESS;

3591
		list_for_each_entry(fcport, &vha->vp_fcports, list) {
L
Linus Torvalds 已提交
3592 3593 3594 3595 3596 3597 3598 3599
			if ((fcport->flags & FCF_FABRIC_DEVICE) == 0 ||
			    (fcport->d_id.b24 & mask) != d_id.b24 ||
			    fcport->port_type == FCT_BROADCAST)
				continue;

			if (atomic_read(&fcport->state) == FCS_ONLINE) {
				if (format != 3 ||
				    fcport->port_type != FCT_INITIATOR) {
3600
					qla2x00_mark_device_lost(vha, fcport,
3601
					    0, 0);
L
Linus Torvalds 已提交
3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625
				}
			}
		}
	}
	return (rval);
}

/*
 * qla2x00_fabric_dev_login
 *	Login fabric target device and update FC port database.
 *
 * Input:
 *	ha:		adapter state pointer.
 *	fcport:		port structure list pointer.
 *	next_loopid:	contains value of a new loop ID that can be used
 *			by the next login attempt.
 *
 * Returns:
 *	qla2x00 local function return status code.
 *
 * Context:
 *	Kernel context.
 */
static int
3626
qla2x00_fabric_dev_login(scsi_qla_host_t *vha, fc_port_t *fcport,
L
Linus Torvalds 已提交
3627 3628 3629 3630
    uint16_t *next_loopid)
{
	int	rval;
	int	retry;
3631
	uint8_t opts;
3632
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
3633 3634 3635 3636

	rval = QLA_SUCCESS;
	retry = 0;

3637
	if (IS_ALOGIO_CAPABLE(ha)) {
3638 3639 3640
		if (fcport->flags & FCF_ASYNC_SENT)
			return rval;
		fcport->flags |= FCF_ASYNC_SENT;
3641 3642 3643 3644 3645
		rval = qla2x00_post_async_login_work(vha, fcport, NULL);
		if (!rval)
			return rval;
	}

3646
	fcport->flags &= ~FCF_ASYNC_SENT;
3647
	rval = qla2x00_fabric_login(vha, fcport, next_loopid);
L
Linus Torvalds 已提交
3648
	if (rval == QLA_SUCCESS) {
3649
		/* Send an ADISC to FCP2 devices.*/
3650
		opts = 0;
3651
		if (fcport->flags & FCF_FCP2_DEVICE)
3652
			opts |= BIT_1;
3653
		rval = qla2x00_get_port_database(vha, fcport, opts);
L
Linus Torvalds 已提交
3654
		if (rval != QLA_SUCCESS) {
3655
			ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3656 3657
			    fcport->d_id.b.domain, fcport->d_id.b.area,
			    fcport->d_id.b.al_pa);
3658
			qla2x00_mark_device_lost(vha, fcport, 1, 0);
L
Linus Torvalds 已提交
3659
		} else {
3660
			qla2x00_update_fcport(vha, fcport);
L
Linus Torvalds 已提交
3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681
		}
	}

	return (rval);
}

/*
 * qla2x00_fabric_login
 *	Issue fabric login command.
 *
 * Input:
 *	ha = adapter block pointer.
 *	device = pointer to FC device type structure.
 *
 * Returns:
 *      0 - Login successfully
 *      1 - Login failed
 *      2 - Initiator device
 *      3 - Fatal error
 */
int
3682
qla2x00_fabric_login(scsi_qla_host_t *vha, fc_port_t *fcport,
L
Linus Torvalds 已提交
3683 3684 3685 3686 3687 3688
    uint16_t *next_loopid)
{
	int	rval;
	int	retry;
	uint16_t tmp_loopid;
	uint16_t mb[MAILBOX_REGISTER_COUNT];
3689
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
3690 3691 3692 3693 3694

	retry = 0;
	tmp_loopid = 0;

	for (;;) {
3695 3696 3697 3698 3699
		ql_dbg(ql_dbg_disc, vha, 0x2000,
		    "Trying Fabric Login w/loop id 0x%04x for port "
		    "%02x%02x%02x.\n",
		    fcport->loop_id, fcport->d_id.b.domain,
		    fcport->d_id.b.area, fcport->d_id.b.al_pa);
L
Linus Torvalds 已提交
3700 3701

		/* Login fcport on switch. */
3702
		ha->isp_ops->fabric_login(vha, fcport->loop_id,
L
Linus Torvalds 已提交
3703 3704 3705 3706 3707
		    fcport->d_id.b.domain, fcport->d_id.b.area,
		    fcport->d_id.b.al_pa, mb, BIT_0);
		if (mb[0] == MBS_PORT_ID_USED) {
			/*
			 * Device has another loop ID.  The firmware team
3708 3709 3710 3711
			 * recommends the driver perform an implicit login with
			 * the specified ID again. The ID we just used is save
			 * here so we return with an ID that can be tried by
			 * the next login.
L
Linus Torvalds 已提交
3712 3713 3714 3715 3716
			 */
			retry++;
			tmp_loopid = fcport->loop_id;
			fcport->loop_id = mb[1];

3717 3718 3719
			ql_dbg(ql_dbg_disc, vha, 0x2001,
			    "Fabric Login: port in use - next loop "
			    "id=0x%04x, port id= %02x%02x%02x.\n",
L
Linus Torvalds 已提交
3720
			    fcport->loop_id, fcport->d_id.b.domain,
3721
			    fcport->d_id.b.area, fcport->d_id.b.al_pa);
L
Linus Torvalds 已提交
3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742

		} else if (mb[0] == MBS_COMMAND_COMPLETE) {
			/*
			 * Login succeeded.
			 */
			if (retry) {
				/* A retry occurred before. */
				*next_loopid = tmp_loopid;
			} else {
				/*
				 * No retry occurred before. Just increment the
				 * ID value for next login.
				 */
				*next_loopid = (fcport->loop_id + 1);
			}

			if (mb[1] & BIT_0) {
				fcport->port_type = FCT_INITIATOR;
			} else {
				fcport->port_type = FCT_TARGET;
				if (mb[1] & BIT_1) {
3743
					fcport->flags |= FCF_FCP2_DEVICE;
L
Linus Torvalds 已提交
3744 3745 3746
				}
			}

3747 3748 3749 3750 3751
			if (mb[10] & BIT_0)
				fcport->supported_classes |= FC_COS_CLASS2;
			if (mb[10] & BIT_1)
				fcport->supported_classes |= FC_COS_CLASS3;

L
Linus Torvalds 已提交
3752 3753 3754 3755 3756 3757 3758
			rval = QLA_SUCCESS;
			break;
		} else if (mb[0] == MBS_LOOP_ID_USED) {
			/*
			 * Loop ID already used, try next loop ID.
			 */
			fcport->loop_id++;
3759
			rval = qla2x00_find_new_loop_id(vha, fcport);
L
Linus Torvalds 已提交
3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770
			if (rval != QLA_SUCCESS) {
				/* Ran out of loop IDs to use */
				break;
			}
		} else if (mb[0] == MBS_COMMAND_ERROR) {
			/*
			 * Firmware possibly timed out during login. If NO
			 * retries are left to do then the device is declared
			 * dead.
			 */
			*next_loopid = fcport->loop_id;
3771
			ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3772 3773
			    fcport->d_id.b.domain, fcport->d_id.b.area,
			    fcport->d_id.b.al_pa);
3774
			qla2x00_mark_device_lost(vha, fcport, 1, 0);
L
Linus Torvalds 已提交
3775 3776 3777 3778 3779 3780 3781

			rval = 1;
			break;
		} else {
			/*
			 * unrecoverable / not handled error
			 */
3782 3783 3784 3785 3786
			ql_dbg(ql_dbg_disc, vha, 0x2002,
			    "Failed=%x port_id=%02x%02x%02x loop_id=%x "
			    "jiffies=%lx.\n", mb[0], fcport->d_id.b.domain,
			    fcport->d_id.b.area, fcport->d_id.b.al_pa,
			    fcport->loop_id, jiffies);
L
Linus Torvalds 已提交
3787 3788

			*next_loopid = fcport->loop_id;
3789
			ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3790 3791
			    fcport->d_id.b.domain, fcport->d_id.b.area,
			    fcport->d_id.b.al_pa);
L
Linus Torvalds 已提交
3792
			fcport->loop_id = FC_NO_LOOP_ID;
3793
			fcport->login_retry = 0;
L
Linus Torvalds 已提交
3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816

			rval = 3;
			break;
		}
	}

	return (rval);
}

/*
 * qla2x00_local_device_login
 *	Issue local device login command.
 *
 * Input:
 *	ha = adapter block pointer.
 *	loop_id = loop id of device to login to.
 *
 * Returns (Where's the #define!!!!):
 *      0 - Login successfully
 *      1 - Login failed
 *      3 - Fatal error
 */
int
3817
qla2x00_local_device_login(scsi_qla_host_t *vha, fc_port_t *fcport)
L
Linus Torvalds 已提交
3818 3819 3820 3821 3822
{
	int		rval;
	uint16_t	mb[MAILBOX_REGISTER_COUNT];

	memset(mb, 0, sizeof(mb));
3823
	rval = qla2x00_login_local_device(vha, fcport, mb, BIT_0);
L
Linus Torvalds 已提交
3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846
	if (rval == QLA_SUCCESS) {
		/* Interrogate mailbox registers for any errors */
		if (mb[0] == MBS_COMMAND_ERROR)
			rval = 1;
		else if (mb[0] == MBS_COMMAND_PARAMETER_ERROR)
			/* device not in PCB table */
			rval = 3;
	}

	return (rval);
}

/*
 *  qla2x00_loop_resync
 *      Resync with fibre channel devices.
 *
 * Input:
 *      ha = adapter block pointer.
 *
 * Returns:
 *      0 = success
 */
int
3847
qla2x00_loop_resync(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
3848
{
3849
	int rval = QLA_SUCCESS;
L
Linus Torvalds 已提交
3850
	uint32_t wait_time;
3851 3852 3853
	struct req_que *req;
	struct rsp_que *rsp;

3854
	if (vha->hw->flags.cpu_affinity_enabled)
3855 3856 3857 3858
		req = vha->hw->req_q_map[0];
	else
		req = vha->req;
	rsp = req->rsp;
L
Linus Torvalds 已提交
3859

3860 3861 3862
	clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
	if (vha->flags.online) {
		if (!(rval = qla2x00_fw_ready(vha))) {
L
Linus Torvalds 已提交
3863 3864 3865
			/* Wait at most MAX_TARGET RSCNs for a stable link. */
			wait_time = 256;
			do {
3866
				/* Issue a marker after FW becomes ready. */
3867 3868
				qla2x00_marker(vha, req, rsp, 0, 0,
					MK_SYNC_ALL);
3869
				vha->marker_needed = 0;
L
Linus Torvalds 已提交
3870 3871

				/* Remap devices on Loop. */
3872
				clear_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
3873

3874
				qla2x00_configure_loop(vha);
L
Linus Torvalds 已提交
3875
				wait_time--;
3876 3877 3878 3879
			} while (!atomic_read(&vha->loop_down_timer) &&
				!(test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
				&& wait_time && (test_bit(LOOP_RESYNC_NEEDED,
				&vha->dpc_flags)));
L
Linus Torvalds 已提交
3880 3881 3882
		}
	}

3883
	if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
L
Linus Torvalds 已提交
3884 3885
		return (QLA_FUNCTION_FAILED);

3886
	if (rval)
3887 3888
		ql_dbg(ql_dbg_disc, vha, 0x206c,
		    "%s *** FAILED ***.\n", __func__);
L
Linus Torvalds 已提交
3889 3890 3891 3892

	return (rval);
}

3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923
/*
* qla2x00_perform_loop_resync
* Description: This function will set the appropriate flags and call
*              qla2x00_loop_resync. If successful loop will be resynced
* Arguments : scsi_qla_host_t pointer
* returm    : Success or Failure
*/

int qla2x00_perform_loop_resync(scsi_qla_host_t *ha)
{
	int32_t rval = 0;

	if (!test_and_set_bit(LOOP_RESYNC_ACTIVE, &ha->dpc_flags)) {
		/*Configure the flags so that resync happens properly*/
		atomic_set(&ha->loop_down_timer, 0);
		if (!(ha->device_flags & DFLG_NO_CABLE)) {
			atomic_set(&ha->loop_state, LOOP_UP);
			set_bit(LOCAL_LOOP_UPDATE, &ha->dpc_flags);
			set_bit(REGISTER_FC4_NEEDED, &ha->dpc_flags);
			set_bit(LOOP_RESYNC_NEEDED, &ha->dpc_flags);

			rval = qla2x00_loop_resync(ha);
		} else
			atomic_set(&ha->loop_state, LOOP_DEAD);

		clear_bit(LOOP_RESYNC_ACTIVE, &ha->dpc_flags);
	}

	return rval;
}

3924
void
3925
qla2x00_update_fcports(scsi_qla_host_t *base_vha)
3926 3927
{
	fc_port_t *fcport;
3928 3929 3930
	struct scsi_qla_host *vha;
	struct qla_hw_data *ha = base_vha->hw;
	unsigned long flags;
3931

3932
	spin_lock_irqsave(&ha->vport_slock, flags);
3933
	/* Go with deferred removal of rport references. */
3934 3935 3936
	list_for_each_entry(vha, &base_vha->hw->vp_list, list) {
		atomic_inc(&vha->vref_count);
		list_for_each_entry(fcport, &vha->vp_fcports, list) {
3937
			if (fcport->drport &&
3938 3939 3940
			    atomic_read(&fcport->state) != FCS_UNCONFIGURED) {
				spin_unlock_irqrestore(&ha->vport_slock, flags);

3941
				qla2x00_rport_del(fcport);
3942 3943 3944 3945 3946 3947 3948

				spin_lock_irqsave(&ha->vport_slock, flags);
			}
		}
		atomic_dec(&vha->vref_count);
	}
	spin_unlock_irqrestore(&ha->vport_slock, flags);
3949 3950
}

3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964
/*
* qla82xx_quiescent_state_cleanup
* Description: This function will block the new I/Os
*              Its not aborting any I/Os as context
*              is not destroyed during quiescence
* Arguments: scsi_qla_host_t
* return   : void
*/
void
qla82xx_quiescent_state_cleanup(scsi_qla_host_t *vha)
{
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *vp;

3965 3966
	ql_dbg(ql_dbg_p3p, vha, 0xb002,
	    "Performing ISP error recovery - ha=%p.\n", ha);
3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982

	atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
	if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
		atomic_set(&vha->loop_state, LOOP_DOWN);
		qla2x00_mark_all_devices_lost(vha, 0);
		list_for_each_entry(vp, &ha->vp_list, list)
			qla2x00_mark_all_devices_lost(vha, 0);
	} else {
		if (!atomic_read(&vha->loop_down_timer))
			atomic_set(&vha->loop_down_timer,
					LOOP_DOWN_TIME);
	}
	/* Wait for pending cmds to complete */
	qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST);
}

3983 3984 3985 3986
void
qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
{
	struct qla_hw_data *ha = vha->hw;
3987
	struct scsi_qla_host *vp;
3988
	unsigned long flags;
3989
	fc_port_t *fcport;
3990

3991 3992 3993 3994 3995
	/* For ISP82XX, driver waits for completion of the commands.
	 * online flag should be set.
	 */
	if (!IS_QLA82XX(ha))
		vha->flags.online = 0;
3996 3997 3998 3999
	ha->flags.chip_reset_done = 0;
	clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
	ha->qla_stats.total_isp_aborts++;

4000 4001
	ql_log(ql_log_info, vha, 0x00af,
	    "Performing ISP error recovery - ha=%p.\n", ha);
4002

4003 4004 4005 4006
	/* For ISP82XX, reset_chip is just disabling interrupts.
	 * Driver waits for the completion of the commands.
	 * the interrupts need to be enabled.
	 */
4007 4008 4009 4010 4011 4012 4013
	if (!IS_QLA82XX(ha))
		ha->isp_ops->reset_chip(vha);

	atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
	if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
		atomic_set(&vha->loop_state, LOOP_DOWN);
		qla2x00_mark_all_devices_lost(vha, 0);
4014 4015

		spin_lock_irqsave(&ha->vport_slock, flags);
4016
		list_for_each_entry(vp, &ha->vp_list, list) {
4017 4018 4019
			atomic_inc(&vp->vref_count);
			spin_unlock_irqrestore(&ha->vport_slock, flags);

4020
			qla2x00_mark_all_devices_lost(vp, 0);
4021 4022 4023 4024 4025

			spin_lock_irqsave(&ha->vport_slock, flags);
			atomic_dec(&vp->vref_count);
		}
		spin_unlock_irqrestore(&ha->vport_slock, flags);
4026 4027 4028 4029 4030 4031
	} else {
		if (!atomic_read(&vha->loop_down_timer))
			atomic_set(&vha->loop_down_timer,
			    LOOP_DOWN_TIME);
	}

4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047
	/* Clear all async request states across all VPs. */
	list_for_each_entry(fcport, &vha->vp_fcports, list)
		fcport->flags &= ~(FCF_LOGIN_NEEDED | FCF_ASYNC_SENT);
	spin_lock_irqsave(&ha->vport_slock, flags);
	list_for_each_entry(vp, &ha->vp_list, list) {
		atomic_inc(&vp->vref_count);
		spin_unlock_irqrestore(&ha->vport_slock, flags);

		list_for_each_entry(fcport, &vp->vp_fcports, list)
			fcport->flags &= ~(FCF_LOGIN_NEEDED | FCF_ASYNC_SENT);

		spin_lock_irqsave(&ha->vport_slock, flags);
		atomic_dec(&vp->vref_count);
	}
	spin_unlock_irqrestore(&ha->vport_slock, flags);

4048 4049 4050
	if (!ha->flags.eeh_busy) {
		/* Make sure for ISP 82XX IO DMA is complete */
		if (IS_QLA82XX(ha)) {
4051
			qla82xx_chip_reset_cleanup(vha);
4052 4053
			ql_log(ql_log_info, vha, 0x00b4,
			    "Done chip reset cleanup.\n");
4054

4055 4056 4057 4058
			/* Done waiting for pending commands.
			 * Reset the online flag.
			 */
			vha->flags.online = 0;
4059
		}
4060

4061 4062 4063
		/* Requeue all commands in outstanding command list. */
		qla2x00_abort_all_cmds(vha, DID_RESET << 16);
	}
4064 4065
}

L
Linus Torvalds 已提交
4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076
/*
*  qla2x00_abort_isp
*      Resets ISP and aborts all outstanding commands.
*
* Input:
*      ha           = adapter block pointer.
*
* Returns:
*      0 = success
*/
int
4077
qla2x00_abort_isp(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
4078
{
4079
	int rval;
L
Linus Torvalds 已提交
4080
	uint8_t        status = 0;
4081 4082
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *vp;
4083
	struct req_que *req = ha->req_q_map[0];
4084
	unsigned long flags;
L
Linus Torvalds 已提交
4085

4086
	if (vha->flags.online) {
4087
		qla2x00_abort_isp_cleanup(vha);
L
Linus Torvalds 已提交
4088

4089 4090 4091 4092 4093 4094 4095
		if (unlikely(pci_channel_offline(ha->pdev) &&
		    ha->flags.pci_channel_io_perm_failure)) {
			clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
			status = 0;
			return status;
		}

4096
		ha->isp_ops->get_flash_version(vha, req->ring);
4097

4098
		ha->isp_ops->nvram_config(vha);
L
Linus Torvalds 已提交
4099

4100 4101
		if (!qla2x00_restart_isp(vha)) {
			clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
4102

4103
			if (!atomic_read(&vha->loop_down_timer)) {
L
Linus Torvalds 已提交
4104 4105 4106 4107
				/*
				 * Issue marker command only when we are going
				 * to start the I/O .
				 */
4108
				vha->marker_needed = 1;
L
Linus Torvalds 已提交
4109 4110
			}

4111
			vha->flags.online = 1;
L
Linus Torvalds 已提交
4112

4113
			ha->isp_ops->enable_intrs(ha);
L
Linus Torvalds 已提交
4114

A
Andrew Vasquez 已提交
4115
			ha->isp_abort_cnt = 0;
4116
			clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
4117

4118 4119
			if (IS_QLA81XX(ha) || IS_QLA8031(ha))
				qla2x00_get_fw_version(vha);
4120 4121 4122 4123
			if (ha->fce) {
				ha->flags.fce_enabled = 1;
				memset(ha->fce, 0,
				    fce_calc_size(ha->fce_bufs));
4124
				rval = qla2x00_enable_fce_trace(vha,
4125 4126 4127
				    ha->fce_dma, ha->fce_bufs, ha->fce_mb,
				    &ha->fce_bufs);
				if (rval) {
4128
					ql_log(ql_log_warn, vha, 0x8033,
4129 4130 4131 4132 4133
					    "Unable to reinitialize FCE "
					    "(%d).\n", rval);
					ha->flags.fce_enabled = 0;
				}
			}
4134 4135 4136

			if (ha->eft) {
				memset(ha->eft, 0, EFT_SIZE);
4137
				rval = qla2x00_enable_eft_trace(vha,
4138 4139
				    ha->eft_dma, EFT_NUM_BUFFERS);
				if (rval) {
4140
					ql_log(ql_log_warn, vha, 0x8034,
4141 4142 4143 4144
					    "Unable to reinitialize EFT "
					    "(%d).\n", rval);
				}
			}
L
Linus Torvalds 已提交
4145
		} else {	/* failed the ISP abort */
4146 4147
			vha->flags.online = 1;
			if (test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
L
Linus Torvalds 已提交
4148
				if (ha->isp_abort_cnt == 0) {
4149 4150 4151
					ql_log(ql_log_fatal, vha, 0x8035,
					    "ISP error recover failed - "
					    "board disabled.\n");
A
Andrew Vasquez 已提交
4152
					/*
L
Linus Torvalds 已提交
4153 4154 4155
					 * The next call disables the board
					 * completely.
					 */
4156 4157
					ha->isp_ops->reset_adapter(vha);
					vha->flags.online = 0;
L
Linus Torvalds 已提交
4158
					clear_bit(ISP_ABORT_RETRY,
4159
					    &vha->dpc_flags);
L
Linus Torvalds 已提交
4160 4161 4162
					status = 0;
				} else { /* schedule another ISP abort */
					ha->isp_abort_cnt--;
4163 4164 4165
					ql_dbg(ql_dbg_taskm, vha, 0x8020,
					    "ISP abort - retry remaining %d.\n",
					    ha->isp_abort_cnt);
L
Linus Torvalds 已提交
4166 4167 4168 4169
					status = 1;
				}
			} else {
				ha->isp_abort_cnt = MAX_RETRIES_OF_ISP_ABORT;
4170 4171 4172
				ql_dbg(ql_dbg_taskm, vha, 0x8021,
				    "ISP error recovery - retrying (%d) "
				    "more times.\n", ha->isp_abort_cnt);
4173
				set_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
L
Linus Torvalds 已提交
4174 4175 4176
				status = 1;
			}
		}
A
Andrew Vasquez 已提交
4177

L
Linus Torvalds 已提交
4178 4179
	}

4180
	if (!status) {
4181
		ql_dbg(ql_dbg_taskm, vha, 0x8022, "%s succeeded.\n", __func__);
4182 4183 4184 4185 4186 4187 4188

		spin_lock_irqsave(&ha->vport_slock, flags);
		list_for_each_entry(vp, &ha->vp_list, list) {
			if (vp->vp_idx) {
				atomic_inc(&vp->vref_count);
				spin_unlock_irqrestore(&ha->vport_slock, flags);

4189
				qla2x00_vp_abort_isp(vp);
4190 4191 4192 4193

				spin_lock_irqsave(&ha->vport_slock, flags);
				atomic_dec(&vp->vref_count);
			}
4194
		}
4195 4196
		spin_unlock_irqrestore(&ha->vport_slock, flags);

4197
	} else {
4198 4199
		ql_log(ql_log_warn, vha, 0x8023, "%s **** FAILED ****.\n",
		       __func__);
L
Linus Torvalds 已提交
4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215
	}

	return(status);
}

/*
*  qla2x00_restart_isp
*      restarts the ISP after a reset
*
* Input:
*      ha = adapter block pointer.
*
* Returns:
*      0 = success
*/
static int
4216
qla2x00_restart_isp(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
4217
{
4218
	int status = 0;
L
Linus Torvalds 已提交
4219
	uint32_t wait_time;
4220
	struct qla_hw_data *ha = vha->hw;
4221 4222
	struct req_que *req = ha->req_q_map[0];
	struct rsp_que *rsp = ha->rsp_q_map[0];
L
Linus Torvalds 已提交
4223 4224

	/* If firmware needs to be loaded */
4225 4226 4227 4228 4229
	if (qla2x00_isp_firmware(vha)) {
		vha->flags.online = 0;
		status = ha->isp_ops->chip_diag(vha);
		if (!status)
			status = qla2x00_setup_chip(vha);
L
Linus Torvalds 已提交
4230 4231
	}

4232 4233
	if (!status && !(status = qla2x00_init_rings(vha))) {
		clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
4234
		ha->flags.chip_reset_done = 1;
4235 4236 4237
		/* Initialize the queues in use */
		qla25xx_init_queues(ha);

4238 4239
		status = qla2x00_fw_ready(vha);
		if (!status) {
4240 4241
			ql_dbg(ql_dbg_taskm, vha, 0x8031,
			    "Start configure loop status = %d.\n", status);
4242 4243

			/* Issue a marker after FW becomes ready. */
4244
			qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL);
4245

4246
			vha->flags.online = 1;
L
Linus Torvalds 已提交
4247 4248 4249
			/* Wait at most MAX_TARGET RSCNs for a stable link. */
			wait_time = 256;
			do {
4250 4251
				clear_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
				qla2x00_configure_loop(vha);
L
Linus Torvalds 已提交
4252
				wait_time--;
4253 4254 4255 4256
			} while (!atomic_read(&vha->loop_down_timer) &&
				!(test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
				&& wait_time && (test_bit(LOOP_RESYNC_NEEDED,
				&vha->dpc_flags)));
L
Linus Torvalds 已提交
4257 4258 4259
		}

		/* if no cable then assume it's good */
4260
		if ((vha->device_flags & DFLG_NO_CABLE))
L
Linus Torvalds 已提交
4261 4262
			status = 0;

4263 4264
		ql_dbg(ql_dbg_taskm, vha, 0x8032,
		    "Configure loop done, status = 0x%x.\n", status);
L
Linus Torvalds 已提交
4265 4266 4267 4268
	}
	return (status);
}

4269 4270 4271 4272 4273 4274 4275 4276 4277
static int
qla25xx_init_queues(struct qla_hw_data *ha)
{
	struct rsp_que *rsp = NULL;
	struct req_que *req = NULL;
	struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
	int ret = -1;
	int i;

4278
	for (i = 1; i < ha->max_rsp_queues; i++) {
4279 4280 4281
		rsp = ha->rsp_q_map[i];
		if (rsp) {
			rsp->options &= ~BIT_0;
4282
			ret = qla25xx_init_rsp_que(base_vha, rsp);
4283
			if (ret != QLA_SUCCESS)
4284 4285 4286
				ql_dbg(ql_dbg_init, base_vha, 0x00ff,
				    "%s Rsp que: %d init failed.\n",
				    __func__, rsp->id);
4287
			else
4288 4289 4290
				ql_dbg(ql_dbg_init, base_vha, 0x0100,
				    "%s Rsp que: %d inited.\n",
				    __func__, rsp->id);
4291
		}
4292 4293
	}
	for (i = 1; i < ha->max_req_queues; i++) {
4294 4295
		req = ha->req_q_map[i];
		if (req) {
4296
		/* Clear outstanding commands array. */
4297
			req->options &= ~BIT_0;
4298
			ret = qla25xx_init_req_que(base_vha, req);
4299
			if (ret != QLA_SUCCESS)
4300 4301 4302
				ql_dbg(ql_dbg_init, base_vha, 0x0101,
				    "%s Req que: %d init failed.\n",
				    __func__, req->id);
4303
			else
4304 4305 4306
				ql_dbg(ql_dbg_init, base_vha, 0x0102,
				    "%s Req que: %d inited.\n",
				    __func__, req->id);
4307 4308 4309 4310 4311
		}
	}
	return ret;
}

L
Linus Torvalds 已提交
4312 4313 4314 4315 4316 4317 4318
/*
* qla2x00_reset_adapter
*      Reset adapter.
*
* Input:
*      ha = adapter block pointer.
*/
4319
void
4320
qla2x00_reset_adapter(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
4321 4322
{
	unsigned long flags = 0;
4323
	struct qla_hw_data *ha = vha->hw;
4324
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
4325

4326
	vha->flags.online = 0;
4327
	ha->isp_ops->disable_intrs(ha);
L
Linus Torvalds 已提交
4328 4329 4330 4331 4332 4333 4334 4335

	spin_lock_irqsave(&ha->hardware_lock, flags);
	WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
	RD_REG_WORD(&reg->hccr);			/* PCI Posting. */
	WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
	RD_REG_WORD(&reg->hccr);			/* PCI Posting. */
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
}
4336 4337

void
4338
qla24xx_reset_adapter(scsi_qla_host_t *vha)
4339 4340
{
	unsigned long flags = 0;
4341
	struct qla_hw_data *ha = vha->hw;
4342 4343
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

4344 4345 4346
	if (IS_QLA82XX(ha))
		return;

4347
	vha->flags.online = 0;
4348
	ha->isp_ops->disable_intrs(ha);
4349 4350 4351 4352 4353 4354 4355

	spin_lock_irqsave(&ha->hardware_lock, flags);
	WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_RESET);
	RD_REG_DWORD(&reg->hccr);
	WRT_REG_DWORD(&reg->hccr, HCCRX_REL_RISC_PAUSE);
	RD_REG_DWORD(&reg->hccr);
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
4356 4357 4358

	if (IS_NOPOLLING_TYPE(ha))
		ha->isp_ops->enable_intrs(ha);
4359 4360
}

4361 4362 4363
/* On sparc systems, obtain port and node WWN from firmware
 * properties.
 */
4364 4365
static void qla24xx_nvram_wwn_from_ofw(scsi_qla_host_t *vha,
	struct nvram_24xx *nv)
4366 4367
{
#ifdef CONFIG_SPARC
4368
	struct qla_hw_data *ha = vha->hw;
4369
	struct pci_dev *pdev = ha->pdev;
D
David S. Miller 已提交
4370 4371
	struct device_node *dp = pci_device_to_OF_node(pdev);
	const u8 *val;
4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383
	int len;

	val = of_get_property(dp, "port-wwn", &len);
	if (val && len >= WWN_SIZE)
		memcpy(nv->port_name, val, WWN_SIZE);

	val = of_get_property(dp, "node-wwn", &len);
	if (val && len >= WWN_SIZE)
		memcpy(nv->node_name, val, WWN_SIZE);
#endif
}

4384
int
4385
qla24xx_nvram_config(scsi_qla_host_t *vha)
4386
{
4387
	int   rval;
4388 4389 4390 4391 4392 4393
	struct init_cb_24xx *icb;
	struct nvram_24xx *nv;
	uint32_t *dptr;
	uint8_t  *dptr1, *dptr2;
	uint32_t chksum;
	uint16_t cnt;
4394
	struct qla_hw_data *ha = vha->hw;
4395

4396
	rval = QLA_SUCCESS;
4397
	icb = (struct init_cb_24xx *)ha->init_cb;
4398
	nv = ha->nvram;
4399 4400

	/* Determine NVRAM starting address. */
4401 4402 4403 4404
	if (ha->flags.port0) {
		ha->nvram_base = FA_NVRAM_FUNC0_ADDR;
		ha->vpd_base = FA_NVRAM_VPD0_ADDR;
	} else {
4405
		ha->nvram_base = FA_NVRAM_FUNC1_ADDR;
4406 4407
		ha->vpd_base = FA_NVRAM_VPD1_ADDR;
	}
4408 4409
	ha->nvram_size = sizeof(struct nvram_24xx);
	ha->vpd_size = FA_NVRAM_VPD_SIZE;
4410 4411
	if (IS_QLA82XX(ha))
		ha->vpd_size = FA_VPD_SIZE_82XX;
4412

4413 4414
	/* Get VPD data into cache */
	ha->vpd = ha->nvram + VPD_OFFSET;
4415
	ha->isp_ops->read_nvram(vha, (uint8_t *)ha->vpd,
4416 4417 4418
	    ha->nvram_base - FA_NVRAM_FUNC0_ADDR, FA_NVRAM_VPD_SIZE * 4);

	/* Get NVRAM data into cache and calculate checksum. */
4419
	dptr = (uint32_t *)nv;
4420
	ha->isp_ops->read_nvram(vha, (uint8_t *)dptr, ha->nvram_base,
4421 4422 4423 4424
	    ha->nvram_size);
	for (cnt = 0, chksum = 0; cnt < ha->nvram_size >> 2; cnt++)
		chksum += le32_to_cpu(*dptr++);

4425 4426 4427 4428
	ql_dbg(ql_dbg_init + ql_dbg_buffer, vha, 0x006a,
	    "Contents of NVRAM\n");
	ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x010d,
	    (uint8_t *)nv, ha->nvram_size);
4429 4430 4431 4432 4433 4434

	/* Bad NVRAM data, set defaults parameters. */
	if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' || nv->id[2] != 'P'
	    || nv->id[3] != ' ' ||
	    nv->nvram_version < __constant_cpu_to_le16(ICB_VERSION)) {
		/* Reset NVRAM data. */
4435 4436 4437 4438 4439 4440
		ql_log(ql_log_warn, vha, 0x006b,
		    "Inconisistent NVRAM detected: checksum=0x%x id=%c "
		    "version=0x%x.\n", chksum, nv->id[0], nv->nvram_version);
		ql_log(ql_log_warn, vha, 0x006c,
		    "Falling back to functioning (yet invalid -- WWPN) "
		    "defaults.\n");
4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452

		/*
		 * Set default initialization control block.
		 */
		memset(nv, 0, ha->nvram_size);
		nv->nvram_version = __constant_cpu_to_le16(ICB_VERSION);
		nv->version = __constant_cpu_to_le16(ICB_VERSION);
		nv->frame_payload_size = __constant_cpu_to_le16(2048);
		nv->execution_throttle = __constant_cpu_to_le16(0xFFFF);
		nv->exchange_count = __constant_cpu_to_le16(0);
		nv->hard_address = __constant_cpu_to_le16(124);
		nv->port_name[0] = 0x21;
4453
		nv->port_name[1] = 0x00 + ha->port_no;
4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467
		nv->port_name[2] = 0x00;
		nv->port_name[3] = 0xe0;
		nv->port_name[4] = 0x8b;
		nv->port_name[5] = 0x1c;
		nv->port_name[6] = 0x55;
		nv->port_name[7] = 0x86;
		nv->node_name[0] = 0x20;
		nv->node_name[1] = 0x00;
		nv->node_name[2] = 0x00;
		nv->node_name[3] = 0xe0;
		nv->node_name[4] = 0x8b;
		nv->node_name[5] = 0x1c;
		nv->node_name[6] = 0x55;
		nv->node_name[7] = 0x86;
4468
		qla24xx_nvram_wwn_from_ofw(vha, nv);
4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484
		nv->login_retry_count = __constant_cpu_to_le16(8);
		nv->interrupt_delay_timer = __constant_cpu_to_le16(0);
		nv->login_timeout = __constant_cpu_to_le16(0);
		nv->firmware_options_1 =
		    __constant_cpu_to_le32(BIT_14|BIT_13|BIT_2|BIT_1);
		nv->firmware_options_2 = __constant_cpu_to_le32(2 << 4);
		nv->firmware_options_2 |= __constant_cpu_to_le32(BIT_12);
		nv->firmware_options_3 = __constant_cpu_to_le32(2 << 13);
		nv->host_p = __constant_cpu_to_le32(BIT_11|BIT_10);
		nv->efi_parameters = __constant_cpu_to_le32(0);
		nv->reset_delay = 5;
		nv->max_luns_per_target = __constant_cpu_to_le16(128);
		nv->port_down_retry_count = __constant_cpu_to_le16(30);
		nv->link_down_timeout = __constant_cpu_to_le16(30);

		rval = 1;
4485 4486 4487
	}

	/* Reset Initialization control block */
4488
	memset(icb, 0, ha->init_cb_size);
4489 4490 4491 4492 4493 4494 4495 4496 4497

	/* Copy 1st segment. */
	dptr1 = (uint8_t *)icb;
	dptr2 = (uint8_t *)&nv->version;
	cnt = (uint8_t *)&icb->response_q_inpointer - (uint8_t *)&icb->version;
	while (cnt--)
		*dptr1++ = *dptr2++;

	icb->login_retry_count = nv->login_retry_count;
4498
	icb->link_down_on_nos = nv->link_down_on_nos;
4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510

	/* Copy 2nd segment. */
	dptr1 = (uint8_t *)&icb->interrupt_delay_timer;
	dptr2 = (uint8_t *)&nv->interrupt_delay_timer;
	cnt = (uint8_t *)&icb->reserved_3 -
	    (uint8_t *)&icb->interrupt_delay_timer;
	while (cnt--)
		*dptr1++ = *dptr2++;

	/*
	 * Setup driver NVRAM options.
	 */
4511
	qla2x00_set_model_info(vha, nv->model_name, sizeof(nv->model_name),
4512
	    "QLA2462");
4513

4514 4515 4516 4517 4518 4519
	/* Use alternate WWN? */
	if (nv->host_p & __constant_cpu_to_le32(BIT_15)) {
		memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
		memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
	}

4520
	/* Prepare nodename */
4521
	if ((icb->firmware_options_1 & __constant_cpu_to_le32(BIT_14)) == 0) {
4522 4523 4524 4525 4526 4527 4528 4529 4530 4531
		/*
		 * Firmware will apply the following mask if the nodename was
		 * not provided.
		 */
		memcpy(icb->node_name, icb->port_name, WWN_SIZE);
		icb->node_name[0] &= 0xF0;
	}

	/* Set host adapter parameters. */
	ha->flags.disable_risc_code_load = 0;
4532 4533 4534 4535 4536
	ha->flags.enable_lip_reset = 0;
	ha->flags.enable_lip_full_login =
	    le32_to_cpu(nv->host_p) & BIT_10 ? 1: 0;
	ha->flags.enable_target_reset =
	    le32_to_cpu(nv->host_p) & BIT_11 ? 1: 0;
4537
	ha->flags.enable_led_scheme = 0;
4538
	ha->flags.disable_serdes = le32_to_cpu(nv->host_p) & BIT_5 ? 1: 0;
4539

4540 4541
	ha->operating_mode = (le32_to_cpu(icb->firmware_options_2) &
	    (BIT_6 | BIT_5 | BIT_4)) >> 4;
4542 4543 4544 4545 4546 4547 4548 4549

	memcpy(ha->fw_seriallink_options24, nv->seriallink_options,
	    sizeof(ha->fw_seriallink_options24));

	/* save HBA serial number */
	ha->serial0 = icb->port_name[5];
	ha->serial1 = icb->port_name[6];
	ha->serial2 = icb->port_name[7];
4550 4551
	memcpy(vha->node_name, icb->node_name, WWN_SIZE);
	memcpy(vha->port_name, icb->port_name, WWN_SIZE);
4552

4553 4554
	icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);

4555 4556 4557 4558 4559 4560 4561 4562
	ha->retry_count = le16_to_cpu(nv->login_retry_count);

	/* Set minimum login_timeout to 4 seconds. */
	if (le16_to_cpu(nv->login_timeout) < ql2xlogintimeout)
		nv->login_timeout = cpu_to_le16(ql2xlogintimeout);
	if (le16_to_cpu(nv->login_timeout) < 4)
		nv->login_timeout = __constant_cpu_to_le16(4);
	ha->login_timeout = le16_to_cpu(nv->login_timeout);
4563
	icb->login_timeout = nv->login_timeout;
4564

4565 4566
	/* Set minimum RATOV to 100 tenths of a second. */
	ha->r_a_tov = 100;
4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604

	ha->loop_reset_delay = nv->reset_delay;

	/* Link Down Timeout = 0:
	 *
	 * 	When Port Down timer expires we will start returning
	 *	I/O's to OS with "DID_NO_CONNECT".
	 *
	 * Link Down Timeout != 0:
	 *
	 *	 The driver waits for the link to come up after link down
	 *	 before returning I/Os to OS with "DID_NO_CONNECT".
	 */
	if (le16_to_cpu(nv->link_down_timeout) == 0) {
		ha->loop_down_abort_time =
		    (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
	} else {
		ha->link_down_timeout =	le16_to_cpu(nv->link_down_timeout);
		ha->loop_down_abort_time =
		    (LOOP_DOWN_TIME - ha->link_down_timeout);
	}

	/* Need enough time to try and get the port back. */
	ha->port_down_retry_count = le16_to_cpu(nv->port_down_retry_count);
	if (qlport_down_retry)
		ha->port_down_retry_count = qlport_down_retry;

	/* Set login_retry_count */
	ha->login_retry_count  = le16_to_cpu(nv->login_retry_count);
	if (ha->port_down_retry_count ==
	    le16_to_cpu(nv->port_down_retry_count) &&
	    ha->port_down_retry_count > 3)
		ha->login_retry_count = ha->port_down_retry_count;
	else if (ha->port_down_retry_count > (int)ha->login_retry_count)
		ha->login_retry_count = ha->port_down_retry_count;
	if (ql2xloginretrycount)
		ha->login_retry_count = ql2xloginretrycount;

4605
	/* Enable ZIO. */
4606
	if (!vha->flags.init_done) {
4607 4608 4609 4610 4611 4612 4613
		ha->zio_mode = le32_to_cpu(icb->firmware_options_2) &
		    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
		ha->zio_timer = le16_to_cpu(icb->interrupt_delay_timer) ?
		    le16_to_cpu(icb->interrupt_delay_timer): 2;
	}
	icb->firmware_options_2 &= __constant_cpu_to_le32(
	    ~(BIT_3 | BIT_2 | BIT_1 | BIT_0));
4614
	vha->flags.process_response_queue = 0;
4615
	if (ha->zio_mode != QLA_ZIO_DISABLED) {
4616 4617
		ha->zio_mode = QLA_ZIO_MODE_6;

4618
		ql_log(ql_log_info, vha, 0x006f,
4619 4620 4621 4622 4623 4624
		    "ZIO mode %d enabled; timer delay (%d us).\n",
		    ha->zio_mode, ha->zio_timer * 100);

		icb->firmware_options_2 |= cpu_to_le32(
		    (uint32_t)ha->zio_mode);
		icb->interrupt_delay_timer = cpu_to_le16(ha->zio_timer);
4625
		vha->flags.process_response_queue = 1;
4626 4627
	}

4628
	if (rval) {
4629 4630
		ql_log(ql_log_warn, vha, 0x0070,
		    "NVRAM configuration failed.\n");
4631 4632
	}
	return (rval);
4633 4634
}

4635
static int
4636 4637
qla24xx_load_risc_flash(scsi_qla_host_t *vha, uint32_t *srisc_addr,
    uint32_t faddr)
4638
{
4639
	int	rval = QLA_SUCCESS;
4640 4641 4642 4643 4644
	int	segments, fragment;
	uint32_t *dcode, dlen;
	uint32_t risc_addr;
	uint32_t risc_size;
	uint32_t i;
4645
	struct qla_hw_data *ha = vha->hw;
4646
	struct req_que *req = ha->req_q_map[0];
4647

4648
	ql_dbg(ql_dbg_init, vha, 0x008b,
4649
	    "FW: Loading firmware from flash (%x).\n", faddr);
4650

4651 4652 4653
	rval = QLA_SUCCESS;

	segments = FA_RISC_CODE_SEGMENTS;
4654
	dcode = (uint32_t *)req->ring;
4655 4656 4657
	*srisc_addr = 0;

	/* Validate firmware image by checking version. */
4658
	qla24xx_read_flash_data(vha, dcode, faddr + 4, 4);
4659 4660 4661 4662 4663 4664
	for (i = 0; i < 4; i++)
		dcode[i] = be32_to_cpu(dcode[i]);
	if ((dcode[0] == 0xffffffff && dcode[1] == 0xffffffff &&
	    dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
	    (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
		dcode[3] == 0)) {
4665 4666 4667 4668 4669 4670
		ql_log(ql_log_fatal, vha, 0x008c,
		    "Unable to verify the integrity of flash firmware "
		    "image.\n");
		ql_log(ql_log_fatal, vha, 0x008d,
		    "Firmware data: %08x %08x %08x %08x.\n",
		    dcode[0], dcode[1], dcode[2], dcode[3]);
4671 4672 4673 4674 4675 4676

		return QLA_FUNCTION_FAILED;
	}

	while (segments && rval == QLA_SUCCESS) {
		/* Read segment's load information. */
4677
		qla24xx_read_flash_data(vha, dcode, faddr, 4);
4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688

		risc_addr = be32_to_cpu(dcode[2]);
		*srisc_addr = *srisc_addr == 0 ? risc_addr : *srisc_addr;
		risc_size = be32_to_cpu(dcode[3]);

		fragment = 0;
		while (risc_size > 0 && rval == QLA_SUCCESS) {
			dlen = (uint32_t)(ha->fw_transfer_size >> 2);
			if (dlen > risc_size)
				dlen = risc_size;

4689 4690 4691 4692
			ql_dbg(ql_dbg_init, vha, 0x008e,
			    "Loading risc segment@ risc addr %x "
			    "number of dwords 0x%x offset 0x%x.\n",
			    risc_addr, dlen, faddr);
4693

4694
			qla24xx_read_flash_data(vha, dcode, faddr, dlen);
4695 4696 4697
			for (i = 0; i < dlen; i++)
				dcode[i] = swab32(dcode[i]);

4698
			rval = qla2x00_load_ram(vha, req->dma, risc_addr,
4699 4700
			    dlen);
			if (rval) {
4701 4702 4703
				ql_log(ql_log_fatal, vha, 0x008f,
				    "Failed to load segment %d of firmware.\n",
				    fragment);
4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721
				break;
			}

			faddr += dlen;
			risc_addr += dlen;
			risc_size -= dlen;
			fragment++;
		}

		/* Next segment. */
		segments--;
	}

	return rval;
}

#define QLA_FW_URL "ftp://ftp.qlogic.com/outgoing/linux/firmware/"

4722
int
4723
qla2x00_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
4724 4725 4726 4727 4728 4729
{
	int	rval;
	int	i, fragment;
	uint16_t *wcode, *fwcode;
	uint32_t risc_addr, risc_size, fwclen, wlen, *seg;
	struct fw_blob *blob;
4730
	struct qla_hw_data *ha = vha->hw;
4731
	struct req_que *req = ha->req_q_map[0];
4732 4733

	/* Load firmware blob. */
4734
	blob = qla2x00_request_firmware(vha);
4735
	if (!blob) {
4736 4737 4738 4739
		ql_log(ql_log_info, vha, 0x0083,
		    "Fimware image unavailable.\n");
		ql_log(ql_log_info, vha, 0x0084,
		    "Firmware images can be retrieved from: "QLA_FW_URL ".\n");
4740 4741 4742 4743 4744
		return QLA_FUNCTION_FAILED;
	}

	rval = QLA_SUCCESS;

4745
	wcode = (uint16_t *)req->ring;
4746 4747 4748 4749 4750 4751
	*srisc_addr = 0;
	fwcode = (uint16_t *)blob->fw->data;
	fwclen = 0;

	/* Validate firmware image by checking version. */
	if (blob->fw->size < 8 * sizeof(uint16_t)) {
4752 4753
		ql_log(ql_log_fatal, vha, 0x0085,
		    "Unable to verify integrity of firmware image (%Zd).\n",
4754 4755 4756 4757 4758 4759 4760 4761
		    blob->fw->size);
		goto fail_fw_integrity;
	}
	for (i = 0; i < 4; i++)
		wcode[i] = be16_to_cpu(fwcode[i + 4]);
	if ((wcode[0] == 0xffff && wcode[1] == 0xffff && wcode[2] == 0xffff &&
	    wcode[3] == 0xffff) || (wcode[0] == 0 && wcode[1] == 0 &&
		wcode[2] == 0 && wcode[3] == 0)) {
4762 4763 4764 4765 4766
		ql_log(ql_log_fatal, vha, 0x0086,
		    "Unable to verify integrity of firmware image.\n");
		ql_log(ql_log_fatal, vha, 0x0087,
		    "Firmware data: %04x %04x %04x %04x.\n",
		    wcode[0], wcode[1], wcode[2], wcode[3]);
4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778
		goto fail_fw_integrity;
	}

	seg = blob->segs;
	while (*seg && rval == QLA_SUCCESS) {
		risc_addr = *seg;
		*srisc_addr = *srisc_addr == 0 ? *seg : *srisc_addr;
		risc_size = be16_to_cpu(fwcode[3]);

		/* Validate firmware image size. */
		fwclen += risc_size * sizeof(uint16_t);
		if (blob->fw->size < fwclen) {
4779
			ql_log(ql_log_fatal, vha, 0x0088,
4780
			    "Unable to verify integrity of firmware image "
4781
			    "(%Zd).\n", blob->fw->size);
4782 4783 4784 4785 4786 4787 4788 4789
			goto fail_fw_integrity;
		}

		fragment = 0;
		while (risc_size > 0 && rval == QLA_SUCCESS) {
			wlen = (uint16_t)(ha->fw_transfer_size >> 1);
			if (wlen > risc_size)
				wlen = risc_size;
4790 4791 4792
			ql_dbg(ql_dbg_init, vha, 0x0089,
			    "Loading risc segment@ risc addr %x number of "
			    "words 0x%x.\n", risc_addr, wlen);
4793 4794 4795 4796

			for (i = 0; i < wlen; i++)
				wcode[i] = swab16(fwcode[i]);

4797
			rval = qla2x00_load_ram(vha, req->dma, risc_addr,
4798 4799
			    wlen);
			if (rval) {
4800 4801 4802
				ql_log(ql_log_fatal, vha, 0x008a,
				    "Failed to load segment %d of firmware.\n",
				    fragment);
4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820
				break;
			}

			fwcode += wlen;
			risc_addr += wlen;
			risc_size -= wlen;
			fragment++;
		}

		/* Next segment. */
		seg++;
	}
	return rval;

fail_fw_integrity:
	return QLA_FUNCTION_FAILED;
}

4821 4822
static int
qla24xx_load_risc_blob(scsi_qla_host_t *vha, uint32_t *srisc_addr)
4823 4824 4825 4826 4827 4828 4829
{
	int	rval;
	int	segments, fragment;
	uint32_t *dcode, dlen;
	uint32_t risc_addr;
	uint32_t risc_size;
	uint32_t i;
4830
	struct fw_blob *blob;
4831
	uint32_t *fwcode, fwclen;
4832
	struct qla_hw_data *ha = vha->hw;
4833
	struct req_que *req = ha->req_q_map[0];
4834

4835
	/* Load firmware blob. */
4836
	blob = qla2x00_request_firmware(vha);
4837
	if (!blob) {
4838 4839 4840 4841 4842
		ql_log(ql_log_warn, vha, 0x0090,
		    "Fimware image unavailable.\n");
		ql_log(ql_log_warn, vha, 0x0091,
		    "Firmware images can be retrieved from: "
		    QLA_FW_URL ".\n");
4843

4844
		return QLA_FUNCTION_FAILED;
4845 4846
	}

4847 4848
	ql_dbg(ql_dbg_init, vha, 0x0092,
	    "FW: Loading via request-firmware.\n");
4849

4850 4851 4852
	rval = QLA_SUCCESS;

	segments = FA_RISC_CODE_SEGMENTS;
4853
	dcode = (uint32_t *)req->ring;
4854
	*srisc_addr = 0;
4855
	fwcode = (uint32_t *)blob->fw->data;
4856 4857 4858
	fwclen = 0;

	/* Validate firmware image by checking version. */
4859
	if (blob->fw->size < 8 * sizeof(uint32_t)) {
4860 4861
		ql_log(ql_log_fatal, vha, 0x0093,
		    "Unable to verify integrity of firmware image (%Zd).\n",
4862
		    blob->fw->size);
4863 4864 4865 4866 4867 4868 4869 4870
		goto fail_fw_integrity;
	}
	for (i = 0; i < 4; i++)
		dcode[i] = be32_to_cpu(fwcode[i + 4]);
	if ((dcode[0] == 0xffffffff && dcode[1] == 0xffffffff &&
	    dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
	    (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
		dcode[3] == 0)) {
4871 4872 4873 4874 4875 4876
		ql_log(ql_log_fatal, vha, 0x0094,
		    "Unable to verify integrity of firmware image (%Zd).\n",
		    blob->fw->size);
		ql_log(ql_log_fatal, vha, 0x0095,
		    "Firmware data: %08x %08x %08x %08x.\n",
		    dcode[0], dcode[1], dcode[2], dcode[3]);
4877 4878 4879 4880 4881 4882 4883 4884 4885 4886
		goto fail_fw_integrity;
	}

	while (segments && rval == QLA_SUCCESS) {
		risc_addr = be32_to_cpu(fwcode[2]);
		*srisc_addr = *srisc_addr == 0 ? risc_addr : *srisc_addr;
		risc_size = be32_to_cpu(fwcode[3]);

		/* Validate firmware image size. */
		fwclen += risc_size * sizeof(uint32_t);
4887
		if (blob->fw->size < fwclen) {
4888
			ql_log(ql_log_fatal, vha, 0x0096,
4889
			    "Unable to verify integrity of firmware image "
4890
			    "(%Zd).\n", blob->fw->size);
4891

4892 4893 4894 4895 4896 4897 4898 4899 4900
			goto fail_fw_integrity;
		}

		fragment = 0;
		while (risc_size > 0 && rval == QLA_SUCCESS) {
			dlen = (uint32_t)(ha->fw_transfer_size >> 2);
			if (dlen > risc_size)
				dlen = risc_size;

4901 4902 4903
			ql_dbg(ql_dbg_init, vha, 0x0097,
			    "Loading risc segment@ risc addr %x "
			    "number of dwords 0x%x.\n", risc_addr, dlen);
4904 4905 4906 4907

			for (i = 0; i < dlen; i++)
				dcode[i] = swab32(fwcode[i]);

4908
			rval = qla2x00_load_ram(vha, req->dma, risc_addr,
4909
			    dlen);
4910
			if (rval) {
4911 4912 4913
				ql_log(ql_log_fatal, vha, 0x0098,
				    "Failed to load segment %d of firmware.\n",
				    fragment);
4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930
				break;
			}

			fwcode += dlen;
			risc_addr += dlen;
			risc_size -= dlen;
			fragment++;
		}

		/* Next segment. */
		segments--;
	}
	return rval;

fail_fw_integrity:
	return QLA_FUNCTION_FAILED;
}
4931

4932 4933 4934 4935 4936
int
qla24xx_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
{
	int rval;

4937 4938 4939
	if (ql2xfwloadbin == 1)
		return qla81xx_load_risc(vha, srisc_addr);

4940 4941 4942 4943 4944 4945 4946 4947 4948
	/*
	 * FW Load priority:
	 * 1) Firmware via request-firmware interface (.bin file).
	 * 2) Firmware residing in flash.
	 */
	rval = qla24xx_load_risc_blob(vha, srisc_addr);
	if (rval == QLA_SUCCESS)
		return rval;

4949 4950
	return qla24xx_load_risc_flash(vha, srisc_addr,
	    vha->hw->flt_region_fw);
4951 4952 4953 4954 4955 4956
}

int
qla81xx_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
{
	int rval;
4957
	struct qla_hw_data *ha = vha->hw;
4958

4959
	if (ql2xfwloadbin == 2)
4960
		goto try_blob_fw;
4961

4962 4963 4964 4965
	/*
	 * FW Load priority:
	 * 1) Firmware residing in flash.
	 * 2) Firmware via request-firmware interface (.bin file).
4966
	 * 3) Golden-Firmware residing in flash -- limited operation.
4967
	 */
4968
	rval = qla24xx_load_risc_flash(vha, srisc_addr, ha->flt_region_fw);
4969 4970 4971
	if (rval == QLA_SUCCESS)
		return rval;

4972 4973 4974 4975 4976
try_blob_fw:
	rval = qla24xx_load_risc_blob(vha, srisc_addr);
	if (rval == QLA_SUCCESS || !ha->flt_region_gold_fw)
		return rval;

4977 4978
	ql_log(ql_log_info, vha, 0x0099,
	    "Attempting to fallback to golden firmware.\n");
4979 4980 4981 4982
	rval = qla24xx_load_risc_flash(vha, srisc_addr, ha->flt_region_gold_fw);
	if (rval != QLA_SUCCESS)
		return rval;

4983
	ql_log(ql_log_info, vha, 0x009a, "Update operational firmware.\n");
4984 4985
	ha->flags.running_gold_fw = 1;
	return rval;
4986 4987
}

4988
void
4989
qla2x00_try_to_stop_firmware(scsi_qla_host_t *vha)
4990 4991
{
	int ret, retries;
4992
	struct qla_hw_data *ha = vha->hw;
4993

4994 4995
	if (ha->flags.pci_channel_io_perm_failure)
		return;
4996
	if (!IS_FWI2_CAPABLE(ha))
4997
		return;
4998 4999
	if (!ha->fw_major_version)
		return;
5000

5001
	ret = qla2x00_stop_firmware(vha);
5002
	for (retries = 5; ret != QLA_SUCCESS && ret != QLA_FUNCTION_TIMEOUT &&
5003
	    ret != QLA_INVALID_COMMAND && retries ; retries--) {
5004 5005
		ha->isp_ops->reset_chip(vha);
		if (ha->isp_ops->chip_diag(vha) != QLA_SUCCESS)
5006
			continue;
5007
		if (qla2x00_setup_chip(vha) != QLA_SUCCESS)
5008
			continue;
5009 5010
		ql_log(ql_log_info, vha, 0x8015,
		    "Attempting retry of stop-firmware command.\n");
5011
		ret = qla2x00_stop_firmware(vha);
5012 5013
	}
}
5014 5015

int
5016
qla24xx_configure_vhba(scsi_qla_host_t *vha)
5017 5018 5019
{
	int rval = QLA_SUCCESS;
	uint16_t mb[MAILBOX_REGISTER_COUNT];
5020 5021
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
5022 5023
	struct req_que *req;
	struct rsp_que *rsp;
5024

5025
	if (!vha->vp_idx)
5026 5027
		return -EINVAL;

5028
	rval = qla2x00_fw_ready(base_vha);
5029
	if (ha->flags.cpu_affinity_enabled)
5030 5031 5032 5033 5034
		req = ha->req_q_map[0];
	else
		req = vha->req;
	rsp = req->rsp;

5035
	if (rval == QLA_SUCCESS) {
5036
		clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
5037
		qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL);
5038 5039
	}

5040
	vha->flags.management_server_logged_in = 0;
5041 5042

	/* Login to SNS first */
5043
	ha->isp_ops->fabric_login(vha, NPH_SNS, 0xff, 0xff, 0xfc, mb, BIT_1);
5044
	if (mb[0] != MBS_COMMAND_COMPLETE) {
5045 5046 5047 5048
		ql_dbg(ql_dbg_init, vha, 0x0103,
		    "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x mb[2]=%x "
		    "mb[6]=%x mb[7]=%x.\n",
		    NPH_SNS, mb[0], mb[1], mb[2], mb[6], mb[7]);
5049 5050 5051
		return (QLA_FUNCTION_FAILED);
	}

5052 5053 5054 5055 5056
	atomic_set(&vha->loop_down_timer, 0);
	atomic_set(&vha->loop_state, LOOP_UP);
	set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
	set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
	rval = qla2x00_loop_resync(base_vha);
5057 5058 5059

	return rval;
}
5060 5061 5062 5063 5064 5065 5066

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

static LIST_HEAD(qla_cs84xx_list);
static DEFINE_MUTEX(qla_cs84xx_mutex);

static struct qla_chip_state_84xx *
5067
qla84xx_get_chip(struct scsi_qla_host *vha)
5068 5069
{
	struct qla_chip_state_84xx *cs84xx;
5070
	struct qla_hw_data *ha = vha->hw;
5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109

	mutex_lock(&qla_cs84xx_mutex);

	/* Find any shared 84xx chip. */
	list_for_each_entry(cs84xx, &qla_cs84xx_list, list) {
		if (cs84xx->bus == ha->pdev->bus) {
			kref_get(&cs84xx->kref);
			goto done;
		}
	}

	cs84xx = kzalloc(sizeof(*cs84xx), GFP_KERNEL);
	if (!cs84xx)
		goto done;

	kref_init(&cs84xx->kref);
	spin_lock_init(&cs84xx->access_lock);
	mutex_init(&cs84xx->fw_update_mutex);
	cs84xx->bus = ha->pdev->bus;

	list_add_tail(&cs84xx->list, &qla_cs84xx_list);
done:
	mutex_unlock(&qla_cs84xx_mutex);
	return cs84xx;
}

static void
__qla84xx_chip_release(struct kref *kref)
{
	struct qla_chip_state_84xx *cs84xx =
	    container_of(kref, struct qla_chip_state_84xx, kref);

	mutex_lock(&qla_cs84xx_mutex);
	list_del(&cs84xx->list);
	mutex_unlock(&qla_cs84xx_mutex);
	kfree(cs84xx);
}

void
5110
qla84xx_put_chip(struct scsi_qla_host *vha)
5111
{
5112
	struct qla_hw_data *ha = vha->hw;
5113 5114 5115 5116 5117
	if (ha->cs84xx)
		kref_put(&ha->cs84xx->kref, __qla84xx_chip_release);
}

static int
5118
qla84xx_init_chip(scsi_qla_host_t *vha)
5119 5120 5121
{
	int rval;
	uint16_t status[2];
5122
	struct qla_hw_data *ha = vha->hw;
5123 5124 5125

	mutex_lock(&ha->cs84xx->fw_update_mutex);

5126
	rval = qla84xx_verify_chip(vha, status);
5127 5128 5129 5130 5131 5132

	mutex_unlock(&ha->cs84xx->fw_update_mutex);

	return rval != QLA_SUCCESS || status[0] ? QLA_FUNCTION_FAILED:
	    QLA_SUCCESS;
}
5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157

/* 81XX Support **************************************************************/

int
qla81xx_nvram_config(scsi_qla_host_t *vha)
{
	int   rval;
	struct init_cb_81xx *icb;
	struct nvram_81xx *nv;
	uint32_t *dptr;
	uint8_t  *dptr1, *dptr2;
	uint32_t chksum;
	uint16_t cnt;
	struct qla_hw_data *ha = vha->hw;

	rval = QLA_SUCCESS;
	icb = (struct init_cb_81xx *)ha->init_cb;
	nv = ha->nvram;

	/* Determine NVRAM starting address. */
	ha->nvram_size = sizeof(struct nvram_81xx);
	ha->vpd_size = FA_NVRAM_VPD_SIZE;

	/* Get VPD data into cache */
	ha->vpd = ha->nvram + VPD_OFFSET;
5158 5159
	ha->isp_ops->read_optrom(vha, ha->vpd, ha->flt_region_vpd << 2,
	    ha->vpd_size);
5160 5161

	/* Get NVRAM data into cache and calculate checksum. */
5162
	ha->isp_ops->read_optrom(vha, ha->nvram, ha->flt_region_nvram << 2,
5163
	    ha->nvram_size);
5164
	dptr = (uint32_t *)nv;
5165 5166 5167
	for (cnt = 0, chksum = 0; cnt < ha->nvram_size >> 2; cnt++)
		chksum += le32_to_cpu(*dptr++);

5168 5169 5170 5171
	ql_dbg(ql_dbg_init + ql_dbg_buffer, vha, 0x0111,
	    "Contents of NVRAM:\n");
	ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x0112,
	    (uint8_t *)nv, ha->nvram_size);
5172 5173 5174 5175 5176 5177

	/* Bad NVRAM data, set defaults parameters. */
	if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' || nv->id[2] != 'P'
	    || nv->id[3] != ' ' ||
	    nv->nvram_version < __constant_cpu_to_le16(ICB_VERSION)) {
		/* Reset NVRAM data. */
5178 5179 5180
		ql_log(ql_log_info, vha, 0x0073,
		    "Inconisistent NVRAM detected: checksum=0x%x id=%c "
		    "version=0x%x.\n", chksum, nv->id[0],
5181
		    le16_to_cpu(nv->nvram_version));
5182 5183 5184
		ql_log(ql_log_info, vha, 0x0074,
		    "Falling back to functioning (yet invalid -- WWPN) "
		    "defaults.\n");
5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195

		/*
		 * Set default initialization control block.
		 */
		memset(nv, 0, ha->nvram_size);
		nv->nvram_version = __constant_cpu_to_le16(ICB_VERSION);
		nv->version = __constant_cpu_to_le16(ICB_VERSION);
		nv->frame_payload_size = __constant_cpu_to_le16(2048);
		nv->execution_throttle = __constant_cpu_to_le16(0xFFFF);
		nv->exchange_count = __constant_cpu_to_le16(0);
		nv->port_name[0] = 0x21;
5196
		nv->port_name[1] = 0x00 + ha->port_no;
5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223
		nv->port_name[2] = 0x00;
		nv->port_name[3] = 0xe0;
		nv->port_name[4] = 0x8b;
		nv->port_name[5] = 0x1c;
		nv->port_name[6] = 0x55;
		nv->port_name[7] = 0x86;
		nv->node_name[0] = 0x20;
		nv->node_name[1] = 0x00;
		nv->node_name[2] = 0x00;
		nv->node_name[3] = 0xe0;
		nv->node_name[4] = 0x8b;
		nv->node_name[5] = 0x1c;
		nv->node_name[6] = 0x55;
		nv->node_name[7] = 0x86;
		nv->login_retry_count = __constant_cpu_to_le16(8);
		nv->interrupt_delay_timer = __constant_cpu_to_le16(0);
		nv->login_timeout = __constant_cpu_to_le16(0);
		nv->firmware_options_1 =
		    __constant_cpu_to_le32(BIT_14|BIT_13|BIT_2|BIT_1);
		nv->firmware_options_2 = __constant_cpu_to_le32(2 << 4);
		nv->firmware_options_2 |= __constant_cpu_to_le32(BIT_12);
		nv->firmware_options_3 = __constant_cpu_to_le32(2 << 13);
		nv->host_p = __constant_cpu_to_le32(BIT_11|BIT_10);
		nv->efi_parameters = __constant_cpu_to_le32(0);
		nv->reset_delay = 5;
		nv->max_luns_per_target = __constant_cpu_to_le16(128);
		nv->port_down_retry_count = __constant_cpu_to_le16(30);
5224
		nv->link_down_timeout = __constant_cpu_to_le16(180);
5225
		nv->enode_mac[0] = 0x00;
5226 5227
		nv->enode_mac[1] = 0xC0;
		nv->enode_mac[2] = 0xDD;
5228 5229
		nv->enode_mac[3] = 0x04;
		nv->enode_mac[4] = 0x05;
5230
		nv->enode_mac[5] = 0x06 + ha->port_no;
5231 5232 5233 5234 5235

		rval = 1;
	}

	/* Reset Initialization control block */
5236
	memset(icb, 0, ha->init_cb_size);
5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262

	/* Copy 1st segment. */
	dptr1 = (uint8_t *)icb;
	dptr2 = (uint8_t *)&nv->version;
	cnt = (uint8_t *)&icb->response_q_inpointer - (uint8_t *)&icb->version;
	while (cnt--)
		*dptr1++ = *dptr2++;

	icb->login_retry_count = nv->login_retry_count;

	/* Copy 2nd segment. */
	dptr1 = (uint8_t *)&icb->interrupt_delay_timer;
	dptr2 = (uint8_t *)&nv->interrupt_delay_timer;
	cnt = (uint8_t *)&icb->reserved_5 -
	    (uint8_t *)&icb->interrupt_delay_timer;
	while (cnt--)
		*dptr1++ = *dptr2++;

	memcpy(icb->enode_mac, nv->enode_mac, sizeof(icb->enode_mac));
	/* Some boards (with valid NVRAMs) still have NULL enode_mac!! */
	if (!memcmp(icb->enode_mac, "\0\0\0\0\0\0", sizeof(icb->enode_mac))) {
		icb->enode_mac[0] = 0x01;
		icb->enode_mac[1] = 0x02;
		icb->enode_mac[2] = 0x03;
		icb->enode_mac[3] = 0x04;
		icb->enode_mac[4] = 0x05;
5263
		icb->enode_mac[5] = 0x06 + ha->port_no;
5264 5265
	}

5266 5267 5268
	/* Use extended-initialization control block. */
	memcpy(ha->ex_init_cb, &nv->ex_version, sizeof(*ha->ex_init_cb));

5269 5270 5271 5272
	/*
	 * Setup driver NVRAM options.
	 */
	qla2x00_set_model_info(vha, nv->model_name, sizeof(nv->model_name),
5273
	    "QLE8XXX");
5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362

	/* Use alternate WWN? */
	if (nv->host_p & __constant_cpu_to_le32(BIT_15)) {
		memcpy(icb->node_name, nv->alternate_node_name, WWN_SIZE);
		memcpy(icb->port_name, nv->alternate_port_name, WWN_SIZE);
	}

	/* Prepare nodename */
	if ((icb->firmware_options_1 & __constant_cpu_to_le32(BIT_14)) == 0) {
		/*
		 * Firmware will apply the following mask if the nodename was
		 * not provided.
		 */
		memcpy(icb->node_name, icb->port_name, WWN_SIZE);
		icb->node_name[0] &= 0xF0;
	}

	/* Set host adapter parameters. */
	ha->flags.disable_risc_code_load = 0;
	ha->flags.enable_lip_reset = 0;
	ha->flags.enable_lip_full_login =
	    le32_to_cpu(nv->host_p) & BIT_10 ? 1: 0;
	ha->flags.enable_target_reset =
	    le32_to_cpu(nv->host_p) & BIT_11 ? 1: 0;
	ha->flags.enable_led_scheme = 0;
	ha->flags.disable_serdes = le32_to_cpu(nv->host_p) & BIT_5 ? 1: 0;

	ha->operating_mode = (le32_to_cpu(icb->firmware_options_2) &
	    (BIT_6 | BIT_5 | BIT_4)) >> 4;

	/* save HBA serial number */
	ha->serial0 = icb->port_name[5];
	ha->serial1 = icb->port_name[6];
	ha->serial2 = icb->port_name[7];
	memcpy(vha->node_name, icb->node_name, WWN_SIZE);
	memcpy(vha->port_name, icb->port_name, WWN_SIZE);

	icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);

	ha->retry_count = le16_to_cpu(nv->login_retry_count);

	/* Set minimum login_timeout to 4 seconds. */
	if (le16_to_cpu(nv->login_timeout) < ql2xlogintimeout)
		nv->login_timeout = cpu_to_le16(ql2xlogintimeout);
	if (le16_to_cpu(nv->login_timeout) < 4)
		nv->login_timeout = __constant_cpu_to_le16(4);
	ha->login_timeout = le16_to_cpu(nv->login_timeout);
	icb->login_timeout = nv->login_timeout;

	/* Set minimum RATOV to 100 tenths of a second. */
	ha->r_a_tov = 100;

	ha->loop_reset_delay = nv->reset_delay;

	/* Link Down Timeout = 0:
	 *
	 * 	When Port Down timer expires we will start returning
	 *	I/O's to OS with "DID_NO_CONNECT".
	 *
	 * Link Down Timeout != 0:
	 *
	 *	 The driver waits for the link to come up after link down
	 *	 before returning I/Os to OS with "DID_NO_CONNECT".
	 */
	if (le16_to_cpu(nv->link_down_timeout) == 0) {
		ha->loop_down_abort_time =
		    (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
	} else {
		ha->link_down_timeout =	le16_to_cpu(nv->link_down_timeout);
		ha->loop_down_abort_time =
		    (LOOP_DOWN_TIME - ha->link_down_timeout);
	}

	/* Need enough time to try and get the port back. */
	ha->port_down_retry_count = le16_to_cpu(nv->port_down_retry_count);
	if (qlport_down_retry)
		ha->port_down_retry_count = qlport_down_retry;

	/* Set login_retry_count */
	ha->login_retry_count  = le16_to_cpu(nv->login_retry_count);
	if (ha->port_down_retry_count ==
	    le16_to_cpu(nv->port_down_retry_count) &&
	    ha->port_down_retry_count > 3)
		ha->login_retry_count = ha->port_down_retry_count;
	else if (ha->port_down_retry_count > (int)ha->login_retry_count)
		ha->login_retry_count = ha->port_down_retry_count;
	if (ql2xloginretrycount)
		ha->login_retry_count = ql2xloginretrycount;

5363 5364 5365 5366
	/* if not running MSI-X we need handshaking on interrupts */
	if (!vha->hw->flags.msix_enabled && IS_QLA83XX(ha))
		icb->firmware_options_2 |= __constant_cpu_to_le32(BIT_22);

5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379
	/* Enable ZIO. */
	if (!vha->flags.init_done) {
		ha->zio_mode = le32_to_cpu(icb->firmware_options_2) &
		    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
		ha->zio_timer = le16_to_cpu(icb->interrupt_delay_timer) ?
		    le16_to_cpu(icb->interrupt_delay_timer): 2;
	}
	icb->firmware_options_2 &= __constant_cpu_to_le32(
	    ~(BIT_3 | BIT_2 | BIT_1 | BIT_0));
	vha->flags.process_response_queue = 0;
	if (ha->zio_mode != QLA_ZIO_DISABLED) {
		ha->zio_mode = QLA_ZIO_MODE_6;

5380
		ql_log(ql_log_info, vha, 0x0075,
5381
		    "ZIO mode %d enabled; timer delay (%d us).\n",
5382 5383
		    ha->zio_mode,
		    ha->zio_timer * 100);
5384 5385 5386 5387 5388 5389 5390 5391

		icb->firmware_options_2 |= cpu_to_le32(
		    (uint32_t)ha->zio_mode);
		icb->interrupt_delay_timer = cpu_to_le16(ha->zio_timer);
		vha->flags.process_response_queue = 1;
	}

	if (rval) {
5392 5393
		ql_log(ql_log_warn, vha, 0x0076,
		    "NVRAM configuration failed.\n");
5394 5395 5396 5397
	}
	return (rval);
}

5398 5399 5400 5401 5402 5403 5404 5405 5406
int
qla82xx_restart_isp(scsi_qla_host_t *vha)
{
	int status, rval;
	uint32_t wait_time;
	struct qla_hw_data *ha = vha->hw;
	struct req_que *req = ha->req_q_map[0];
	struct rsp_que *rsp = ha->rsp_q_map[0];
	struct scsi_qla_host *vp;
5407
	unsigned long flags;
5408 5409 5410 5411 5412 5413 5414 5415

	status = qla2x00_init_rings(vha);
	if (!status) {
		clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
		ha->flags.chip_reset_done = 1;

		status = qla2x00_fw_ready(vha);
		if (!status) {
5416 5417
			ql_log(ql_log_info, vha, 0x803c,
			    "Start configure loop, status =%d.\n", status);
5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438

			/* Issue a marker after FW becomes ready. */
			qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL);

			vha->flags.online = 1;
			/* Wait at most MAX_TARGET RSCNs for a stable link. */
			wait_time = 256;
			do {
				clear_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
				qla2x00_configure_loop(vha);
				wait_time--;
			} while (!atomic_read(&vha->loop_down_timer) &&
			    !(test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags)) &&
			    wait_time &&
			    (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)));
		}

		/* if no cable then assume it's good */
		if ((vha->device_flags & DFLG_NO_CABLE))
			status = 0;

5439
		ql_log(ql_log_info, vha, 0x8000,
5440
		    "Configure loop done, status = 0x%x.\n", status);
5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460
	}

	if (!status) {
		clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);

		if (!atomic_read(&vha->loop_down_timer)) {
			/*
			 * Issue marker command only when we are going
			 * to start the I/O .
			 */
			vha->marker_needed = 1;
		}

		vha->flags.online = 1;

		ha->isp_ops->enable_intrs(ha);

		ha->isp_abort_cnt = 0;
		clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);

5461
		/* Update the firmware version */
5462
		status = qla82xx_check_md_needed(vha);
5463

5464 5465 5466 5467 5468 5469 5470 5471
		if (ha->fce) {
			ha->flags.fce_enabled = 1;
			memset(ha->fce, 0,
			    fce_calc_size(ha->fce_bufs));
			rval = qla2x00_enable_fce_trace(vha,
			    ha->fce_dma, ha->fce_bufs, ha->fce_mb,
			    &ha->fce_bufs);
			if (rval) {
5472
				ql_log(ql_log_warn, vha, 0x8001,
5473 5474
				    "Unable to reinitialize FCE (%d).\n",
				    rval);
5475 5476 5477 5478 5479 5480 5481 5482 5483
				ha->flags.fce_enabled = 0;
			}
		}

		if (ha->eft) {
			memset(ha->eft, 0, EFT_SIZE);
			rval = qla2x00_enable_eft_trace(vha,
			    ha->eft_dma, EFT_NUM_BUFFERS);
			if (rval) {
5484
				ql_log(ql_log_warn, vha, 0x8010,
5485 5486
				    "Unable to reinitialize EFT (%d).\n",
				    rval);
5487 5488 5489 5490 5491
			}
		}
	}

	if (!status) {
5492
		ql_dbg(ql_dbg_taskm, vha, 0x8011,
5493
		    "qla82xx_restart_isp succeeded.\n");
5494 5495 5496 5497 5498 5499 5500

		spin_lock_irqsave(&ha->vport_slock, flags);
		list_for_each_entry(vp, &ha->vp_list, list) {
			if (vp->vp_idx) {
				atomic_inc(&vp->vref_count);
				spin_unlock_irqrestore(&ha->vport_slock, flags);

5501
				qla2x00_vp_abort_isp(vp);
5502 5503 5504 5505

				spin_lock_irqsave(&ha->vport_slock, flags);
				atomic_dec(&vp->vref_count);
			}
5506
		}
5507 5508
		spin_unlock_irqrestore(&ha->vport_slock, flags);

5509
	} else {
5510
		ql_log(ql_log_warn, vha, 0x8016,
5511
		    "qla82xx_restart_isp **** FAILED ****.\n");
5512 5513 5514 5515 5516
	}

	return status;
}

5517
void
5518
qla81xx_update_fw_options(scsi_qla_host_t *vha)
5519
{
5520 5521 5522 5523 5524 5525 5526 5527 5528
	struct qla_hw_data *ha = vha->hw;

	if (!ql2xetsenable)
		return;

	/* Enable ETS Burst. */
	memset(ha->fw_options, 0, sizeof(ha->fw_options));
	ha->fw_options[2] |= BIT_9;
	qla2x00_set_fw_options(vha, ha->fw_options);
5529
}
S
Sarang Radke 已提交
5530 5531 5532 5533 5534 5535 5536 5537 5538

/*
 * qla24xx_get_fcp_prio
 *	Gets the fcp cmd priority value for the logged in port.
 *	Looks for a match of the port descriptors within
 *	each of the fcp prio config entries. If a match is found,
 *	the tag (priority) value is returned.
 *
 * Input:
5539
 *	vha = scsi host structure pointer.
S
Sarang Radke 已提交
5540 5541 5542
 *	fcport = port structure pointer.
 *
 * Return:
5543
 *	non-zero (if found)
5544
 *	-1 (if not found)
S
Sarang Radke 已提交
5545 5546 5547 5548
 *
 * Context:
 * 	Kernel context
 */
5549
static int
S
Sarang Radke 已提交
5550 5551 5552 5553
qla24xx_get_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
{
	int i, entries;
	uint8_t pid_match, wwn_match;
5554
	int priority;
S
Sarang Radke 已提交
5555 5556 5557 5558 5559 5560
	uint32_t pid1, pid2;
	uint64_t wwn1, wwn2;
	struct qla_fcp_prio_entry *pri_entry;
	struct qla_hw_data *ha = vha->hw;

	if (!ha->fcp_prio_cfg || !ha->flags.fcp_prio_enabled)
5561
		return -1;
S
Sarang Radke 已提交
5562

5563
	priority = -1;
S
Sarang Radke 已提交
5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632
	entries = ha->fcp_prio_cfg->num_entries;
	pri_entry = &ha->fcp_prio_cfg->entry[0];

	for (i = 0; i < entries; i++) {
		pid_match = wwn_match = 0;

		if (!(pri_entry->flags & FCP_PRIO_ENTRY_VALID)) {
			pri_entry++;
			continue;
		}

		/* check source pid for a match */
		if (pri_entry->flags & FCP_PRIO_ENTRY_SPID_VALID) {
			pid1 = pri_entry->src_pid & INVALID_PORT_ID;
			pid2 = vha->d_id.b24 & INVALID_PORT_ID;
			if (pid1 == INVALID_PORT_ID)
				pid_match++;
			else if (pid1 == pid2)
				pid_match++;
		}

		/* check destination pid for a match */
		if (pri_entry->flags & FCP_PRIO_ENTRY_DPID_VALID) {
			pid1 = pri_entry->dst_pid & INVALID_PORT_ID;
			pid2 = fcport->d_id.b24 & INVALID_PORT_ID;
			if (pid1 == INVALID_PORT_ID)
				pid_match++;
			else if (pid1 == pid2)
				pid_match++;
		}

		/* check source WWN for a match */
		if (pri_entry->flags & FCP_PRIO_ENTRY_SWWN_VALID) {
			wwn1 = wwn_to_u64(vha->port_name);
			wwn2 = wwn_to_u64(pri_entry->src_wwpn);
			if (wwn2 == (uint64_t)-1)
				wwn_match++;
			else if (wwn1 == wwn2)
				wwn_match++;
		}

		/* check destination WWN for a match */
		if (pri_entry->flags & FCP_PRIO_ENTRY_DWWN_VALID) {
			wwn1 = wwn_to_u64(fcport->port_name);
			wwn2 = wwn_to_u64(pri_entry->dst_wwpn);
			if (wwn2 == (uint64_t)-1)
				wwn_match++;
			else if (wwn1 == wwn2)
				wwn_match++;
		}

		if (pid_match == 2 || wwn_match == 2) {
			/* Found a matching entry */
			if (pri_entry->flags & FCP_PRIO_ENTRY_TAG_VALID)
				priority = pri_entry->tag;
			break;
		}

		pri_entry++;
	}

	return priority;
}

/*
 * qla24xx_update_fcport_fcp_prio
 *	Activates fcp priority for the logged in fc port
 *
 * Input:
5633
 *	vha = scsi host structure pointer.
S
Sarang Radke 已提交
5634 5635 5636 5637 5638 5639 5640 5641 5642
 *	fcp = port structure pointer.
 *
 * Return:
 *	QLA_SUCCESS or QLA_FUNCTION_FAILED
 *
 * Context:
 *	Kernel context.
 */
int
5643
qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
S
Sarang Radke 已提交
5644 5645
{
	int ret;
5646
	int priority;
S
Sarang Radke 已提交
5647 5648
	uint16_t mb[5];

5649 5650
	if (fcport->port_type != FCT_TARGET ||
	    fcport->loop_id == FC_NO_LOOP_ID)
S
Sarang Radke 已提交
5651 5652
		return QLA_FUNCTION_FAILED;

5653
	priority = qla24xx_get_fcp_prio(vha, fcport);
5654 5655 5656
	if (priority < 0)
		return QLA_FUNCTION_FAILED;

5657 5658 5659 5660 5661
	if (IS_QLA82XX(vha->hw)) {
		fcport->fcp_prio = priority & 0xf;
		return QLA_SUCCESS;
	}

5662
	ret = qla24xx_set_fcp_prio(vha, fcport->loop_id, priority, mb);
5663 5664 5665 5666 5667 5668 5669
	if (ret == QLA_SUCCESS) {
		if (fcport->fcp_prio != priority)
			ql_dbg(ql_dbg_user, vha, 0x709e,
			    "Updated FCP_CMND priority - value=%d loop_id=%d "
			    "port_id=%02x%02x%02x.\n", priority,
			    fcport->loop_id, fcport->d_id.b.domain,
			    fcport->d_id.b.area, fcport->d_id.b.al_pa);
5670
		fcport->fcp_prio = priority & 0xf;
5671
	} else
5672
		ql_dbg(ql_dbg_user, vha, 0x704f,
5673 5674 5675 5676
		    "Unable to update FCP_CMND priority - ret=0x%x for "
		    "loop_id=%d port_id=%02x%02x%02x.\n", ret, fcport->loop_id,
		    fcport->d_id.b.domain, fcport->d_id.b.area,
		    fcport->d_id.b.al_pa);
S
Sarang Radke 已提交
5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705
	return  ret;
}

/*
 * qla24xx_update_all_fcp_prio
 *	Activates fcp priority for all the logged in ports
 *
 * Input:
 *	ha = adapter block pointer.
 *
 * Return:
 *	QLA_SUCCESS or QLA_FUNCTION_FAILED
 *
 * Context:
 *	Kernel context.
 */
int
qla24xx_update_all_fcp_prio(scsi_qla_host_t *vha)
{
	int ret;
	fc_port_t *fcport;

	ret = QLA_FUNCTION_FAILED;
	/* We need to set priority for all logged in ports */
	list_for_each_entry(fcport, &vha->vp_fcports, list)
		ret = qla24xx_update_fcport_fcp_prio(vha, fcport);

	return ret;
}