qla_init.c 143.9 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
/*
*  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_fabric_dev_login(scsi_qla_host_t *, fc_port_t *,
    uint16_t *);

static int qla2x00_restart_isp(scsi_qla_host_t *);

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

41 42
/* SRB Extensions ---------------------------------------------------------- */

43 44
void
qla2x00_sp_timeout(unsigned long __data)
45 46
{
	srb_t *sp = (srb_t *)__data;
47
	struct srb_iocb *iocb;
48 49 50 51 52 53 54 55
	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;
56
	iocb = &sp->u.iocb_cmd;
57
	iocb->timeout(sp);
58
	sp->free(fcport->vha, sp);
59
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
60 61
}

62 63
void
qla2x00_sp_free(void *data, void *ptr)
64
{
65 66 67
	srb_t *sp = (srb_t *)ptr;
	struct srb_iocb *iocb = &sp->u.iocb_cmd;
	struct scsi_qla_host *vha = (scsi_qla_host_t *)data;
68

69
	del_timer(&iocb->timer);
70
	mempool_free(sp, vha->hw->srb_mempool);
71 72

	QLA_VHA_MARK_NOT_BUSY(vha);
73 74 75 76
}

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

77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
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;
}
94 95

static void
96
qla2x00_async_iocb_timeout(void *data)
97
{
98
	srb_t *sp = (srb_t *)data;
99 100
	fc_port_t *fcport = sp->fcport;

101
	ql_dbg(ql_dbg_disc, fcport->vha, 0x2071,
102
	    "Async-%s timeout - hdl=%x portid=%02x%02x%02x.\n",
103
	    sp->name, sp->handle, fcport->d_id.b.domain, fcport->d_id.b.area,
104
	    fcport->d_id.b.al_pa);
105

106
	fcport->flags &= ~FCF_ASYNC_SENT;
107 108
	if (sp->type == SRB_LOGIN_CMD) {
		struct srb_iocb *lio = &sp->u.iocb_cmd;
109
		qla2x00_post_async_logout_work(fcport->vha, fcport, NULL);
110 111 112 113 114 115 116
		/* 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);
	}
117 118
}

119
static void
120
qla2x00_async_login_sp_done(void *data, void *ptr, int res)
121
{
122 123 124 125 126 127 128 129
	srb_t *sp = (srb_t *)ptr;
	struct srb_iocb *lio = &sp->u.iocb_cmd;
	struct scsi_qla_host *vha = (scsi_qla_host_t *)data;

	if (!test_bit(UNLOADING, &vha->dpc_flags))
		qla2x00_post_async_login_done_work(sp->fcport->vha, sp->fcport,
		    lio->u.logio.data);
	sp->free(sp->fcport->vha, sp);
130 131
}

132 133 134 135 136
int
qla2x00_async_login(struct scsi_qla_host *vha, fc_port_t *fcport,
    uint16_t *data)
{
	srb_t *sp;
137
	struct srb_iocb *lio;
138 139 140
	int rval;

	rval = QLA_FUNCTION_FAILED;
141
	sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
142 143 144
	if (!sp)
		goto done;

145 146 147 148 149
	sp->type = SRB_LOGIN_CMD;
	sp->name = "login";
	qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);

	lio = &sp->u.iocb_cmd;
150
	lio->timeout = qla2x00_async_iocb_timeout;
151
	sp->done = qla2x00_async_login_sp_done;
152
	lio->u.logio.flags |= SRB_LOGIN_COND_PLOGI;
153
	if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
154
		lio->u.logio.flags |= SRB_LOGIN_RETRIED;
155 156 157 158
	rval = qla2x00_start_sp(sp);
	if (rval != QLA_SUCCESS)
		goto done_free_sp;

159
	ql_dbg(ql_dbg_disc, vha, 0x2072,
160 161 162 163
	    "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);
164 165 166
	return rval;

done_free_sp:
167
	sp->free(fcport->vha, sp);
168 169 170 171
done:
	return rval;
}

172
static void
173
qla2x00_async_logout_sp_done(void *data, void *ptr, int res)
174
{
175 176 177 178 179 180 181 182
	srb_t *sp = (srb_t *)ptr;
	struct srb_iocb *lio = &sp->u.iocb_cmd;
	struct scsi_qla_host *vha = (scsi_qla_host_t *)data;

	if (!test_bit(UNLOADING, &vha->dpc_flags))
		qla2x00_post_async_logout_done_work(sp->fcport->vha, sp->fcport,
		    lio->u.logio.data);
	sp->free(sp->fcport->vha, sp);
183 184
}

185 186 187 188
int
qla2x00_async_logout(struct scsi_qla_host *vha, fc_port_t *fcport)
{
	srb_t *sp;
189
	struct srb_iocb *lio;
190 191 192
	int rval;

	rval = QLA_FUNCTION_FAILED;
193
	sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
194 195 196
	if (!sp)
		goto done;

197 198 199 200 201
	sp->type = SRB_LOGOUT_CMD;
	sp->name = "logout";
	qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);

	lio = &sp->u.iocb_cmd;
202
	lio->timeout = qla2x00_async_iocb_timeout;
203
	sp->done = qla2x00_async_logout_sp_done;
204 205 206 207
	rval = qla2x00_start_sp(sp);
	if (rval != QLA_SUCCESS)
		goto done_free_sp;

208
	ql_dbg(ql_dbg_disc, vha, 0x2070,
209 210 211
	    "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);
212 213 214
	return rval;

done_free_sp:
215
	sp->free(fcport->vha, sp);
216 217 218 219
done:
	return rval;
}

220
static void
221
qla2x00_async_adisc_sp_done(void *data, void *ptr, int res)
222
{
223 224 225 226 227 228 229 230
	srb_t *sp = (srb_t *)ptr;
	struct srb_iocb *lio = &sp->u.iocb_cmd;
	struct scsi_qla_host *vha = (scsi_qla_host_t *)data;

	if (!test_bit(UNLOADING, &vha->dpc_flags))
		qla2x00_post_async_adisc_done_work(sp->fcport->vha, sp->fcport,
		    lio->u.logio.data);
	sp->free(sp->fcport->vha, sp);
231 232 233 234 235 236 237
}

int
qla2x00_async_adisc(struct scsi_qla_host *vha, fc_port_t *fcport,
    uint16_t *data)
{
	srb_t *sp;
238
	struct srb_iocb *lio;
239 240 241
	int rval;

	rval = QLA_FUNCTION_FAILED;
242
	sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
243 244 245
	if (!sp)
		goto done;

246 247 248 249 250
	sp->type = SRB_ADISC_CMD;
	sp->name = "adisc";
	qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);

	lio = &sp->u.iocb_cmd;
251
	lio->timeout = qla2x00_async_iocb_timeout;
252
	sp->done = qla2x00_async_adisc_sp_done;
253
	if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
254
		lio->u.logio.flags |= SRB_LOGIN_RETRIED;
255 256 257 258
	rval = qla2x00_start_sp(sp);
	if (rval != QLA_SUCCESS)
		goto done_free_sp;

259
	ql_dbg(ql_dbg_disc, vha, 0x206f,
260 261 262
	    "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);
263 264 265
	return rval;

done_free_sp:
266
	sp->free(fcport->vha, sp);
267 268 269 270
done:
	return rval;
}

271
static void
272
qla2x00_async_tm_cmd_done(void *data, void *ptr, int res)
273
{
274 275 276 277 278 279
	srb_t *sp = (srb_t *)ptr;
	struct srb_iocb *iocb = &sp->u.iocb_cmd;
	struct scsi_qla_host *vha = (scsi_qla_host_t *)data;
	uint32_t flags;
	uint16_t lun;
	int rval;
280

281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
	if (!test_bit(UNLOADING, &vha->dpc_flags)) {
		flags = iocb->u.tmf.flags;
		lun = (uint16_t)iocb->u.tmf.lun;

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

		if ((rval != QLA_SUCCESS) || iocb->u.tmf.data) {
			ql_dbg(ql_dbg_taskm, vha, 0x8030,
			    "TM IOCB failed (%x).\n", rval);
		}
	}
	sp->free(sp->fcport->vha, sp);
296 297 298
}

int
299
qla2x00_async_tm_cmd(fc_port_t *fcport, uint32_t tm_flags, uint32_t lun,
300 301 302 303 304 305 306 307
	uint32_t tag)
{
	struct scsi_qla_host *vha = fcport->vha;
	srb_t *sp;
	struct srb_iocb *tcf;
	int rval;

	rval = QLA_FUNCTION_FAILED;
308
	sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
309 310 311
	if (!sp)
		goto done;

312 313 314 315 316 317
	sp->type = SRB_TM_CMD;
	sp->name = "tmf";
	qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);

	tcf = &sp->u.iocb_cmd;
	tcf->u.tmf.flags = tm_flags;
318 319 320
	tcf->u.tmf.lun = lun;
	tcf->u.tmf.data = tag;
	tcf->timeout = qla2x00_async_iocb_timeout;
321
	sp->done = qla2x00_async_tm_cmd_done;
322 323 324 325 326

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

327
	ql_dbg(ql_dbg_taskm, vha, 0x802f,
328 329 330
	    "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);
331 332 333
	return rval;

done_free_sp:
334
	sp->free(fcport->vha, sp);
335 336 337 338
done:
	return rval;
}

339
void
340 341 342 343 344 345 346
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:
347 348 349 350 351 352
		/*
		 * 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);
353 354 355 356 357 358 359
		if (rval == QLA_NOT_LOGGED_IN) {
			fcport->flags &= ~FCF_ASYNC_SENT;
			fcport->flags |= FCF_LOGIN_NEEDED;
			set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
			break;
		}

360 361 362 363 364
		if (rval != QLA_SUCCESS) {
			qla2x00_post_async_logout_work(vha, fcport, NULL);
			qla2x00_post_async_login_work(vha, fcport, NULL);
			break;
		}
365
		if (fcport->flags & FCF_FCP2_DEVICE) {
366 367
			qla2x00_post_async_adisc_work(vha, fcport, data);
			break;
368 369
		}
		qla2x00_update_fcport(vha, fcport);
370 371
		break;
	case MBS_COMMAND_ERROR:
372
		fcport->flags &= ~FCF_ASYNC_SENT;
373 374 375
		if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
			set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
		else
376
			qla2x00_mark_device_lost(vha, fcport, 1, 0);
377 378 379
		break;
	case MBS_PORT_ID_USED:
		fcport->loop_id = data[1];
380
		qla2x00_post_async_logout_work(vha, fcport, NULL);
381 382 383 384 385 386
		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) {
387
			fcport->flags &= ~FCF_ASYNC_SENT;
388
			qla2x00_mark_device_lost(vha, fcport, 1, 0);
389 390 391 392 393
			break;
		}
		qla2x00_post_async_login_work(vha, fcport, NULL);
		break;
	}
394
	return;
395 396
}

397
void
398 399 400 401
qla2x00_async_logout_done(struct scsi_qla_host *vha, fc_port_t *fcport,
    uint16_t *data)
{
	qla2x00_mark_device_lost(vha, fcport, 1, 0);
402
	return;
403 404
}

405
void
406 407 408 409 410 411
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);

412
		return;
413 414 415 416 417 418 419
	}

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

422
	return;
423 424
}

L
Linus Torvalds 已提交
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
/****************************************************************************/
/*                QLogic ISP2x00 Hardware Support Functions.                */
/****************************************************************************/

/*
* qla2x00_initialize_adapter
*      Initialize board.
*
* Input:
*      ha = adapter block pointer.
*
* Returns:
*      0 = success
*/
int
440
qla2x00_initialize_adapter(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
441 442
{
	int	rval;
443
	struct qla_hw_data *ha = vha->hw;
444
	struct req_que *req = ha->req_q_map[0];
445

L
Linus Torvalds 已提交
446
	/* Clear adapter flags. */
447
	vha->flags.online = 0;
448
	ha->flags.chip_reset_done = 0;
449
	vha->flags.reset_active = 0;
450 451
	ha->flags.pci_channel_io_perm_failure = 0;
	ha->flags.eeh_busy = 0;
452
	ha->flags.thermal_supported = 1;
453 454 455 456 457 458
	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 已提交
459 460 461
	ha->isp_abort_cnt = 0;
	ha->beacon_blink_led = 0;

462 463 464
	set_bit(0, ha->req_qid_map);
	set_bit(0, ha->rsp_qid_map);

465
	ql_dbg(ql_dbg_init, vha, 0x0040,
466
	    "Configuring PCI space...\n");
467
	rval = ha->isp_ops->pci_config(vha);
L
Linus Torvalds 已提交
468
	if (rval) {
469 470
		ql_log(ql_log_warn, vha, 0x0044,
		    "Unable to configure PCI space.\n");
L
Linus Torvalds 已提交
471 472 473
		return (rval);
	}

474
	ha->isp_ops->reset_chip(vha);
L
Linus Torvalds 已提交
475

476
	rval = qla2xxx_get_flash_info(vha);
477
	if (rval) {
478 479
		ql_log(ql_log_fatal, vha, 0x004f,
		    "Unable to validate FLASH data.\n");
480 481 482
		return (rval);
	}

483
	ha->isp_ops->get_flash_version(vha, req->ring);
484
	ql_dbg(ql_dbg_init, vha, 0x0061,
485
	    "Configure NVRAM parameters...\n");
486

487
	ha->isp_ops->nvram_config(vha);
L
Linus Torvalds 已提交
488

489 490
	if (ha->flags.disable_serdes) {
		/* Mask HBA via NVRAM settings? */
491 492
		ql_log(ql_log_info, vha, 0x0077,
		    "Masking HBA WWPN "
493
		    "%02x%02x%02x%02x%02x%02x%02x%02x (via NVRAM).\n",
494 495 496 497
		    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]);
498 499 500
		return QLA_FUNCTION_FAILED;
	}

501
	ql_dbg(ql_dbg_init, vha, 0x0078,
502
	    "Verifying loaded RISC code...\n");
L
Linus Torvalds 已提交
503

504 505
	if (qla2x00_isp_firmware(vha) != QLA_SUCCESS) {
		rval = ha->isp_ops->chip_diag(vha);
506 507
		if (rval)
			return (rval);
508
		rval = qla2x00_setup_chip(vha);
509 510
		if (rval)
			return (rval);
L
Linus Torvalds 已提交
511
	}
512

513
	if (IS_QLA84XX(ha)) {
514
		ha->cs84xx = qla84xx_get_chip(vha);
515
		if (!ha->cs84xx) {
516
			ql_log(ql_log_warn, vha, 0x00d0,
517 518 519 520
			    "Unable to configure ISP84XX.\n");
			return QLA_FUNCTION_FAILED;
		}
	}
521
	rval = qla2x00_init_rings(vha);
522
	ha->flags.chip_reset_done = 1;
L
Linus Torvalds 已提交
523

524
	if (rval == QLA_SUCCESS && IS_QLA84XX(ha)) {
525
		/* Issue verify 84xx FW IOCB to complete 84xx initialization */
526 527
		rval = qla84xx_init_chip(vha);
		if (rval != QLA_SUCCESS) {
528 529
			ql_log(ql_log_warn, vha, 0x00d4,
			    "Unable to initialize ISP84XX.\n");
530 531 532 533
		qla84xx_put_chip(vha);
		}
	}

534 535
	if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha))
		qla24xx_read_fcp_prio_cfg(vha);
S
Sarang Radke 已提交
536

L
Linus Torvalds 已提交
537 538 539 540
	return (rval);
}

/**
541
 * qla2100_pci_config() - Setup ISP21xx PCI configuration registers.
L
Linus Torvalds 已提交
542 543 544 545
 * @ha: HA context
 *
 * Returns 0 on success.
 */
546
int
547
qla2100_pci_config(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
548
{
549
	uint16_t w;
550
	unsigned long flags;
551
	struct qla_hw_data *ha = vha->hw;
552
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
553 554

	pci_set_master(ha->pdev);
555
	pci_try_set_mwi(ha->pdev);
L
Linus Torvalds 已提交
556 557

	pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
558
	w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
559 560
	pci_write_config_word(ha->pdev, PCI_COMMAND, w);

561
	pci_disable_rom(ha->pdev);
L
Linus Torvalds 已提交
562 563 564

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

568 569
	return QLA_SUCCESS;
}
L
Linus Torvalds 已提交
570

571 572 573 574 575 576 577
/**
 * qla2300_pci_config() - Setup ISP23xx PCI configuration registers.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
int
578
qla2300_pci_config(scsi_qla_host_t *vha)
579
{
580
	uint16_t	w;
581 582
	unsigned long   flags = 0;
	uint32_t	cnt;
583
	struct qla_hw_data *ha = vha->hw;
584
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
585

586
	pci_set_master(ha->pdev);
587
	pci_try_set_mwi(ha->pdev);
L
Linus Torvalds 已提交
588

589
	pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
590
	w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
L
Linus Torvalds 已提交
591

592 593
	if (IS_QLA2322(ha) || IS_QLA6322(ha))
		w &= ~PCI_COMMAND_INTX_DISABLE;
594
	pci_write_config_word(ha->pdev, PCI_COMMAND, w);
L
Linus Torvalds 已提交
595

596 597 598 599 600 601 602 603 604
	/*
	 * 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 已提交
605

606
		/* Pause RISC. */
607
		WRT_REG_WORD(&reg->hccr, HCCR_PAUSE_RISC);
608
		for (cnt = 0; cnt < 30000; cnt++) {
609
			if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) != 0)
610
				break;
L
Linus Torvalds 已提交
611

612 613
			udelay(10);
		}
L
Linus Torvalds 已提交
614

615
		/* Select FPM registers. */
616 617
		WRT_REG_WORD(&reg->ctrl_status, 0x20);
		RD_REG_WORD(&reg->ctrl_status);
618 619

		/* Get the fb rev level */
620
		ha->fb_rev = RD_FB_CMD_REG(ha, reg);
621 622

		if (ha->fb_rev == FPM_2300)
623
			pci_clear_mwi(ha->pdev);
624 625

		/* Deselect FPM registers. */
626 627
		WRT_REG_WORD(&reg->ctrl_status, 0x0);
		RD_REG_WORD(&reg->ctrl_status);
628 629

		/* Release RISC module. */
630
		WRT_REG_WORD(&reg->hccr, HCCR_RELEASE_RISC);
631
		for (cnt = 0; cnt < 30000; cnt++) {
632
			if ((RD_REG_WORD(&reg->hccr) & HCCR_RISC_PAUSE) == 0)
633 634 635
				break;

			udelay(10);
L
Linus Torvalds 已提交
636 637
		}

638 639
		spin_unlock_irqrestore(&ha->hardware_lock, flags);
	}
L
Linus Torvalds 已提交
640

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

643
	pci_disable_rom(ha->pdev);
L
Linus Torvalds 已提交
644

645 646
	/* Get PCI bus information. */
	spin_lock_irqsave(&ha->hardware_lock, flags);
647
	ha->pci_attr = RD_REG_WORD(&reg->ctrl_status);
648 649 650
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

	return QLA_SUCCESS;
L
Linus Torvalds 已提交
651 652
}

653 654 655 656 657 658 659
/**
 * qla24xx_pci_config() - Setup ISP24xx PCI configuration registers.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
int
660
qla24xx_pci_config(scsi_qla_host_t *vha)
661
{
662
	uint16_t w;
663
	unsigned long flags = 0;
664
	struct qla_hw_data *ha = vha->hw;
665 666 667
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

	pci_set_master(ha->pdev);
668
	pci_try_set_mwi(ha->pdev);
669 670

	pci_read_config_word(ha->pdev, PCI_COMMAND, &w);
671
	w |= (PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
672 673 674 675 676 677
	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). */
678 679
	if (pci_find_capability(ha->pdev, PCI_CAP_ID_PCIX))
		pcix_set_mmrbc(ha->pdev, 2048);
680 681

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

685
	pci_disable_rom(ha->pdev);
686

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

689 690 691 692 693 694 695 696
	/* 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;
}

697 698 699 700 701 702 703
/**
 * qla25xx_pci_config() - Setup ISP25xx PCI configuration registers.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
int
704
qla25xx_pci_config(scsi_qla_host_t *vha)
705 706
{
	uint16_t w;
707
	struct qla_hw_data *ha = vha->hw;
708 709 710 711 712 713 714 715 716 717 718 719 720

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

721
	pci_disable_rom(ha->pdev);
722 723 724 725 726 727

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

	return QLA_SUCCESS;
}

L
Linus Torvalds 已提交
728 729 730 731 732 733 734
/**
 * qla2x00_isp_firmware() - Choose firmware image.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
static int
735
qla2x00_isp_firmware(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
736 737
{
	int  rval;
738 739
	uint16_t loop_id, topo, sw_cap;
	uint8_t domain, area, al_pa;
740
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
741 742

	/* Assume loading risc code */
A
Andrew Vasquez 已提交
743
	rval = QLA_FUNCTION_FAILED;
L
Linus Torvalds 已提交
744 745

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

		/* Verify checksum of loaded RISC code. */
749
		rval = qla2x00_verify_checksum(vha, ha->fw_srisc_address);
750 751
		if (rval == QLA_SUCCESS) {
			/* And, verify we are not in ROM code. */
752
			rval = qla2x00_get_adapter_id(vha, &loop_id, &al_pa,
753 754
			    &area, &domain, &topo, &sw_cap);
		}
L
Linus Torvalds 已提交
755 756
	}

757 758 759
	if (rval)
		ql_dbg(ql_dbg_init, vha, 0x007a,
		    "**** Load RISC code ****.\n");
L
Linus Torvalds 已提交
760 761 762 763 764 765 766 767 768 769

	return (rval);
}

/**
 * qla2x00_reset_chip() - Reset ISP chip.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
770
void
771
qla2x00_reset_chip(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
772 773
{
	unsigned long   flags = 0;
774
	struct qla_hw_data *ha = vha->hw;
775
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
776 777 778
	uint32_t	cnt;
	uint16_t	cmd;

779 780 781
	if (unlikely(pci_channel_offline(ha->pdev)))
		return;

782
	ha->isp_ops->disable_intrs(ha);
L
Linus Torvalds 已提交
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 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

	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++) {
887
			if (RD_MAILBOX_REG(ha, reg, 0) != MBS_BUSY)
L
Linus Torvalds 已提交
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
				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);
}

908 909 910 911 912 913 914 915 916 917
/**
 * 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};

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

921 922 923
	return qla81xx_write_mpi_register(vha, mb);
}

924
/**
925
 * qla24xx_reset_risc() - Perform full reset of ISP24xx RISC.
926 927 928 929
 * @ha: HA context
 *
 * Returns 0 on success.
 */
930
static inline void
931
qla24xx_reset_risc(scsi_qla_host_t *vha)
932 933
{
	unsigned long flags = 0;
934
	struct qla_hw_data *ha = vha->hw;
935 936
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
	uint32_t cnt, d2;
937
	uint16_t wd;
938
	static int abts_cnt; /* ISP abort retry counts */
939 940 941 942 943 944 945 946 947 948 949 950 951 952

	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);
953
	pci_read_config_word(ha->pdev, PCI_COMMAND, &wd);
954

955
	udelay(100);
956 957 958 959 960 961 962 963
	/* 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();
	}

964
	/* Wait for soft-reset to complete. */
965 966 967 968 969 970 971
	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();
	}

972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
	/* 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;
			}
		}
	}

989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
	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);
1006 1007 1008

	if (IS_NOPOLLING_TYPE(ha))
		ha->isp_ops->enable_intrs(ha);
1009 1010
}

1011 1012 1013 1014 1015 1016 1017
/**
 * qla24xx_reset_chip() - Reset ISP24xx chip.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
void
1018
qla24xx_reset_chip(scsi_qla_host_t *vha)
1019
{
1020
	struct qla_hw_data *ha = vha->hw;
1021 1022 1023 1024 1025 1026

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

1027
	ha->isp_ops->disable_intrs(ha);
1028 1029

	/* Perform RISC reset. */
1030
	qla24xx_reset_risc(vha);
1031 1032
}

L
Linus Torvalds 已提交
1033 1034 1035 1036 1037 1038
/**
 * qla2x00_chip_diag() - Test chip for proper operation.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
1039
int
1040
qla2x00_chip_diag(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1041 1042
{
	int		rval;
1043
	struct qla_hw_data *ha = vha->hw;
1044
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
1045 1046 1047 1048
	unsigned long	flags = 0;
	uint16_t	data;
	uint32_t	cnt;
	uint16_t	mb[5];
1049
	struct req_que *req = ha->req_q_map[0];
L
Linus Torvalds 已提交
1050 1051 1052 1053

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

1054 1055
	ql_dbg(ql_dbg_init, vha, 0x007b,
	    "Testing device at %lx.\n", (u_long)&reg->flash_address);
L
Linus Torvalds 已提交
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076

	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;

1077 1078
	ql_dbg(ql_dbg_init, vha, 0x007c,
	    "Reset register cleared by chip reset.\n");
L
Linus Torvalds 已提交
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089

	/* 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 已提交
1090
			barrier();
L
Linus Torvalds 已提交
1091 1092 1093 1094 1095 1096 1097 1098
		}
	} else
		udelay(10);

	if (!cnt)
		goto chip_diag_failed;

	/* Check product ID of chip */
1099
	ql_dbg(ql_dbg_init, vha, 0x007d, "Checking product Id of chip.\n");
L
Linus Torvalds 已提交
1100 1101 1102 1103 1104 1105 1106

	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) {
1107 1108 1109
		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 已提交
1110 1111 1112 1113 1114 1115 1116 1117 1118

		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 */
1119
	if (req->length > 1024)
L
Linus Torvalds 已提交
1120 1121 1122
		ha->fw_transfer_size = REQUEST_ENTRY_SIZE * 1024;
	else
		ha->fw_transfer_size = REQUEST_ENTRY_SIZE *
1123
		    req->length;
L
Linus Torvalds 已提交
1124 1125 1126 1127

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

1130
		ha->device_type |= DT_ISP2200A;
L
Linus Torvalds 已提交
1131 1132 1133 1134 1135 1136
		ha->fw_transfer_size = 128;
	}

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

1137
	ql_dbg(ql_dbg_init, vha, 0x007f, "Checking mailboxes.\n");
1138
	rval = qla2x00_mbx_reg_test(vha);
1139 1140 1141 1142
	if (rval)
		ql_log(ql_log_warn, vha, 0x0080,
		    "Failed mailbox send register test.\n");
	else
L
Linus Torvalds 已提交
1143 1144 1145 1146 1147 1148
		/* Flag a successful rval */
		rval = QLA_SUCCESS;
	spin_lock_irqsave(&ha->hardware_lock, flags);

chip_diag_failed:
	if (rval)
1149 1150
		ql_log(ql_log_info, vha, 0x0081,
		    "Chip diagnostics **** FAILED ****.\n");
L
Linus Torvalds 已提交
1151 1152 1153 1154 1155 1156

	spin_unlock_irqrestore(&ha->hardware_lock, flags);

	return (rval);
}

1157 1158 1159 1160 1161 1162 1163
/**
 * qla24xx_chip_diag() - Test ISP24xx for proper operation.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
int
1164
qla24xx_chip_diag(scsi_qla_host_t *vha)
1165 1166
{
	int rval;
1167
	struct qla_hw_data *ha = vha->hw;
1168
	struct req_que *req = ha->req_q_map[0];
1169

1170 1171 1172
	if (IS_QLA82XX(ha))
		return QLA_SUCCESS;

1173
	ha->fw_transfer_size = REQUEST_ENTRY_SIZE * req->length;
1174

1175
	rval = qla2x00_mbx_reg_test(vha);
1176
	if (rval) {
1177 1178
		ql_log(ql_log_warn, vha, 0x0082,
		    "Failed mailbox send register test.\n");
1179 1180 1181 1182 1183 1184 1185 1186
	} else {
		/* Flag a successful rval */
		rval = QLA_SUCCESS;
	}

	return rval;
}

1187
void
1188
qla2x00_alloc_fw_dump(scsi_qla_host_t *vha)
1189
{
1190 1191
	int rval;
	uint32_t dump_size, fixed_size, mem_size, req_q_size, rsp_q_size,
1192
	    eft_size, fce_size, mq_size;
1193 1194
	dma_addr_t tc_dma;
	void *tc;
1195
	struct qla_hw_data *ha = vha->hw;
1196 1197
	struct req_que *req = ha->req_q_map[0];
	struct rsp_que *rsp = ha->rsp_q_map[0];
1198 1199

	if (ha->fw_dump) {
1200 1201
		ql_dbg(ql_dbg_init, vha, 0x00bd,
		    "Firmware dump already allocated.\n");
1202 1203
		return;
	}
1204

1205
	ha->fw_dumped = 0;
1206
	fixed_size = mem_size = eft_size = fce_size = mq_size = 0;
1207
	if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
1208
		fixed_size = sizeof(struct qla2100_fw_dump);
1209
	} else if (IS_QLA23XX(ha)) {
1210 1211 1212
		fixed_size = offsetof(struct qla2300_fw_dump, data_ram);
		mem_size = (ha->fw_memory_size - 0x11000 + 1) *
		    sizeof(uint16_t);
1213
	} else if (IS_FWI2_CAPABLE(ha)) {
1214 1215 1216
		if (IS_QLA83XX(ha))
			fixed_size = offsetof(struct qla83xx_fw_dump, ext_mem);
		else if (IS_QLA81XX(ha))
1217 1218 1219 1220 1221
			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);
1222 1223
		mem_size = (ha->fw_memory_size - 0x100000 + 1) *
		    sizeof(uint32_t);
1224
		if (ha->mqenable) {
1225 1226
			if (!IS_QLA83XX(ha))
				mq_size = sizeof(struct qla2xxx_mq_chain);
1227 1228 1229 1230 1231 1232 1233 1234 1235
			/*
			 * 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));
		}
1236
		/* Allocate memory for Fibre Channel Event Buffer. */
1237
		if (!IS_QLA25XX(ha) && !IS_QLA81XX(ha) && !IS_QLA83XX(ha))
1238
			goto try_eft;
1239 1240 1241 1242

		tc = dma_alloc_coherent(&ha->pdev->dev, FCE_SIZE, &tc_dma,
		    GFP_KERNEL);
		if (!tc) {
1243 1244 1245
			ql_log(ql_log_warn, vha, 0x00be,
			    "Unable to allocate (%d KB) for FCE.\n",
			    FCE_SIZE / 1024);
1246
			goto try_eft;
1247 1248 1249
		}

		memset(tc, 0, FCE_SIZE);
1250
		rval = qla2x00_enable_fce_trace(vha, tc_dma, FCE_NUM_BUFFERS,
1251 1252
		    ha->fce_mb, &ha->fce_bufs);
		if (rval) {
1253 1254
			ql_log(ql_log_warn, vha, 0x00bf,
			    "Unable to initialize FCE (%d).\n", rval);
1255 1256 1257
			dma_free_coherent(&ha->pdev->dev, FCE_SIZE, tc,
			    tc_dma);
			ha->flags.fce_enabled = 0;
1258
			goto try_eft;
1259
		}
1260
		ql_dbg(ql_dbg_init, vha, 0x00c0,
1261
		    "Allocate (%d KB) for FCE...\n", FCE_SIZE / 1024);
1262

1263
		fce_size = sizeof(struct qla2xxx_fce_chain) + FCE_SIZE;
1264 1265 1266
		ha->flags.fce_enabled = 1;
		ha->fce_dma = tc_dma;
		ha->fce = tc;
1267 1268 1269 1270 1271
try_eft:
		/* Allocate memory for Extended Trace Buffer. */
		tc = dma_alloc_coherent(&ha->pdev->dev, EFT_SIZE, &tc_dma,
		    GFP_KERNEL);
		if (!tc) {
1272 1273 1274
			ql_log(ql_log_warn, vha, 0x00c1,
			    "Unable to allocate (%d KB) for EFT.\n",
			    EFT_SIZE / 1024);
1275 1276 1277 1278
			goto cont_alloc;
		}

		memset(tc, 0, EFT_SIZE);
1279
		rval = qla2x00_enable_eft_trace(vha, tc_dma, EFT_NUM_BUFFERS);
1280
		if (rval) {
1281 1282
			ql_log(ql_log_warn, vha, 0x00c2,
			    "Unable to initialize EFT (%d).\n", rval);
1283 1284 1285 1286
			dma_free_coherent(&ha->pdev->dev, EFT_SIZE, tc,
			    tc_dma);
			goto cont_alloc;
		}
1287
		ql_dbg(ql_dbg_init, vha, 0x00c3,
1288
		    "Allocated (%d KB) EFT ...\n", EFT_SIZE / 1024);
1289 1290 1291 1292

		eft_size = EFT_SIZE;
		ha->eft_dma = tc_dma;
		ha->eft = tc;
1293
	}
1294
cont_alloc:
1295 1296
	req_q_size = req->length * sizeof(request_t);
	rsp_q_size = rsp->length * sizeof(response_t);
1297 1298

	dump_size = offsetof(struct qla2xxx_fw_dump, isp);
1299
	dump_size += fixed_size + mem_size + req_q_size + rsp_q_size + eft_size;
1300 1301
	ha->chain_offset = dump_size;
	dump_size += mq_size + fce_size;
1302 1303

	ha->fw_dump = vmalloc(dump_size);
1304
	if (!ha->fw_dump) {
1305 1306 1307
		ql_log(ql_log_warn, vha, 0x00c4,
		    "Unable to allocate (%d KB) for firmware dump.\n",
		    dump_size / 1024);
1308

1309 1310 1311 1312 1313 1314 1315
		if (ha->fce) {
			dma_free_coherent(&ha->pdev->dev, FCE_SIZE, ha->fce,
			    ha->fce_dma);
			ha->fce = NULL;
			ha->fce_dma = 0;
		}

1316 1317 1318 1319 1320 1321 1322 1323
		if (ha->eft) {
			dma_free_coherent(&ha->pdev->dev, eft_size, ha->eft,
			    ha->eft_dma);
			ha->eft = NULL;
			ha->eft_dma = 0;
		}
		return;
	}
1324
	ql_dbg(ql_dbg_init, vha, 0x00c5,
1325
	    "Allocated (%d KB) for firmware dump.\n", dump_size / 1024);
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344

	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));
1345 1346
}

1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
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) {
1360 1361
		ql_log(ql_log_warn, vha, 0x0105,
		    "Unable to acquire semaphore.\n");
1362 1363 1364 1365 1366 1367
		goto done;
	}

	pci_read_config_word(vha->hw->pdev, 0x54, &dc);
	rval = qla2x00_read_ram_word(vha, 0x7a15, &dw);
	if (rval != QLA_SUCCESS) {
1368
		ql_log(ql_log_warn, vha, 0x0067, "Unable to read sync.\n");
1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
		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) {
1380
		ql_log(ql_log_warn, vha, 0x0114, "Unable to gain sync.\n");
1381 1382 1383 1384 1385
	}

done_release:
	rval = qla2x00_write_ram_word(vha, 0x7c00, 0);
	if (rval != QLA_SUCCESS) {
1386 1387
		ql_log(ql_log_warn, vha, 0x006d,
		    "Unable to release semaphore.\n");
1388 1389 1390 1391 1392 1393
	}

done:
	return rval;
}

L
Linus Torvalds 已提交
1394 1395 1396 1397 1398 1399 1400
/**
 * qla2x00_setup_chip() - Load and start RISC firmware.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
static int
1401
qla2x00_setup_chip(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1402
{
1403 1404
	int rval;
	uint32_t srisc_address = 0;
1405
	struct qla_hw_data *ha = vha->hw;
1406 1407
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
	unsigned long flags;
1408
	uint16_t fw_major_version;
1409

1410 1411
	if (IS_QLA82XX(ha)) {
		rval = ha->isp_ops->load_risc(vha, &srisc_address);
1412 1413
		if (rval == QLA_SUCCESS) {
			qla2x00_stop_firmware(vha);
1414
			goto enable_82xx_npiv;
1415
		} else
1416
			goto failed;
1417 1418
	}

1419 1420 1421 1422 1423 1424 1425
	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 已提交
1426

1427 1428
	qla81xx_mpi_sync(vha);

L
Linus Torvalds 已提交
1429
	/* Load firmware sequences */
1430
	rval = ha->isp_ops->load_risc(vha, &srisc_address);
1431
	if (rval == QLA_SUCCESS) {
1432 1433
		ql_dbg(ql_dbg_init, vha, 0x00c9,
		    "Verifying Checksum of loaded RISC code.\n");
L
Linus Torvalds 已提交
1434

1435
		rval = qla2x00_verify_checksum(vha, srisc_address);
L
Linus Torvalds 已提交
1436 1437
		if (rval == QLA_SUCCESS) {
			/* Start firmware execution. */
1438 1439
			ql_dbg(ql_dbg_init, vha, 0x00ca,
			    "Starting firmware.\n");
L
Linus Torvalds 已提交
1440

1441
			rval = qla2x00_execute_fw(vha, srisc_address);
L
Linus Torvalds 已提交
1442
			/* Retrieve firmware information. */
1443
			if (rval == QLA_SUCCESS) {
1444
enable_82xx_npiv:
1445
				fw_major_version = ha->fw_major_version;
1446 1447
				if (IS_QLA82XX(ha))
					qla82xx_check_md_needed(vha);
1448 1449
				else
					rval = qla2x00_get_fw_version(vha);
1450 1451
				if (rval != QLA_SUCCESS)
					goto failed;
1452
				ha->flags.npiv_supported = 0;
1453
				if (IS_QLA2XXX_MIDTYPE(ha) &&
1454
					 (ha->fw_attributes & BIT_2)) {
1455
					ha->flags.npiv_supported = 1;
1456 1457
					if ((!ha->max_npiv_vports) ||
					    ((ha->max_npiv_vports + 1) %
1458
					    MIN_MULTI_ID_FABRIC))
1459
						ha->max_npiv_vports =
1460
						    MIN_MULTI_ID_FABRIC - 1;
1461
				}
1462 1463
				qla2x00_get_resource_cnts(vha, NULL,
				    &ha->fw_xcb_count, NULL, NULL,
1464
				    &ha->max_npiv_vports, NULL);
1465

1466 1467
				if (!fw_major_version && ql2xallocfwdump
				    && !IS_QLA82XX(ha))
1468
					qla2x00_alloc_fw_dump(vha);
L
Linus Torvalds 已提交
1469 1470
			}
		} else {
1471 1472 1473
			ql_log(ql_log_fatal, vha, 0x00cd,
			    "ISP Firmware failed checksum.\n");
			goto failed;
L
Linus Torvalds 已提交
1474 1475 1476
		}
	}

1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489
	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);
	}

1490 1491 1492
	if (IS_QLA83XX(ha))
		goto skip_fac_check;

1493 1494 1495 1496 1497 1498 1499 1500
	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 {
1501
			ql_log(ql_log_warn, vha, 0x00ce,
1502 1503 1504
			    "Unsupported FAC firmware (%d.%02d.%02d).\n",
			    ha->fw_major_version, ha->fw_minor_version,
			    ha->fw_subminor_version);
1505 1506 1507 1508 1509
skip_fac_check:
			if (IS_QLA83XX(ha)) {
				ha->flags.fac_supported = 0;
				rval = QLA_SUCCESS;
			}
1510 1511
		}
	}
1512
failed:
L
Linus Torvalds 已提交
1513
	if (rval) {
1514 1515
		ql_log(ql_log_fatal, vha, 0x00cf,
		    "Setup chip ****FAILED****.\n");
L
Linus Torvalds 已提交
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
	}

	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.
 */
1530 1531
void
qla2x00_init_response_q_entries(struct rsp_que *rsp)
L
Linus Torvalds 已提交
1532 1533 1534 1535
{
	uint16_t cnt;
	response_t *pkt;

1536 1537 1538
	rsp->ring_ptr = rsp->ring;
	rsp->ring_index    = 0;
	rsp->status_srb = NULL;
1539 1540
	pkt = rsp->ring_ptr;
	for (cnt = 0; cnt < rsp->length; cnt++) {
L
Linus Torvalds 已提交
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551
		pkt->signature = RESPONSE_PROCESSED;
		pkt++;
	}
}

/**
 * qla2x00_update_fw_options() - Read and process firmware options.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
1552
void
1553
qla2x00_update_fw_options(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1554 1555
{
	uint16_t swing, emphasis, tx_sens, rx_sens;
1556
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1557 1558

	memset(ha->fw_options, 0, sizeof(ha->fw_options));
1559
	qla2x00_get_fw_options(vha, ha->fw_options);
L
Linus Torvalds 已提交
1560 1561 1562 1563 1564

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

	/* Serial Link options. */
1565 1566 1567 1568 1569
	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 已提交
1570 1571 1572 1573 1574 1575 1576 1577 1578 1579

	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 已提交
1580
		    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
L
Linus Torvalds 已提交
1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
		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 已提交
1598
		    (BIT_3 | BIT_2 | BIT_1 | BIT_0);
L
Linus Torvalds 已提交
1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
		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;

1620 1621 1622 1623
	/* Detect ISP6312. */
	if (IS_QLA6312(ha))
		ha->fw_options[2] |= BIT_13;

L
Linus Torvalds 已提交
1624
	/* Update firmware options. */
1625
	qla2x00_set_fw_options(vha, ha->fw_options);
L
Linus Torvalds 已提交
1626 1627
}

1628
void
1629
qla24xx_update_fw_options(scsi_qla_host_t *vha)
1630 1631
{
	int rval;
1632
	struct qla_hw_data *ha = vha->hw;
1633

1634 1635 1636
	if (IS_QLA82XX(ha))
		return;

1637
	/* Update Serial Link options. */
1638
	if ((le16_to_cpu(ha->fw_seriallink_options24[0]) & BIT_0) == 0)
1639 1640
		return;

1641
	rval = qla2x00_set_serdes_params(vha,
1642 1643 1644
	    le16_to_cpu(ha->fw_seriallink_options24[1]),
	    le16_to_cpu(ha->fw_seriallink_options24[2]),
	    le16_to_cpu(ha->fw_seriallink_options24[3]));
1645
	if (rval != QLA_SUCCESS) {
1646
		ql_log(ql_log_warn, vha, 0x0104,
1647 1648 1649 1650
		    "Unable to update Serial Link options (%x).\n", rval);
	}
}

1651
void
1652
qla2x00_config_rings(struct scsi_qla_host *vha)
1653
{
1654
	struct qla_hw_data *ha = vha->hw;
1655
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
1656 1657
	struct req_que *req = ha->req_q_map[0];
	struct rsp_que *rsp = ha->rsp_q_map[0];
1658 1659 1660 1661

	/* 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);
1662 1663 1664 1665 1666 1667
	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));
1668 1669 1670 1671 1672 1673 1674 1675

	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. */
}

1676
void
1677
qla24xx_config_rings(struct scsi_qla_host *vha)
1678
{
1679
	struct qla_hw_data *ha = vha->hw;
1680 1681 1682
	device_reg_t __iomem *reg = ISP_QUE_REG(ha, 0);
	struct device_reg_2xxx __iomem *ioreg = &ha->iobase->isp;
	struct qla_msix_entry *msix;
1683
	struct init_cb_24xx *icb;
1684 1685 1686
	uint16_t rid = 0;
	struct req_que *req = ha->req_q_map[0];
	struct rsp_que *rsp = ha->rsp_q_map[0];
1687

1688
	/* Setup ring parameters in initialization control block. */
1689 1690 1691
	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);
1692 1693 1694 1695 1696 1697
	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));
1698

1699
	if (ha->mqenable || IS_QLA83XX(ha)) {
1700 1701 1702 1703
		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];
1704 1705 1706
			ql_dbg(ql_dbg_init, vha, 0x00fd,
			    "Registering vector 0x%x for base que.\n",
			    msix->entry);
1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
			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);

1718
		/* Use Disable MSIX Handshake mode for capable adapters */
1719 1720
		if ((ha->fw_attributes & BIT_6) && (IS_MSIX_NACK_CAPABLE(ha)) &&
		    (ha->flags.msix_enabled)) {
1721 1722 1723
			icb->firmware_options_2 &=
				__constant_cpu_to_le32(~BIT_22);
			ha->flags.disable_msix_handshake = 1;
1724 1725
			ql_dbg(ql_dbg_init, vha, 0x00fe,
			    "MSIX Handshake Disable Mode turned on.\n");
1726 1727 1728 1729
		} else {
			icb->firmware_options_2 |=
				__constant_cpu_to_le32(BIT_22);
		}
1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
		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);
1744 1745
}

L
Linus Torvalds 已提交
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755
/**
 * 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
1756
qla2x00_init_rings(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1757 1758 1759
{
	int	rval;
	unsigned long flags = 0;
1760
	int cnt, que;
1761
	struct qla_hw_data *ha = vha->hw;
1762 1763
	struct req_que *req;
	struct rsp_que *rsp;
1764 1765
	struct mid_init_cb_24xx *mid_init_cb =
	    (struct mid_init_cb_24xx *) ha->init_cb;
L
Linus Torvalds 已提交
1766 1767 1768 1769

	spin_lock_irqsave(&ha->hardware_lock, flags);

	/* Clear outstanding commands array. */
1770
	for (que = 0; que < ha->max_req_queues; que++) {
1771 1772 1773
		req = ha->req_q_map[que];
		if (!req)
			continue;
1774
		for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++)
1775
			req->outstanding_cmds[cnt] = NULL;
L
Linus Torvalds 已提交
1776

1777
		req->current_outstanding_cmd = 1;
L
Linus Torvalds 已提交
1778

1779 1780 1781 1782 1783
		/* Initialize firmware. */
		req->ring_ptr  = req->ring;
		req->ring_index    = 0;
		req->cnt      = req->length;
	}
L
Linus Torvalds 已提交
1784

1785
	for (que = 0; que < ha->max_rsp_queues; que++) {
1786 1787 1788 1789 1790 1791
		rsp = ha->rsp_q_map[que];
		if (!rsp)
			continue;
		/* Initialize response queue entries */
		qla2x00_init_response_q_entries(rsp);
	}
L
Linus Torvalds 已提交
1792

1793
	spin_lock(&ha->vport_slock);
1794

1795
	spin_unlock(&ha->vport_slock);
1796

1797
	ha->isp_ops->config_rings(vha);
L
Linus Torvalds 已提交
1798 1799 1800 1801

	spin_unlock_irqrestore(&ha->hardware_lock, flags);

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

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

1806 1807 1808
	if (ha->flags.npiv_supported) {
		if (ha->operating_mode == LOOP)
			ha->max_npiv_vports = MIN_MULTI_ID_FABRIC - 1;
1809
		mid_init_cb->count = cpu_to_le16(ha->max_npiv_vports);
1810 1811
	}

1812 1813 1814 1815 1816
	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);
	}
1817

1818
	rval = qla2x00_init_firmware(vha, ha->init_cb_size);
L
Linus Torvalds 已提交
1819
	if (rval) {
1820 1821
		ql_log(ql_log_fatal, vha, 0x00d2,
		    "Init Firmware **** FAILED ****.\n");
L
Linus Torvalds 已提交
1822
	} else {
1823 1824
		ql_dbg(ql_dbg_init, vha, 0x00d3,
		    "Init Firmware -- success.\n");
L
Linus Torvalds 已提交
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836
	}

	return (rval);
}

/**
 * qla2x00_fw_ready() - Waits for firmware ready.
 * @ha: HA context
 *
 * Returns 0 on success.
 */
static int
1837
qla2x00_fw_ready(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1838 1839
{
	int		rval;
1840
	unsigned long	wtime, mtime, cs84xx_time;
L
Linus Torvalds 已提交
1841 1842
	uint16_t	min_wait;	/* Minimum wait time if loop is down */
	uint16_t	wait_time;	/* Wait time if loop is coming ready */
1843
	uint16_t	state[5];
1844
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1845 1846 1847 1848

	rval = QLA_SUCCESS;

	/* 20 seconds for loop down. */
A
Andrew Vasquez 已提交
1849
	min_wait = 20;
L
Linus Torvalds 已提交
1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865

	/*
	 * 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 */
1866
	if (!vha->flags.init_done)
1867 1868
		ql_log(ql_log_info, vha, 0x801e,
		    "Waiting for LIP to complete.\n");
L
Linus Torvalds 已提交
1869 1870

	do {
1871
		rval = qla2x00_get_firmware_state(vha, state);
L
Linus Torvalds 已提交
1872
		if (rval == QLA_SUCCESS) {
1873
			if (state[0] < FSTATE_LOSS_OF_SYNC) {
1874
				vha->device_flags &= ~DFLG_NO_CABLE;
L
Linus Torvalds 已提交
1875
			}
1876
			if (IS_QLA84XX(ha) && state[0] != FSTATE_READY) {
1877 1878 1879
				ql_dbg(ql_dbg_taskm, vha, 0x801f,
				    "fw_state=%x 84xx=%x.\n", state[0],
				    state[2]);
1880 1881
				if ((state[2] & FSTATE_LOGGED_IN) &&
				     (state[2] & FSTATE_WAITING_FOR_VERIFY)) {
1882 1883
					ql_dbg(ql_dbg_taskm, vha, 0x8028,
					    "Sending verify iocb.\n");
1884 1885

					cs84xx_time = jiffies;
1886
					rval = qla84xx_init_chip(vha);
1887 1888
					if (rval != QLA_SUCCESS) {
						ql_log(ql_log_warn,
1889
						    vha, 0x8007,
1890
						    "Init chip failed.\n");
1891
						break;
1892
					}
1893 1894 1895 1896 1897

					/* Add time taken to initialize. */
					cs84xx_time = jiffies - cs84xx_time;
					wtime += cs84xx_time;
					mtime += cs84xx_time;
1898
					ql_dbg(ql_dbg_taskm, vha, 0x8008,
1899 1900 1901
					    "Increasing wait time by %ld. "
					    "New time %ld.\n", cs84xx_time,
					    wtime);
1902 1903
				}
			} else if (state[0] == FSTATE_READY) {
1904 1905
				ql_dbg(ql_dbg_taskm, vha, 0x8037,
				    "F/W Ready - OK.\n");
L
Linus Torvalds 已提交
1906

1907
				qla2x00_get_retry_cnt(vha, &ha->retry_count,
L
Linus Torvalds 已提交
1908 1909 1910 1911 1912 1913 1914 1915
				    &ha->login_timeout, &ha->r_a_tov);

				rval = QLA_SUCCESS;
				break;
			}

			rval = QLA_FUNCTION_FAILED;

1916
			if (atomic_read(&vha->loop_down_timer) &&
1917
			    state[0] != FSTATE_READY) {
L
Linus Torvalds 已提交
1918
				/* Loop down. Timeout on min_wait for states
A
Andrew Vasquez 已提交
1919 1920
				 * other than Wait for Login.
				 */
L
Linus Torvalds 已提交
1921
				if (time_after_eq(jiffies, mtime)) {
1922
					ql_log(ql_log_info, vha, 0x8038,
L
Linus Torvalds 已提交
1923 1924
					    "Cable is unplugged...\n");

1925
					vha->device_flags |= DFLG_NO_CABLE;
L
Linus Torvalds 已提交
1926 1927 1928 1929 1930
					break;
				}
			}
		} else {
			/* Mailbox cmd failed. Timeout on min_wait. */
1931
			if (time_after_eq(jiffies, mtime) ||
1932
				ha->flags.isp82xx_fw_hung)
L
Linus Torvalds 已提交
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
				break;
		}

		if (time_after_eq(jiffies, wtime))
			break;

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

1943 1944 1945
	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 已提交
1946

1947
	if (rval && !(vha->device_flags & DFLG_NO_CABLE)) {
1948 1949
		ql_log(ql_log_warn, vha, 0x803b,
		    "Firmware ready **** FAILED ****.\n");
L
Linus Torvalds 已提交
1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968
	}

	return (rval);
}

/*
*  qla2x00_configure_hba
*      Setup adapter context.
*
* Input:
*      ha = adapter state pointer.
*
* Returns:
*      0 = success
*
* Context:
*      Kernel context.
*/
static int
1969
qla2x00_configure_hba(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
1970 1971 1972 1973
{
	int       rval;
	uint16_t      loop_id;
	uint16_t      topo;
1974
	uint16_t      sw_cap;
L
Linus Torvalds 已提交
1975 1976 1977 1978
	uint8_t       al_pa;
	uint8_t       area;
	uint8_t       domain;
	char		connect_type[22];
1979
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
1980 1981

	/* Get host addresses. */
1982
	rval = qla2x00_get_adapter_id(vha,
1983
	    &loop_id, &al_pa, &area, &domain, &topo, &sw_cap);
L
Linus Torvalds 已提交
1984
	if (rval != QLA_SUCCESS) {
1985
		if (LOOP_TRANSITION(vha) || atomic_read(&ha->loop_down_timer) ||
1986
		    IS_CNA_CAPABLE(ha) ||
1987
		    (rval == QLA_COMMAND_ERROR && loop_id == 0x7)) {
1988 1989
			ql_dbg(ql_dbg_disc, vha, 0x2008,
			    "Loop is in a transition state.\n");
1990
		} else {
1991 1992
			ql_log(ql_log_warn, vha, 0x2009,
			    "Unable to get host loop ID.\n");
1993
			set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1994
		}
L
Linus Torvalds 已提交
1995 1996 1997 1998
		return (rval);
	}

	if (topo == 4) {
1999 2000
		ql_log(ql_log_info, vha, 0x200a,
		    "Cannot get topology - retrying.\n");
L
Linus Torvalds 已提交
2001 2002 2003
		return (QLA_FUNCTION_FAILED);
	}

2004
	vha->loop_id = loop_id;
L
Linus Torvalds 已提交
2005 2006 2007 2008

	/* initialize */
	ha->min_external_loopid = SNS_FIRST_LOOP_ID;
	ha->operating_mode = LOOP;
2009
	ha->switch_cap = 0;
L
Linus Torvalds 已提交
2010 2011 2012

	switch (topo) {
	case 0:
2013
		ql_dbg(ql_dbg_disc, vha, 0x200b, "HBA in NL topology.\n");
L
Linus Torvalds 已提交
2014 2015 2016 2017 2018
		ha->current_topology = ISP_CFG_NL;
		strcpy(connect_type, "(Loop)");
		break;

	case 1:
2019
		ql_dbg(ql_dbg_disc, vha, 0x200c, "HBA in FL topology.\n");
2020
		ha->switch_cap = sw_cap;
L
Linus Torvalds 已提交
2021 2022 2023 2024 2025
		ha->current_topology = ISP_CFG_FL;
		strcpy(connect_type, "(FL_Port)");
		break;

	case 2:
2026
		ql_dbg(ql_dbg_disc, vha, 0x200d, "HBA in N P2P topology.\n");
L
Linus Torvalds 已提交
2027 2028 2029 2030 2031 2032
		ha->operating_mode = P2P;
		ha->current_topology = ISP_CFG_N;
		strcpy(connect_type, "(N_Port-to-N_Port)");
		break;

	case 3:
2033
		ql_dbg(ql_dbg_disc, vha, 0x200e, "HBA in F P2P topology.\n");
2034
		ha->switch_cap = sw_cap;
L
Linus Torvalds 已提交
2035 2036 2037 2038 2039 2040
		ha->operating_mode = P2P;
		ha->current_topology = ISP_CFG_F;
		strcpy(connect_type, "(F_Port)");
		break;

	default:
2041 2042
		ql_dbg(ql_dbg_disc, vha, 0x200f,
		    "HBA in unknown topology %x, using NL.\n", topo);
L
Linus Torvalds 已提交
2043 2044 2045 2046 2047 2048 2049
		ha->current_topology = ISP_CFG_NL;
		strcpy(connect_type, "(Loop)");
		break;
	}

	/* Save Host port and loop ID. */
	/* byte order - Big Endian */
2050 2051 2052
	vha->d_id.b.domain = domain;
	vha->d_id.b.area = area;
	vha->d_id.b.al_pa = al_pa;
L
Linus Torvalds 已提交
2053

2054
	if (!vha->flags.init_done)
2055 2056
		ql_log(ql_log_info, vha, 0x2010,
		    "Topology - %s, Host Loop address 0x%x.\n",
2057
		    connect_type, vha->loop_id);
L
Linus Torvalds 已提交
2058 2059

	if (rval) {
2060 2061
		ql_log(ql_log_warn, vha, 0x2011,
		    "%s FAILED\n", __func__);
L
Linus Torvalds 已提交
2062
	} else {
2063 2064
		ql_dbg(ql_dbg_disc, vha, 0x2012,
		    "%s success\n", __func__);
L
Linus Torvalds 已提交
2065 2066 2067 2068 2069
	}

	return(rval);
}

2070
inline void
2071 2072
qla2x00_set_model_info(scsi_qla_host_t *vha, uint8_t *model, size_t len,
	char *def)
2073 2074 2075
{
	char *st, *en;
	uint16_t index;
2076
	struct qla_hw_data *ha = vha->hw;
2077
	int use_tbl = !IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha) &&
2078
	    !IS_CNA_CAPABLE(ha) && !IS_QLA2031(ha);
2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090

	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);
2091 2092
		if (use_tbl &&
		    ha->pdev->subsystem_vendor == PCI_VENDOR_ID_QLOGIC &&
2093
		    index < QLA_MODEL_NAMES)
2094 2095 2096
			strncpy(ha->model_desc,
			    qla2x00_model_name[index * 2 + 1],
			    sizeof(ha->model_desc) - 1);
2097 2098
	} else {
		index = (ha->pdev->subsystem_device & 0xff);
2099 2100
		if (use_tbl &&
		    ha->pdev->subsystem_vendor == PCI_VENDOR_ID_QLOGIC &&
2101 2102 2103
		    index < QLA_MODEL_NAMES) {
			strcpy(ha->model_number,
			    qla2x00_model_name[index * 2]);
2104 2105 2106
			strncpy(ha->model_desc,
			    qla2x00_model_name[index * 2 + 1],
			    sizeof(ha->model_desc) - 1);
2107 2108 2109 2110
		} else {
			strcpy(ha->model_number, def);
		}
	}
2111
	if (IS_FWI2_CAPABLE(ha))
2112
		qla2xxx_get_vpd_field(vha, "\x82", ha->model_desc,
2113
		    sizeof(ha->model_desc));
2114 2115
}

2116 2117 2118
/* On sparc systems, obtain port and node WWN from firmware
 * properties.
 */
2119
static void qla2xxx_nvram_wwn_from_ofw(scsi_qla_host_t *vha, nvram_t *nv)
2120 2121
{
#ifdef CONFIG_SPARC
2122
	struct qla_hw_data *ha = vha->hw;
2123
	struct pci_dev *pdev = ha->pdev;
D
David S. Miller 已提交
2124 2125
	struct device_node *dp = pci_device_to_OF_node(pdev);
	const u8 *val;
2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137
	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 已提交
2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
/*
* 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.
*/
2151
int
2152
qla2x00_nvram_config(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
2153
{
2154
	int             rval;
2155 2156 2157
	uint8_t         chksum = 0;
	uint16_t        cnt;
	uint8_t         *dptr1, *dptr2;
2158
	struct qla_hw_data *ha = vha->hw;
2159
	init_cb_t       *icb = ha->init_cb;
2160 2161
	nvram_t         *nv = ha->nvram;
	uint8_t         *ptr = ha->nvram;
2162
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
2163

2164 2165
	rval = QLA_SUCCESS;

L
Linus Torvalds 已提交
2166
	/* Determine NVRAM starting address. */
2167
	ha->nvram_size = sizeof(nvram_t);
L
Linus Torvalds 已提交
2168 2169 2170 2171 2172 2173
	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. */
2174
	ha->isp_ops->read_nvram(vha, ptr, ha->nvram_base, ha->nvram_size);
2175 2176
	for (cnt = 0, chksum = 0; cnt < ha->nvram_size; cnt++)
		chksum += *ptr++;
L
Linus Torvalds 已提交
2177

2178 2179 2180 2181
	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 已提交
2182 2183 2184 2185 2186

	/* 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. */
2187
		ql_log(ql_log_warn, vha, 0x0064,
2188
		    "Inconsistent NVRAM "
2189 2190 2191 2192 2193
		    "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");
2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228

		/*
		 * 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;

2229
		qla2xxx_nvram_wwn_from_ofw(vha, nv);
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242

		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 已提交
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259
	}

#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 */
2260
	memset(icb, 0, ha->init_cb_size);
L
Linus Torvalds 已提交
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272

	/*
	 * 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;
2273
		nv->firmware_options[0] &= ~BIT_6;
2274
		nv->add_firmware_options[1] |= BIT_5 | BIT_4;
L
Linus Torvalds 已提交
2275 2276 2277 2278 2279 2280 2281 2282

		if (IS_QLA2300(ha)) {
			if (ha->fb_rev == FPM_2310) {
				strcpy(ha->model_number, "QLA2310");
			} else {
				strcpy(ha->model_number, "QLA2300");
			}
		} else {
2283
			qla2x00_set_model_info(vha, nv->model_number,
2284
			    sizeof(nv->model_number), "QLA23xx");
L
Linus Torvalds 已提交
2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
		}
	} 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++;

2318 2319 2320 2321 2322 2323
	/* 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 已提交
2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
	/* 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.
	 */
2337 2338 2339 2340 2341

	/*
	 * BIT_7 in the host-parameters section allows for modification to
	 * internal driver logging.
	 */
2342
	if (nv->host_p[0] & BIT_7)
2343
		ql2xextended_error_logging = QL_DBG_DEFAULT1_MASK;
L
Linus Torvalds 已提交
2344 2345 2346 2347 2348 2349 2350
	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);
2351
	ha->flags.enable_led_scheme = (nv->special_options[1] & BIT_4) ? 1 : 0;
2352
	ha->flags.disable_serdes = 0;
L
Linus Torvalds 已提交
2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363

	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];
2364 2365
	memcpy(vha->node_name, icb->node_name, WWN_SIZE);
	memcpy(vha->port_name, icb->port_name, WWN_SIZE);
L
Linus Torvalds 已提交
2366 2367 2368 2369 2370 2371

	icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);

	ha->retry_count = nv->retry_count;

	/* Set minimum login_timeout to 4 seconds. */
2372
	if (nv->login_timeout != ql2xlogintimeout)
L
Linus Torvalds 已提交
2373 2374 2375 2376 2377 2378
		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;

2379 2380
	/* Set minimum RATOV to 100 tenths of a second. */
	ha->r_a_tov = 100;
L
Linus Torvalds 已提交
2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392

	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 已提交
2393
	 */
L
Linus Torvalds 已提交
2394 2395
	if (nv->link_down_timeout == 0) {
		ha->loop_down_abort_time =
2396
		    (LOOP_DOWN_TIME - LOOP_DOWN_TIMEOUT);
L
Linus Torvalds 已提交
2397 2398 2399 2400
	} else {
		ha->link_down_timeout =	 nv->link_down_timeout;
		ha->loop_down_abort_time =
		    (LOOP_DOWN_TIME - ha->link_down_timeout);
A
Andrew Vasquez 已提交
2401
	}
L
Linus Torvalds 已提交
2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432

	/*
	 * 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;

2433
		vha->flags.process_response_queue = 1;
L
Linus Torvalds 已提交
2434
	} else {
2435
		/* Enable ZIO. */
2436
		if (!vha->flags.init_done) {
2437 2438 2439 2440 2441
			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 已提交
2442 2443
		icb->add_firmware_options[0] &=
		    ~(BIT_3 | BIT_2 | BIT_1 | BIT_0);
2444
		vha->flags.process_response_queue = 0;
2445
		if (ha->zio_mode != QLA_ZIO_DISABLED) {
2446 2447
			ha->zio_mode = QLA_ZIO_MODE_6;

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

2452 2453
			icb->add_firmware_options[0] |= (uint8_t)ha->zio_mode;
			icb->interrupt_delay_timer = (uint8_t)ha->zio_timer;
2454
			vha->flags.process_response_queue = 1;
L
Linus Torvalds 已提交
2455 2456 2457
		}
	}

2458
	if (rval) {
2459 2460
		ql_log(ql_log_warn, vha, 0x0069,
		    "NVRAM configuration failed.\n");
2461 2462
	}
	return (rval);
L
Linus Torvalds 已提交
2463 2464
}

2465 2466 2467 2468
static void
qla2x00_rport_del(void *data)
{
	fc_port_t *fcport = data;
2469
	struct fc_rport *rport;
2470
	unsigned long flags;
2471

2472
	spin_lock_irqsave(fcport->vha->host->host_lock, flags);
2473
	rport = fcport->drport ? fcport->drport: fcport->rport;
2474
	fcport->drport = NULL;
2475
	spin_unlock_irqrestore(fcport->vha->host->host_lock, flags);
2476 2477
	if (rport)
		fc_remote_port_delete(rport);
2478 2479
}

L
Linus Torvalds 已提交
2480 2481 2482 2483 2484 2485 2486
/**
 * 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.
 */
2487
fc_port_t *
2488
qla2x00_alloc_fcport(scsi_qla_host_t *vha, gfp_t flags)
L
Linus Torvalds 已提交
2489 2490 2491
{
	fc_port_t *fcport;

2492 2493 2494
	fcport = kzalloc(sizeof(fc_port_t), flags);
	if (!fcport)
		return NULL;
L
Linus Torvalds 已提交
2495 2496

	/* Setup fcport template structure. */
2497 2498
	fcport->vha = vha;
	fcport->vp_idx = vha->vp_idx;
L
Linus Torvalds 已提交
2499 2500
	fcport->port_type = FCT_UNKNOWN;
	fcport->loop_id = FC_NO_LOOP_ID;
2501
	qla2x00_set_fcport_state(fcport, FCS_UNCONFIGURED);
2502
	fcport->supported_classes = FC_COS_UNSPECIFIED;
L
Linus Torvalds 已提交
2503

2504
	return fcport;
L
Linus Torvalds 已提交
2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519
}

/*
 * 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
2520
qla2x00_configure_loop(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
2521 2522 2523
{
	int  rval;
	unsigned long flags, save_flags;
2524
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
2525 2526 2527
	rval = QLA_SUCCESS;

	/* Get Initiator ID */
2528 2529
	if (test_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags)) {
		rval = qla2x00_configure_hba(vha);
L
Linus Torvalds 已提交
2530
		if (rval != QLA_SUCCESS) {
2531 2532
			ql_dbg(ql_dbg_disc, vha, 0x2013,
			    "Unable to configure HBA.\n");
L
Linus Torvalds 已提交
2533 2534 2535 2536
			return (rval);
		}
	}

2537
	save_flags = flags = vha->dpc_flags;
2538 2539
	ql_dbg(ql_dbg_disc, vha, 0x2014,
	    "Configure loop -- dpc flags = 0x%lx.\n", flags);
L
Linus Torvalds 已提交
2540 2541 2542 2543 2544

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

2548 2549
	qla2x00_get_data_rate(vha);

L
Linus Torvalds 已提交
2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
	/* Determine what we need to do */
	if (ha->current_topology == ISP_CFG_FL &&
	    (test_bit(LOCAL_LOOP_UPDATE, &flags))) {

		set_bit(RSCN_UPDATE, &flags);

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

		set_bit(RSCN_UPDATE, &flags);
		clear_bit(LOCAL_LOOP_UPDATE, &flags);
2561 2562 2563

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

2565
	} else if (!vha->flags.online ||
L
Linus Torvalds 已提交
2566 2567 2568 2569 2570 2571 2572
	    (test_bit(ABORT_ISP_ACTIVE, &flags))) {

		set_bit(RSCN_UPDATE, &flags);
		set_bit(LOCAL_LOOP_UPDATE, &flags);
	}

	if (test_bit(LOCAL_LOOP_UPDATE, &flags)) {
2573 2574 2575
		if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
			ql_dbg(ql_dbg_disc, vha, 0x2015,
			    "Loop resync needed, failing.\n");
L
Linus Torvalds 已提交
2576
			rval = QLA_FUNCTION_FAILED;
2577
		} else
2578
			rval = qla2x00_configure_local_loop(vha);
L
Linus Torvalds 已提交
2579 2580 2581
	}

	if (rval == QLA_SUCCESS && test_bit(RSCN_UPDATE, &flags)) {
2582 2583 2584
		if (LOOP_TRANSITION(vha)) {
			ql_dbg(ql_dbg_disc, vha, 0x201e,
			    "Needs RSCN update and loop transition.\n");
L
Linus Torvalds 已提交
2585
			rval = QLA_FUNCTION_FAILED;
2586
		}
2587 2588
		else
			rval = qla2x00_configure_fabric(vha);
L
Linus Torvalds 已提交
2589 2590 2591
	}

	if (rval == QLA_SUCCESS) {
2592 2593
		if (atomic_read(&vha->loop_down_timer) ||
		    test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
L
Linus Torvalds 已提交
2594 2595
			rval = QLA_FUNCTION_FAILED;
		} else {
2596
			atomic_set(&vha->loop_state, LOOP_READY);
2597 2598
			ql_dbg(ql_dbg_disc, vha, 0x2069,
			    "LOOP READY.\n");
L
Linus Torvalds 已提交
2599 2600 2601 2602
		}
	}

	if (rval) {
2603 2604
		ql_dbg(ql_dbg_disc, vha, 0x206a,
		    "%s *** FAILED ***.\n", __func__);
L
Linus Torvalds 已提交
2605
	} else {
2606 2607
		ql_dbg(ql_dbg_disc, vha, 0x206b,
		    "%s: exiting normally.\n", __func__);
L
Linus Torvalds 已提交
2608 2609
	}

2610
	/* Restore state if a resync event occurred during processing */
2611
	if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
L
Linus Torvalds 已提交
2612
		if (test_bit(LOCAL_LOOP_UPDATE, &save_flags))
2613
			set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
2614
		if (test_bit(RSCN_UPDATE, &save_flags)) {
2615
			set_bit(RSCN_UPDATE, &vha->dpc_flags);
2616
		}
L
Linus Torvalds 已提交
2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634
	}

	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
2635
qla2x00_configure_local_loop(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
{
	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;
2647
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
2648 2649 2650

	found_devs = 0;
	new_fcport = NULL;
2651
	entries = MAX_FIBRE_DEVICES_LOOP;
L
Linus Torvalds 已提交
2652

2653 2654 2655 2656
	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 已提交
2657 2658

	/* Get list of logged in devices. */
2659
	memset(ha->gid_list, 0, qla2x00_gid_list_size(ha));
2660
	rval = qla2x00_get_id_list(vha, ha->gid_list, ha->gid_list_dma,
L
Linus Torvalds 已提交
2661 2662 2663 2664
	    &entries);
	if (rval != QLA_SUCCESS)
		goto cleanup_allocation;

2665 2666 2667 2668 2669
	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 已提交
2670 2671

	/* Allocate temporary fcport for any new fcports discovered. */
2672
	new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
L
Linus Torvalds 已提交
2673
	if (new_fcport == NULL) {
2674 2675
		ql_log(ql_log_warn, vha, 0x2018,
		    "Memory allocation failed for fcport.\n");
L
Linus Torvalds 已提交
2676 2677 2678 2679 2680 2681 2682 2683
		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.
	 */
2684
	list_for_each_entry(fcport, &vha->vp_fcports, list) {
L
Linus Torvalds 已提交
2685 2686 2687 2688
		if (atomic_read(&fcport->state) == FCS_ONLINE &&
		    fcport->port_type != FCT_BROADCAST &&
		    (fcport->flags & FCF_FABRIC_DEVICE) == 0) {

2689 2690 2691
			ql_dbg(ql_dbg_disc, vha, 0x2019,
			    "Marking port lost loop_id=0x%04x.\n",
			    fcport->loop_id);
L
Linus Torvalds 已提交
2692

2693
			qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
L
Linus Torvalds 已提交
2694 2695 2696 2697 2698 2699 2700 2701 2702
		}
	}

	/* 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;
2703
		if (IS_QLA2100(ha) || IS_QLA2200(ha))
L
Linus Torvalds 已提交
2704 2705
			loop_id = (uint16_t)
			    ((struct gid_list_info *)id_iter)->loop_id_2100;
2706
		else
L
Linus Torvalds 已提交
2707 2708
			loop_id = le16_to_cpu(
			    ((struct gid_list_info *)id_iter)->loop_id);
2709
		id_iter += ha->gid_list_info_size;
L
Linus Torvalds 已提交
2710 2711 2712 2713 2714 2715

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

		/* Bypass if not same domain and area of adapter. */
2716
		if (area && domain &&
2717
		    (area != vha->d_id.b.area || domain != vha->d_id.b.domain))
L
Linus Torvalds 已提交
2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728
			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;
2729 2730
		new_fcport->vp_idx = vha->vp_idx;
		rval2 = qla2x00_get_port_database(vha, new_fcport, 0);
L
Linus Torvalds 已提交
2731
		if (rval2 != QLA_SUCCESS) {
2732 2733 2734 2735 2736 2737
			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");
2738
			set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
2739 2740 2741 2742 2743 2744
			continue;
		}

		/* Check for matching device in port list. */
		found = 0;
		fcport = NULL;
2745
		list_for_each_entry(fcport, &vha->vp_fcports, list) {
L
Linus Torvalds 已提交
2746 2747 2748 2749
			if (memcmp(new_fcport->port_name, fcport->port_name,
			    WWN_SIZE))
				continue;

2750
			fcport->flags &= ~FCF_FABRIC_DEVICE;
L
Linus Torvalds 已提交
2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762
			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. */
2763 2764 2765
			if (vha->vp_idx) {
				new_fcport->vha = vha;
				new_fcport->vp_idx = vha->vp_idx;
2766
			}
2767
			list_add_tail(&new_fcport->list, &vha->vp_fcports);
L
Linus Torvalds 已提交
2768 2769 2770

			/* Allocate a new replacement fcport. */
			fcport = new_fcport;
2771
			new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
L
Linus Torvalds 已提交
2772
			if (new_fcport == NULL) {
2773 2774
				ql_log(ql_log_warn, vha, 0x201c,
				    "Failed to allocate memory for fcport.\n");
L
Linus Torvalds 已提交
2775 2776 2777 2778 2779 2780
				rval = QLA_MEMORY_ALLOC_FAILED;
				goto cleanup_allocation;
			}
			new_fcport->flags &= ~FCF_FABRIC_DEVICE;
		}

2781
		/* Base iIDMA settings on HBA port speed. */
2782
		fcport->fp_speed = ha->link_data_rate;
2783

2784
		qla2x00_update_fcport(vha, fcport);
L
Linus Torvalds 已提交
2785 2786 2787 2788 2789

		found_devs++;
	}

cleanup_allocation:
J
Jesper Juhl 已提交
2790
	kfree(new_fcport);
L
Linus Torvalds 已提交
2791 2792

	if (rval != QLA_SUCCESS) {
2793 2794
		ql_dbg(ql_dbg_disc, vha, 0x201d,
		    "Configure local loop error exit: rval=%x.\n", rval);
L
Linus Torvalds 已提交
2795 2796 2797 2798 2799
	}

	return (rval);
}

2800
static void
2801
qla2x00_iidma_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
2802 2803
{
#define LS_UNKNOWN      2
2804 2805
	static char *link_speeds[] = { "1", "2", "?", "4", "8", "10" };
	char *link_speed;
2806
	int rval;
2807
	uint16_t mb[4];
2808
	struct qla_hw_data *ha = vha->hw;
2809

2810
	if (!IS_IIDMA_CAPABLE(ha))
2811 2812
		return;

2813 2814 2815
	if (atomic_read(&fcport->state) != FCS_ONLINE)
		return;

2816 2817
	if (fcport->fp_speed == PORT_SPEED_UNKNOWN ||
	    fcport->fp_speed > ha->link_data_rate)
2818 2819
		return;

2820
	rval = qla2x00_set_idma_speed(vha, fcport->loop_id, fcport->fp_speed,
2821
	    mb);
2822
	if (rval != QLA_SUCCESS) {
2823 2824 2825 2826
		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],
2827 2828 2829
		    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,
2830
		    fcport->fp_speed, mb[0], mb[1]);
2831
	} else {
2832 2833 2834 2835 2836
		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];
2837 2838 2839 2840 2841 2842 2843
		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]);
2844 2845 2846
	}
}

2847
static void
2848
qla2x00_reg_remote_port(scsi_qla_host_t *vha, fc_port_t *fcport)
已提交
2849 2850
{
	struct fc_rport_identifiers rport_ids;
2851
	struct fc_rport *rport;
2852
	unsigned long flags;
已提交
2853

2854
	qla2x00_rport_del(fcport);
已提交
2855

2856 2857
	rport_ids.node_name = wwn_to_u64(fcport->node_name);
	rport_ids.port_name = wwn_to_u64(fcport->port_name);
已提交
2858 2859
	rport_ids.port_id = fcport->d_id.b.domain << 16 |
	    fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
2860
	rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
2861
	fcport->rport = rport = fc_remote_port_add(vha->host, 0, &rport_ids);
2862
	if (!rport) {
2863 2864
		ql_log(ql_log_warn, vha, 0x2006,
		    "Unable to allocate fc remote port.\n");
2865 2866
		return;
	}
2867
	spin_lock_irqsave(fcport->vha->host->host_lock, flags);
2868
	*((fc_port_t **)rport->dd_data) = fcport;
2869
	spin_unlock_irqrestore(fcport->vha->host->host_lock, flags);
2870

2871
	rport->supported_classes = fcport->supported_classes;
2872

已提交
2873 2874 2875 2876 2877
	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;
2878
	fc_remote_port_rolechg(rport, rport_ids.roles);
L
Linus Torvalds 已提交
2879 2880
}

2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896
/*
 * 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
2897
qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
2898
{
2899
	fcport->vha = vha;
2900
	fcport->login_retry = 0;
2901
	fcport->flags &= ~(FCF_LOGIN_NEEDED | FCF_ASYNC_SENT);
2902

2903
	qla2x00_iidma_fcport(vha, fcport);
2904
	qla24xx_update_fcport_fcp_prio(vha, fcport);
2905
	qla2x00_reg_remote_port(vha, fcport);
2906
	qla2x00_set_fcport_state(fcport, FCS_ONLINE);
2907 2908
}

L
Linus Torvalds 已提交
2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920
/*
 * qla2x00_configure_fabric
 *      Setup SNS devices with loop ID's.
 *
 * Input:
 *      ha = adapter block pointer.
 *
 * Returns:
 *      0 = success.
 *      BIT_0 = error
 */
static int
2921
qla2x00_configure_fabric(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
2922
{
2923
	int	rval;
L
Linus Torvalds 已提交
2924 2925 2926
	fc_port_t	*fcport, *fcptemp;
	uint16_t	next_loopid;
	uint16_t	mb[MAILBOX_REGISTER_COUNT];
2927
	uint16_t	loop_id;
L
Linus Torvalds 已提交
2928
	LIST_HEAD(new_fcports);
2929 2930
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
L
Linus Torvalds 已提交
2931 2932

	/* If FL port exists, then SNS is present */
2933
	if (IS_FWI2_CAPABLE(ha))
2934 2935 2936
		loop_id = NPH_F_PORT;
	else
		loop_id = SNS_FL_PORT;
2937
	rval = qla2x00_get_port_name(vha, loop_id, vha->fabric_node_name, 1);
L
Linus Torvalds 已提交
2938
	if (rval != QLA_SUCCESS) {
2939 2940
		ql_dbg(ql_dbg_disc, vha, 0x201f,
		    "MBX_GET_PORT_NAME failed, No FL Port.\n");
L
Linus Torvalds 已提交
2941

2942
		vha->device_flags &= ~SWITCH_FOUND;
L
Linus Torvalds 已提交
2943 2944
		return (QLA_SUCCESS);
	}
2945
	vha->device_flags |= SWITCH_FOUND;
L
Linus Torvalds 已提交
2946 2947

	do {
2948 2949
		/* FDMI support. */
		if (ql2xfdmienable &&
2950 2951
		    test_and_clear_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags))
			qla2x00_fdmi_register(vha);
2952

L
Linus Torvalds 已提交
2953
		/* Ensure we are logged into the SNS. */
2954
		if (IS_FWI2_CAPABLE(ha))
2955 2956 2957
			loop_id = NPH_SNS;
		else
			loop_id = SIMPLE_NAME_SERVER;
2958 2959 2960 2961 2962 2963
		rval = ha->isp_ops->fabric_login(vha, loop_id, 0xff, 0xff,
		    0xfc, mb, BIT_1|BIT_0);
		if (rval != QLA_SUCCESS) {
			set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
			return rval;
		}
L
Linus Torvalds 已提交
2964
		if (mb[0] != MBS_COMMAND_COMPLETE) {
2965 2966 2967 2968
			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 已提交
2969 2970 2971
			return (QLA_SUCCESS);
		}

2972 2973
		if (test_and_clear_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags)) {
			if (qla2x00_rft_id(vha)) {
L
Linus Torvalds 已提交
2974
				/* EMPTY */
2975 2976
				ql_dbg(ql_dbg_disc, vha, 0x2045,
				    "Register FC-4 TYPE failed.\n");
L
Linus Torvalds 已提交
2977
			}
2978
			if (qla2x00_rff_id(vha)) {
L
Linus Torvalds 已提交
2979
				/* EMPTY */
2980 2981
				ql_dbg(ql_dbg_disc, vha, 0x2049,
				    "Register FC-4 Features failed.\n");
L
Linus Torvalds 已提交
2982
			}
2983
			if (qla2x00_rnn_id(vha)) {
L
Linus Torvalds 已提交
2984
				/* EMPTY */
2985 2986
				ql_dbg(ql_dbg_disc, vha, 0x204f,
				    "Register Node Name failed.\n");
2987
			} else if (qla2x00_rsnn_nn(vha)) {
L
Linus Torvalds 已提交
2988
				/* EMPTY */
2989 2990
				ql_dbg(ql_dbg_disc, vha, 0x2053,
				    "Register Symobilic Node Name failed.\n");
L
Linus Torvalds 已提交
2991 2992 2993
			}
		}

2994 2995 2996 2997 2998 2999 3000
#define QLA_FCPORT_SCAN		1
#define QLA_FCPORT_FOUND	2

		list_for_each_entry(fcport, &vha->vp_fcports, list) {
			fcport->scan_state = QLA_FCPORT_SCAN;
		}

3001
		rval = qla2x00_find_all_fabric_devs(vha, &new_fcports);
L
Linus Torvalds 已提交
3002 3003 3004 3005 3006
		if (rval != QLA_SUCCESS)
			break;

		/*
		 * Logout all previous fabric devices marked lost, except
3007
		 * FCP2 devices.
L
Linus Torvalds 已提交
3008
		 */
3009 3010
		list_for_each_entry(fcport, &vha->vp_fcports, list) {
			if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
L
Linus Torvalds 已提交
3011 3012 3013 3014 3015
				break;

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

3016 3017
			if (fcport->scan_state == QLA_FCPORT_SCAN &&
			    atomic_read(&fcport->state) == FCS_ONLINE) {
3018
				qla2x00_mark_device_lost(vha, fcport,
3019
				    ql2xplogiabsentdevice, 0);
L
Linus Torvalds 已提交
3020
				if (fcport->loop_id != FC_NO_LOOP_ID &&
3021
				    (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
L
Linus Torvalds 已提交
3022 3023
				    fcport->port_type != FCT_INITIATOR &&
				    fcport->port_type != FCT_BROADCAST) {
3024
					ha->isp_ops->fabric_logout(vha,
3025 3026 3027 3028
					    fcport->loop_id,
					    fcport->d_id.b.domain,
					    fcport->d_id.b.area,
					    fcport->d_id.b.al_pa);
L
Linus Torvalds 已提交
3029 3030 3031 3032 3033 3034
					fcport->loop_id = FC_NO_LOOP_ID;
				}
			}
		}

		/* Starting free loop ID. */
3035
		next_loopid = ha->min_external_loopid;
L
Linus Torvalds 已提交
3036 3037 3038 3039 3040

		/*
		 * Scan through our port list and login entries that need to be
		 * logged in.
		 */
3041 3042 3043
		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 已提交
3044 3045 3046 3047 3048 3049 3050 3051
				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;
3052
				rval = qla2x00_find_new_loop_id(
3053
				    base_vha, fcport);
L
Linus Torvalds 已提交
3054 3055 3056 3057 3058 3059
				if (rval != QLA_SUCCESS) {
					/* Ran out of IDs to use */
					break;
				}
			}
			/* Login and update database */
3060
			qla2x00_fabric_dev_login(vha, fcport, &next_loopid);
L
Linus Torvalds 已提交
3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071
		}

		/* 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) {
3072 3073
			if (atomic_read(&vha->loop_down_timer) ||
			    test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
L
Linus Torvalds 已提交
3074 3075 3076 3077
				break;

			/* Find a new loop ID to use. */
			fcport->loop_id = next_loopid;
3078
			rval = qla2x00_find_new_loop_id(base_vha, fcport);
L
Linus Torvalds 已提交
3079 3080 3081 3082 3083
			if (rval != QLA_SUCCESS) {
				/* Ran out of IDs to use */
				break;
			}

3084
			/* Login and update database */
3085 3086 3087 3088 3089 3090 3091
			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 已提交
3092 3093 3094 3095 3096 3097 3098 3099 3100 3101
		}
	} 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) {
3102 3103
		ql_dbg(ql_dbg_disc, vha, 0x2068,
		    "Configure fabric error exit rval=%d.\n", rval);
L
Linus Torvalds 已提交
3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122
	}

	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
3123 3124
qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
	struct list_head *new_fcports)
L
Linus Torvalds 已提交
3125 3126 3127 3128 3129 3130 3131 3132 3133
{
	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;
3134
	port_id_t	wrap = {}, nxt_d_id;
3135 3136
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *vp, *base_vha = pci_get_drvdata(ha->pdev);
3137
	struct scsi_qla_host *tvp;
L
Linus Torvalds 已提交
3138 3139 3140 3141

	rval = QLA_SUCCESS;

	/* Try GID_PT to get device list, else GAN. */
3142
	if (!ha->swl)
3143
		ha->swl = kcalloc(ha->max_fibre_devices, sizeof(sw_info_t),
3144 3145
		    GFP_KERNEL);
	swl = ha->swl;
3146
	if (!swl) {
L
Linus Torvalds 已提交
3147
		/*EMPTY*/
3148 3149
		ql_dbg(ql_dbg_disc, vha, 0x2054,
		    "GID_PT allocations failed, fallback on GA_NXT.\n");
L
Linus Torvalds 已提交
3150
	} else {
3151
		memset(swl, 0, ha->max_fibre_devices * sizeof(sw_info_t));
3152
		if (qla2x00_gid_pt(vha, swl) != QLA_SUCCESS) {
L
Linus Torvalds 已提交
3153
			swl = NULL;
3154
		} else if (qla2x00_gpn_id(vha, swl) != QLA_SUCCESS) {
L
Linus Torvalds 已提交
3155
			swl = NULL;
3156
		} else if (qla2x00_gnn_id(vha, swl) != QLA_SUCCESS) {
L
Linus Torvalds 已提交
3157
			swl = NULL;
3158
		} else if (ql2xiidmaenable &&
3159 3160
		    qla2x00_gfpn_id(vha, swl) == QLA_SUCCESS) {
			qla2x00_gpsc(vha, swl);
L
Linus Torvalds 已提交
3161
		}
3162 3163 3164 3165

		/* If other queries succeeded probe for FC-4 type */
		if (swl)
			qla2x00_gff_id(vha, swl);
L
Linus Torvalds 已提交
3166 3167 3168 3169
	}
	swl_idx = 0;

	/* Allocate temporary fcport for any new fcports discovered. */
3170
	new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
L
Linus Torvalds 已提交
3171
	if (new_fcport == NULL) {
3172 3173
		ql_log(ql_log_warn, vha, 0x205e,
		    "Failed to allocate memory for fcport.\n");
L
Linus Torvalds 已提交
3174 3175 3176 3177 3178 3179 3180 3181
		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. */
3182 3183 3184
	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 已提交
3185 3186
			continue;

3187 3188 3189
		if (ha->current_topology == ISP_CFG_FL &&
		    (atomic_read(&vha->loop_down_timer) ||
		     LOOP_TRANSITION(vha))) {
3190 3191 3192
			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 已提交
3193
			break;
3194
		}
L
Linus Torvalds 已提交
3195 3196 3197 3198 3199 3200 3201 3202 3203 3204

		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);
3205 3206 3207
				memcpy(new_fcport->fabric_port_name,
				    swl[swl_idx].fabric_port_name, WWN_SIZE);
				new_fcport->fp_speed = swl[swl_idx].fp_speed;
3208
				new_fcport->fc4_type = swl[swl_idx].fc4_type;
L
Linus Torvalds 已提交
3209 3210 3211 3212 3213 3214 3215 3216

				if (swl[swl_idx].d_id.b.rsvd_1 != 0) {
					last_dev = 1;
				}
				swl_idx++;
			}
		} else {
			/* Send GA_NXT to the switch */
3217
			rval = qla2x00_ga_nxt(vha, new_fcport);
L
Linus Torvalds 已提交
3218
			if (rval != QLA_SUCCESS) {
3219 3220 3221
				ql_log(ql_log_warn, vha, 0x2064,
				    "SNS scan failed -- assuming "
				    "zero-entry result.\n");
L
Linus Torvalds 已提交
3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236
				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) {
3237 3238 3239 3240 3241
			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 已提交
3242 3243 3244
			break;
		}

3245
		/* Bypass if same physical adapter. */
3246
		if (new_fcport->d_id.b24 == base_vha->d_id.b24)
L
Linus Torvalds 已提交
3247 3248
			continue;

3249
		/* Bypass virtual ports of the same host. */
3250 3251
		found = 0;
		if (ha->num_vhosts) {
3252 3253 3254
			unsigned long flags;

			spin_lock_irqsave(&ha->vport_slock, flags);
3255
			list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
3256 3257
				if (new_fcport->d_id.b24 == vp->d_id.b24) {
					found = 1;
3258
					break;
3259
				}
3260
			}
3261 3262
			spin_unlock_irqrestore(&ha->vport_slock, flags);

3263
			if (found)
3264 3265 3266
				continue;
		}

3267 3268
		/* Bypass if same domain and area of adapter. */
		if (((new_fcport->d_id.b24 & 0xffff00) ==
3269
		    (vha->d_id.b24 & 0xffff00)) && ha->current_topology ==
3270 3271 3272
			ISP_CFG_FL)
			    continue;

L
Linus Torvalds 已提交
3273 3274 3275 3276
		/* Bypass reserved domain fields. */
		if ((new_fcport->d_id.b.domain & 0xf0) == 0xf0)
			continue;

3277
		/* Bypass ports whose FCP-4 type is not FCP_SCSI */
3278 3279 3280
		if (ql2xgffidenable &&
		    (new_fcport->fc4_type != FC4_TYPE_FCP_SCSI &&
		    new_fcport->fc4_type != FC4_TYPE_UNKNOWN))
3281 3282
			continue;

L
Linus Torvalds 已提交
3283 3284
		/* Locate matching device in database. */
		found = 0;
3285
		list_for_each_entry(fcport, &vha->vp_fcports, list) {
L
Linus Torvalds 已提交
3286 3287 3288 3289
			if (memcmp(new_fcport->port_name, fcport->port_name,
			    WWN_SIZE))
				continue;

3290 3291
			fcport->scan_state = QLA_FCPORT_FOUND;

L
Linus Torvalds 已提交
3292 3293
			found++;

3294 3295 3296 3297 3298
			/* 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 已提交
3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326
			/*
			 * 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 &&
3327
			    (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
3328
			    (fcport->flags & FCF_ASYNC_SENT) == 0 &&
L
Linus Torvalds 已提交
3329 3330
			    fcport->port_type != FCT_INITIATOR &&
			    fcport->port_type != FCT_BROADCAST) {
3331
				ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3332 3333
				    fcport->d_id.b.domain, fcport->d_id.b.area,
				    fcport->d_id.b.al_pa);
L
Linus Torvalds 已提交
3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346
				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;
3347
		new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
L
Linus Torvalds 已提交
3348
		if (new_fcport == NULL) {
3349 3350
			ql_log(ql_log_warn, vha, 0x2066,
			    "Memory allocation failed for fcport.\n");
L
Linus Torvalds 已提交
3351 3352 3353 3354 3355 3356
			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 已提交
3357
	kfree(new_fcport);
L
Linus Torvalds 已提交
3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375

	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.
 */
3376
int
3377
qla2x00_find_new_loop_id(scsi_qla_host_t *vha, fc_port_t *dev)
L
Linus Torvalds 已提交
3378 3379 3380 3381 3382
{
	int	rval;
	int	found;
	fc_port_t *fcport;
	uint16_t first_loop_id;
3383 3384
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *vp;
3385
	struct scsi_qla_host *tvp;
3386
	unsigned long flags = 0;
L
Linus Torvalds 已提交
3387 3388 3389 3390 3391 3392 3393 3394

	rval = QLA_SUCCESS;

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

	for (;;) {
		/* Skip loop ID if already used by adapter. */
3395
		if (dev->loop_id == vha->loop_id)
L
Linus Torvalds 已提交
3396 3397 3398
			dev->loop_id++;

		/* Skip reserved loop IDs. */
3399
		while (qla2x00_is_reserved_id(vha, dev->loop_id))
L
Linus Torvalds 已提交
3400 3401 3402
			dev->loop_id++;

		/* Reset loop ID if passed the end. */
3403
		if (dev->loop_id > ha->max_loop_id) {
L
Linus Torvalds 已提交
3404 3405 3406 3407 3408 3409 3410
			/* first loop ID. */
			dev->loop_id = ha->min_external_loopid;
		}

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

		spin_lock_irqsave(&ha->vport_slock, flags);
3413
		list_for_each_entry_safe(vp, tvp, &ha->vp_list, list) {
3414 3415 3416 3417 3418 3419 3420
			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 已提交
3421
			}
3422 3423
			if (found)
				break;
L
Linus Torvalds 已提交
3424
		}
3425
		spin_unlock_irqrestore(&ha->vport_slock, flags);
L
Linus Torvalds 已提交
3426 3427 3428

		/* If not in use then it is free to use. */
		if (!found) {
3429 3430 3431
			ql_dbg(ql_dbg_disc, dev->vha, 0x2086,
			    "Assigning new loopid=%x, portid=%x.\n",
			    dev->loop_id, dev->d_id.b24);
L
Linus Torvalds 已提交
3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465
			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_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
3466
qla2x00_fabric_dev_login(scsi_qla_host_t *vha, fc_port_t *fcport,
L
Linus Torvalds 已提交
3467 3468 3469 3470
    uint16_t *next_loopid)
{
	int	rval;
	int	retry;
3471
	uint8_t opts;
3472
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
3473 3474 3475 3476

	rval = QLA_SUCCESS;
	retry = 0;

3477
	if (IS_ALOGIO_CAPABLE(ha)) {
3478 3479 3480
		if (fcport->flags & FCF_ASYNC_SENT)
			return rval;
		fcport->flags |= FCF_ASYNC_SENT;
3481 3482 3483 3484 3485
		rval = qla2x00_post_async_login_work(vha, fcport, NULL);
		if (!rval)
			return rval;
	}

3486
	fcport->flags &= ~FCF_ASYNC_SENT;
3487
	rval = qla2x00_fabric_login(vha, fcport, next_loopid);
L
Linus Torvalds 已提交
3488
	if (rval == QLA_SUCCESS) {
3489
		/* Send an ADISC to FCP2 devices.*/
3490
		opts = 0;
3491
		if (fcport->flags & FCF_FCP2_DEVICE)
3492
			opts |= BIT_1;
3493
		rval = qla2x00_get_port_database(vha, fcport, opts);
L
Linus Torvalds 已提交
3494
		if (rval != QLA_SUCCESS) {
3495
			ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3496 3497
			    fcport->d_id.b.domain, fcport->d_id.b.area,
			    fcport->d_id.b.al_pa);
3498
			qla2x00_mark_device_lost(vha, fcport, 1, 0);
L
Linus Torvalds 已提交
3499
		} else {
3500
			qla2x00_update_fcport(vha, fcport);
L
Linus Torvalds 已提交
3501
		}
3502 3503 3504
	} else {
		/* Retry Login. */
		qla2x00_mark_device_lost(vha, fcport, 1, 0);
L
Linus Torvalds 已提交
3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524
	}

	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
3525
qla2x00_fabric_login(scsi_qla_host_t *vha, fc_port_t *fcport,
L
Linus Torvalds 已提交
3526 3527 3528 3529 3530 3531
    uint16_t *next_loopid)
{
	int	rval;
	int	retry;
	uint16_t tmp_loopid;
	uint16_t mb[MAILBOX_REGISTER_COUNT];
3532
	struct qla_hw_data *ha = vha->hw;
L
Linus Torvalds 已提交
3533 3534 3535 3536 3537

	retry = 0;
	tmp_loopid = 0;

	for (;;) {
3538 3539 3540 3541 3542
		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 已提交
3543 3544

		/* Login fcport on switch. */
3545
		rval = ha->isp_ops->fabric_login(vha, fcport->loop_id,
L
Linus Torvalds 已提交
3546 3547
		    fcport->d_id.b.domain, fcport->d_id.b.area,
		    fcport->d_id.b.al_pa, mb, BIT_0);
3548 3549 3550
		if (rval != QLA_SUCCESS) {
			return rval;
		}
L
Linus Torvalds 已提交
3551 3552 3553
		if (mb[0] == MBS_PORT_ID_USED) {
			/*
			 * Device has another loop ID.  The firmware team
3554 3555 3556 3557
			 * 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 已提交
3558 3559 3560 3561 3562
			 */
			retry++;
			tmp_loopid = fcport->loop_id;
			fcport->loop_id = mb[1];

3563 3564 3565
			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 已提交
3566
			    fcport->loop_id, fcport->d_id.b.domain,
3567
			    fcport->d_id.b.area, fcport->d_id.b.al_pa);
L
Linus Torvalds 已提交
3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588

		} 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) {
3589
					fcport->flags |= FCF_FCP2_DEVICE;
L
Linus Torvalds 已提交
3590 3591 3592
				}
			}

3593 3594 3595 3596 3597
			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 已提交
3598 3599 3600 3601 3602 3603 3604
			rval = QLA_SUCCESS;
			break;
		} else if (mb[0] == MBS_LOOP_ID_USED) {
			/*
			 * Loop ID already used, try next loop ID.
			 */
			fcport->loop_id++;
3605
			rval = qla2x00_find_new_loop_id(vha, fcport);
L
Linus Torvalds 已提交
3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616
			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;
3617
			ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3618 3619
			    fcport->d_id.b.domain, fcport->d_id.b.area,
			    fcport->d_id.b.al_pa);
3620
			qla2x00_mark_device_lost(vha, fcport, 1, 0);
L
Linus Torvalds 已提交
3621 3622 3623 3624 3625 3626 3627

			rval = 1;
			break;
		} else {
			/*
			 * unrecoverable / not handled error
			 */
3628 3629 3630 3631 3632
			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 已提交
3633 3634

			*next_loopid = fcport->loop_id;
3635
			ha->isp_ops->fabric_logout(vha, fcport->loop_id,
3636 3637
			    fcport->d_id.b.domain, fcport->d_id.b.area,
			    fcport->d_id.b.al_pa);
L
Linus Torvalds 已提交
3638
			fcport->loop_id = FC_NO_LOOP_ID;
3639
			fcport->login_retry = 0;
L
Linus Torvalds 已提交
3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662

			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
3663
qla2x00_local_device_login(scsi_qla_host_t *vha, fc_port_t *fcport)
L
Linus Torvalds 已提交
3664 3665 3666 3667 3668
{
	int		rval;
	uint16_t	mb[MAILBOX_REGISTER_COUNT];

	memset(mb, 0, sizeof(mb));
3669
	rval = qla2x00_login_local_device(vha, fcport, mb, BIT_0);
L
Linus Torvalds 已提交
3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692
	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
3693
qla2x00_loop_resync(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
3694
{
3695
	int rval = QLA_SUCCESS;
L
Linus Torvalds 已提交
3696
	uint32_t wait_time;
3697 3698 3699
	struct req_que *req;
	struct rsp_que *rsp;

3700
	if (vha->hw->flags.cpu_affinity_enabled)
3701 3702 3703 3704
		req = vha->hw->req_q_map[0];
	else
		req = vha->req;
	rsp = req->rsp;
L
Linus Torvalds 已提交
3705

3706 3707 3708
	clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
	if (vha->flags.online) {
		if (!(rval = qla2x00_fw_ready(vha))) {
L
Linus Torvalds 已提交
3709 3710 3711
			/* Wait at most MAX_TARGET RSCNs for a stable link. */
			wait_time = 256;
			do {
3712
				/* Issue a marker after FW becomes ready. */
3713 3714
				qla2x00_marker(vha, req, rsp, 0, 0,
					MK_SYNC_ALL);
3715
				vha->marker_needed = 0;
L
Linus Torvalds 已提交
3716 3717

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

3720
				qla2x00_configure_loop(vha);
L
Linus Torvalds 已提交
3721
				wait_time--;
3722 3723 3724 3725
			} 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 已提交
3726 3727 3728
		}
	}

3729
	if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
L
Linus Torvalds 已提交
3730 3731
		return (QLA_FUNCTION_FAILED);

3732
	if (rval)
3733 3734
		ql_dbg(ql_dbg_disc, vha, 0x206c,
		    "%s *** FAILED ***.\n", __func__);
L
Linus Torvalds 已提交
3735 3736 3737 3738

	return (rval);
}

3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769
/*
* 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;
}

3770
void
3771
qla2x00_update_fcports(scsi_qla_host_t *base_vha)
3772 3773
{
	fc_port_t *fcport;
3774 3775 3776
	struct scsi_qla_host *vha;
	struct qla_hw_data *ha = base_vha->hw;
	unsigned long flags;
3777

3778
	spin_lock_irqsave(&ha->vport_slock, flags);
3779
	/* Go with deferred removal of rport references. */
3780 3781 3782
	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) {
3783
			if (fcport->drport &&
3784 3785 3786
			    atomic_read(&fcport->state) != FCS_UNCONFIGURED) {
				spin_unlock_irqrestore(&ha->vport_slock, flags);

3787
				qla2x00_rport_del(fcport);
3788 3789 3790 3791 3792 3793 3794

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

3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810
/*
* 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;

3811 3812
	ql_dbg(ql_dbg_p3p, vha, 0xb002,
	    "Performing ISP error recovery - ha=%p.\n", ha);
3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828

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

3829 3830 3831 3832
void
qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
{
	struct qla_hw_data *ha = vha->hw;
3833
	struct scsi_qla_host *vp;
3834
	unsigned long flags;
3835
	fc_port_t *fcport;
3836

3837 3838 3839 3840 3841
	/* For ISP82XX, driver waits for completion of the commands.
	 * online flag should be set.
	 */
	if (!IS_QLA82XX(ha))
		vha->flags.online = 0;
3842 3843
	ha->flags.chip_reset_done = 0;
	clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
3844
	vha->qla_stats.total_isp_aborts++;
3845

3846 3847
	ql_log(ql_log_info, vha, 0x00af,
	    "Performing ISP error recovery - ha=%p.\n", ha);
3848

3849 3850 3851 3852
	/* For ISP82XX, reset_chip is just disabling interrupts.
	 * Driver waits for the completion of the commands.
	 * the interrupts need to be enabled.
	 */
3853 3854 3855 3856 3857 3858 3859
	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);
3860 3861

		spin_lock_irqsave(&ha->vport_slock, flags);
3862
		list_for_each_entry(vp, &ha->vp_list, list) {
3863 3864 3865
			atomic_inc(&vp->vref_count);
			spin_unlock_irqrestore(&ha->vport_slock, flags);

3866
			qla2x00_mark_all_devices_lost(vp, 0);
3867 3868 3869 3870 3871

			spin_lock_irqsave(&ha->vport_slock, flags);
			atomic_dec(&vp->vref_count);
		}
		spin_unlock_irqrestore(&ha->vport_slock, flags);
3872 3873 3874 3875 3876 3877
	} else {
		if (!atomic_read(&vha->loop_down_timer))
			atomic_set(&vha->loop_down_timer,
			    LOOP_DOWN_TIME);
	}

3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893
	/* 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);

3894 3895 3896
	if (!ha->flags.eeh_busy) {
		/* Make sure for ISP 82XX IO DMA is complete */
		if (IS_QLA82XX(ha)) {
3897
			qla82xx_chip_reset_cleanup(vha);
3898 3899
			ql_log(ql_log_info, vha, 0x00b4,
			    "Done chip reset cleanup.\n");
3900

3901 3902 3903 3904
			/* Done waiting for pending commands.
			 * Reset the online flag.
			 */
			vha->flags.online = 0;
3905
		}
3906

3907 3908 3909
		/* Requeue all commands in outstanding command list. */
		qla2x00_abort_all_cmds(vha, DID_RESET << 16);
	}
3910 3911
}

L
Linus Torvalds 已提交
3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922
/*
*  qla2x00_abort_isp
*      Resets ISP and aborts all outstanding commands.
*
* Input:
*      ha           = adapter block pointer.
*
* Returns:
*      0 = success
*/
int
3923
qla2x00_abort_isp(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
3924
{
3925
	int rval;
L
Linus Torvalds 已提交
3926
	uint8_t        status = 0;
3927 3928
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *vp;
3929
	struct req_que *req = ha->req_q_map[0];
3930
	unsigned long flags;
L
Linus Torvalds 已提交
3931

3932
	if (vha->flags.online) {
3933
		qla2x00_abort_isp_cleanup(vha);
L
Linus Torvalds 已提交
3934

3935 3936 3937 3938 3939 3940 3941
		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;
		}

3942
		ha->isp_ops->get_flash_version(vha, req->ring);
3943

3944
		ha->isp_ops->nvram_config(vha);
L
Linus Torvalds 已提交
3945

3946 3947
		if (!qla2x00_restart_isp(vha)) {
			clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
L
Linus Torvalds 已提交
3948

3949
			if (!atomic_read(&vha->loop_down_timer)) {
L
Linus Torvalds 已提交
3950 3951 3952 3953
				/*
				 * Issue marker command only when we are going
				 * to start the I/O .
				 */
3954
				vha->marker_needed = 1;
L
Linus Torvalds 已提交
3955 3956
			}

3957
			vha->flags.online = 1;
L
Linus Torvalds 已提交
3958

3959
			ha->isp_ops->enable_intrs(ha);
L
Linus Torvalds 已提交
3960

A
Andrew Vasquez 已提交
3961
			ha->isp_abort_cnt = 0;
3962
			clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
3963

3964 3965
			if (IS_QLA81XX(ha) || IS_QLA8031(ha))
				qla2x00_get_fw_version(vha);
3966 3967 3968 3969
			if (ha->fce) {
				ha->flags.fce_enabled = 1;
				memset(ha->fce, 0,
				    fce_calc_size(ha->fce_bufs));
3970
				rval = qla2x00_enable_fce_trace(vha,
3971 3972 3973
				    ha->fce_dma, ha->fce_bufs, ha->fce_mb,
				    &ha->fce_bufs);
				if (rval) {
3974
					ql_log(ql_log_warn, vha, 0x8033,
3975 3976 3977 3978 3979
					    "Unable to reinitialize FCE "
					    "(%d).\n", rval);
					ha->flags.fce_enabled = 0;
				}
			}
3980 3981 3982

			if (ha->eft) {
				memset(ha->eft, 0, EFT_SIZE);
3983
				rval = qla2x00_enable_eft_trace(vha,
3984 3985
				    ha->eft_dma, EFT_NUM_BUFFERS);
				if (rval) {
3986
					ql_log(ql_log_warn, vha, 0x8034,
3987 3988 3989 3990
					    "Unable to reinitialize EFT "
					    "(%d).\n", rval);
				}
			}
L
Linus Torvalds 已提交
3991
		} else {	/* failed the ISP abort */
3992 3993
			vha->flags.online = 1;
			if (test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
L
Linus Torvalds 已提交
3994
				if (ha->isp_abort_cnt == 0) {
3995 3996 3997
					ql_log(ql_log_fatal, vha, 0x8035,
					    "ISP error recover failed - "
					    "board disabled.\n");
A
Andrew Vasquez 已提交
3998
					/*
L
Linus Torvalds 已提交
3999 4000 4001
					 * The next call disables the board
					 * completely.
					 */
4002 4003
					ha->isp_ops->reset_adapter(vha);
					vha->flags.online = 0;
L
Linus Torvalds 已提交
4004
					clear_bit(ISP_ABORT_RETRY,
4005
					    &vha->dpc_flags);
L
Linus Torvalds 已提交
4006 4007 4008
					status = 0;
				} else { /* schedule another ISP abort */
					ha->isp_abort_cnt--;
4009 4010 4011
					ql_dbg(ql_dbg_taskm, vha, 0x8020,
					    "ISP abort - retry remaining %d.\n",
					    ha->isp_abort_cnt);
L
Linus Torvalds 已提交
4012 4013 4014 4015
					status = 1;
				}
			} else {
				ha->isp_abort_cnt = MAX_RETRIES_OF_ISP_ABORT;
4016 4017 4018
				ql_dbg(ql_dbg_taskm, vha, 0x8021,
				    "ISP error recovery - retrying (%d) "
				    "more times.\n", ha->isp_abort_cnt);
4019
				set_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
L
Linus Torvalds 已提交
4020 4021 4022
				status = 1;
			}
		}
A
Andrew Vasquez 已提交
4023

L
Linus Torvalds 已提交
4024 4025
	}

4026
	if (!status) {
4027
		ql_dbg(ql_dbg_taskm, vha, 0x8022, "%s succeeded.\n", __func__);
4028 4029 4030 4031 4032 4033 4034

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

4035
				qla2x00_vp_abort_isp(vp);
4036 4037 4038 4039

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

4043
	} else {
4044 4045
		ql_log(ql_log_warn, vha, 0x8023, "%s **** FAILED ****.\n",
		       __func__);
L
Linus Torvalds 已提交
4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061
	}

	return(status);
}

/*
*  qla2x00_restart_isp
*      restarts the ISP after a reset
*
* Input:
*      ha = adapter block pointer.
*
* Returns:
*      0 = success
*/
static int
4062
qla2x00_restart_isp(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
4063
{
4064
	int status = 0;
L
Linus Torvalds 已提交
4065
	uint32_t wait_time;
4066
	struct qla_hw_data *ha = vha->hw;
4067 4068
	struct req_que *req = ha->req_q_map[0];
	struct rsp_que *rsp = ha->rsp_q_map[0];
L
Linus Torvalds 已提交
4069 4070

	/* If firmware needs to be loaded */
4071 4072 4073 4074 4075
	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 已提交
4076 4077
	}

4078 4079
	if (!status && !(status = qla2x00_init_rings(vha))) {
		clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
4080
		ha->flags.chip_reset_done = 1;
4081 4082 4083
		/* Initialize the queues in use */
		qla25xx_init_queues(ha);

4084 4085
		status = qla2x00_fw_ready(vha);
		if (!status) {
4086 4087
			ql_dbg(ql_dbg_taskm, vha, 0x8031,
			    "Start configure loop status = %d.\n", status);
4088 4089

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

4092
			vha->flags.online = 1;
L
Linus Torvalds 已提交
4093 4094 4095
			/* Wait at most MAX_TARGET RSCNs for a stable link. */
			wait_time = 256;
			do {
4096 4097
				clear_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
				qla2x00_configure_loop(vha);
L
Linus Torvalds 已提交
4098
				wait_time--;
4099 4100 4101 4102
			} 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 已提交
4103 4104 4105
		}

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

4109 4110
		ql_dbg(ql_dbg_taskm, vha, 0x8032,
		    "Configure loop done, status = 0x%x.\n", status);
L
Linus Torvalds 已提交
4111 4112 4113 4114
	}
	return (status);
}

4115 4116 4117 4118 4119 4120 4121 4122 4123
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;

4124
	for (i = 1; i < ha->max_rsp_queues; i++) {
4125 4126 4127
		rsp = ha->rsp_q_map[i];
		if (rsp) {
			rsp->options &= ~BIT_0;
4128
			ret = qla25xx_init_rsp_que(base_vha, rsp);
4129
			if (ret != QLA_SUCCESS)
4130 4131 4132
				ql_dbg(ql_dbg_init, base_vha, 0x00ff,
				    "%s Rsp que: %d init failed.\n",
				    __func__, rsp->id);
4133
			else
4134 4135 4136
				ql_dbg(ql_dbg_init, base_vha, 0x0100,
				    "%s Rsp que: %d inited.\n",
				    __func__, rsp->id);
4137
		}
4138 4139
	}
	for (i = 1; i < ha->max_req_queues; i++) {
4140 4141
		req = ha->req_q_map[i];
		if (req) {
4142
		/* Clear outstanding commands array. */
4143
			req->options &= ~BIT_0;
4144
			ret = qla25xx_init_req_que(base_vha, req);
4145
			if (ret != QLA_SUCCESS)
4146 4147 4148
				ql_dbg(ql_dbg_init, base_vha, 0x0101,
				    "%s Req que: %d init failed.\n",
				    __func__, req->id);
4149
			else
4150 4151 4152
				ql_dbg(ql_dbg_init, base_vha, 0x0102,
				    "%s Req que: %d inited.\n",
				    __func__, req->id);
4153 4154 4155 4156 4157
		}
	}
	return ret;
}

L
Linus Torvalds 已提交
4158 4159 4160 4161 4162 4163 4164
/*
* qla2x00_reset_adapter
*      Reset adapter.
*
* Input:
*      ha = adapter block pointer.
*/
4165
void
4166
qla2x00_reset_adapter(scsi_qla_host_t *vha)
L
Linus Torvalds 已提交
4167 4168
{
	unsigned long flags = 0;
4169
	struct qla_hw_data *ha = vha->hw;
4170
	struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
L
Linus Torvalds 已提交
4171

4172
	vha->flags.online = 0;
4173
	ha->isp_ops->disable_intrs(ha);
L
Linus Torvalds 已提交
4174 4175 4176 4177 4178 4179 4180 4181

	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);
}
4182 4183

void
4184
qla24xx_reset_adapter(scsi_qla_host_t *vha)
4185 4186
{
	unsigned long flags = 0;
4187
	struct qla_hw_data *ha = vha->hw;
4188 4189
	struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;

4190 4191 4192
	if (IS_QLA82XX(ha))
		return;

4193
	vha->flags.online = 0;
4194
	ha->isp_ops->disable_intrs(ha);
4195 4196 4197 4198 4199 4200 4201

	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);
4202 4203 4204

	if (IS_NOPOLLING_TYPE(ha))
		ha->isp_ops->enable_intrs(ha);
4205 4206
}

4207 4208 4209
/* On sparc systems, obtain port and node WWN from firmware
 * properties.
 */
4210 4211
static void qla24xx_nvram_wwn_from_ofw(scsi_qla_host_t *vha,
	struct nvram_24xx *nv)
4212 4213
{
#ifdef CONFIG_SPARC
4214
	struct qla_hw_data *ha = vha->hw;
4215
	struct pci_dev *pdev = ha->pdev;
D
David S. Miller 已提交
4216 4217
	struct device_node *dp = pci_device_to_OF_node(pdev);
	const u8 *val;
4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229
	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
}

4230
int
4231
qla24xx_nvram_config(scsi_qla_host_t *vha)
4232
{
4233
	int   rval;
4234 4235 4236 4237 4238 4239
	struct init_cb_24xx *icb;
	struct nvram_24xx *nv;
	uint32_t *dptr;
	uint8_t  *dptr1, *dptr2;
	uint32_t chksum;
	uint16_t cnt;
4240
	struct qla_hw_data *ha = vha->hw;
4241

4242
	rval = QLA_SUCCESS;
4243
	icb = (struct init_cb_24xx *)ha->init_cb;
4244
	nv = ha->nvram;
4245 4246

	/* Determine NVRAM starting address. */
4247 4248 4249 4250
	if (ha->flags.port0) {
		ha->nvram_base = FA_NVRAM_FUNC0_ADDR;
		ha->vpd_base = FA_NVRAM_VPD0_ADDR;
	} else {
4251
		ha->nvram_base = FA_NVRAM_FUNC1_ADDR;
4252 4253
		ha->vpd_base = FA_NVRAM_VPD1_ADDR;
	}
4254 4255
	ha->nvram_size = sizeof(struct nvram_24xx);
	ha->vpd_size = FA_NVRAM_VPD_SIZE;
4256 4257
	if (IS_QLA82XX(ha))
		ha->vpd_size = FA_VPD_SIZE_82XX;
4258

4259 4260
	/* Get VPD data into cache */
	ha->vpd = ha->nvram + VPD_OFFSET;
4261
	ha->isp_ops->read_nvram(vha, (uint8_t *)ha->vpd,
4262 4263 4264
	    ha->nvram_base - FA_NVRAM_FUNC0_ADDR, FA_NVRAM_VPD_SIZE * 4);

	/* Get NVRAM data into cache and calculate checksum. */
4265
	dptr = (uint32_t *)nv;
4266
	ha->isp_ops->read_nvram(vha, (uint8_t *)dptr, ha->nvram_base,
4267 4268 4269 4270
	    ha->nvram_size);
	for (cnt = 0, chksum = 0; cnt < ha->nvram_size >> 2; cnt++)
		chksum += le32_to_cpu(*dptr++);

4271 4272 4273 4274
	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);
4275 4276 4277 4278 4279 4280

	/* 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. */
4281
		ql_log(ql_log_warn, vha, 0x006b,
4282
		    "Inconsistent NVRAM detected: checksum=0x%x id=%c "
4283 4284 4285 4286
		    "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");
4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298

		/*
		 * 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;
4299
		nv->port_name[1] = 0x00 + ha->port_no;
4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313
		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;
4314
		qla24xx_nvram_wwn_from_ofw(vha, nv);
4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330
		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;
4331 4332 4333
	}

	/* Reset Initialization control block */
4334
	memset(icb, 0, ha->init_cb_size);
4335 4336 4337 4338 4339 4340 4341 4342 4343

	/* 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;
4344
	icb->link_down_on_nos = nv->link_down_on_nos;
4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356

	/* 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.
	 */
4357
	qla2x00_set_model_info(vha, nv->model_name, sizeof(nv->model_name),
4358
	    "QLA2462");
4359

4360 4361 4362 4363 4364 4365
	/* 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);
	}

4366
	/* Prepare nodename */
4367
	if ((icb->firmware_options_1 & __constant_cpu_to_le32(BIT_14)) == 0) {
4368 4369 4370 4371 4372 4373 4374 4375 4376 4377
		/*
		 * 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;
4378 4379 4380 4381 4382
	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;
4383
	ha->flags.enable_led_scheme = 0;
4384
	ha->flags.disable_serdes = le32_to_cpu(nv->host_p) & BIT_5 ? 1: 0;
4385

4386 4387
	ha->operating_mode = (le32_to_cpu(icb->firmware_options_2) &
	    (BIT_6 | BIT_5 | BIT_4)) >> 4;
4388 4389 4390 4391 4392 4393 4394 4395

	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];
4396 4397
	memcpy(vha->node_name, icb->node_name, WWN_SIZE);
	memcpy(vha->port_name, icb->port_name, WWN_SIZE);
4398

4399 4400
	icb->execution_throttle = __constant_cpu_to_le16(0xFFFF);

4401 4402 4403 4404 4405 4406 4407 4408
	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);
4409
	icb->login_timeout = nv->login_timeout;
4410

4411 4412
	/* Set minimum RATOV to 100 tenths of a second. */
	ha->r_a_tov = 100;
4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450

	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;

4451
	/* Enable ZIO. */
4452
	if (!vha->flags.init_done) {
4453 4454 4455 4456 4457 4458 4459
		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));
4460
	vha->flags.process_response_queue = 0;
4461
	if (ha->zio_mode != QLA_ZIO_DISABLED) {
4462 4463
		ha->zio_mode = QLA_ZIO_MODE_6;

4464
		ql_log(ql_log_info, vha, 0x006f,
4465 4466 4467 4468 4469 4470
		    "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);
4471
		vha->flags.process_response_queue = 1;
4472 4473
	}

4474
	if (rval) {
4475 4476
		ql_log(ql_log_warn, vha, 0x0070,
		    "NVRAM configuration failed.\n");
4477 4478
	}
	return (rval);
4479 4480
}

4481
static int
4482 4483
qla24xx_load_risc_flash(scsi_qla_host_t *vha, uint32_t *srisc_addr,
    uint32_t faddr)
4484
{
4485
	int	rval = QLA_SUCCESS;
4486 4487 4488 4489 4490
	int	segments, fragment;
	uint32_t *dcode, dlen;
	uint32_t risc_addr;
	uint32_t risc_size;
	uint32_t i;
4491
	struct qla_hw_data *ha = vha->hw;
4492
	struct req_que *req = ha->req_q_map[0];
4493

4494
	ql_dbg(ql_dbg_init, vha, 0x008b,
4495
	    "FW: Loading firmware from flash (%x).\n", faddr);
4496

4497 4498 4499
	rval = QLA_SUCCESS;

	segments = FA_RISC_CODE_SEGMENTS;
4500
	dcode = (uint32_t *)req->ring;
4501 4502 4503
	*srisc_addr = 0;

	/* Validate firmware image by checking version. */
4504
	qla24xx_read_flash_data(vha, dcode, faddr + 4, 4);
4505 4506 4507 4508 4509 4510
	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)) {
4511 4512 4513 4514 4515 4516
		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]);
4517 4518 4519 4520 4521 4522

		return QLA_FUNCTION_FAILED;
	}

	while (segments && rval == QLA_SUCCESS) {
		/* Read segment's load information. */
4523
		qla24xx_read_flash_data(vha, dcode, faddr, 4);
4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534

		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;

4535 4536 4537 4538
			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);
4539

4540
			qla24xx_read_flash_data(vha, dcode, faddr, dlen);
4541 4542 4543
			for (i = 0; i < dlen; i++)
				dcode[i] = swab32(dcode[i]);

4544
			rval = qla2x00_load_ram(vha, req->dma, risc_addr,
4545 4546
			    dlen);
			if (rval) {
4547 4548 4549
				ql_log(ql_log_fatal, vha, 0x008f,
				    "Failed to load segment %d of firmware.\n",
				    fragment);
4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567
				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/"

4568
int
4569
qla2x00_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
4570 4571 4572 4573 4574 4575
{
	int	rval;
	int	i, fragment;
	uint16_t *wcode, *fwcode;
	uint32_t risc_addr, risc_size, fwclen, wlen, *seg;
	struct fw_blob *blob;
4576
	struct qla_hw_data *ha = vha->hw;
4577
	struct req_que *req = ha->req_q_map[0];
4578 4579

	/* Load firmware blob. */
4580
	blob = qla2x00_request_firmware(vha);
4581
	if (!blob) {
4582 4583 4584 4585
		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");
4586 4587 4588 4589 4590
		return QLA_FUNCTION_FAILED;
	}

	rval = QLA_SUCCESS;

4591
	wcode = (uint16_t *)req->ring;
4592 4593 4594 4595 4596 4597
	*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)) {
4598 4599
		ql_log(ql_log_fatal, vha, 0x0085,
		    "Unable to verify integrity of firmware image (%Zd).\n",
4600 4601 4602 4603 4604 4605 4606 4607
		    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)) {
4608 4609 4610 4611 4612
		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]);
4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624
		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) {
4625
			ql_log(ql_log_fatal, vha, 0x0088,
4626
			    "Unable to verify integrity of firmware image "
4627
			    "(%Zd).\n", blob->fw->size);
4628 4629 4630 4631 4632 4633 4634 4635
			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;
4636 4637 4638
			ql_dbg(ql_dbg_init, vha, 0x0089,
			    "Loading risc segment@ risc addr %x number of "
			    "words 0x%x.\n", risc_addr, wlen);
4639 4640 4641 4642

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

4643
			rval = qla2x00_load_ram(vha, req->dma, risc_addr,
4644 4645
			    wlen);
			if (rval) {
4646 4647 4648
				ql_log(ql_log_fatal, vha, 0x008a,
				    "Failed to load segment %d of firmware.\n",
				    fragment);
4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666
				break;
			}

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

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

fail_fw_integrity:
	return QLA_FUNCTION_FAILED;
}

4667 4668
static int
qla24xx_load_risc_blob(scsi_qla_host_t *vha, uint32_t *srisc_addr)
4669 4670 4671 4672 4673 4674 4675
{
	int	rval;
	int	segments, fragment;
	uint32_t *dcode, dlen;
	uint32_t risc_addr;
	uint32_t risc_size;
	uint32_t i;
4676
	struct fw_blob *blob;
4677
	uint32_t *fwcode, fwclen;
4678
	struct qla_hw_data *ha = vha->hw;
4679
	struct req_que *req = ha->req_q_map[0];
4680

4681
	/* Load firmware blob. */
4682
	blob = qla2x00_request_firmware(vha);
4683
	if (!blob) {
4684 4685 4686 4687 4688
		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");
4689

4690
		return QLA_FUNCTION_FAILED;
4691 4692
	}

4693 4694
	ql_dbg(ql_dbg_init, vha, 0x0092,
	    "FW: Loading via request-firmware.\n");
4695

4696 4697 4698
	rval = QLA_SUCCESS;

	segments = FA_RISC_CODE_SEGMENTS;
4699
	dcode = (uint32_t *)req->ring;
4700
	*srisc_addr = 0;
4701
	fwcode = (uint32_t *)blob->fw->data;
4702 4703 4704
	fwclen = 0;

	/* Validate firmware image by checking version. */
4705
	if (blob->fw->size < 8 * sizeof(uint32_t)) {
4706 4707
		ql_log(ql_log_fatal, vha, 0x0093,
		    "Unable to verify integrity of firmware image (%Zd).\n",
4708
		    blob->fw->size);
4709 4710 4711 4712 4713 4714 4715 4716
		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)) {
4717 4718 4719 4720 4721 4722
		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]);
4723 4724 4725 4726 4727 4728 4729 4730 4731 4732
		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);
4733
		if (blob->fw->size < fwclen) {
4734
			ql_log(ql_log_fatal, vha, 0x0096,
4735
			    "Unable to verify integrity of firmware image "
4736
			    "(%Zd).\n", blob->fw->size);
4737

4738 4739 4740 4741 4742 4743 4744 4745 4746
			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;

4747 4748 4749
			ql_dbg(ql_dbg_init, vha, 0x0097,
			    "Loading risc segment@ risc addr %x "
			    "number of dwords 0x%x.\n", risc_addr, dlen);
4750 4751 4752 4753

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

4754
			rval = qla2x00_load_ram(vha, req->dma, risc_addr,
4755
			    dlen);
4756
			if (rval) {
4757 4758 4759
				ql_log(ql_log_fatal, vha, 0x0098,
				    "Failed to load segment %d of firmware.\n",
				    fragment);
4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776
				break;
			}

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

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

fail_fw_integrity:
	return QLA_FUNCTION_FAILED;
}
4777

4778 4779 4780 4781 4782
int
qla24xx_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
{
	int rval;

4783 4784 4785
	if (ql2xfwloadbin == 1)
		return qla81xx_load_risc(vha, srisc_addr);

4786 4787 4788 4789 4790 4791 4792 4793 4794
	/*
	 * 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;

4795 4796
	return qla24xx_load_risc_flash(vha, srisc_addr,
	    vha->hw->flt_region_fw);
4797 4798 4799 4800 4801 4802
}

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

4805
	if (ql2xfwloadbin == 2)
4806
		goto try_blob_fw;
4807

4808 4809 4810 4811
	/*
	 * FW Load priority:
	 * 1) Firmware residing in flash.
	 * 2) Firmware via request-firmware interface (.bin file).
4812
	 * 3) Golden-Firmware residing in flash -- limited operation.
4813
	 */
4814
	rval = qla24xx_load_risc_flash(vha, srisc_addr, ha->flt_region_fw);
4815 4816 4817
	if (rval == QLA_SUCCESS)
		return rval;

4818 4819 4820 4821 4822
try_blob_fw:
	rval = qla24xx_load_risc_blob(vha, srisc_addr);
	if (rval == QLA_SUCCESS || !ha->flt_region_gold_fw)
		return rval;

4823 4824
	ql_log(ql_log_info, vha, 0x0099,
	    "Attempting to fallback to golden firmware.\n");
4825 4826 4827 4828
	rval = qla24xx_load_risc_flash(vha, srisc_addr, ha->flt_region_gold_fw);
	if (rval != QLA_SUCCESS)
		return rval;

4829
	ql_log(ql_log_info, vha, 0x009a, "Update operational firmware.\n");
4830 4831
	ha->flags.running_gold_fw = 1;
	return rval;
4832 4833
}

4834
void
4835
qla2x00_try_to_stop_firmware(scsi_qla_host_t *vha)
4836 4837
{
	int ret, retries;
4838
	struct qla_hw_data *ha = vha->hw;
4839

4840 4841
	if (ha->flags.pci_channel_io_perm_failure)
		return;
4842
	if (!IS_FWI2_CAPABLE(ha))
4843
		return;
4844 4845
	if (!ha->fw_major_version)
		return;
4846

4847
	ret = qla2x00_stop_firmware(vha);
4848
	for (retries = 5; ret != QLA_SUCCESS && ret != QLA_FUNCTION_TIMEOUT &&
4849
	    ret != QLA_INVALID_COMMAND && retries ; retries--) {
4850 4851
		ha->isp_ops->reset_chip(vha);
		if (ha->isp_ops->chip_diag(vha) != QLA_SUCCESS)
4852
			continue;
4853
		if (qla2x00_setup_chip(vha) != QLA_SUCCESS)
4854
			continue;
4855 4856
		ql_log(ql_log_info, vha, 0x8015,
		    "Attempting retry of stop-firmware command.\n");
4857
		ret = qla2x00_stop_firmware(vha);
4858 4859
	}
}
4860 4861

int
4862
qla24xx_configure_vhba(scsi_qla_host_t *vha)
4863 4864
{
	int rval = QLA_SUCCESS;
4865
	int rval2;
4866
	uint16_t mb[MAILBOX_REGISTER_COUNT];
4867 4868
	struct qla_hw_data *ha = vha->hw;
	struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
4869 4870
	struct req_que *req;
	struct rsp_que *rsp;
4871

4872
	if (!vha->vp_idx)
4873 4874
		return -EINVAL;

4875
	rval = qla2x00_fw_ready(base_vha);
4876
	if (ha->flags.cpu_affinity_enabled)
4877 4878 4879 4880 4881
		req = ha->req_q_map[0];
	else
		req = vha->req;
	rsp = req->rsp;

4882
	if (rval == QLA_SUCCESS) {
4883
		clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
4884
		qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL);
4885 4886
	}

4887
	vha->flags.management_server_logged_in = 0;
4888 4889

	/* Login to SNS first */
4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901
	rval2 = ha->isp_ops->fabric_login(vha, NPH_SNS, 0xff, 0xff, 0xfc, mb,
	    BIT_1);
	if (rval2 != QLA_SUCCESS || mb[0] != MBS_COMMAND_COMPLETE) {
		if (rval2 == QLA_MEMORY_ALLOC_FAILED)
			ql_dbg(ql_dbg_init, vha, 0x0120,
			    "Failed SNS login: loop_id=%x, rval2=%d\n",
			    NPH_SNS, rval2);
		else
			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]);
4902 4903 4904
		return (QLA_FUNCTION_FAILED);
	}

4905 4906 4907 4908 4909
	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);
4910 4911 4912

	return rval;
}
4913 4914 4915 4916 4917 4918 4919

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

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

static struct qla_chip_state_84xx *
4920
qla84xx_get_chip(struct scsi_qla_host *vha)
4921 4922
{
	struct qla_chip_state_84xx *cs84xx;
4923
	struct qla_hw_data *ha = vha->hw;
4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962

	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
4963
qla84xx_put_chip(struct scsi_qla_host *vha)
4964
{
4965
	struct qla_hw_data *ha = vha->hw;
4966 4967 4968 4969 4970
	if (ha->cs84xx)
		kref_put(&ha->cs84xx->kref, __qla84xx_chip_release);
}

static int
4971
qla84xx_init_chip(scsi_qla_host_t *vha)
4972 4973 4974
{
	int rval;
	uint16_t status[2];
4975
	struct qla_hw_data *ha = vha->hw;
4976 4977 4978

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

4979
	rval = qla84xx_verify_chip(vha, status);
4980 4981 4982 4983 4984 4985

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

	return rval != QLA_SUCCESS || status[0] ? QLA_FUNCTION_FAILED:
	    QLA_SUCCESS;
}
4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010

/* 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;
5011 5012
	ha->isp_ops->read_optrom(vha, ha->vpd, ha->flt_region_vpd << 2,
	    ha->vpd_size);
5013 5014

	/* Get NVRAM data into cache and calculate checksum. */
5015
	ha->isp_ops->read_optrom(vha, ha->nvram, ha->flt_region_nvram << 2,
5016
	    ha->nvram_size);
5017
	dptr = (uint32_t *)nv;
5018 5019 5020
	for (cnt = 0, chksum = 0; cnt < ha->nvram_size >> 2; cnt++)
		chksum += le32_to_cpu(*dptr++);

5021 5022 5023 5024
	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);
5025 5026 5027 5028 5029 5030

	/* 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. */
5031
		ql_log(ql_log_info, vha, 0x0073,
5032
		    "Inconsistent NVRAM detected: checksum=0x%x id=%c "
5033
		    "version=0x%x.\n", chksum, nv->id[0],
5034
		    le16_to_cpu(nv->nvram_version));
5035 5036 5037
		ql_log(ql_log_info, vha, 0x0074,
		    "Falling back to functioning (yet invalid -- WWPN) "
		    "defaults.\n");
5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048

		/*
		 * 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;
5049
		nv->port_name[1] = 0x00 + ha->port_no;
5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076
		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);
5077
		nv->link_down_timeout = __constant_cpu_to_le16(180);
5078
		nv->enode_mac[0] = 0x00;
5079 5080
		nv->enode_mac[1] = 0xC0;
		nv->enode_mac[2] = 0xDD;
5081 5082
		nv->enode_mac[3] = 0x04;
		nv->enode_mac[4] = 0x05;
5083
		nv->enode_mac[5] = 0x06 + ha->port_no;
5084 5085 5086 5087 5088

		rval = 1;
	}

	/* Reset Initialization control block */
5089
	memset(icb, 0, ha->init_cb_size);
5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110

	/* 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))) {
5111 5112 5113
		icb->enode_mac[0] = 0x00;
		icb->enode_mac[1] = 0xC0;
		icb->enode_mac[2] = 0xDD;
5114 5115
		icb->enode_mac[3] = 0x04;
		icb->enode_mac[4] = 0x05;
5116
		icb->enode_mac[5] = 0x06 + ha->port_no;
5117 5118
	}

5119 5120 5121
	/* Use extended-initialization control block. */
	memcpy(ha->ex_init_cb, &nv->ex_version, sizeof(*ha->ex_init_cb));

5122 5123 5124 5125
	/*
	 * Setup driver NVRAM options.
	 */
	qla2x00_set_model_info(vha, nv->model_name, sizeof(nv->model_name),
5126
	    "QLE8XXX");
5127 5128 5129 5130 5131 5132 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 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215

	/* 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;

5216 5217 5218 5219
	/* 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);

5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232
	/* 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;

5233
		ql_log(ql_log_info, vha, 0x0075,
5234
		    "ZIO mode %d enabled; timer delay (%d us).\n",
5235 5236
		    ha->zio_mode,
		    ha->zio_timer * 100);
5237 5238 5239 5240 5241 5242 5243 5244

		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) {
5245 5246
		ql_log(ql_log_warn, vha, 0x0076,
		    "NVRAM configuration failed.\n");
5247 5248 5249 5250
	}
	return (rval);
}

5251 5252 5253 5254 5255 5256 5257 5258 5259
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;
5260
	unsigned long flags;
5261 5262 5263 5264 5265 5266 5267 5268

	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) {
5269 5270
			ql_log(ql_log_info, vha, 0x803c,
			    "Start configure loop, status =%d.\n", status);
5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291

			/* 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;

5292
		ql_log(ql_log_info, vha, 0x8000,
5293
		    "Configure loop done, status = 0x%x.\n", status);
5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313
	}

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

5314
		/* Update the firmware version */
5315
		status = qla82xx_check_md_needed(vha);
5316

5317 5318 5319 5320 5321 5322 5323 5324
		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) {
5325
				ql_log(ql_log_warn, vha, 0x8001,
5326 5327
				    "Unable to reinitialize FCE (%d).\n",
				    rval);
5328 5329 5330 5331 5332 5333 5334 5335 5336
				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) {
5337
				ql_log(ql_log_warn, vha, 0x8010,
5338 5339
				    "Unable to reinitialize EFT (%d).\n",
				    rval);
5340 5341 5342 5343 5344
			}
		}
	}

	if (!status) {
5345
		ql_dbg(ql_dbg_taskm, vha, 0x8011,
5346
		    "qla82xx_restart_isp succeeded.\n");
5347 5348 5349 5350 5351 5352 5353

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

5354
				qla2x00_vp_abort_isp(vp);
5355 5356 5357 5358

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

5362
	} else {
5363
		ql_log(ql_log_warn, vha, 0x8016,
5364
		    "qla82xx_restart_isp **** FAILED ****.\n");
5365 5366 5367 5368 5369
	}

	return status;
}

5370
void
5371
qla81xx_update_fw_options(scsi_qla_host_t *vha)
5372
{
5373 5374 5375 5376 5377 5378 5379 5380 5381
	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);
5382
}
S
Sarang Radke 已提交
5383 5384 5385 5386 5387 5388 5389 5390 5391

/*
 * 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:
5392
 *	vha = scsi host structure pointer.
S
Sarang Radke 已提交
5393 5394 5395
 *	fcport = port structure pointer.
 *
 * Return:
5396
 *	non-zero (if found)
5397
 *	-1 (if not found)
S
Sarang Radke 已提交
5398 5399 5400 5401
 *
 * Context:
 * 	Kernel context
 */
5402
static int
S
Sarang Radke 已提交
5403 5404 5405 5406
qla24xx_get_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
{
	int i, entries;
	uint8_t pid_match, wwn_match;
5407
	int priority;
S
Sarang Radke 已提交
5408 5409 5410 5411 5412 5413
	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)
5414
		return -1;
S
Sarang Radke 已提交
5415

5416
	priority = -1;
S
Sarang Radke 已提交
5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485
	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:
5486
 *	vha = scsi host structure pointer.
S
Sarang Radke 已提交
5487 5488 5489 5490 5491 5492 5493 5494 5495
 *	fcp = port structure pointer.
 *
 * Return:
 *	QLA_SUCCESS or QLA_FUNCTION_FAILED
 *
 * Context:
 *	Kernel context.
 */
int
5496
qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
S
Sarang Radke 已提交
5497 5498
{
	int ret;
5499
	int priority;
S
Sarang Radke 已提交
5500 5501
	uint16_t mb[5];

5502 5503
	if (fcport->port_type != FCT_TARGET ||
	    fcport->loop_id == FC_NO_LOOP_ID)
S
Sarang Radke 已提交
5504 5505
		return QLA_FUNCTION_FAILED;

5506
	priority = qla24xx_get_fcp_prio(vha, fcport);
5507 5508 5509
	if (priority < 0)
		return QLA_FUNCTION_FAILED;

5510 5511 5512 5513 5514
	if (IS_QLA82XX(vha->hw)) {
		fcport->fcp_prio = priority & 0xf;
		return QLA_SUCCESS;
	}

5515
	ret = qla24xx_set_fcp_prio(vha, fcport->loop_id, priority, mb);
5516 5517 5518 5519 5520 5521 5522
	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);
5523
		fcport->fcp_prio = priority & 0xf;
5524
	} else
5525
		ql_dbg(ql_dbg_user, vha, 0x704f,
5526 5527 5528 5529
		    "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 已提交
5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558
	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;
}