qla_gs.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * QLogic Fibre Channel HBA Driver
   4 * Copyright (c)  2003-2014 QLogic Corporation
   5 */
   6#include "qla_def.h"
   7#include "qla_target.h"
   8#include <linux/utsname.h>
   9
  10static int qla2x00_sns_ga_nxt(scsi_qla_host_t *, fc_port_t *);
  11static int qla2x00_sns_gid_pt(scsi_qla_host_t *, sw_info_t *);
  12static int qla2x00_sns_gpn_id(scsi_qla_host_t *, sw_info_t *);
  13static int qla2x00_sns_gnn_id(scsi_qla_host_t *, sw_info_t *);
  14static int qla2x00_sns_rft_id(scsi_qla_host_t *);
  15static int qla2x00_sns_rnn_id(scsi_qla_host_t *);
  16static int qla_async_rftid(scsi_qla_host_t *, port_id_t *);
  17static int qla_async_rffid(scsi_qla_host_t *, port_id_t *, u8, u8);
  18static int qla_async_rnnid(scsi_qla_host_t *, port_id_t *, u8*);
  19static int qla_async_rsnn_nn(scsi_qla_host_t *);
  20
  21
  22
  23/**
  24 * qla2x00_prep_ms_iocb() - Prepare common MS/CT IOCB fields for SNS CT query.
  25 * @vha: HA context
  26 * @arg: CT arguments
  27 *
  28 * Returns a pointer to the @vha's ms_iocb.
  29 */
  30void *
  31qla2x00_prep_ms_iocb(scsi_qla_host_t *vha, struct ct_arg *arg)
  32{
  33	struct qla_hw_data *ha = vha->hw;
  34	ms_iocb_entry_t *ms_pkt;
  35
  36	ms_pkt = (ms_iocb_entry_t *)arg->iocb;
  37	memset(ms_pkt, 0, sizeof(ms_iocb_entry_t));
  38
  39	ms_pkt->entry_type = MS_IOCB_TYPE;
  40	ms_pkt->entry_count = 1;
  41	SET_TARGET_ID(ha, ms_pkt->loop_id, SIMPLE_NAME_SERVER);
  42	ms_pkt->control_flags = cpu_to_le16(CF_READ | CF_HEAD_TAG);
  43	ms_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
  44	ms_pkt->cmd_dsd_count = cpu_to_le16(1);
  45	ms_pkt->total_dsd_count = cpu_to_le16(2);
  46	ms_pkt->rsp_bytecount = cpu_to_le32(arg->rsp_size);
  47	ms_pkt->req_bytecount = cpu_to_le32(arg->req_size);
  48
  49	put_unaligned_le64(arg->req_dma, &ms_pkt->req_dsd.address);
  50	ms_pkt->req_dsd.length = ms_pkt->req_bytecount;
  51
  52	put_unaligned_le64(arg->rsp_dma, &ms_pkt->rsp_dsd.address);
  53	ms_pkt->rsp_dsd.length = ms_pkt->rsp_bytecount;
  54
  55	vha->qla_stats.control_requests++;
  56
  57	return (ms_pkt);
  58}
  59
  60/**
  61 * qla24xx_prep_ms_iocb() - Prepare common CT IOCB fields for SNS CT query.
  62 * @vha: HA context
  63 * @arg: CT arguments
  64 *
  65 * Returns a pointer to the @ha's ms_iocb.
  66 */
  67void *
  68qla24xx_prep_ms_iocb(scsi_qla_host_t *vha, struct ct_arg *arg)
  69{
  70	struct qla_hw_data *ha = vha->hw;
  71	struct ct_entry_24xx *ct_pkt;
  72
  73	ct_pkt = (struct ct_entry_24xx *)arg->iocb;
  74	memset(ct_pkt, 0, sizeof(struct ct_entry_24xx));
  75
  76	ct_pkt->entry_type = CT_IOCB_TYPE;
  77	ct_pkt->entry_count = 1;
  78	ct_pkt->nport_handle = cpu_to_le16(arg->nport_handle);
  79	ct_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
  80	ct_pkt->cmd_dsd_count = cpu_to_le16(1);
  81	ct_pkt->rsp_dsd_count = cpu_to_le16(1);
  82	ct_pkt->rsp_byte_count = cpu_to_le32(arg->rsp_size);
  83	ct_pkt->cmd_byte_count = cpu_to_le32(arg->req_size);
  84
  85	put_unaligned_le64(arg->req_dma, &ct_pkt->dsd[0].address);
  86	ct_pkt->dsd[0].length = ct_pkt->cmd_byte_count;
  87
  88	put_unaligned_le64(arg->rsp_dma, &ct_pkt->dsd[1].address);
  89	ct_pkt->dsd[1].length = ct_pkt->rsp_byte_count;
  90	ct_pkt->vp_index = vha->vp_idx;
  91
  92	vha->qla_stats.control_requests++;
  93
  94	return (ct_pkt);
  95}
  96
  97/**
  98 * qla2x00_prep_ct_req() - Prepare common CT request fields for SNS query.
  99 * @p: CT request buffer
 100 * @cmd: GS command
 101 * @rsp_size: response size in bytes
 102 *
 103 * Returns a pointer to the intitialized @ct_req.
 104 */
 105static inline struct ct_sns_req *
 106qla2x00_prep_ct_req(struct ct_sns_pkt *p, uint16_t cmd, uint16_t rsp_size)
 107{
 108	memset(p, 0, sizeof(struct ct_sns_pkt));
 109
 110	p->p.req.header.revision = 0x01;
 111	p->p.req.header.gs_type = 0xFC;
 112	p->p.req.header.gs_subtype = 0x02;
 113	p->p.req.command = cpu_to_be16(cmd);
 114	p->p.req.max_rsp_size = cpu_to_be16((rsp_size - 16) / 4);
 115
 116	return &p->p.req;
 117}
 118
 119int
 120qla2x00_chk_ms_status(scsi_qla_host_t *vha, ms_iocb_entry_t *ms_pkt,
 121    struct ct_sns_rsp *ct_rsp, const char *routine)
 122{
 123	int rval;
 124	uint16_t comp_status;
 125	struct qla_hw_data *ha = vha->hw;
 126	bool lid_is_sns = false;
 127
 128	rval = QLA_FUNCTION_FAILED;
 129	if (ms_pkt->entry_status != 0) {
 130		ql_dbg(ql_dbg_disc, vha, 0x2031,
 131		    "%s failed, error status (%x) on port_id: %02x%02x%02x.\n",
 132		    routine, ms_pkt->entry_status, vha->d_id.b.domain,
 133		    vha->d_id.b.area, vha->d_id.b.al_pa);
 134	} else {
 135		if (IS_FWI2_CAPABLE(ha))
 136			comp_status = le16_to_cpu(
 137			    ((struct ct_entry_24xx *)ms_pkt)->comp_status);
 138		else
 139			comp_status = le16_to_cpu(ms_pkt->status);
 140		switch (comp_status) {
 141		case CS_COMPLETE:
 142		case CS_DATA_UNDERRUN:
 143		case CS_DATA_OVERRUN:		/* Overrun? */
 144			if (ct_rsp->header.response !=
 145			    cpu_to_be16(CT_ACCEPT_RESPONSE)) {
 146				ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2077,
 147				    "%s failed rejected request on port_id: %02x%02x%02x Completion status 0x%x, response 0x%x\n",
 148				    routine, vha->d_id.b.domain,
 149				    vha->d_id.b.area, vha->d_id.b.al_pa,
 150				    comp_status, ct_rsp->header.response);
 151				ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha,
 152				    0x2078, ct_rsp,
 153				    offsetof(typeof(*ct_rsp), rsp));
 154				rval = QLA_INVALID_COMMAND;
 155			} else
 156				rval = QLA_SUCCESS;
 157			break;
 158		case CS_PORT_LOGGED_OUT:
 159			if (IS_FWI2_CAPABLE(ha)) {
 160				if (le16_to_cpu(ms_pkt->loop_id.extended) ==
 161				    NPH_SNS)
 162					lid_is_sns = true;
 163			} else {
 164				if (le16_to_cpu(ms_pkt->loop_id.extended) ==
 165				    SIMPLE_NAME_SERVER)
 166					lid_is_sns = true;
 167			}
 168			if (lid_is_sns) {
 169				ql_dbg(ql_dbg_async, vha, 0x502b,
 170					"%s failed, Name server has logged out",
 171					routine);
 172				rval = QLA_NOT_LOGGED_IN;
 173				set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
 174				set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
 175			}
 176			break;
 177		case CS_TIMEOUT:
 178			rval = QLA_FUNCTION_TIMEOUT;
 179			fallthrough;
 180		default:
 181			ql_dbg(ql_dbg_disc, vha, 0x2033,
 182			    "%s failed, completion status (%x) on port_id: "
 183			    "%02x%02x%02x.\n", routine, comp_status,
 184			    vha->d_id.b.domain, vha->d_id.b.area,
 185			    vha->d_id.b.al_pa);
 186			break;
 187		}
 188	}
 189	return rval;
 190}
 191
 192/**
 193 * qla2x00_ga_nxt() - SNS scan for fabric devices via GA_NXT command.
 194 * @vha: HA context
 195 * @fcport: fcport entry to updated
 196 *
 197 * Returns 0 on success.
 198 */
 199int
 200qla2x00_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
 201{
 202	int		rval;
 203
 204	ms_iocb_entry_t	*ms_pkt;
 205	struct ct_sns_req	*ct_req;
 206	struct ct_sns_rsp	*ct_rsp;
 207	struct qla_hw_data *ha = vha->hw;
 208	struct ct_arg arg;
 209
 210	if (IS_QLA2100(ha) || IS_QLA2200(ha))
 211		return qla2x00_sns_ga_nxt(vha, fcport);
 212
 213	arg.iocb = ha->ms_iocb;
 214	arg.req_dma = ha->ct_sns_dma;
 215	arg.rsp_dma = ha->ct_sns_dma;
 216	arg.req_size = GA_NXT_REQ_SIZE;
 217	arg.rsp_size = GA_NXT_RSP_SIZE;
 218	arg.nport_handle = NPH_SNS;
 219
 220	/* Issue GA_NXT */
 221	/* Prepare common MS IOCB */
 222	ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
 223
 224	/* Prepare CT request */
 225	ct_req = qla2x00_prep_ct_req(ha->ct_sns, GA_NXT_CMD,
 226	    GA_NXT_RSP_SIZE);
 227	ct_rsp = &ha->ct_sns->p.rsp;
 228
 229	/* Prepare CT arguments -- port_id */
 230	ct_req->req.port_id.port_id = port_id_to_be_id(fcport->d_id);
 231
 232	/* Execute MS IOCB */
 233	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
 234	    sizeof(ms_iocb_entry_t));
 235	if (rval != QLA_SUCCESS) {
 236		/*EMPTY*/
 237		ql_dbg(ql_dbg_disc, vha, 0x2062,
 238		    "GA_NXT issue IOCB failed (%d).\n", rval);
 239	} else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "GA_NXT") !=
 240	    QLA_SUCCESS) {
 241		rval = QLA_FUNCTION_FAILED;
 242	} else {
 243		/* Populate fc_port_t entry. */
 244		fcport->d_id = be_to_port_id(ct_rsp->rsp.ga_nxt.port_id);
 245
 246		memcpy(fcport->node_name, ct_rsp->rsp.ga_nxt.node_name,
 247		    WWN_SIZE);
 248		memcpy(fcport->port_name, ct_rsp->rsp.ga_nxt.port_name,
 249		    WWN_SIZE);
 250
 251		fcport->fc4_type = (ct_rsp->rsp.ga_nxt.fc4_types[2] & BIT_0) ?
 252		    FS_FC4TYPE_FCP : FC4_TYPE_OTHER;
 253
 254		if (ct_rsp->rsp.ga_nxt.port_type != NS_N_PORT_TYPE &&
 255		    ct_rsp->rsp.ga_nxt.port_type != NS_NL_PORT_TYPE)
 256			fcport->d_id.b.domain = 0xf0;
 257
 258		ql_dbg(ql_dbg_disc, vha, 0x2063,
 259		    "GA_NXT entry - nn %8phN pn %8phN "
 260		    "port_id=%02x%02x%02x.\n",
 261		    fcport->node_name, fcport->port_name,
 262		    fcport->d_id.b.domain, fcport->d_id.b.area,
 263		    fcport->d_id.b.al_pa);
 264	}
 265
 266	return (rval);
 267}
 268
 269static inline int
 270qla2x00_gid_pt_rsp_size(scsi_qla_host_t *vha)
 271{
 272	return vha->hw->max_fibre_devices * 4 + 16;
 273}
 274
 275/**
 276 * qla2x00_gid_pt() - SNS scan for fabric devices via GID_PT command.
 277 * @vha: HA context
 278 * @list: switch info entries to populate
 279 *
 280 * NOTE: Non-Nx_Ports are not requested.
 281 *
 282 * Returns 0 on success.
 283 */
 284int
 285qla2x00_gid_pt(scsi_qla_host_t *vha, sw_info_t *list)
 286{
 287	int		rval;
 288	uint16_t	i;
 289
 290	ms_iocb_entry_t	*ms_pkt;
 291	struct ct_sns_req	*ct_req;
 292	struct ct_sns_rsp	*ct_rsp;
 293
 294	struct ct_sns_gid_pt_data *gid_data;
 295	struct qla_hw_data *ha = vha->hw;
 296	uint16_t gid_pt_rsp_size;
 297	struct ct_arg arg;
 298
 299	if (IS_QLA2100(ha) || IS_QLA2200(ha))
 300		return qla2x00_sns_gid_pt(vha, list);
 301
 302	gid_data = NULL;
 303	gid_pt_rsp_size = qla2x00_gid_pt_rsp_size(vha);
 304
 305	arg.iocb = ha->ms_iocb;
 306	arg.req_dma = ha->ct_sns_dma;
 307	arg.rsp_dma = ha->ct_sns_dma;
 308	arg.req_size = GID_PT_REQ_SIZE;
 309	arg.rsp_size = gid_pt_rsp_size;
 310	arg.nport_handle = NPH_SNS;
 311
 312	/* Issue GID_PT */
 313	/* Prepare common MS IOCB */
 314	ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
 315
 316	/* Prepare CT request */
 317	ct_req = qla2x00_prep_ct_req(ha->ct_sns, GID_PT_CMD, gid_pt_rsp_size);
 318	ct_rsp = &ha->ct_sns->p.rsp;
 319
 320	/* Prepare CT arguments -- port_type */
 321	ct_req->req.gid_pt.port_type = NS_NX_PORT_TYPE;
 322
 323	/* Execute MS IOCB */
 324	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
 325	    sizeof(ms_iocb_entry_t));
 326	if (rval != QLA_SUCCESS) {
 327		/*EMPTY*/
 328		ql_dbg(ql_dbg_disc, vha, 0x2055,
 329		    "GID_PT issue IOCB failed (%d).\n", rval);
 330	} else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "GID_PT") !=
 331	    QLA_SUCCESS) {
 332		rval = QLA_FUNCTION_FAILED;
 333	} else {
 334		/* Set port IDs in switch info list. */
 335		for (i = 0; i < ha->max_fibre_devices; i++) {
 336			gid_data = &ct_rsp->rsp.gid_pt.entries[i];
 337			list[i].d_id = be_to_port_id(gid_data->port_id);
 338			memset(list[i].fabric_port_name, 0, WWN_SIZE);
 339			list[i].fp_speed = PORT_SPEED_UNKNOWN;
 340
 341			/* Last one exit. */
 342			if (gid_data->control_byte & BIT_7) {
 343				list[i].d_id.b.rsvd_1 = gid_data->control_byte;
 344				break;
 345			}
 346		}
 347
 348		/*
 349		 * If we've used all available slots, then the switch is
 350		 * reporting back more devices than we can handle with this
 351		 * single call.  Return a failed status, and let GA_NXT handle
 352		 * the overload.
 353		 */
 354		if (i == ha->max_fibre_devices)
 355			rval = QLA_FUNCTION_FAILED;
 356	}
 357
 358	return (rval);
 359}
 360
 361/**
 362 * qla2x00_gpn_id() - SNS Get Port Name (GPN_ID) query.
 363 * @vha: HA context
 364 * @list: switch info entries to populate
 365 *
 366 * Returns 0 on success.
 367 */
 368int
 369qla2x00_gpn_id(scsi_qla_host_t *vha, sw_info_t *list)
 370{
 371	int		rval = QLA_SUCCESS;
 372	uint16_t	i;
 373
 374	ms_iocb_entry_t	*ms_pkt;
 375	struct ct_sns_req	*ct_req;
 376	struct ct_sns_rsp	*ct_rsp;
 377	struct qla_hw_data *ha = vha->hw;
 378	struct ct_arg arg;
 379
 380	if (IS_QLA2100(ha) || IS_QLA2200(ha))
 381		return qla2x00_sns_gpn_id(vha, list);
 382
 383	arg.iocb = ha->ms_iocb;
 384	arg.req_dma = ha->ct_sns_dma;
 385	arg.rsp_dma = ha->ct_sns_dma;
 386	arg.req_size = GPN_ID_REQ_SIZE;
 387	arg.rsp_size = GPN_ID_RSP_SIZE;
 388	arg.nport_handle = NPH_SNS;
 389
 390	for (i = 0; i < ha->max_fibre_devices; i++) {
 391		/* Issue GPN_ID */
 392		/* Prepare common MS IOCB */
 393		ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
 394
 395		/* Prepare CT request */
 396		ct_req = qla2x00_prep_ct_req(ha->ct_sns, GPN_ID_CMD,
 397		    GPN_ID_RSP_SIZE);
 398		ct_rsp = &ha->ct_sns->p.rsp;
 399
 400		/* Prepare CT arguments -- port_id */
 401		ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
 402
 403		/* Execute MS IOCB */
 404		rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
 405		    sizeof(ms_iocb_entry_t));
 406		if (rval != QLA_SUCCESS) {
 407			/*EMPTY*/
 408			ql_dbg(ql_dbg_disc, vha, 0x2056,
 409			    "GPN_ID issue IOCB failed (%d).\n", rval);
 410			break;
 411		} else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
 412		    "GPN_ID") != QLA_SUCCESS) {
 413			rval = QLA_FUNCTION_FAILED;
 414			break;
 415		} else {
 416			/* Save portname */
 417			memcpy(list[i].port_name,
 418			    ct_rsp->rsp.gpn_id.port_name, WWN_SIZE);
 419		}
 420
 421		/* Last device exit. */
 422		if (list[i].d_id.b.rsvd_1 != 0)
 423			break;
 424	}
 425
 426	return (rval);
 427}
 428
 429/**
 430 * qla2x00_gnn_id() - SNS Get Node Name (GNN_ID) query.
 431 * @vha: HA context
 432 * @list: switch info entries to populate
 433 *
 434 * Returns 0 on success.
 435 */
 436int
 437qla2x00_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
 438{
 439	int		rval = QLA_SUCCESS;
 440	uint16_t	i;
 441	struct qla_hw_data *ha = vha->hw;
 442	ms_iocb_entry_t	*ms_pkt;
 443	struct ct_sns_req	*ct_req;
 444	struct ct_sns_rsp	*ct_rsp;
 445	struct ct_arg arg;
 446
 447	if (IS_QLA2100(ha) || IS_QLA2200(ha))
 448		return qla2x00_sns_gnn_id(vha, list);
 449
 450	arg.iocb = ha->ms_iocb;
 451	arg.req_dma = ha->ct_sns_dma;
 452	arg.rsp_dma = ha->ct_sns_dma;
 453	arg.req_size = GNN_ID_REQ_SIZE;
 454	arg.rsp_size = GNN_ID_RSP_SIZE;
 455	arg.nport_handle = NPH_SNS;
 456
 457	for (i = 0; i < ha->max_fibre_devices; i++) {
 458		/* Issue GNN_ID */
 459		/* Prepare common MS IOCB */
 460		ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
 461
 462		/* Prepare CT request */
 463		ct_req = qla2x00_prep_ct_req(ha->ct_sns, GNN_ID_CMD,
 464		    GNN_ID_RSP_SIZE);
 465		ct_rsp = &ha->ct_sns->p.rsp;
 466
 467		/* Prepare CT arguments -- port_id */
 468		ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
 469
 470		/* Execute MS IOCB */
 471		rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
 472		    sizeof(ms_iocb_entry_t));
 473		if (rval != QLA_SUCCESS) {
 474			/*EMPTY*/
 475			ql_dbg(ql_dbg_disc, vha, 0x2057,
 476			    "GNN_ID issue IOCB failed (%d).\n", rval);
 477			break;
 478		} else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
 479		    "GNN_ID") != QLA_SUCCESS) {
 480			rval = QLA_FUNCTION_FAILED;
 481			break;
 482		} else {
 483			/* Save nodename */
 484			memcpy(list[i].node_name,
 485			    ct_rsp->rsp.gnn_id.node_name, WWN_SIZE);
 486
 487			ql_dbg(ql_dbg_disc, vha, 0x2058,
 488			    "GID_PT entry - nn %8phN pn %8phN "
 489			    "portid=%02x%02x%02x.\n",
 490			    list[i].node_name, list[i].port_name,
 491			    list[i].d_id.b.domain, list[i].d_id.b.area,
 492			    list[i].d_id.b.al_pa);
 493		}
 494
 495		/* Last device exit. */
 496		if (list[i].d_id.b.rsvd_1 != 0)
 497			break;
 498	}
 499
 500	return (rval);
 501}
 502
 503static void qla2x00_async_sns_sp_done(srb_t *sp, int rc)
 504{
 505	struct scsi_qla_host *vha = sp->vha;
 506	struct ct_sns_pkt *ct_sns;
 507	struct qla_work_evt *e;
 508
 509	sp->rc = rc;
 510	if (rc == QLA_SUCCESS) {
 511		ql_dbg(ql_dbg_disc, vha, 0x204f,
 512		    "Async done-%s exiting normally.\n",
 513		    sp->name);
 514	} else if (rc == QLA_FUNCTION_TIMEOUT) {
 515		ql_dbg(ql_dbg_disc, vha, 0x204f,
 516		    "Async done-%s timeout\n", sp->name);
 517	} else {
 518		ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
 519		memset(ct_sns, 0, sizeof(*ct_sns));
 520		sp->retry_count++;
 521		if (sp->retry_count > 3)
 522			goto err;
 523
 524		ql_dbg(ql_dbg_disc, vha, 0x204f,
 525		    "Async done-%s fail rc %x.  Retry count %d\n",
 526		    sp->name, rc, sp->retry_count);
 527
 528		e = qla2x00_alloc_work(vha, QLA_EVT_SP_RETRY);
 529		if (!e)
 530			goto err2;
 531
 532		e->u.iosb.sp = sp;
 533		qla2x00_post_work(vha, e);
 534		return;
 535	}
 536
 537err:
 538	e = qla2x00_alloc_work(vha, QLA_EVT_UNMAP);
 539err2:
 540	if (!e) {
 541		/* please ignore kernel warning. otherwise, we have mem leak. */
 542		if (sp->u.iocb_cmd.u.ctarg.req) {
 543			dma_free_coherent(&vha->hw->pdev->dev,
 544			    sp->u.iocb_cmd.u.ctarg.req_allocated_size,
 545			    sp->u.iocb_cmd.u.ctarg.req,
 546			    sp->u.iocb_cmd.u.ctarg.req_dma);
 547			sp->u.iocb_cmd.u.ctarg.req = NULL;
 548		}
 549
 550		if (sp->u.iocb_cmd.u.ctarg.rsp) {
 551			dma_free_coherent(&vha->hw->pdev->dev,
 552			    sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
 553			    sp->u.iocb_cmd.u.ctarg.rsp,
 554			    sp->u.iocb_cmd.u.ctarg.rsp_dma);
 555			sp->u.iocb_cmd.u.ctarg.rsp = NULL;
 556		}
 557
 558		/* ref: INIT */
 559		kref_put(&sp->cmd_kref, qla2x00_sp_release);
 560		return;
 561	}
 562
 563	e->u.iosb.sp = sp;
 564	qla2x00_post_work(vha, e);
 565}
 566
 567/**
 568 * qla2x00_rft_id() - SNS Register FC-4 TYPEs (RFT_ID) supported by the HBA.
 569 * @vha: HA context
 570 *
 571 * Returns 0 on success.
 572 */
 573int
 574qla2x00_rft_id(scsi_qla_host_t *vha)
 575{
 576	struct qla_hw_data *ha = vha->hw;
 577
 578	if (IS_QLA2100(ha) || IS_QLA2200(ha))
 579		return qla2x00_sns_rft_id(vha);
 580
 581	return qla_async_rftid(vha, &vha->d_id);
 582}
 583
 584static int qla_async_rftid(scsi_qla_host_t *vha, port_id_t *d_id)
 585{
 586	int rval = QLA_MEMORY_ALLOC_FAILED;
 587	struct ct_sns_req *ct_req;
 588	srb_t *sp;
 589	struct ct_sns_pkt *ct_sns;
 590
 591	if (!vha->flags.online)
 592		goto done;
 593
 594	/* ref: INIT */
 595	sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
 596	if (!sp)
 597		goto done;
 598
 599	sp->type = SRB_CT_PTHRU_CMD;
 600	sp->name = "rft_id";
 601	qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
 602			      qla2x00_async_sns_sp_done);
 603
 604	sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
 605	    sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
 606	    GFP_KERNEL);
 607	sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
 608	if (!sp->u.iocb_cmd.u.ctarg.req) {
 609		ql_log(ql_log_warn, vha, 0xd041,
 610		    "%s: Failed to allocate ct_sns request.\n",
 611		    __func__);
 612		goto done_free_sp;
 613	}
 614
 615	sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
 616	    sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
 617	    GFP_KERNEL);
 618	sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
 619	if (!sp->u.iocb_cmd.u.ctarg.rsp) {
 620		ql_log(ql_log_warn, vha, 0xd042,
 621		    "%s: Failed to allocate ct_sns request.\n",
 622		    __func__);
 623		goto done_free_sp;
 624	}
 625	ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
 626	memset(ct_sns, 0, sizeof(*ct_sns));
 627	ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
 628
 629	/* Prepare CT request */
 630	ct_req = qla2x00_prep_ct_req(ct_sns, RFT_ID_CMD, RFT_ID_RSP_SIZE);
 631
 632	/* Prepare CT arguments -- port_id, FC-4 types */
 633	ct_req->req.rft_id.port_id = port_id_to_be_id(vha->d_id);
 634	ct_req->req.rft_id.fc4_types[2] = 0x01;		/* FCP-3 */
 635
 636	if (vha->flags.nvme_enabled && qla_ini_mode_enabled(vha))
 637		ct_req->req.rft_id.fc4_types[6] = 1;    /* NVMe type 28h */
 638
 639	sp->u.iocb_cmd.u.ctarg.req_size = RFT_ID_REQ_SIZE;
 640	sp->u.iocb_cmd.u.ctarg.rsp_size = RFT_ID_RSP_SIZE;
 641	sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
 642
 643	ql_dbg(ql_dbg_disc, vha, 0xffff,
 644	    "Async-%s - hdl=%x portid %06x.\n",
 645	    sp->name, sp->handle, d_id->b24);
 646
 647	rval = qla2x00_start_sp(sp);
 648	if (rval != QLA_SUCCESS) {
 649		ql_dbg(ql_dbg_disc, vha, 0x2043,
 650		    "RFT_ID issue IOCB failed (%d).\n", rval);
 651		goto done_free_sp;
 652	}
 653	return rval;
 654done_free_sp:
 655	/* ref: INIT */
 656	kref_put(&sp->cmd_kref, qla2x00_sp_release);
 657done:
 658	return rval;
 659}
 660
 661/**
 662 * qla2x00_rff_id() - SNS Register FC-4 Features (RFF_ID) supported by the HBA.
 663 * @vha: HA context
 664 * @type: not used
 665 *
 666 * Returns 0 on success.
 667 */
 668int
 669qla2x00_rff_id(scsi_qla_host_t *vha, u8 type)
 670{
 671	struct qla_hw_data *ha = vha->hw;
 672
 673	if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 674		ql_dbg(ql_dbg_disc, vha, 0x2046,
 675		    "RFF_ID call not supported on ISP2100/ISP2200.\n");
 676		return (QLA_SUCCESS);
 677	}
 678
 679	return qla_async_rffid(vha, &vha->d_id, qlt_rff_id(vha), type);
 680}
 681
 682static int qla_async_rffid(scsi_qla_host_t *vha, port_id_t *d_id,
 683    u8 fc4feature, u8 fc4type)
 684{
 685	int rval = QLA_MEMORY_ALLOC_FAILED;
 686	struct ct_sns_req *ct_req;
 687	srb_t *sp;
 688	struct ct_sns_pkt *ct_sns;
 689
 690	/* ref: INIT */
 691	sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
 692	if (!sp)
 693		goto done;
 694
 695	sp->type = SRB_CT_PTHRU_CMD;
 696	sp->name = "rff_id";
 697	qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
 698			      qla2x00_async_sns_sp_done);
 699
 700	sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
 701	    sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
 702	    GFP_KERNEL);
 703	sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
 704	if (!sp->u.iocb_cmd.u.ctarg.req) {
 705		ql_log(ql_log_warn, vha, 0xd041,
 706		    "%s: Failed to allocate ct_sns request.\n",
 707		    __func__);
 708		goto done_free_sp;
 709	}
 710
 711	sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
 712	    sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
 713	    GFP_KERNEL);
 714	sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
 715	if (!sp->u.iocb_cmd.u.ctarg.rsp) {
 716		ql_log(ql_log_warn, vha, 0xd042,
 717		    "%s: Failed to allocate ct_sns request.\n",
 718		    __func__);
 719		goto done_free_sp;
 720	}
 721	ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
 722	memset(ct_sns, 0, sizeof(*ct_sns));
 723	ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
 724
 725	/* Prepare CT request */
 726	ct_req = qla2x00_prep_ct_req(ct_sns, RFF_ID_CMD, RFF_ID_RSP_SIZE);
 727
 728	/* Prepare CT arguments -- port_id, FC-4 feature, FC-4 type */
 729	ct_req->req.rff_id.port_id = port_id_to_be_id(*d_id);
 730	ct_req->req.rff_id.fc4_feature = fc4feature;
 731	ct_req->req.rff_id.fc4_type = fc4type;		/* SCSI-FCP or FC-NVMe */
 732
 733	sp->u.iocb_cmd.u.ctarg.req_size = RFF_ID_REQ_SIZE;
 734	sp->u.iocb_cmd.u.ctarg.rsp_size = RFF_ID_RSP_SIZE;
 735	sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
 736
 737	ql_dbg(ql_dbg_disc, vha, 0xffff,
 738	    "Async-%s - hdl=%x portid %06x feature %x type %x.\n",
 739	    sp->name, sp->handle, d_id->b24, fc4feature, fc4type);
 740
 741	rval = qla2x00_start_sp(sp);
 742	if (rval != QLA_SUCCESS) {
 743		ql_dbg(ql_dbg_disc, vha, 0x2047,
 744		    "RFF_ID issue IOCB failed (%d).\n", rval);
 745		goto done_free_sp;
 746	}
 747
 748	return rval;
 749
 750done_free_sp:
 751	/* ref: INIT */
 752	kref_put(&sp->cmd_kref, qla2x00_sp_release);
 753done:
 754	return rval;
 755}
 756
 757/**
 758 * qla2x00_rnn_id() - SNS Register Node Name (RNN_ID) of the HBA.
 759 * @vha: HA context
 760 *
 761 * Returns 0 on success.
 762 */
 763int
 764qla2x00_rnn_id(scsi_qla_host_t *vha)
 765{
 766	struct qla_hw_data *ha = vha->hw;
 767
 768	if (IS_QLA2100(ha) || IS_QLA2200(ha))
 769		return qla2x00_sns_rnn_id(vha);
 770
 771	return  qla_async_rnnid(vha, &vha->d_id, vha->node_name);
 772}
 773
 774static int qla_async_rnnid(scsi_qla_host_t *vha, port_id_t *d_id,
 775	u8 *node_name)
 776{
 777	int rval = QLA_MEMORY_ALLOC_FAILED;
 778	struct ct_sns_req *ct_req;
 779	srb_t *sp;
 780	struct ct_sns_pkt *ct_sns;
 781
 782	/* ref: INIT */
 783	sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
 784	if (!sp)
 785		goto done;
 786
 787	sp->type = SRB_CT_PTHRU_CMD;
 788	sp->name = "rnid";
 789	qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
 790			      qla2x00_async_sns_sp_done);
 791
 792	sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
 793	    sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
 794	    GFP_KERNEL);
 795	sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
 796	if (!sp->u.iocb_cmd.u.ctarg.req) {
 797		ql_log(ql_log_warn, vha, 0xd041,
 798		    "%s: Failed to allocate ct_sns request.\n",
 799		    __func__);
 800		goto done_free_sp;
 801	}
 802
 803	sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
 804	    sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
 805	    GFP_KERNEL);
 806	sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
 807	if (!sp->u.iocb_cmd.u.ctarg.rsp) {
 808		ql_log(ql_log_warn, vha, 0xd042,
 809		    "%s: Failed to allocate ct_sns request.\n",
 810		    __func__);
 811		goto done_free_sp;
 812	}
 813	ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
 814	memset(ct_sns, 0, sizeof(*ct_sns));
 815	ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
 816
 817	/* Prepare CT request */
 818	ct_req = qla2x00_prep_ct_req(ct_sns, RNN_ID_CMD, RNN_ID_RSP_SIZE);
 819
 820	/* Prepare CT arguments -- port_id, node_name */
 821	ct_req->req.rnn_id.port_id = port_id_to_be_id(vha->d_id);
 822	memcpy(ct_req->req.rnn_id.node_name, vha->node_name, WWN_SIZE);
 823
 824	sp->u.iocb_cmd.u.ctarg.req_size = RNN_ID_REQ_SIZE;
 825	sp->u.iocb_cmd.u.ctarg.rsp_size = RNN_ID_RSP_SIZE;
 826	sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
 827
 828	ql_dbg(ql_dbg_disc, vha, 0xffff,
 829	    "Async-%s - hdl=%x portid %06x\n",
 830	    sp->name, sp->handle, d_id->b24);
 831
 832	rval = qla2x00_start_sp(sp);
 833	if (rval != QLA_SUCCESS) {
 834		ql_dbg(ql_dbg_disc, vha, 0x204d,
 835		    "RNN_ID issue IOCB failed (%d).\n", rval);
 836		goto done_free_sp;
 837	}
 838
 839	return rval;
 840
 841done_free_sp:
 842	/* ref: INIT */
 843	kref_put(&sp->cmd_kref, qla2x00_sp_release);
 844done:
 845	return rval;
 846}
 847
 848size_t
 849qla2x00_get_sym_node_name(scsi_qla_host_t *vha, uint8_t *snn, size_t size)
 850{
 851	struct qla_hw_data *ha = vha->hw;
 852
 853	if (IS_QLAFX00(ha))
 854		return scnprintf(snn, size, "%s FW:v%s DVR:v%s",
 855		    ha->model_number, ha->mr.fw_version, qla2x00_version_str);
 856
 857	return scnprintf(snn, size, "%s FW:v%d.%02d.%02d DVR:v%s",
 858	    ha->model_number, ha->fw_major_version, ha->fw_minor_version,
 859	    ha->fw_subminor_version, qla2x00_version_str);
 860}
 861
 862/**
 863 * qla2x00_rsnn_nn() - SNS Register Symbolic Node Name (RSNN_NN) of the HBA.
 864 * @vha: HA context
 865 *
 866 * Returns 0 on success.
 867 */
 868int
 869qla2x00_rsnn_nn(scsi_qla_host_t *vha)
 870{
 871	struct qla_hw_data *ha = vha->hw;
 872
 873	if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 874		ql_dbg(ql_dbg_disc, vha, 0x2050,
 875		    "RSNN_ID call unsupported on ISP2100/ISP2200.\n");
 876		return (QLA_SUCCESS);
 877	}
 878
 879	return qla_async_rsnn_nn(vha);
 880}
 881
 882static int qla_async_rsnn_nn(scsi_qla_host_t *vha)
 883{
 884	int rval = QLA_MEMORY_ALLOC_FAILED;
 885	struct ct_sns_req *ct_req;
 886	srb_t *sp;
 887	struct ct_sns_pkt *ct_sns;
 888
 889	/* ref: INIT */
 890	sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
 891	if (!sp)
 892		goto done;
 893
 894	sp->type = SRB_CT_PTHRU_CMD;
 895	sp->name = "rsnn_nn";
 896	qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
 897			      qla2x00_async_sns_sp_done);
 898
 899	sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
 900	    sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
 901	    GFP_KERNEL);
 902	sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
 903	if (!sp->u.iocb_cmd.u.ctarg.req) {
 904		ql_log(ql_log_warn, vha, 0xd041,
 905		    "%s: Failed to allocate ct_sns request.\n",
 906		    __func__);
 907		goto done_free_sp;
 908	}
 909
 910	sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
 911	    sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
 912	    GFP_KERNEL);
 913	sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
 914	if (!sp->u.iocb_cmd.u.ctarg.rsp) {
 915		ql_log(ql_log_warn, vha, 0xd042,
 916		    "%s: Failed to allocate ct_sns request.\n",
 917		    __func__);
 918		goto done_free_sp;
 919	}
 920	ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
 921	memset(ct_sns, 0, sizeof(*ct_sns));
 922	ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
 923
 924	/* Prepare CT request */
 925	ct_req = qla2x00_prep_ct_req(ct_sns, RSNN_NN_CMD, RSNN_NN_RSP_SIZE);
 926
 927	/* Prepare CT arguments -- node_name, symbolic node_name, size */
 928	memcpy(ct_req->req.rsnn_nn.node_name, vha->node_name, WWN_SIZE);
 929
 930	/* Prepare the Symbolic Node Name */
 931	qla2x00_get_sym_node_name(vha, ct_req->req.rsnn_nn.sym_node_name,
 932	    sizeof(ct_req->req.rsnn_nn.sym_node_name));
 933	ct_req->req.rsnn_nn.name_len =
 934	    (uint8_t)strlen(ct_req->req.rsnn_nn.sym_node_name);
 935
 936
 937	sp->u.iocb_cmd.u.ctarg.req_size = 24 + 1 + ct_req->req.rsnn_nn.name_len;
 938	sp->u.iocb_cmd.u.ctarg.rsp_size = RSNN_NN_RSP_SIZE;
 939	sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
 940
 941	ql_dbg(ql_dbg_disc, vha, 0xffff,
 942	    "Async-%s - hdl=%x.\n",
 943	    sp->name, sp->handle);
 944
 945	rval = qla2x00_start_sp(sp);
 946	if (rval != QLA_SUCCESS) {
 947		ql_dbg(ql_dbg_disc, vha, 0x2043,
 948		    "RFT_ID issue IOCB failed (%d).\n", rval);
 949		goto done_free_sp;
 950	}
 951
 952	return rval;
 953
 954done_free_sp:
 955	/* ref: INIT */
 956	kref_put(&sp->cmd_kref, qla2x00_sp_release);
 957done:
 958	return rval;
 959}
 960
 961/**
 962 * qla2x00_prep_sns_cmd() - Prepare common SNS command request fields for query.
 963 * @vha: HA context
 964 * @cmd: GS command
 965 * @scmd_len: Subcommand length
 966 * @data_size: response size in bytes
 967 *
 968 * Returns a pointer to the @ha's sns_cmd.
 969 */
 970static inline struct sns_cmd_pkt *
 971qla2x00_prep_sns_cmd(scsi_qla_host_t *vha, uint16_t cmd, uint16_t scmd_len,
 972    uint16_t data_size)
 973{
 974	uint16_t		wc;
 975	struct sns_cmd_pkt	*sns_cmd;
 976	struct qla_hw_data *ha = vha->hw;
 977
 978	sns_cmd = ha->sns_cmd;
 979	memset(sns_cmd, 0, sizeof(struct sns_cmd_pkt));
 980	wc = data_size / 2;			/* Size in 16bit words. */
 981	sns_cmd->p.cmd.buffer_length = cpu_to_le16(wc);
 982	put_unaligned_le64(ha->sns_cmd_dma, &sns_cmd->p.cmd.buffer_address);
 983	sns_cmd->p.cmd.subcommand_length = cpu_to_le16(scmd_len);
 984	sns_cmd->p.cmd.subcommand = cpu_to_le16(cmd);
 985	wc = (data_size - 16) / 4;		/* Size in 32bit words. */
 986	sns_cmd->p.cmd.size = cpu_to_le16(wc);
 987
 988	vha->qla_stats.control_requests++;
 989
 990	return (sns_cmd);
 991}
 992
 993/**
 994 * qla2x00_sns_ga_nxt() - SNS scan for fabric devices via GA_NXT command.
 995 * @vha: HA context
 996 * @fcport: fcport entry to updated
 997 *
 998 * This command uses the old Exectute SNS Command mailbox routine.
 999 *
1000 * Returns 0 on success.
1001 */
1002static int
1003qla2x00_sns_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
1004{
1005	int		rval = QLA_SUCCESS;
1006	struct qla_hw_data *ha = vha->hw;
1007	struct sns_cmd_pkt	*sns_cmd;
1008
1009	/* Issue GA_NXT. */
1010	/* Prepare SNS command request. */
1011	sns_cmd = qla2x00_prep_sns_cmd(vha, GA_NXT_CMD, GA_NXT_SNS_SCMD_LEN,
1012	    GA_NXT_SNS_DATA_SIZE);
1013
1014	/* Prepare SNS command arguments -- port_id. */
1015	sns_cmd->p.cmd.param[0] = fcport->d_id.b.al_pa;
1016	sns_cmd->p.cmd.param[1] = fcport->d_id.b.area;
1017	sns_cmd->p.cmd.param[2] = fcport->d_id.b.domain;
1018
1019	/* Execute SNS command. */
1020	rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, GA_NXT_SNS_CMD_SIZE / 2,
1021	    sizeof(struct sns_cmd_pkt));
1022	if (rval != QLA_SUCCESS) {
1023		/*EMPTY*/
1024		ql_dbg(ql_dbg_disc, vha, 0x205f,
1025		    "GA_NXT Send SNS failed (%d).\n", rval);
1026	} else if (sns_cmd->p.gan_data[8] != 0x80 ||
1027	    sns_cmd->p.gan_data[9] != 0x02) {
1028		ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2084,
1029		    "GA_NXT failed, rejected request ga_nxt_rsp:\n");
1030		ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2074,
1031		    sns_cmd->p.gan_data, 16);
1032		rval = QLA_FUNCTION_FAILED;
1033	} else {
1034		/* Populate fc_port_t entry. */
1035		fcport->d_id.b.domain = sns_cmd->p.gan_data[17];
1036		fcport->d_id.b.area = sns_cmd->p.gan_data[18];
1037		fcport->d_id.b.al_pa = sns_cmd->p.gan_data[19];
1038
1039		memcpy(fcport->node_name, &sns_cmd->p.gan_data[284], WWN_SIZE);
1040		memcpy(fcport->port_name, &sns_cmd->p.gan_data[20], WWN_SIZE);
1041
1042		if (sns_cmd->p.gan_data[16] != NS_N_PORT_TYPE &&
1043		    sns_cmd->p.gan_data[16] != NS_NL_PORT_TYPE)
1044			fcport->d_id.b.domain = 0xf0;
1045
1046		ql_dbg(ql_dbg_disc, vha, 0x2061,
1047		    "GA_NXT entry - nn %8phN pn %8phN "
1048		    "port_id=%02x%02x%02x.\n",
1049		    fcport->node_name, fcport->port_name,
1050		    fcport->d_id.b.domain, fcport->d_id.b.area,
1051		    fcport->d_id.b.al_pa);
1052	}
1053
1054	return (rval);
1055}
1056
1057/**
1058 * qla2x00_sns_gid_pt() - SNS scan for fabric devices via GID_PT command.
1059 * @vha: HA context
1060 * @list: switch info entries to populate
1061 *
1062 * This command uses the old Exectute SNS Command mailbox routine.
1063 *
1064 * NOTE: Non-Nx_Ports are not requested.
1065 *
1066 * Returns 0 on success.
1067 */
1068static int
1069qla2x00_sns_gid_pt(scsi_qla_host_t *vha, sw_info_t *list)
1070{
1071	int		rval;
1072	struct qla_hw_data *ha = vha->hw;
1073	uint16_t	i;
1074	uint8_t		*entry;
1075	struct sns_cmd_pkt	*sns_cmd;
1076	uint16_t gid_pt_sns_data_size;
1077
1078	gid_pt_sns_data_size = qla2x00_gid_pt_rsp_size(vha);
1079
1080	/* Issue GID_PT. */
1081	/* Prepare SNS command request. */
1082	sns_cmd = qla2x00_prep_sns_cmd(vha, GID_PT_CMD, GID_PT_SNS_SCMD_LEN,
1083	    gid_pt_sns_data_size);
1084
1085	/* Prepare SNS command arguments -- port_type. */
1086	sns_cmd->p.cmd.param[0] = NS_NX_PORT_TYPE;
1087
1088	/* Execute SNS command. */
1089	rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, GID_PT_SNS_CMD_SIZE / 2,
1090	    sizeof(struct sns_cmd_pkt));
1091	if (rval != QLA_SUCCESS) {
1092		/*EMPTY*/
1093		ql_dbg(ql_dbg_disc, vha, 0x206d,
1094		    "GID_PT Send SNS failed (%d).\n", rval);
1095	} else if (sns_cmd->p.gid_data[8] != 0x80 ||
1096	    sns_cmd->p.gid_data[9] != 0x02) {
1097		ql_dbg(ql_dbg_disc, vha, 0x202f,
1098		    "GID_PT failed, rejected request, gid_rsp:\n");
1099		ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2081,
1100		    sns_cmd->p.gid_data, 16);
1101		rval = QLA_FUNCTION_FAILED;
1102	} else {
1103		/* Set port IDs in switch info list. */
1104		for (i = 0; i < ha->max_fibre_devices; i++) {
1105			entry = &sns_cmd->p.gid_data[(i * 4) + 16];
1106			list[i].d_id.b.domain = entry[1];
1107			list[i].d_id.b.area = entry[2];
1108			list[i].d_id.b.al_pa = entry[3];
1109
1110			/* Last one exit. */
1111			if (entry[0] & BIT_7) {
1112				list[i].d_id.b.rsvd_1 = entry[0];
1113				break;
1114			}
1115		}
1116
1117		/*
1118		 * If we've used all available slots, then the switch is
1119		 * reporting back more devices that we can handle with this
1120		 * single call.  Return a failed status, and let GA_NXT handle
1121		 * the overload.
1122		 */
1123		if (i == ha->max_fibre_devices)
1124			rval = QLA_FUNCTION_FAILED;
1125	}
1126
1127	return (rval);
1128}
1129
1130/**
1131 * qla2x00_sns_gpn_id() - SNS Get Port Name (GPN_ID) query.
1132 * @vha: HA context
1133 * @list: switch info entries to populate
1134 *
1135 * This command uses the old Exectute SNS Command mailbox routine.
1136 *
1137 * Returns 0 on success.
1138 */
1139static int
1140qla2x00_sns_gpn_id(scsi_qla_host_t *vha, sw_info_t *list)
1141{
1142	int		rval = QLA_SUCCESS;
1143	struct qla_hw_data *ha = vha->hw;
1144	uint16_t	i;
1145	struct sns_cmd_pkt	*sns_cmd;
1146
1147	for (i = 0; i < ha->max_fibre_devices; i++) {
1148		/* Issue GPN_ID */
1149		/* Prepare SNS command request. */
1150		sns_cmd = qla2x00_prep_sns_cmd(vha, GPN_ID_CMD,
1151		    GPN_ID_SNS_SCMD_LEN, GPN_ID_SNS_DATA_SIZE);
1152
1153		/* Prepare SNS command arguments -- port_id. */
1154		sns_cmd->p.cmd.param[0] = list[i].d_id.b.al_pa;
1155		sns_cmd->p.cmd.param[1] = list[i].d_id.b.area;
1156		sns_cmd->p.cmd.param[2] = list[i].d_id.b.domain;
1157
1158		/* Execute SNS command. */
1159		rval = qla2x00_send_sns(vha, ha->sns_cmd_dma,
1160		    GPN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt));
1161		if (rval != QLA_SUCCESS) {
1162			/*EMPTY*/
1163			ql_dbg(ql_dbg_disc, vha, 0x2032,
1164			    "GPN_ID Send SNS failed (%d).\n", rval);
1165		} else if (sns_cmd->p.gpn_data[8] != 0x80 ||
1166		    sns_cmd->p.gpn_data[9] != 0x02) {
1167			ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x207e,
1168			    "GPN_ID failed, rejected request, gpn_rsp:\n");
1169			ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x207f,
1170			    sns_cmd->p.gpn_data, 16);
1171			rval = QLA_FUNCTION_FAILED;
1172		} else {
1173			/* Save portname */
1174			memcpy(list[i].port_name, &sns_cmd->p.gpn_data[16],
1175			    WWN_SIZE);
1176		}
1177
1178		/* Last device exit. */
1179		if (list[i].d_id.b.rsvd_1 != 0)
1180			break;
1181	}
1182
1183	return (rval);
1184}
1185
1186/**
1187 * qla2x00_sns_gnn_id() - SNS Get Node Name (GNN_ID) query.
1188 * @vha: HA context
1189 * @list: switch info entries to populate
1190 *
1191 * This command uses the old Exectute SNS Command mailbox routine.
1192 *
1193 * Returns 0 on success.
1194 */
1195static int
1196qla2x00_sns_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
1197{
1198	int		rval = QLA_SUCCESS;
1199	struct qla_hw_data *ha = vha->hw;
1200	uint16_t	i;
1201	struct sns_cmd_pkt	*sns_cmd;
1202
1203	for (i = 0; i < ha->max_fibre_devices; i++) {
1204		/* Issue GNN_ID */
1205		/* Prepare SNS command request. */
1206		sns_cmd = qla2x00_prep_sns_cmd(vha, GNN_ID_CMD,
1207		    GNN_ID_SNS_SCMD_LEN, GNN_ID_SNS_DATA_SIZE);
1208
1209		/* Prepare SNS command arguments -- port_id. */
1210		sns_cmd->p.cmd.param[0] = list[i].d_id.b.al_pa;
1211		sns_cmd->p.cmd.param[1] = list[i].d_id.b.area;
1212		sns_cmd->p.cmd.param[2] = list[i].d_id.b.domain;
1213
1214		/* Execute SNS command. */
1215		rval = qla2x00_send_sns(vha, ha->sns_cmd_dma,
1216		    GNN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt));
1217		if (rval != QLA_SUCCESS) {
1218			/*EMPTY*/
1219			ql_dbg(ql_dbg_disc, vha, 0x203f,
1220			    "GNN_ID Send SNS failed (%d).\n", rval);
1221		} else if (sns_cmd->p.gnn_data[8] != 0x80 ||
1222		    sns_cmd->p.gnn_data[9] != 0x02) {
1223			ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2082,
1224			    "GNN_ID failed, rejected request, gnn_rsp:\n");
1225			ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x207a,
1226			    sns_cmd->p.gnn_data, 16);
1227			rval = QLA_FUNCTION_FAILED;
1228		} else {
1229			/* Save nodename */
1230			memcpy(list[i].node_name, &sns_cmd->p.gnn_data[16],
1231			    WWN_SIZE);
1232
1233			ql_dbg(ql_dbg_disc, vha, 0x206e,
1234			    "GID_PT entry - nn %8phN pn %8phN "
1235			    "port_id=%02x%02x%02x.\n",
1236			    list[i].node_name, list[i].port_name,
1237			    list[i].d_id.b.domain, list[i].d_id.b.area,
1238			    list[i].d_id.b.al_pa);
1239		}
1240
1241		/* Last device exit. */
1242		if (list[i].d_id.b.rsvd_1 != 0)
1243			break;
1244	}
1245
1246	return (rval);
1247}
1248
1249/**
1250 * qla2x00_sns_rft_id() - SNS Register FC-4 TYPEs (RFT_ID) supported by the HBA.
1251 * @vha: HA context
1252 *
1253 * This command uses the old Exectute SNS Command mailbox routine.
1254 *
1255 * Returns 0 on success.
1256 */
1257static int
1258qla2x00_sns_rft_id(scsi_qla_host_t *vha)
1259{
1260	int		rval;
1261	struct qla_hw_data *ha = vha->hw;
1262	struct sns_cmd_pkt	*sns_cmd;
1263
1264	/* Issue RFT_ID. */
1265	/* Prepare SNS command request. */
1266	sns_cmd = qla2x00_prep_sns_cmd(vha, RFT_ID_CMD, RFT_ID_SNS_SCMD_LEN,
1267	    RFT_ID_SNS_DATA_SIZE);
1268
1269	/* Prepare SNS command arguments -- port_id, FC-4 types */
1270	sns_cmd->p.cmd.param[0] = vha->d_id.b.al_pa;
1271	sns_cmd->p.cmd.param[1] = vha->d_id.b.area;
1272	sns_cmd->p.cmd.param[2] = vha->d_id.b.domain;
1273
1274	sns_cmd->p.cmd.param[5] = 0x01;			/* FCP-3 */
1275
1276	/* Execute SNS command. */
1277	rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, RFT_ID_SNS_CMD_SIZE / 2,
1278	    sizeof(struct sns_cmd_pkt));
1279	if (rval != QLA_SUCCESS) {
1280		/*EMPTY*/
1281		ql_dbg(ql_dbg_disc, vha, 0x2060,
1282		    "RFT_ID Send SNS failed (%d).\n", rval);
1283	} else if (sns_cmd->p.rft_data[8] != 0x80 ||
1284	    sns_cmd->p.rft_data[9] != 0x02) {
1285		ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2083,
1286		    "RFT_ID failed, rejected request rft_rsp:\n");
1287		ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2080,
1288		    sns_cmd->p.rft_data, 16);
1289		rval = QLA_FUNCTION_FAILED;
1290	} else {
1291		ql_dbg(ql_dbg_disc, vha, 0x2073,
1292		    "RFT_ID exiting normally.\n");
1293	}
1294
1295	return (rval);
1296}
1297
1298/**
1299 * qla2x00_sns_rnn_id() - SNS Register Node Name (RNN_ID) of the HBA.
1300 * @vha: HA context
1301 *
1302 * This command uses the old Exectute SNS Command mailbox routine.
1303 *
1304 * Returns 0 on success.
1305 */
1306static int
1307qla2x00_sns_rnn_id(scsi_qla_host_t *vha)
1308{
1309	int		rval;
1310	struct qla_hw_data *ha = vha->hw;
1311	struct sns_cmd_pkt	*sns_cmd;
1312
1313	/* Issue RNN_ID. */
1314	/* Prepare SNS command request. */
1315	sns_cmd = qla2x00_prep_sns_cmd(vha, RNN_ID_CMD, RNN_ID_SNS_SCMD_LEN,
1316	    RNN_ID_SNS_DATA_SIZE);
1317
1318	/* Prepare SNS command arguments -- port_id, nodename. */
1319	sns_cmd->p.cmd.param[0] = vha->d_id.b.al_pa;
1320	sns_cmd->p.cmd.param[1] = vha->d_id.b.area;
1321	sns_cmd->p.cmd.param[2] = vha->d_id.b.domain;
1322
1323	sns_cmd->p.cmd.param[4] = vha->node_name[7];
1324	sns_cmd->p.cmd.param[5] = vha->node_name[6];
1325	sns_cmd->p.cmd.param[6] = vha->node_name[5];
1326	sns_cmd->p.cmd.param[7] = vha->node_name[4];
1327	sns_cmd->p.cmd.param[8] = vha->node_name[3];
1328	sns_cmd->p.cmd.param[9] = vha->node_name[2];
1329	sns_cmd->p.cmd.param[10] = vha->node_name[1];
1330	sns_cmd->p.cmd.param[11] = vha->node_name[0];
1331
1332	/* Execute SNS command. */
1333	rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, RNN_ID_SNS_CMD_SIZE / 2,
1334	    sizeof(struct sns_cmd_pkt));
1335	if (rval != QLA_SUCCESS) {
1336		/*EMPTY*/
1337		ql_dbg(ql_dbg_disc, vha, 0x204a,
1338		    "RNN_ID Send SNS failed (%d).\n", rval);
1339	} else if (sns_cmd->p.rnn_data[8] != 0x80 ||
1340	    sns_cmd->p.rnn_data[9] != 0x02) {
1341		ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x207b,
1342		    "RNN_ID failed, rejected request, rnn_rsp:\n");
1343		ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x207c,
1344		    sns_cmd->p.rnn_data, 16);
1345		rval = QLA_FUNCTION_FAILED;
1346	} else {
1347		ql_dbg(ql_dbg_disc, vha, 0x204c,
1348		    "RNN_ID exiting normally.\n");
1349	}
1350
1351	return (rval);
1352}
1353
1354/**
1355 * qla2x00_mgmt_svr_login() - Login to fabric Management Service.
1356 * @vha: HA context
1357 *
1358 * Returns 0 on success.
1359 */
1360int
1361qla2x00_mgmt_svr_login(scsi_qla_host_t *vha)
1362{
1363	int ret, rval;
1364	uint16_t mb[MAILBOX_REGISTER_COUNT];
1365	struct qla_hw_data *ha = vha->hw;
1366
1367	ret = QLA_SUCCESS;
1368	if (vha->flags.management_server_logged_in)
1369		return ret;
1370
1371	rval = ha->isp_ops->fabric_login(vha, vha->mgmt_svr_loop_id, 0xff, 0xff,
1372	    0xfa, mb, BIT_1);
1373	if (rval != QLA_SUCCESS || mb[0] != MBS_COMMAND_COMPLETE) {
1374		if (rval == QLA_MEMORY_ALLOC_FAILED)
1375			ql_dbg(ql_dbg_disc, vha, 0x2085,
1376			    "Failed management_server login: loopid=%x "
1377			    "rval=%d\n", vha->mgmt_svr_loop_id, rval);
1378		else
1379			ql_dbg(ql_dbg_disc, vha, 0x2024,
1380			    "Failed management_server login: loopid=%x "
1381			    "mb[0]=%x mb[1]=%x mb[2]=%x mb[6]=%x mb[7]=%x.\n",
1382			    vha->mgmt_svr_loop_id, mb[0], mb[1], mb[2], mb[6],
1383			    mb[7]);
1384		ret = QLA_FUNCTION_FAILED;
1385	} else
1386		vha->flags.management_server_logged_in = 1;
1387
1388	return ret;
1389}
1390
1391/**
1392 * qla2x00_prep_ms_fdmi_iocb() - Prepare common MS IOCB fields for FDMI query.
1393 * @vha: HA context
1394 * @req_size: request size in bytes
1395 * @rsp_size: response size in bytes
1396 *
1397 * Returns a pointer to the @ha's ms_iocb.
1398 */
1399void *
1400qla2x00_prep_ms_fdmi_iocb(scsi_qla_host_t *vha, uint32_t req_size,
1401    uint32_t rsp_size)
1402{
1403	ms_iocb_entry_t *ms_pkt;
1404	struct qla_hw_data *ha = vha->hw;
1405
1406	ms_pkt = ha->ms_iocb;
1407	memset(ms_pkt, 0, sizeof(ms_iocb_entry_t));
1408
1409	ms_pkt->entry_type = MS_IOCB_TYPE;
1410	ms_pkt->entry_count = 1;
1411	SET_TARGET_ID(ha, ms_pkt->loop_id, vha->mgmt_svr_loop_id);
1412	ms_pkt->control_flags = cpu_to_le16(CF_READ | CF_HEAD_TAG);
1413	ms_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
1414	ms_pkt->cmd_dsd_count = cpu_to_le16(1);
1415	ms_pkt->total_dsd_count = cpu_to_le16(2);
1416	ms_pkt->rsp_bytecount = cpu_to_le32(rsp_size);
1417	ms_pkt->req_bytecount = cpu_to_le32(req_size);
1418
1419	put_unaligned_le64(ha->ct_sns_dma, &ms_pkt->req_dsd.address);
1420	ms_pkt->req_dsd.length = ms_pkt->req_bytecount;
1421
1422	put_unaligned_le64(ha->ct_sns_dma, &ms_pkt->rsp_dsd.address);
1423	ms_pkt->rsp_dsd.length = ms_pkt->rsp_bytecount;
1424
1425	return ms_pkt;
1426}
1427
1428/**
1429 * qla24xx_prep_ms_fdmi_iocb() - Prepare common MS IOCB fields for FDMI query.
1430 * @vha: HA context
1431 * @req_size: request size in bytes
1432 * @rsp_size: response size in bytes
1433 *
1434 * Returns a pointer to the @ha's ms_iocb.
1435 */
1436void *
1437qla24xx_prep_ms_fdmi_iocb(scsi_qla_host_t *vha, uint32_t req_size,
1438    uint32_t rsp_size)
1439{
1440	struct ct_entry_24xx *ct_pkt;
1441	struct qla_hw_data *ha = vha->hw;
1442
1443	ct_pkt = (struct ct_entry_24xx *)ha->ms_iocb;
1444	memset(ct_pkt, 0, sizeof(struct ct_entry_24xx));
1445
1446	ct_pkt->entry_type = CT_IOCB_TYPE;
1447	ct_pkt->entry_count = 1;
1448	ct_pkt->nport_handle = cpu_to_le16(vha->mgmt_svr_loop_id);
1449	ct_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
1450	ct_pkt->cmd_dsd_count = cpu_to_le16(1);
1451	ct_pkt->rsp_dsd_count = cpu_to_le16(1);
1452	ct_pkt->rsp_byte_count = cpu_to_le32(rsp_size);
1453	ct_pkt->cmd_byte_count = cpu_to_le32(req_size);
1454
1455	put_unaligned_le64(ha->ct_sns_dma, &ct_pkt->dsd[0].address);
1456	ct_pkt->dsd[0].length = ct_pkt->cmd_byte_count;
1457
1458	put_unaligned_le64(ha->ct_sns_dma, &ct_pkt->dsd[1].address);
1459	ct_pkt->dsd[1].length = ct_pkt->rsp_byte_count;
1460	ct_pkt->vp_index = vha->vp_idx;
1461
1462	return ct_pkt;
1463}
1464
1465static void
1466qla2x00_update_ms_fdmi_iocb(scsi_qla_host_t *vha, uint32_t req_size)
1467{
1468	struct qla_hw_data *ha = vha->hw;
1469	ms_iocb_entry_t *ms_pkt = ha->ms_iocb;
1470	struct ct_entry_24xx *ct_pkt = (struct ct_entry_24xx *)ha->ms_iocb;
1471
1472	if (IS_FWI2_CAPABLE(ha)) {
1473		ct_pkt->cmd_byte_count = cpu_to_le32(req_size);
1474		ct_pkt->dsd[0].length = ct_pkt->cmd_byte_count;
1475	} else {
1476		ms_pkt->req_bytecount = cpu_to_le32(req_size);
1477		ms_pkt->req_dsd.length = ms_pkt->req_bytecount;
1478	}
1479}
1480
1481/**
1482 * qla2x00_prep_ct_fdmi_req() - Prepare common CT request fields for SNS query.
1483 * @p: CT request buffer
1484 * @cmd: GS command
1485 * @rsp_size: response size in bytes
1486 *
1487 * Returns a pointer to the intitialized @ct_req.
1488 */
1489static inline struct ct_sns_req *
1490qla2x00_prep_ct_fdmi_req(struct ct_sns_pkt *p, uint16_t cmd,
1491    uint16_t rsp_size)
1492{
1493	memset(p, 0, sizeof(struct ct_sns_pkt));
1494
1495	p->p.req.header.revision = 0x01;
1496	p->p.req.header.gs_type = 0xFA;
1497	p->p.req.header.gs_subtype = 0x10;
1498	p->p.req.command = cpu_to_be16(cmd);
1499	p->p.req.max_rsp_size = cpu_to_be16((rsp_size - 16) / 4);
1500
1501	return &p->p.req;
1502}
1503
1504uint
1505qla25xx_fdmi_port_speed_capability(struct qla_hw_data *ha)
1506{
1507	uint speeds = 0;
1508
1509	if (IS_CNA_CAPABLE(ha))
1510		return FDMI_PORT_SPEED_10GB;
1511	if (IS_QLA28XX(ha) || IS_QLA27XX(ha)) {
1512		if (ha->max_supported_speed == 2) {
1513			if (ha->min_supported_speed <= 6)
1514				speeds |= FDMI_PORT_SPEED_64GB;
1515		}
1516		if (ha->max_supported_speed == 2 ||
1517		    ha->max_supported_speed == 1) {
1518			if (ha->min_supported_speed <= 5)
1519				speeds |= FDMI_PORT_SPEED_32GB;
1520		}
1521		if (ha->max_supported_speed == 2 ||
1522		    ha->max_supported_speed == 1 ||
1523		    ha->max_supported_speed == 0) {
1524			if (ha->min_supported_speed <= 4)
1525				speeds |= FDMI_PORT_SPEED_16GB;
1526		}
1527		if (ha->max_supported_speed == 1 ||
1528		    ha->max_supported_speed == 0) {
1529			if (ha->min_supported_speed <= 3)
1530				speeds |= FDMI_PORT_SPEED_8GB;
1531		}
1532		if (ha->max_supported_speed == 0) {
1533			if (ha->min_supported_speed <= 2)
1534				speeds |= FDMI_PORT_SPEED_4GB;
1535		}
1536		return speeds;
1537	}
1538	if (IS_QLA2031(ha)) {
1539		if ((ha->pdev->subsystem_vendor == 0x103C) &&
1540		    ((ha->pdev->subsystem_device == 0x8002) ||
1541		    (ha->pdev->subsystem_device == 0x8086))) {
1542			speeds = FDMI_PORT_SPEED_16GB;
1543		} else {
1544			speeds = FDMI_PORT_SPEED_16GB|FDMI_PORT_SPEED_8GB|
1545				FDMI_PORT_SPEED_4GB;
1546		}
1547		return speeds;
1548	}
1549	if (IS_QLA25XX(ha) || IS_QLAFX00(ha))
1550		return FDMI_PORT_SPEED_8GB|FDMI_PORT_SPEED_4GB|
1551			FDMI_PORT_SPEED_2GB|FDMI_PORT_SPEED_1GB;
1552	if (IS_QLA24XX_TYPE(ha))
1553		return FDMI_PORT_SPEED_4GB|FDMI_PORT_SPEED_2GB|
1554			FDMI_PORT_SPEED_1GB;
1555	if (IS_QLA23XX(ha))
1556		return FDMI_PORT_SPEED_2GB|FDMI_PORT_SPEED_1GB;
1557	return FDMI_PORT_SPEED_1GB;
1558}
1559
1560uint
1561qla25xx_fdmi_port_speed_currently(struct qla_hw_data *ha)
1562{
1563	switch (ha->link_data_rate) {
1564	case PORT_SPEED_1GB:
1565		return FDMI_PORT_SPEED_1GB;
1566	case PORT_SPEED_2GB:
1567		return FDMI_PORT_SPEED_2GB;
1568	case PORT_SPEED_4GB:
1569		return FDMI_PORT_SPEED_4GB;
1570	case PORT_SPEED_8GB:
1571		return FDMI_PORT_SPEED_8GB;
1572	case PORT_SPEED_10GB:
1573		return FDMI_PORT_SPEED_10GB;
1574	case PORT_SPEED_16GB:
1575		return FDMI_PORT_SPEED_16GB;
1576	case PORT_SPEED_32GB:
1577		return FDMI_PORT_SPEED_32GB;
1578	case PORT_SPEED_64GB:
1579		return FDMI_PORT_SPEED_64GB;
1580	default:
1581		return FDMI_PORT_SPEED_UNKNOWN;
1582	}
1583}
1584
1585/**
1586 * qla2x00_hba_attributes() - perform HBA attributes registration
1587 * @vha: HA context
1588 * @entries: number of entries to use
1589 * @callopt: Option to issue extended or standard FDMI
1590 *           command parameter
1591 *
1592 * Returns 0 on success.
1593 */
1594static unsigned long
1595qla2x00_hba_attributes(scsi_qla_host_t *vha, void *entries,
1596	unsigned int callopt)
1597{
1598	struct qla_hw_data *ha = vha->hw;
1599	struct new_utsname *p_sysid = utsname();
1600	struct ct_fdmi_hba_attr *eiter;
1601	uint16_t alen;
1602	unsigned long size = 0;
1603
1604	/* Nodename. */
1605	eiter = entries + size;
1606	eiter->type = cpu_to_be16(FDMI_HBA_NODE_NAME);
1607	memcpy(eiter->a.node_name, vha->node_name, sizeof(eiter->a.node_name));
1608	alen = sizeof(eiter->a.node_name);
1609	alen += FDMI_ATTR_TYPELEN(eiter);
1610	eiter->len = cpu_to_be16(alen);
1611	size += alen;
1612	ql_dbg(ql_dbg_disc, vha, 0x20a0,
1613	    "NODENAME = %016llx.\n", wwn_to_u64(eiter->a.node_name));
1614	/* Manufacturer. */
1615	eiter = entries + size;
1616	eiter->type = cpu_to_be16(FDMI_HBA_MANUFACTURER);
1617	alen = scnprintf(
1618		eiter->a.manufacturer, sizeof(eiter->a.manufacturer),
1619		"%s", QLA2XXX_MANUFACTURER);
1620	alen += FDMI_ATTR_ALIGNMENT(alen);
1621	alen += FDMI_ATTR_TYPELEN(eiter);
1622	eiter->len = cpu_to_be16(alen);
1623	size += alen;
1624	ql_dbg(ql_dbg_disc, vha, 0x20a1,
1625	    "MANUFACTURER = %s.\n", eiter->a.manufacturer);
1626	/* Serial number. */
1627	eiter = entries + size;
1628	eiter->type = cpu_to_be16(FDMI_HBA_SERIAL_NUMBER);
1629	alen = 0;
1630	if (IS_FWI2_CAPABLE(ha)) {
1631		alen = qla2xxx_get_vpd_field(vha, "SN",
1632		    eiter->a.serial_num, sizeof(eiter->a.serial_num));
1633	}
1634	if (!alen) {
1635		uint32_t sn = ((ha->serial0 & 0x1f) << 16) |
1636			(ha->serial2 << 8) | ha->serial1;
1637		alen = scnprintf(
1638			eiter->a.serial_num, sizeof(eiter->a.serial_num),
1639			"%c%05d", 'A' + sn / 100000, sn % 100000);
1640	}
1641	alen += FDMI_ATTR_ALIGNMENT(alen);
1642	alen += FDMI_ATTR_TYPELEN(eiter);
1643	eiter->len = cpu_to_be16(alen);
1644	size += alen;
1645	ql_dbg(ql_dbg_disc, vha, 0x20a2,
1646	    "SERIAL NUMBER = %s.\n", eiter->a.serial_num);
1647	/* Model name. */
1648	eiter = entries + size;
1649	eiter->type = cpu_to_be16(FDMI_HBA_MODEL);
1650	alen = scnprintf(
1651		eiter->a.model, sizeof(eiter->a.model),
1652		"%s", ha->model_number);
1653	alen += FDMI_ATTR_ALIGNMENT(alen);
1654	alen += FDMI_ATTR_TYPELEN(eiter);
1655	eiter->len = cpu_to_be16(alen);
1656	size += alen;
1657	ql_dbg(ql_dbg_disc, vha, 0x20a3,
1658	    "MODEL NAME = %s.\n", eiter->a.model);
1659	/* Model description. */
1660	eiter = entries + size;
1661	eiter->type = cpu_to_be16(FDMI_HBA_MODEL_DESCRIPTION);
1662	alen = scnprintf(
1663		eiter->a.model_desc, sizeof(eiter->a.model_desc),
1664		"%s", ha->model_desc);
1665	alen += FDMI_ATTR_ALIGNMENT(alen);
1666	alen += FDMI_ATTR_TYPELEN(eiter);
1667	eiter->len = cpu_to_be16(alen);
1668	size += alen;
1669	ql_dbg(ql_dbg_disc, vha, 0x20a4,
1670	    "MODEL DESCRIPTION = %s.\n", eiter->a.model_desc);
1671	/* Hardware version. */
1672	eiter = entries + size;
1673	eiter->type = cpu_to_be16(FDMI_HBA_HARDWARE_VERSION);
1674	alen = 0;
1675	if (IS_FWI2_CAPABLE(ha)) {
1676		if (!alen) {
1677			alen = qla2xxx_get_vpd_field(vha, "MN",
1678			    eiter->a.hw_version, sizeof(eiter->a.hw_version));
1679		}
1680		if (!alen) {
1681			alen = qla2xxx_get_vpd_field(vha, "EC",
1682			    eiter->a.hw_version, sizeof(eiter->a.hw_version));
1683		}
1684	}
1685	if (!alen) {
1686		alen = scnprintf(
1687			eiter->a.hw_version, sizeof(eiter->a.hw_version),
1688			"HW:%s", ha->adapter_id);
1689	}
1690	alen += FDMI_ATTR_ALIGNMENT(alen);
1691	alen += FDMI_ATTR_TYPELEN(eiter);
1692	eiter->len = cpu_to_be16(alen);
1693	size += alen;
1694	ql_dbg(ql_dbg_disc, vha, 0x20a5,
1695	    "HARDWARE VERSION = %s.\n", eiter->a.hw_version);
1696	/* Driver version. */
1697	eiter = entries + size;
1698	eiter->type = cpu_to_be16(FDMI_HBA_DRIVER_VERSION);
1699	alen = scnprintf(
1700		eiter->a.driver_version, sizeof(eiter->a.driver_version),
1701		"%s", qla2x00_version_str);
1702	alen += FDMI_ATTR_ALIGNMENT(alen);
1703	alen += FDMI_ATTR_TYPELEN(eiter);
1704	eiter->len = cpu_to_be16(alen);
1705	size += alen;
1706	ql_dbg(ql_dbg_disc, vha, 0x20a6,
1707	    "DRIVER VERSION = %s.\n", eiter->a.driver_version);
1708	/* Option ROM version. */
1709	eiter = entries + size;
1710	eiter->type = cpu_to_be16(FDMI_HBA_OPTION_ROM_VERSION);
1711	alen = scnprintf(
1712		eiter->a.orom_version, sizeof(eiter->a.orom_version),
1713		"%d.%02d", ha->efi_revision[1], ha->efi_revision[0]);
1714	alen += FDMI_ATTR_ALIGNMENT(alen);
1715	alen += FDMI_ATTR_TYPELEN(eiter);
1716	eiter->len = cpu_to_be16(alen);
1717	size += alen;
1718
1719	ql_dbg(ql_dbg_disc, vha, 0x20a7,
1720	    "OPTROM VERSION = %d.%02d.\n",
1721	    eiter->a.orom_version[1], eiter->a.orom_version[0]);
1722	/* Firmware version */
1723	eiter = entries + size;
1724	eiter->type = cpu_to_be16(FDMI_HBA_FIRMWARE_VERSION);
1725	ha->isp_ops->fw_version_str(vha, eiter->a.fw_version,
1726	    sizeof(eiter->a.fw_version));
1727	alen += FDMI_ATTR_ALIGNMENT(alen);
1728	alen += FDMI_ATTR_TYPELEN(eiter);
1729	eiter->len = cpu_to_be16(alen);
1730	size += alen;
1731	ql_dbg(ql_dbg_disc, vha, 0x20a8,
1732	    "FIRMWARE VERSION = %s.\n", eiter->a.fw_version);
1733	/* OS Name and Version */
1734	eiter = entries + size;
1735	eiter->type = cpu_to_be16(FDMI_HBA_OS_NAME_AND_VERSION);
1736	alen = 0;
1737	if (p_sysid) {
1738		alen = scnprintf(
1739			eiter->a.os_version, sizeof(eiter->a.os_version),
1740			"%s %s %s",
1741			p_sysid->sysname, p_sysid->release, p_sysid->machine);
1742	}
1743	if (!alen) {
1744		alen = scnprintf(
1745			eiter->a.os_version, sizeof(eiter->a.os_version),
1746			"%s %s",
1747			"Linux", fc_host_system_hostname(vha->host));
1748	}
1749	alen += FDMI_ATTR_ALIGNMENT(alen);
1750	alen += FDMI_ATTR_TYPELEN(eiter);
1751	eiter->len = cpu_to_be16(alen);
1752	size += alen;
1753	ql_dbg(ql_dbg_disc, vha, 0x20a9,
1754	    "OS VERSION = %s.\n", eiter->a.os_version);
1755	if (callopt == CALLOPT_FDMI1)
1756		goto done;
1757	/* MAX CT Payload Length */
1758	eiter = entries + size;
1759	eiter->type = cpu_to_be16(FDMI_HBA_MAXIMUM_CT_PAYLOAD_LENGTH);
1760	eiter->a.max_ct_len = cpu_to_be32(ha->frame_payload_size >> 2);
1761
1762	alen = sizeof(eiter->a.max_ct_len);
1763	alen += FDMI_ATTR_TYPELEN(eiter);
1764	eiter->len = cpu_to_be16(alen);
1765	size += alen;
1766	ql_dbg(ql_dbg_disc, vha, 0x20aa,
1767	    "CT PAYLOAD LENGTH = 0x%x.\n", be32_to_cpu(eiter->a.max_ct_len));
1768	/* Node Symbolic Name */
1769	eiter = entries + size;
1770	eiter->type = cpu_to_be16(FDMI_HBA_NODE_SYMBOLIC_NAME);
1771	alen = qla2x00_get_sym_node_name(vha, eiter->a.sym_name,
1772	    sizeof(eiter->a.sym_name));
1773	alen += FDMI_ATTR_ALIGNMENT(alen);
1774	alen += FDMI_ATTR_TYPELEN(eiter);
1775	eiter->len = cpu_to_be16(alen);
1776	size += alen;
1777	ql_dbg(ql_dbg_disc, vha, 0x20ab,
1778	    "SYMBOLIC NAME = %s.\n", eiter->a.sym_name);
1779	/* Vendor Specific information */
1780	eiter = entries + size;
1781	eiter->type = cpu_to_be16(FDMI_HBA_VENDOR_SPECIFIC_INFO);
1782	eiter->a.vendor_specific_info = cpu_to_be32(PCI_VENDOR_ID_QLOGIC);
1783	alen = sizeof(eiter->a.vendor_specific_info);
1784	alen += FDMI_ATTR_TYPELEN(eiter);
1785	eiter->len = cpu_to_be16(alen);
1786	size += alen;
1787	ql_dbg(ql_dbg_disc, vha, 0x20ac,
1788	    "VENDOR SPECIFIC INFO = 0x%x.\n",
1789	    be32_to_cpu(eiter->a.vendor_specific_info));
1790	/* Num Ports */
1791	eiter = entries + size;
1792	eiter->type = cpu_to_be16(FDMI_HBA_NUM_PORTS);
1793	eiter->a.num_ports = cpu_to_be32(1);
1794	alen = sizeof(eiter->a.num_ports);
1795	alen += FDMI_ATTR_TYPELEN(eiter);
1796	eiter->len = cpu_to_be16(alen);
1797	size += alen;
1798	ql_dbg(ql_dbg_disc, vha, 0x20ad,
1799	    "PORT COUNT = %x.\n", be32_to_cpu(eiter->a.num_ports));
1800	/* Fabric Name */
1801	eiter = entries + size;
1802	eiter->type = cpu_to_be16(FDMI_HBA_FABRIC_NAME);
1803	memcpy(eiter->a.fabric_name, vha->fabric_node_name,
1804	    sizeof(eiter->a.fabric_name));
1805	alen = sizeof(eiter->a.fabric_name);
1806	alen += FDMI_ATTR_TYPELEN(eiter);
1807	eiter->len = cpu_to_be16(alen);
1808	size += alen;
1809	ql_dbg(ql_dbg_disc, vha, 0x20ae,
1810	    "FABRIC NAME = %016llx.\n", wwn_to_u64(eiter->a.fabric_name));
1811	/* BIOS Version */
1812	eiter = entries + size;
1813	eiter->type = cpu_to_be16(FDMI_HBA_BOOT_BIOS_NAME);
1814	alen = scnprintf(
1815		eiter->a.bios_name, sizeof(eiter->a.bios_name),
1816		"BIOS %d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
1817	alen += FDMI_ATTR_ALIGNMENT(alen);
1818	alen += FDMI_ATTR_TYPELEN(eiter);
1819	eiter->len = cpu_to_be16(alen);
1820	size += alen;
1821	ql_dbg(ql_dbg_disc, vha, 0x20af,
1822	    "BIOS NAME = %s\n", eiter->a.bios_name);
1823	/* Vendor Identifier */
1824	eiter = entries + size;
1825	eiter->type = cpu_to_be16(FDMI_HBA_VENDOR_IDENTIFIER);
1826	alen = scnprintf(
1827		eiter->a.vendor_identifier, sizeof(eiter->a.vendor_identifier),
1828		"%s", "QLGC");
1829	alen += FDMI_ATTR_ALIGNMENT(alen);
1830	alen += FDMI_ATTR_TYPELEN(eiter);
1831	eiter->len = cpu_to_be16(alen);
1832	size += alen;
1833	ql_dbg(ql_dbg_disc, vha, 0x20b0,
1834	    "VENDOR IDENTIFIER = %s.\n", eiter->a.vendor_identifier);
1835done:
1836	return size;
1837}
1838
1839/**
1840 * qla2x00_port_attributes() - perform Port attributes registration
1841 * @vha: HA context
1842 * @entries: number of entries to use
1843 * @callopt: Option to issue extended or standard FDMI
1844 *           command parameter
1845 *
1846 * Returns 0 on success.
1847 */
1848static unsigned long
1849qla2x00_port_attributes(scsi_qla_host_t *vha, void *entries,
1850	unsigned int callopt)
1851{
1852	struct qla_hw_data *ha = vha->hw;
1853	struct new_utsname *p_sysid = utsname();
1854	char *hostname = p_sysid ?
1855		p_sysid->nodename : fc_host_system_hostname(vha->host);
1856	struct ct_fdmi_port_attr *eiter;
1857	uint16_t alen;
1858	unsigned long size = 0;
1859
1860	/* FC4 types. */
1861	eiter = entries + size;
1862	eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPES);
1863	eiter->a.fc4_types[0] = 0x00;
1864	eiter->a.fc4_types[1] = 0x00;
1865	eiter->a.fc4_types[2] = 0x01;
1866	eiter->a.fc4_types[3] = 0x00;
1867	alen = sizeof(eiter->a.fc4_types);
1868	alen += FDMI_ATTR_TYPELEN(eiter);
1869	eiter->len = cpu_to_be16(alen);
1870	size += alen;
1871	ql_dbg(ql_dbg_disc, vha, 0x20c0,
1872	    "FC4 TYPES = %016llx.\n", *(uint64_t *)eiter->a.fc4_types);
1873	if (vha->flags.nvme_enabled) {
1874		eiter->a.fc4_types[6] = 1;      /* NVMe type 28h */
1875		ql_dbg(ql_dbg_disc, vha, 0x211f,
1876		    "NVME FC4 Type = %02x 0x0 0x0 0x0 0x0 0x0.\n",
1877		    eiter->a.fc4_types[6]);
1878	}
1879	/* Supported speed. */
1880	eiter = entries + size;
1881	eiter->type = cpu_to_be16(FDMI_PORT_SUPPORT_SPEED);
1882	eiter->a.sup_speed = cpu_to_be32(
1883		qla25xx_fdmi_port_speed_capability(ha));
1884	alen = sizeof(eiter->a.sup_speed);
1885	alen += FDMI_ATTR_TYPELEN(eiter);
1886	eiter->len = cpu_to_be16(alen);
1887	size += alen;
1888	ql_dbg(ql_dbg_disc, vha, 0x20c1,
1889	    "SUPPORTED SPEED = %x.\n", be32_to_cpu(eiter->a.sup_speed));
1890	/* Current speed. */
1891	eiter = entries + size;
1892	eiter->type = cpu_to_be16(FDMI_PORT_CURRENT_SPEED);
1893	eiter->a.cur_speed = cpu_to_be32(
1894		qla25xx_fdmi_port_speed_currently(ha));
1895	alen = sizeof(eiter->a.cur_speed);
1896	alen += FDMI_ATTR_TYPELEN(eiter);
1897	eiter->len = cpu_to_be16(alen);
1898	size += alen;
1899	ql_dbg(ql_dbg_disc, vha, 0x20c2,
1900	    "CURRENT SPEED = %x.\n", be32_to_cpu(eiter->a.cur_speed));
1901	/* Max frame size. */
1902	eiter = entries + size;
1903	eiter->type = cpu_to_be16(FDMI_PORT_MAX_FRAME_SIZE);
1904	eiter->a.max_frame_size = cpu_to_be32(ha->frame_payload_size);
1905	alen = sizeof(eiter->a.max_frame_size);
1906	alen += FDMI_ATTR_TYPELEN(eiter);
1907	eiter->len = cpu_to_be16(alen);
1908	size += alen;
1909	ql_dbg(ql_dbg_disc, vha, 0x20c3,
1910	    "MAX FRAME SIZE = %x.\n", be32_to_cpu(eiter->a.max_frame_size));
1911	/* OS device name. */
1912	eiter = entries + size;
1913	eiter->type = cpu_to_be16(FDMI_PORT_OS_DEVICE_NAME);
1914	alen = scnprintf(
1915		eiter->a.os_dev_name, sizeof(eiter->a.os_dev_name),
1916		"%s:host%lu", QLA2XXX_DRIVER_NAME, vha->host_no);
1917	alen += FDMI_ATTR_ALIGNMENT(alen);
1918	alen += FDMI_ATTR_TYPELEN(eiter);
1919	eiter->len = cpu_to_be16(alen);
1920	size += alen;
1921	ql_dbg(ql_dbg_disc, vha, 0x20c4,
1922	    "OS DEVICE NAME = %s.\n", eiter->a.os_dev_name);
1923	/* Hostname. */
1924	eiter = entries + size;
1925	eiter->type = cpu_to_be16(FDMI_PORT_HOST_NAME);
1926	if (!*hostname || !strncmp(hostname, "(none)", 6))
1927		hostname = "Linux-default";
1928	alen = scnprintf(
1929		eiter->a.host_name, sizeof(eiter->a.host_name),
1930		"%s", hostname);
1931	alen += FDMI_ATTR_ALIGNMENT(alen);
1932	alen += FDMI_ATTR_TYPELEN(eiter);
1933	eiter->len = cpu_to_be16(alen);
1934	size += alen;
1935	ql_dbg(ql_dbg_disc, vha, 0x20c5,
1936	    "HOSTNAME = %s.\n", eiter->a.host_name);
1937
1938	if (callopt == CALLOPT_FDMI1)
1939		goto done;
1940
1941	/* Node Name */
1942	eiter = entries + size;
1943	eiter->type = cpu_to_be16(FDMI_PORT_NODE_NAME);
1944	memcpy(eiter->a.node_name, vha->node_name, sizeof(eiter->a.node_name));
1945	alen = sizeof(eiter->a.node_name);
1946	alen += FDMI_ATTR_TYPELEN(eiter);
1947	eiter->len = cpu_to_be16(alen);
1948	size += alen;
1949	ql_dbg(ql_dbg_disc, vha, 0x20c6,
1950	    "NODENAME = %016llx.\n", wwn_to_u64(eiter->a.node_name));
1951
1952	/* Port Name */
1953	eiter = entries + size;
1954	eiter->type = cpu_to_be16(FDMI_PORT_NAME);
1955	memcpy(eiter->a.port_name, vha->port_name, sizeof(eiter->a.port_name));
1956	alen = sizeof(eiter->a.port_name);
1957	alen += FDMI_ATTR_TYPELEN(eiter);
1958	eiter->len = cpu_to_be16(alen);
1959	size += alen;
1960	ql_dbg(ql_dbg_disc, vha, 0x20c7,
1961	    "PORTNAME = %016llx.\n", wwn_to_u64(eiter->a.port_name));
1962
1963	/* Port Symbolic Name */
1964	eiter = entries + size;
1965	eiter->type = cpu_to_be16(FDMI_PORT_SYM_NAME);
1966	alen = qla2x00_get_sym_node_name(vha, eiter->a.port_sym_name,
1967	    sizeof(eiter->a.port_sym_name));
1968	alen += FDMI_ATTR_ALIGNMENT(alen);
1969	alen += FDMI_ATTR_TYPELEN(eiter);
1970	eiter->len = cpu_to_be16(alen);
1971	size += alen;
1972	ql_dbg(ql_dbg_disc, vha, 0x20c8,
1973	    "PORT SYMBOLIC NAME = %s\n", eiter->a.port_sym_name);
1974
1975	/* Port Type */
1976	eiter = entries + size;
1977	eiter->type = cpu_to_be16(FDMI_PORT_TYPE);
1978	eiter->a.port_type = cpu_to_be32(NS_NX_PORT_TYPE);
1979	alen = sizeof(eiter->a.port_type);
1980	alen += FDMI_ATTR_TYPELEN(eiter);
1981	eiter->len = cpu_to_be16(alen);
1982	size += alen;
1983	ql_dbg(ql_dbg_disc, vha, 0x20c9,
1984	    "PORT TYPE = %x.\n", be32_to_cpu(eiter->a.port_type));
1985
1986	/* Supported Class of Service */
1987	eiter = entries + size;
1988	eiter->type = cpu_to_be16(FDMI_PORT_SUPP_COS);
1989	eiter->a.port_supported_cos = cpu_to_be32(FC_CLASS_3);
1990	alen = sizeof(eiter->a.port_supported_cos);
1991	alen += FDMI_ATTR_TYPELEN(eiter);
1992	eiter->len = cpu_to_be16(alen);
1993	size += alen;
1994	ql_dbg(ql_dbg_disc, vha, 0x20ca,
1995	    "SUPPORTED COS = %08x\n", be32_to_cpu(eiter->a.port_supported_cos));
1996
1997	/* Port Fabric Name */
1998	eiter = entries + size;
1999	eiter->type = cpu_to_be16(FDMI_PORT_FABRIC_NAME);
2000	memcpy(eiter->a.fabric_name, vha->fabric_node_name,
2001	    sizeof(eiter->a.fabric_name));
2002	alen = sizeof(eiter->a.fabric_name);
2003	alen += FDMI_ATTR_TYPELEN(eiter);
2004	eiter->len = cpu_to_be16(alen);
2005	size += alen;
2006	ql_dbg(ql_dbg_disc, vha, 0x20cb,
2007	    "FABRIC NAME = %016llx.\n", wwn_to_u64(eiter->a.fabric_name));
2008
2009	/* FC4_type */
2010	eiter = entries + size;
2011	eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPE);
2012	eiter->a.port_fc4_type[0] = 0x00;
2013	eiter->a.port_fc4_type[1] = 0x00;
2014	eiter->a.port_fc4_type[2] = 0x01;
2015	eiter->a.port_fc4_type[3] = 0x00;
2016	alen = sizeof(eiter->a.port_fc4_type);
2017	alen += FDMI_ATTR_TYPELEN(eiter);
2018	eiter->len = cpu_to_be16(alen);
2019	size += alen;
2020	ql_dbg(ql_dbg_disc, vha, 0x20cc,
2021	    "PORT ACTIVE FC4 TYPE = %016llx.\n",
2022	    *(uint64_t *)eiter->a.port_fc4_type);
2023
2024	/* Port State */
2025	eiter = entries + size;
2026	eiter->type = cpu_to_be16(FDMI_PORT_STATE);
2027	eiter->a.port_state = cpu_to_be32(2);
2028	alen = sizeof(eiter->a.port_state);
2029	alen += FDMI_ATTR_TYPELEN(eiter);
2030	eiter->len = cpu_to_be16(alen);
2031	size += alen;
2032	ql_dbg(ql_dbg_disc, vha, 0x20cd,
2033	    "PORT_STATE = %x.\n", be32_to_cpu(eiter->a.port_state));
2034
2035	/* Number of Ports */
2036	eiter = entries + size;
2037	eiter->type = cpu_to_be16(FDMI_PORT_COUNT);
2038	eiter->a.num_ports = cpu_to_be32(1);
2039	alen = sizeof(eiter->a.num_ports);
2040	alen += FDMI_ATTR_TYPELEN(eiter);
2041	eiter->len = cpu_to_be16(alen);
2042	size += alen;
2043	ql_dbg(ql_dbg_disc, vha, 0x20ce,
2044	    "PORT COUNT = %x.\n", be32_to_cpu(eiter->a.num_ports));
2045
2046	/* Port Identifier */
2047	eiter = entries + size;
2048	eiter->type = cpu_to_be16(FDMI_PORT_IDENTIFIER);
2049	eiter->a.port_id = cpu_to_be32(vha->d_id.b24);
2050	alen = sizeof(eiter->a.port_id);
2051	alen += FDMI_ATTR_TYPELEN(eiter);
2052	eiter->len = cpu_to_be16(alen);
2053	size += alen;
2054	ql_dbg(ql_dbg_disc, vha, 0x20cf,
2055	    "PORT ID = %x.\n", be32_to_cpu(eiter->a.port_id));
2056
2057	if (callopt == CALLOPT_FDMI2 || !ql2xsmartsan)
2058		goto done;
2059
2060	/* Smart SAN Service Category (Populate Smart SAN Initiator)*/
2061	eiter = entries + size;
2062	eiter->type = cpu_to_be16(FDMI_SMARTSAN_SERVICE);
2063	alen = scnprintf(
2064		eiter->a.smartsan_service, sizeof(eiter->a.smartsan_service),
2065		"%s", "Smart SAN Initiator");
2066	alen += FDMI_ATTR_ALIGNMENT(alen);
2067	alen += FDMI_ATTR_TYPELEN(eiter);
2068	eiter->len = cpu_to_be16(alen);
2069	size += alen;
2070	ql_dbg(ql_dbg_disc, vha, 0x20d0,
2071	    "SMARTSAN SERVICE CATEGORY = %s.\n", eiter->a.smartsan_service);
2072
2073	/* Smart SAN GUID (NWWN+PWWN) */
2074	eiter = entries + size;
2075	eiter->type = cpu_to_be16(FDMI_SMARTSAN_GUID);
2076	memcpy(eiter->a.smartsan_guid, vha->node_name, WWN_SIZE);
2077	memcpy(eiter->a.smartsan_guid + WWN_SIZE, vha->port_name, WWN_SIZE);
2078	alen = sizeof(eiter->a.smartsan_guid);
2079	alen += FDMI_ATTR_TYPELEN(eiter);
2080	eiter->len = cpu_to_be16(alen);
2081	size += alen;
2082	ql_dbg(ql_dbg_disc, vha, 0x20d1,
2083	    "Smart SAN GUID = %016llx-%016llx\n",
2084	    wwn_to_u64(eiter->a.smartsan_guid),
2085	    wwn_to_u64(eiter->a.smartsan_guid + WWN_SIZE));
2086
2087	/* Smart SAN Version (populate "Smart SAN Version 1.0") */
2088	eiter = entries + size;
2089	eiter->type = cpu_to_be16(FDMI_SMARTSAN_VERSION);
2090	alen = scnprintf(
2091		eiter->a.smartsan_version, sizeof(eiter->a.smartsan_version),
2092		"%s", "Smart SAN Version 2.0");
2093	alen += FDMI_ATTR_ALIGNMENT(alen);
2094	alen += FDMI_ATTR_TYPELEN(eiter);
2095	eiter->len = cpu_to_be16(alen);
2096	size += alen;
2097	ql_dbg(ql_dbg_disc, vha, 0x20d2,
2098	    "SMARTSAN VERSION = %s\n", eiter->a.smartsan_version);
2099
2100	/* Smart SAN Product Name (Specify Adapter Model No) */
2101	eiter = entries + size;
2102	eiter->type = cpu_to_be16(FDMI_SMARTSAN_PROD_NAME);
2103	alen = scnprintf(eiter->a.smartsan_prod_name,
2104		sizeof(eiter->a.smartsan_prod_name),
2105		"ISP%04x", ha->pdev->device);
2106	alen += FDMI_ATTR_ALIGNMENT(alen);
2107	alen += FDMI_ATTR_TYPELEN(eiter);
2108	eiter->len = cpu_to_be16(alen);
2109	size += alen;
2110	ql_dbg(ql_dbg_disc, vha, 0x20d3,
2111	    "SMARTSAN PRODUCT NAME = %s\n", eiter->a.smartsan_prod_name);
2112
2113	/* Smart SAN Port Info (specify: 1=Physical, 2=NPIV, 3=SRIOV) */
2114	eiter = entries + size;
2115	eiter->type = cpu_to_be16(FDMI_SMARTSAN_PORT_INFO);
2116	eiter->a.smartsan_port_info = cpu_to_be32(vha->vp_idx ? 2 : 1);
2117	alen = sizeof(eiter->a.smartsan_port_info);
2118	alen += FDMI_ATTR_TYPELEN(eiter);
2119	eiter->len = cpu_to_be16(alen);
2120	size += alen;
2121	ql_dbg(ql_dbg_disc, vha, 0x20d4,
2122	    "SMARTSAN PORT INFO = %x\n", eiter->a.smartsan_port_info);
2123
2124	/* Smart SAN Security Support */
2125	eiter = entries + size;
2126	eiter->type = cpu_to_be16(FDMI_SMARTSAN_SECURITY_SUPPORT);
2127	eiter->a.smartsan_security_support = cpu_to_be32(1);
2128	alen = sizeof(eiter->a.smartsan_security_support);
2129	alen += FDMI_ATTR_TYPELEN(eiter);
2130	eiter->len = cpu_to_be16(alen);
2131	size += alen;
2132	ql_dbg(ql_dbg_disc, vha, 0x20d6,
2133	    "SMARTSAN SECURITY SUPPORT = %d\n",
2134	    be32_to_cpu(eiter->a.smartsan_security_support));
2135
2136done:
2137	return size;
2138}
2139
2140/**
2141 * qla2x00_fdmi_rhba() - perform RHBA FDMI registration
2142 * @vha: HA context
2143 * @callopt: Option to issue FDMI registration
2144 *
2145 * Returns 0 on success.
2146 */
2147static int
2148qla2x00_fdmi_rhba(scsi_qla_host_t *vha, unsigned int callopt)
2149{
2150	struct qla_hw_data *ha = vha->hw;
2151	unsigned long size = 0;
2152	unsigned int rval, count;
2153	ms_iocb_entry_t *ms_pkt;
2154	struct ct_sns_req *ct_req;
2155	struct ct_sns_rsp *ct_rsp;
2156	void *entries;
2157
2158	count = callopt != CALLOPT_FDMI1 ?
2159	    FDMI2_HBA_ATTR_COUNT : FDMI1_HBA_ATTR_COUNT;
2160
2161	size = RHBA_RSP_SIZE;
2162
2163	ql_dbg(ql_dbg_disc, vha, 0x20e0,
2164	    "RHBA (callopt=%x count=%u size=%lu).\n", callopt, count, size);
2165
2166	/*   Request size adjusted after CT preparation */
2167	ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, size);
2168
2169	/* Prepare CT request */
2170	ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RHBA_CMD, size);
2171	ct_rsp = &ha->ct_sns->p.rsp;
2172
2173	/* Prepare FDMI command entries */
2174	memcpy(ct_req->req.rhba.hba_identifier, vha->port_name,
2175	    sizeof(ct_req->req.rhba.hba_identifier));
2176	size += sizeof(ct_req->req.rhba.hba_identifier);
2177
2178	ct_req->req.rhba.entry_count = cpu_to_be32(1);
2179	size += sizeof(ct_req->req.rhba.entry_count);
2180
2181	memcpy(ct_req->req.rhba.port_name, vha->port_name,
2182	    sizeof(ct_req->req.rhba.port_name));
2183	size += sizeof(ct_req->req.rhba.port_name);
2184
2185	/* Attribute count */
2186	ct_req->req.rhba.attrs.count = cpu_to_be32(count);
2187	size += sizeof(ct_req->req.rhba.attrs.count);
2188
2189	/* Attribute block */
2190	entries = &ct_req->req.rhba.attrs.entry;
2191
2192	size += qla2x00_hba_attributes(vha, entries, callopt);
2193
2194	/* Update MS request size. */
2195	qla2x00_update_ms_fdmi_iocb(vha, size + 16);
2196
2197	ql_dbg(ql_dbg_disc, vha, 0x20e1,
2198	    "RHBA %016llx %016llx.\n",
2199	    wwn_to_u64(ct_req->req.rhba.hba_identifier),
2200	    wwn_to_u64(ct_req->req.rhba.port_name));
2201
2202	ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20e2,
2203	    entries, size);
2204
2205	/* Execute MS IOCB */
2206	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2207	    sizeof(*ha->ms_iocb));
2208	if (rval) {
2209		ql_dbg(ql_dbg_disc, vha, 0x20e3,
2210		    "RHBA iocb failed (%d).\n", rval);
2211		return rval;
2212	}
2213
2214	rval = qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RHBA");
2215	if (rval) {
2216		if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
2217		    ct_rsp->header.explanation_code ==
2218		    CT_EXPL_ALREADY_REGISTERED) {
2219			ql_dbg(ql_dbg_disc, vha, 0x20e4,
2220			    "RHBA already registered.\n");
2221			return QLA_ALREADY_REGISTERED;
2222		}
2223
2224		ql_dbg(ql_dbg_disc, vha, 0x20e5,
2225		    "RHBA failed, CT Reason %#x, CT Explanation %#x\n",
2226		    ct_rsp->header.reason_code,
2227		    ct_rsp->header.explanation_code);
2228		return rval;
2229	}
2230
2231	ql_dbg(ql_dbg_disc, vha, 0x20e6, "RHBA exiting normally.\n");
2232	return rval;
2233}
2234
2235
2236static int
2237qla2x00_fdmi_dhba(scsi_qla_host_t *vha)
2238{
2239	int rval;
2240	struct qla_hw_data *ha = vha->hw;
2241	ms_iocb_entry_t *ms_pkt;
2242	struct ct_sns_req *ct_req;
2243	struct ct_sns_rsp *ct_rsp;
2244	/* Issue RPA */
2245	/* Prepare common MS IOCB */
2246	ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, DHBA_REQ_SIZE,
2247	    DHBA_RSP_SIZE);
2248	/* Prepare CT request */
2249	ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, DHBA_CMD, DHBA_RSP_SIZE);
2250	ct_rsp = &ha->ct_sns->p.rsp;
2251	/* Prepare FDMI command arguments -- portname. */
2252	memcpy(ct_req->req.dhba.port_name, vha->port_name, WWN_SIZE);
2253	ql_dbg(ql_dbg_disc, vha, 0x2036,
2254	    "DHBA portname = %8phN.\n", ct_req->req.dhba.port_name);
2255	/* Execute MS IOCB */
2256	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2257	    sizeof(ms_iocb_entry_t));
2258	if (rval != QLA_SUCCESS) {
2259		/*EMPTY*/
2260		ql_dbg(ql_dbg_disc, vha, 0x2037,
2261		    "DHBA issue IOCB failed (%d).\n", rval);
2262	} else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "DHBA") !=
2263	    QLA_SUCCESS) {
2264		rval = QLA_FUNCTION_FAILED;
2265	} else {
2266		ql_dbg(ql_dbg_disc, vha, 0x2038,
2267		    "DHBA exiting normally.\n");
2268	}
2269	return rval;
2270}
2271
2272/**
2273 * qla2x00_fdmi_rprt() - perform RPRT registration
2274 * @vha: HA context
2275 * @callopt: Option to issue extended or standard FDMI
2276 *           command parameter
2277 *
2278 * Returns 0 on success.
2279 */
2280static int
2281qla2x00_fdmi_rprt(scsi_qla_host_t *vha, int callopt)
2282{
2283	struct scsi_qla_host *base_vha = pci_get_drvdata(vha->hw->pdev);
2284	struct qla_hw_data *ha = vha->hw;
2285	ulong size = 0;
2286	uint rval, count;
2287	ms_iocb_entry_t *ms_pkt;
2288	struct ct_sns_req *ct_req;
2289	struct ct_sns_rsp *ct_rsp;
2290	void *entries;
2291	count = callopt == CALLOPT_FDMI2_SMARTSAN && ql2xsmartsan ?
2292		FDMI2_SMARTSAN_PORT_ATTR_COUNT :
2293		callopt != CALLOPT_FDMI1 ?
2294		FDMI2_PORT_ATTR_COUNT : FDMI1_PORT_ATTR_COUNT;
2295
2296	size = RPRT_RSP_SIZE;
2297	ql_dbg(ql_dbg_disc, vha, 0x20e8,
2298	    "RPRT (callopt=%x count=%u size=%lu).\n", callopt, count, size);
2299	/* Request size adjusted after CT preparation */
2300	ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, size);
2301	/* Prepare CT request */
2302	ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RPRT_CMD, size);
2303	ct_rsp = &ha->ct_sns->p.rsp;
2304	/* Prepare FDMI command entries */
2305	memcpy(ct_req->req.rprt.hba_identifier, base_vha->port_name,
2306	    sizeof(ct_req->req.rprt.hba_identifier));
2307	size += sizeof(ct_req->req.rprt.hba_identifier);
2308	memcpy(ct_req->req.rprt.port_name, vha->port_name,
2309	    sizeof(ct_req->req.rprt.port_name));
2310	size += sizeof(ct_req->req.rprt.port_name);
2311	/* Attribute count */
2312	ct_req->req.rprt.attrs.count = cpu_to_be32(count);
2313	size += sizeof(ct_req->req.rprt.attrs.count);
2314	/* Attribute block */
2315	entries = ct_req->req.rprt.attrs.entry;
2316	size += qla2x00_port_attributes(vha, entries, callopt);
2317	/* Update MS request size. */
2318	qla2x00_update_ms_fdmi_iocb(vha, size + 16);
2319	ql_dbg(ql_dbg_disc, vha, 0x20e9,
2320	    "RPRT %016llx  %016llx.\n",
2321	    wwn_to_u64(ct_req->req.rprt.port_name),
2322	    wwn_to_u64(ct_req->req.rprt.port_name));
2323	ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20ea,
2324	    entries, size);
2325	/* Execute MS IOCB */
2326	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2327	    sizeof(*ha->ms_iocb));
2328	if (rval) {
2329		ql_dbg(ql_dbg_disc, vha, 0x20eb,
2330		    "RPRT iocb failed (%d).\n", rval);
2331		return rval;
2332	}
2333	rval = qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPRT");
2334	if (rval) {
2335		if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
2336		    ct_rsp->header.explanation_code ==
2337		    CT_EXPL_ALREADY_REGISTERED) {
2338			ql_dbg(ql_dbg_disc, vha, 0x20ec,
2339			    "RPRT already registered.\n");
2340			return QLA_ALREADY_REGISTERED;
2341		}
2342
2343		ql_dbg(ql_dbg_disc, vha, 0x20ed,
2344		    "RPRT failed, CT Reason code: %#x, CT Explanation %#x\n",
2345		    ct_rsp->header.reason_code,
2346		    ct_rsp->header.explanation_code);
2347		return rval;
2348	}
2349	ql_dbg(ql_dbg_disc, vha, 0x20ee, "RPRT exiting normally.\n");
2350	return rval;
2351}
2352
2353/**
2354 * qla2x00_fdmi_rpa() - perform RPA registration
2355 * @vha: HA context
2356 * @callopt: Option to issue FDMI registration
2357 *
2358 * Returns 0 on success.
2359 */
2360static int
2361qla2x00_fdmi_rpa(scsi_qla_host_t *vha, uint callopt)
2362{
2363	struct qla_hw_data *ha = vha->hw;
2364	ulong size = 0;
2365	uint rval, count;
2366	ms_iocb_entry_t *ms_pkt;
2367	struct ct_sns_req *ct_req;
2368	struct ct_sns_rsp *ct_rsp;
2369	void *entries;
2370
2371	count =
2372	    callopt == CALLOPT_FDMI2_SMARTSAN && ql2xsmartsan ?
2373		FDMI2_SMARTSAN_PORT_ATTR_COUNT :
2374	    callopt != CALLOPT_FDMI1 ?
2375		FDMI2_PORT_ATTR_COUNT : FDMI1_PORT_ATTR_COUNT;
2376
2377	size =
2378	    callopt != CALLOPT_FDMI1 ?
2379		SMARTSAN_RPA_RSP_SIZE : RPA_RSP_SIZE;
2380
2381	ql_dbg(ql_dbg_disc, vha, 0x20f0,
2382	    "RPA (callopt=%x count=%u size=%lu).\n", callopt, count, size);
2383
2384	/* Request size adjusted after CT preparation */
2385	ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, size);
2386
2387	/* Prepare CT request */
2388	ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RPA_CMD, size);
2389	ct_rsp = &ha->ct_sns->p.rsp;
2390
2391	/* Prepare FDMI command entries. */
2392	memcpy(ct_req->req.rpa.port_name, vha->port_name,
2393	    sizeof(ct_req->req.rpa.port_name));
2394	size += sizeof(ct_req->req.rpa.port_name);
2395
2396	/* Attribute count */
2397	ct_req->req.rpa.attrs.count = cpu_to_be32(count);
2398	size += sizeof(ct_req->req.rpa.attrs.count);
2399
2400	/* Attribute block */
2401	entries = ct_req->req.rpa.attrs.entry;
2402
2403	size += qla2x00_port_attributes(vha, entries, callopt);
2404
2405	/* Update MS request size. */
2406	qla2x00_update_ms_fdmi_iocb(vha, size + 16);
2407
2408	ql_dbg(ql_dbg_disc, vha, 0x20f1,
2409	    "RPA %016llx.\n", wwn_to_u64(ct_req->req.rpa.port_name));
2410
2411	ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20f2,
2412	    entries, size);
2413
2414	/* Execute MS IOCB */
2415	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2416	    sizeof(*ha->ms_iocb));
2417	if (rval) {
2418		ql_dbg(ql_dbg_disc, vha, 0x20f3,
2419		    "RPA iocb failed (%d).\n", rval);
2420		return rval;
2421	}
2422
2423	rval = qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPA");
2424	if (rval) {
2425		if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
2426		    ct_rsp->header.explanation_code ==
2427		    CT_EXPL_ALREADY_REGISTERED) {
2428			ql_dbg(ql_dbg_disc, vha, 0x20f4,
2429			    "RPA already registered.\n");
2430			return QLA_ALREADY_REGISTERED;
2431		}
2432
2433		ql_dbg(ql_dbg_disc, vha, 0x20f5,
2434		    "RPA failed, CT Reason code: %#x, CT Explanation %#x\n",
2435		    ct_rsp->header.reason_code,
2436		    ct_rsp->header.explanation_code);
2437		return rval;
2438	}
2439
2440	ql_dbg(ql_dbg_disc, vha, 0x20f6, "RPA exiting normally.\n");
2441	return rval;
2442}
2443
2444/**
2445 * qla2x00_fdmi_register() -
2446 * @vha: HA context
2447 *
2448 * Returns 0 on success.
2449 */
2450int
2451qla2x00_fdmi_register(scsi_qla_host_t *vha)
2452{
2453	int rval = QLA_SUCCESS;
2454	struct qla_hw_data *ha = vha->hw;
2455
2456	if (IS_QLA2100(ha) || IS_QLA2200(ha) ||
2457	    IS_QLAFX00(ha))
2458		return rval;
2459
2460	rval = qla2x00_mgmt_svr_login(vha);
2461	if (rval)
2462		return rval;
2463
2464	/* For npiv/vport send rprt only */
2465	if (vha->vp_idx) {
2466		if (ql2xsmartsan)
2467			rval = qla2x00_fdmi_rprt(vha, CALLOPT_FDMI2_SMARTSAN);
2468		if (rval || !ql2xsmartsan)
2469			rval = qla2x00_fdmi_rprt(vha, CALLOPT_FDMI2);
2470		if (rval)
2471			rval = qla2x00_fdmi_rprt(vha, CALLOPT_FDMI1);
2472
2473		return rval;
2474	}
2475
2476	/* Try fdmi2 first, if fails then try fdmi1 */
2477	rval = qla2x00_fdmi_rhba(vha, CALLOPT_FDMI2);
2478	if (rval) {
2479		if (rval != QLA_ALREADY_REGISTERED)
2480			goto try_fdmi;
2481
2482		rval = qla2x00_fdmi_dhba(vha);
2483		if (rval)
2484			goto try_fdmi;
2485
2486		rval = qla2x00_fdmi_rhba(vha, CALLOPT_FDMI2);
2487		if (rval)
2488			goto try_fdmi;
2489	}
2490
2491	if (ql2xsmartsan)
2492		rval = qla2x00_fdmi_rpa(vha, CALLOPT_FDMI2_SMARTSAN);
2493	if (rval || !ql2xsmartsan)
2494		rval = qla2x00_fdmi_rpa(vha, CALLOPT_FDMI2);
2495	if (rval)
2496		goto try_fdmi;
2497
2498	return rval;
2499
2500try_fdmi:
2501	rval = qla2x00_fdmi_rhba(vha, CALLOPT_FDMI1);
2502	if (rval) {
2503		if (rval != QLA_ALREADY_REGISTERED)
2504			return rval;
2505
2506		rval = qla2x00_fdmi_dhba(vha);
2507		if (rval)
2508			return rval;
2509
2510		rval = qla2x00_fdmi_rhba(vha, CALLOPT_FDMI1);
2511		if (rval)
2512			return rval;
2513	}
2514
2515	rval = qla2x00_fdmi_rpa(vha, CALLOPT_FDMI1);
2516
2517	return rval;
2518}
2519
2520/**
2521 * qla2x00_gfpn_id() - SNS Get Fabric Port Name (GFPN_ID) query.
2522 * @vha: HA context
2523 * @list: switch info entries to populate
2524 *
2525 * Returns 0 on success.
2526 */
2527int
2528qla2x00_gfpn_id(scsi_qla_host_t *vha, sw_info_t *list)
2529{
2530	int		rval = QLA_SUCCESS;
2531	uint16_t	i;
2532	struct qla_hw_data *ha = vha->hw;
2533	ms_iocb_entry_t	*ms_pkt;
2534	struct ct_sns_req	*ct_req;
2535	struct ct_sns_rsp	*ct_rsp;
2536	struct ct_arg arg;
2537
2538	if (!IS_IIDMA_CAPABLE(ha))
2539		return QLA_FUNCTION_FAILED;
2540
2541	arg.iocb = ha->ms_iocb;
2542	arg.req_dma = ha->ct_sns_dma;
2543	arg.rsp_dma = ha->ct_sns_dma;
2544	arg.req_size = GFPN_ID_REQ_SIZE;
2545	arg.rsp_size = GFPN_ID_RSP_SIZE;
2546	arg.nport_handle = NPH_SNS;
2547
2548	for (i = 0; i < ha->max_fibre_devices; i++) {
2549		/* Issue GFPN_ID */
2550		/* Prepare common MS IOCB */
2551		ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
2552
2553		/* Prepare CT request */
2554		ct_req = qla2x00_prep_ct_req(ha->ct_sns, GFPN_ID_CMD,
2555		    GFPN_ID_RSP_SIZE);
2556		ct_rsp = &ha->ct_sns->p.rsp;
2557
2558		/* Prepare CT arguments -- port_id */
2559		ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
2560
2561		/* Execute MS IOCB */
2562		rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2563		    sizeof(ms_iocb_entry_t));
2564		if (rval != QLA_SUCCESS) {
2565			/*EMPTY*/
2566			ql_dbg(ql_dbg_disc, vha, 0x2023,
2567			    "GFPN_ID issue IOCB failed (%d).\n", rval);
2568			break;
2569		} else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
2570		    "GFPN_ID") != QLA_SUCCESS) {
2571			rval = QLA_FUNCTION_FAILED;
2572			break;
2573		} else {
2574			/* Save fabric portname */
2575			memcpy(list[i].fabric_port_name,
2576			    ct_rsp->rsp.gfpn_id.port_name, WWN_SIZE);
2577		}
2578
2579		/* Last device exit. */
2580		if (list[i].d_id.b.rsvd_1 != 0)
2581			break;
2582	}
2583
2584	return (rval);
2585}
2586
2587
2588static inline struct ct_sns_req *
2589qla24xx_prep_ct_fm_req(struct ct_sns_pkt *p, uint16_t cmd,
2590    uint16_t rsp_size)
2591{
2592	memset(p, 0, sizeof(struct ct_sns_pkt));
2593
2594	p->p.req.header.revision = 0x01;
2595	p->p.req.header.gs_type = 0xFA;
2596	p->p.req.header.gs_subtype = 0x01;
2597	p->p.req.command = cpu_to_be16(cmd);
2598	p->p.req.max_rsp_size = cpu_to_be16((rsp_size - 16) / 4);
2599
2600	return &p->p.req;
2601}
2602
2603static uint16_t
2604qla2x00_port_speed_capability(uint16_t speed)
2605{
2606	switch (speed) {
2607	case BIT_15:
2608		return PORT_SPEED_1GB;
2609	case BIT_14:
2610		return PORT_SPEED_2GB;
2611	case BIT_13:
2612		return PORT_SPEED_4GB;
2613	case BIT_12:
2614		return PORT_SPEED_10GB;
2615	case BIT_11:
2616		return PORT_SPEED_8GB;
2617	case BIT_10:
2618		return PORT_SPEED_16GB;
2619	case BIT_8:
2620		return PORT_SPEED_32GB;
2621	case BIT_7:
2622		return PORT_SPEED_64GB;
2623	default:
2624		return PORT_SPEED_UNKNOWN;
2625	}
2626}
2627
2628/**
2629 * qla2x00_gff_id() - SNS Get FC-4 Features (GFF_ID) query.
2630 *
2631 * @vha: HA context
2632 * @list: switch info entries to populate
2633 *
2634 */
2635void
2636qla2x00_gff_id(scsi_qla_host_t *vha, sw_info_t *list)
2637{
2638	int		rval;
2639	uint16_t	i;
2640
2641	ms_iocb_entry_t	*ms_pkt;
2642	struct ct_sns_req	*ct_req;
2643	struct ct_sns_rsp	*ct_rsp;
2644	struct qla_hw_data *ha = vha->hw;
2645	uint8_t fcp_scsi_features = 0, nvme_features = 0;
2646	struct ct_arg arg;
2647
2648	for (i = 0; i < ha->max_fibre_devices; i++) {
2649		/* Set default FC4 Type as UNKNOWN so the default is to
2650		 * Process this port */
2651		list[i].fc4_type = 0;
2652
2653		/* Do not attempt GFF_ID if we are not FWI_2 capable */
2654		if (!IS_FWI2_CAPABLE(ha))
2655			continue;
2656
2657		arg.iocb = ha->ms_iocb;
2658		arg.req_dma = ha->ct_sns_dma;
2659		arg.rsp_dma = ha->ct_sns_dma;
2660		arg.req_size = GFF_ID_REQ_SIZE;
2661		arg.rsp_size = GFF_ID_RSP_SIZE;
2662		arg.nport_handle = NPH_SNS;
2663
2664		/* Prepare common MS IOCB */
2665		ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
2666
2667		/* Prepare CT request */
2668		ct_req = qla2x00_prep_ct_req(ha->ct_sns, GFF_ID_CMD,
2669		    GFF_ID_RSP_SIZE);
2670		ct_rsp = &ha->ct_sns->p.rsp;
2671
2672		/* Prepare CT arguments -- port_id */
2673		ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
2674
2675		/* Execute MS IOCB */
2676		rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2677		   sizeof(ms_iocb_entry_t));
2678
2679		if (rval != QLA_SUCCESS) {
2680			ql_dbg(ql_dbg_disc, vha, 0x205c,
2681			    "GFF_ID issue IOCB failed (%d).\n", rval);
2682		} else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
2683			       "GFF_ID") != QLA_SUCCESS) {
2684			ql_dbg(ql_dbg_disc, vha, 0x205d,
2685			    "GFF_ID IOCB status had a failure status code.\n");
2686		} else {
2687			fcp_scsi_features =
2688			   ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET];
2689			fcp_scsi_features &= 0x0f;
2690
2691			if (fcp_scsi_features) {
2692				list[i].fc4_type = FS_FC4TYPE_FCP;
2693				list[i].fc4_features = fcp_scsi_features;
2694			}
2695
2696			nvme_features =
2697			    ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET];
2698			nvme_features &= 0xf;
2699
2700			if (nvme_features) {
2701				list[i].fc4_type |= FS_FC4TYPE_NVME;
2702				list[i].fc4_features = nvme_features;
2703			}
2704		}
2705
2706		/* Last device exit. */
2707		if (list[i].d_id.b.rsvd_1 != 0)
2708			break;
2709	}
2710}
2711
2712int qla24xx_post_gpsc_work(struct scsi_qla_host *vha, fc_port_t *fcport)
2713{
2714	struct qla_work_evt *e;
2715
2716	e = qla2x00_alloc_work(vha, QLA_EVT_GPSC);
2717	if (!e)
2718		return QLA_FUNCTION_FAILED;
2719
2720	e->u.fcport.fcport = fcport;
2721	return qla2x00_post_work(vha, e);
2722}
2723
2724void qla24xx_handle_gpsc_event(scsi_qla_host_t *vha, struct event_arg *ea)
2725{
2726	struct fc_port *fcport = ea->fcport;
2727
2728	ql_dbg(ql_dbg_disc, vha, 0x20d8,
2729	    "%s %8phC DS %d LS %d rc %d login %d|%d rscn %d|%d lid %d\n",
2730	    __func__, fcport->port_name, fcport->disc_state,
2731	    fcport->fw_login_state, ea->rc, ea->sp->gen2, fcport->login_gen,
2732	    ea->sp->gen2, fcport->rscn_gen|ea->sp->gen1, fcport->loop_id);
2733
2734	if (fcport->disc_state == DSC_DELETE_PEND)
2735		return;
2736
2737	/* We will figure-out what happen after AUTH completes */
2738	if (fcport->disc_state == DSC_LOGIN_AUTH_PEND)
2739		return;
2740
2741	if (ea->sp->gen2 != fcport->login_gen) {
2742		/* target side must have changed it. */
2743		ql_dbg(ql_dbg_disc, vha, 0x20d3,
2744		    "%s %8phC generation changed\n",
2745		    __func__, fcport->port_name);
2746		return;
2747	} else if (ea->sp->gen1 != fcport->rscn_gen) {
2748		return;
2749	}
2750
2751	qla_post_iidma_work(vha, fcport);
2752}
2753
2754static void qla24xx_async_gpsc_sp_done(srb_t *sp, int res)
2755{
2756	struct scsi_qla_host *vha = sp->vha;
2757	struct qla_hw_data *ha = vha->hw;
2758	fc_port_t *fcport = sp->fcport;
2759	struct ct_sns_rsp       *ct_rsp;
2760	struct event_arg ea;
2761
2762	ct_rsp = &fcport->ct_desc.ct_sns->p.rsp;
2763
2764	ql_dbg(ql_dbg_disc, vha, 0x2053,
2765	    "Async done-%s res %x, WWPN %8phC \n",
2766	    sp->name, res, fcport->port_name);
2767
2768	fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
2769
2770	if (res == QLA_FUNCTION_TIMEOUT)
2771		goto done;
2772
2773	if (res == (DID_ERROR << 16)) {
2774		/* entry status error */
2775		goto done;
2776	} else if (res) {
2777		if ((ct_rsp->header.reason_code ==
2778			 CT_REASON_INVALID_COMMAND_CODE) ||
2779			(ct_rsp->header.reason_code ==
2780			CT_REASON_COMMAND_UNSUPPORTED)) {
2781			ql_dbg(ql_dbg_disc, vha, 0x2019,
2782			    "GPSC command unsupported, disabling query.\n");
2783			ha->flags.gpsc_supported = 0;
2784			goto done;
2785		}
2786	} else {
2787		fcport->fp_speed = qla2x00_port_speed_capability(
2788		    be16_to_cpu(ct_rsp->rsp.gpsc.speed));
2789
2790		ql_dbg(ql_dbg_disc, vha, 0x2054,
2791		    "Async-%s OUT WWPN %8phC speeds=%04x speed=%04x.\n",
2792		    sp->name, fcport->fabric_port_name,
2793		    be16_to_cpu(ct_rsp->rsp.gpsc.speeds),
2794		    be16_to_cpu(ct_rsp->rsp.gpsc.speed));
2795	}
2796	memset(&ea, 0, sizeof(ea));
2797	ea.rc = res;
2798	ea.fcport = fcport;
2799	ea.sp = sp;
2800	qla24xx_handle_gpsc_event(vha, &ea);
2801
2802done:
2803	/* ref: INIT */
2804	kref_put(&sp->cmd_kref, qla2x00_sp_release);
2805}
2806
2807int qla24xx_async_gpsc(scsi_qla_host_t *vha, fc_port_t *fcport)
2808{
2809	int rval = QLA_FUNCTION_FAILED;
2810	struct ct_sns_req       *ct_req;
2811	srb_t *sp;
2812
2813	if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
2814		return rval;
2815
2816	/* ref: INIT */
2817	sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
2818	if (!sp)
2819		goto done;
2820
2821	sp->type = SRB_CT_PTHRU_CMD;
2822	sp->name = "gpsc";
2823	sp->gen1 = fcport->rscn_gen;
2824	sp->gen2 = fcport->login_gen;
2825	qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
2826			      qla24xx_async_gpsc_sp_done);
2827
2828	/* CT_IU preamble  */
2829	ct_req = qla24xx_prep_ct_fm_req(fcport->ct_desc.ct_sns, GPSC_CMD,
2830		GPSC_RSP_SIZE);
2831
2832	/* GPSC req */
2833	memcpy(ct_req->req.gpsc.port_name, fcport->fabric_port_name,
2834		WWN_SIZE);
2835
2836	sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
2837	sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
2838	sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
2839	sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
2840	sp->u.iocb_cmd.u.ctarg.req_size = GPSC_REQ_SIZE;
2841	sp->u.iocb_cmd.u.ctarg.rsp_size = GPSC_RSP_SIZE;
2842	sp->u.iocb_cmd.u.ctarg.nport_handle = vha->mgmt_svr_loop_id;
2843
2844	ql_dbg(ql_dbg_disc, vha, 0x205e,
2845	    "Async-%s %8phC hdl=%x loopid=%x portid=%02x%02x%02x.\n",
2846	    sp->name, fcport->port_name, sp->handle,
2847	    fcport->loop_id, fcport->d_id.b.domain,
2848	    fcport->d_id.b.area, fcport->d_id.b.al_pa);
2849
2850	rval = qla2x00_start_sp(sp);
2851	if (rval != QLA_SUCCESS)
2852		goto done_free_sp;
2853	return rval;
2854
2855done_free_sp:
2856	/* ref: INIT */
2857	kref_put(&sp->cmd_kref, qla2x00_sp_release);
2858done:
2859	return rval;
2860}
2861
2862void qla24xx_sp_unmap(scsi_qla_host_t *vha, srb_t *sp)
2863{
2864	struct srb_iocb *c = &sp->u.iocb_cmd;
2865
2866	switch (sp->type) {
2867	case SRB_ELS_DCMD:
2868		qla2x00_els_dcmd2_free(vha, &c->u.els_plogi);
2869		break;
2870	case SRB_CT_PTHRU_CMD:
2871	default:
2872		if (sp->u.iocb_cmd.u.ctarg.req) {
2873			dma_free_coherent(&vha->hw->pdev->dev,
2874			    sp->u.iocb_cmd.u.ctarg.req_allocated_size,
2875			    sp->u.iocb_cmd.u.ctarg.req,
2876			    sp->u.iocb_cmd.u.ctarg.req_dma);
2877			sp->u.iocb_cmd.u.ctarg.req = NULL;
2878		}
2879
2880		if (sp->u.iocb_cmd.u.ctarg.rsp) {
2881			dma_free_coherent(&vha->hw->pdev->dev,
2882			    sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
2883			    sp->u.iocb_cmd.u.ctarg.rsp,
2884			    sp->u.iocb_cmd.u.ctarg.rsp_dma);
2885			sp->u.iocb_cmd.u.ctarg.rsp = NULL;
2886		}
2887		break;
2888	}
2889
2890	/* ref: INIT */
2891	kref_put(&sp->cmd_kref, qla2x00_sp_release);
2892}
2893
2894void qla24xx_async_gffid_sp_done(srb_t *sp, int res)
2895{
2896	struct scsi_qla_host *vha = sp->vha;
2897	fc_port_t *fcport = sp->fcport;
2898	struct ct_sns_rsp *ct_rsp;
2899	uint8_t fc4_scsi_feat;
2900	uint8_t fc4_nvme_feat;
2901
2902	ql_dbg(ql_dbg_disc, vha, 0x2133,
2903	       "Async done-%s res %x ID %x. %8phC\n",
2904	       sp->name, res, fcport->d_id.b24, fcport->port_name);
2905
2906	ct_rsp = sp->u.iocb_cmd.u.ctarg.rsp;
2907	fc4_scsi_feat = ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET];
2908	fc4_nvme_feat = ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET];
2909	sp->rc = res;
2910
2911	/*
2912	 * FC-GS-7, 5.2.3.12 FC-4 Features - format
2913	 * The format of the FC-4 Features object, as defined by the FC-4,
2914	 * Shall be an array of 4-bit values, one for each type code value
2915	 */
2916	if (!res) {
2917		if (fc4_scsi_feat & 0xf) {
2918			/* w1 b00:03 */
2919			fcport->fc4_type = FS_FC4TYPE_FCP;
2920			fcport->fc4_features = fc4_scsi_feat & 0xf;
2921		}
2922
2923		if (fc4_nvme_feat & 0xf) {
2924			/* w5 [00:03]/28h */
2925			fcport->fc4_type |= FS_FC4TYPE_NVME;
2926			fcport->fc4_features = fc4_nvme_feat & 0xf;
2927		}
2928	}
2929
2930	if (sp->flags & SRB_WAKEUP_ON_COMP) {
2931		complete(sp->comp);
2932	} else  {
2933		if (sp->u.iocb_cmd.u.ctarg.req) {
2934			dma_free_coherent(&vha->hw->pdev->dev,
2935				sp->u.iocb_cmd.u.ctarg.req_allocated_size,
2936				sp->u.iocb_cmd.u.ctarg.req,
2937				sp->u.iocb_cmd.u.ctarg.req_dma);
2938			sp->u.iocb_cmd.u.ctarg.req = NULL;
2939		}
2940
2941		if (sp->u.iocb_cmd.u.ctarg.rsp) {
2942			dma_free_coherent(&vha->hw->pdev->dev,
2943				sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
2944				sp->u.iocb_cmd.u.ctarg.rsp,
2945				sp->u.iocb_cmd.u.ctarg.rsp_dma);
2946			sp->u.iocb_cmd.u.ctarg.rsp = NULL;
2947		}
2948
2949		/* ref: INIT */
2950		kref_put(&sp->cmd_kref, qla2x00_sp_release);
2951		/* we should not be here */
2952		dump_stack();
2953	}
2954}
2955
2956/* Get FC4 Feature with Nport ID. */
2957int qla24xx_async_gffid(scsi_qla_host_t *vha, fc_port_t *fcport, bool wait)
2958{
2959	int rval = QLA_FUNCTION_FAILED;
2960	struct ct_sns_req       *ct_req;
2961	srb_t *sp;
2962	DECLARE_COMPLETION_ONSTACK(comp);
2963
2964	/* this routine does not have handling for no wait */
2965	if (!vha->flags.online || !wait)
2966		return rval;
2967
2968	/* ref: INIT */
2969	sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
2970	if (!sp)
2971		return rval;
2972
2973	sp->type = SRB_CT_PTHRU_CMD;
2974	sp->name = "gffid";
2975	sp->gen1 = fcport->rscn_gen;
2976	sp->gen2 = fcport->login_gen;
2977	qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
2978			      qla24xx_async_gffid_sp_done);
2979	sp->comp = &comp;
2980	sp->u.iocb_cmd.timeout = qla2x00_els_dcmd2_iocb_timeout;
2981
2982	if (wait)
2983		sp->flags = SRB_WAKEUP_ON_COMP;
2984
2985	sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
2986	sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
2987				sp->u.iocb_cmd.u.ctarg.req_allocated_size,
2988				&sp->u.iocb_cmd.u.ctarg.req_dma,
2989	    GFP_KERNEL);
2990	if (!sp->u.iocb_cmd.u.ctarg.req) {
2991		ql_log(ql_log_warn, vha, 0xd041,
2992		       "%s: Failed to allocate ct_sns request.\n",
2993		       __func__);
2994		goto done_free_sp;
2995	}
2996
2997	sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
2998	sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
2999				sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
3000				&sp->u.iocb_cmd.u.ctarg.rsp_dma,
3001	    GFP_KERNEL);
3002	if (!sp->u.iocb_cmd.u.ctarg.rsp) {
3003		ql_log(ql_log_warn, vha, 0xd041,
3004		       "%s: Failed to allocate ct_sns response.\n",
3005		       __func__);
3006		goto done_free_sp;
3007	}
3008
3009	/* CT_IU preamble  */
3010	ct_req = qla2x00_prep_ct_req(sp->u.iocb_cmd.u.ctarg.req, GFF_ID_CMD, GFF_ID_RSP_SIZE);
3011
3012	ct_req->req.gff_id.port_id[0] = fcport->d_id.b.domain;
3013	ct_req->req.gff_id.port_id[1] = fcport->d_id.b.area;
3014	ct_req->req.gff_id.port_id[2] = fcport->d_id.b.al_pa;
3015
3016	sp->u.iocb_cmd.u.ctarg.req_size = GFF_ID_REQ_SIZE;
3017	sp->u.iocb_cmd.u.ctarg.rsp_size = GFF_ID_RSP_SIZE;
3018	sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3019
3020	rval = qla2x00_start_sp(sp);
3021
3022	if (rval != QLA_SUCCESS) {
3023		rval = QLA_FUNCTION_FAILED;
3024		goto done_free_sp;
3025	} else {
3026		ql_dbg(ql_dbg_disc, vha, 0x3074,
3027		       "Async-%s hdl=%x portid %06x\n",
3028		       sp->name, sp->handle, fcport->d_id.b24);
3029	}
3030
3031	wait_for_completion(sp->comp);
3032	rval = sp->rc;
3033
3034done_free_sp:
3035	if (sp->u.iocb_cmd.u.ctarg.req) {
3036		dma_free_coherent(&vha->hw->pdev->dev,
3037				  sp->u.iocb_cmd.u.ctarg.req_allocated_size,
3038				  sp->u.iocb_cmd.u.ctarg.req,
3039				  sp->u.iocb_cmd.u.ctarg.req_dma);
3040		sp->u.iocb_cmd.u.ctarg.req = NULL;
3041	}
3042
3043	if (sp->u.iocb_cmd.u.ctarg.rsp) {
3044		dma_free_coherent(&vha->hw->pdev->dev,
3045				  sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
3046				  sp->u.iocb_cmd.u.ctarg.rsp,
3047				  sp->u.iocb_cmd.u.ctarg.rsp_dma);
3048		sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3049	}
3050
3051	/* ref: INIT */
3052	kref_put(&sp->cmd_kref, qla2x00_sp_release);
3053	return rval;
3054}
3055
3056/* GPN_FT + GNN_FT*/
3057static int qla2x00_is_a_vp(scsi_qla_host_t *vha, u64 wwn)
3058{
3059	struct qla_hw_data *ha = vha->hw;
3060	scsi_qla_host_t *vp;
3061	unsigned long flags;
3062	u64 twwn;
3063	int rc = 0;
3064
3065	if (!ha->num_vhosts)
3066		return 0;
3067
3068	spin_lock_irqsave(&ha->vport_slock, flags);
3069	list_for_each_entry(vp, &ha->vp_list, list) {
3070		twwn = wwn_to_u64(vp->port_name);
3071		if (wwn == twwn) {
3072			rc = 1;
3073			break;
3074		}
3075	}
3076	spin_unlock_irqrestore(&ha->vport_slock, flags);
3077
3078	return rc;
3079}
3080
3081static bool qla_ok_to_clear_rscn(scsi_qla_host_t *vha, fc_port_t *fcport)
3082{
3083	u32 rscn_gen;
3084
3085	rscn_gen = atomic_read(&vha->rscn_gen);
3086	ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0x2017,
3087	    "%s %d %8phC rscn_gen %x start %x end %x current %x\n",
3088	    __func__, __LINE__, fcport->port_name, fcport->rscn_gen,
3089	    vha->scan.rscn_gen_start, vha->scan.rscn_gen_end, rscn_gen);
3090
3091	if (val_is_in_range(fcport->rscn_gen, vha->scan.rscn_gen_start,
3092	    vha->scan.rscn_gen_end))
3093		/* rscn came in before fabric scan */
3094		return true;
3095
3096	if (val_is_in_range(fcport->rscn_gen, vha->scan.rscn_gen_end, rscn_gen))
3097		/* rscn came in after fabric scan */
3098		return false;
3099
3100	/* rare: fcport's scan_needed + rscn_gen must be stale */
3101	return true;
3102}
3103
3104void qla_fab_scan_finish(scsi_qla_host_t *vha, srb_t *sp)
3105{
3106	fc_port_t *fcport;
3107	u32 i, rc;
3108	bool found;
3109	struct fab_scan_rp *rp, *trp;
3110	unsigned long flags;
3111	u8 recheck = 0;
3112	u16 dup = 0, dup_cnt = 0;
3113
3114	ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0xffff,
3115	    "%s enter\n", __func__);
3116
3117	if (sp->gen1 != vha->hw->base_qpair->chip_reset) {
3118		ql_dbg(ql_dbg_disc, vha, 0xffff,
3119		    "%s scan stop due to chip reset %x/%x\n",
3120		    sp->name, sp->gen1, vha->hw->base_qpair->chip_reset);
3121		goto out;
3122	}
3123
3124	rc = sp->rc;
3125	if (rc) {
3126		vha->scan.scan_retry++;
3127		if (vha->scan.scan_retry < MAX_SCAN_RETRIES) {
3128			set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3129			set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3130			goto out;
3131		} else {
3132			ql_dbg(ql_dbg_disc, vha, 0xffff,
3133			    "%s: Fabric scan failed for %d retries.\n",
3134			    __func__, vha->scan.scan_retry);
3135			/*
3136			 * Unable to scan any rports. logout loop below
3137			 * will unregister all sessions.
3138			 */
3139			list_for_each_entry(fcport, &vha->vp_fcports, list) {
3140				if ((fcport->flags & FCF_FABRIC_DEVICE) != 0) {
3141					fcport->scan_state = QLA_FCPORT_SCAN;
3142					if (fcport->loop_id == FC_NO_LOOP_ID)
3143						fcport->logout_on_delete = 0;
3144					else
3145						fcport->logout_on_delete = 1;
3146				}
3147			}
3148			goto login_logout;
3149		}
3150	}
3151	vha->scan.scan_retry = 0;
3152
3153	list_for_each_entry(fcport, &vha->vp_fcports, list)
3154		fcport->scan_state = QLA_FCPORT_SCAN;
3155
3156	for (i = 0; i < vha->hw->max_fibre_devices; i++) {
3157		u64 wwn;
3158		int k;
3159
3160		rp = &vha->scan.l[i];
3161		found = false;
3162
3163		wwn = wwn_to_u64(rp->port_name);
3164		if (wwn == 0)
3165			continue;
3166
3167		/* Remove duplicate NPORT ID entries from switch data base */
3168		for (k = i + 1; k < vha->hw->max_fibre_devices; k++) {
3169			trp = &vha->scan.l[k];
3170			if (rp->id.b24 == trp->id.b24) {
3171				dup = 1;
3172				dup_cnt++;
3173				ql_dbg(ql_dbg_disc + ql_dbg_verbose,
3174				    vha, 0xffff,
3175				    "Detected duplicate NPORT ID from switch data base: ID %06x WWN %8phN WWN %8phN\n",
3176				    rp->id.b24, rp->port_name, trp->port_name);
3177				memset(trp, 0, sizeof(*trp));
3178			}
3179		}
3180
3181		if (!memcmp(rp->port_name, vha->port_name, WWN_SIZE))
3182			continue;
3183
3184		/* Bypass reserved domain fields. */
3185		if ((rp->id.b.domain & 0xf0) == 0xf0)
3186			continue;
3187
3188		/* Bypass virtual ports of the same host. */
3189		if (qla2x00_is_a_vp(vha, wwn))
3190			continue;
3191
3192		list_for_each_entry(fcport, &vha->vp_fcports, list) {
3193			if (memcmp(rp->port_name, fcport->port_name, WWN_SIZE))
3194				continue;
3195			fcport->scan_state = QLA_FCPORT_FOUND;
3196			fcport->last_rscn_gen = fcport->rscn_gen;
3197			fcport->fc4_type = rp->fc4type;
3198			found = true;
3199
3200			if (fcport->scan_needed) {
3201				if (NVME_PRIORITY(vha->hw, fcport))
3202					fcport->do_prli_nvme = 1;
3203				else
3204					fcport->do_prli_nvme = 0;
3205			}
3206
3207			/*
3208			 * If device was not a fabric device before.
3209			 */
3210			if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
3211				qla2x00_clear_loop_id(fcport);
3212				fcport->flags |= FCF_FABRIC_DEVICE;
3213			} else if (fcport->d_id.b24 != rp->id.b24 ||
3214				   (fcport->scan_needed &&
3215				    fcport->port_type != FCT_INITIATOR &&
3216				    fcport->port_type != FCT_NVME_INITIATOR)) {
3217				fcport->scan_needed = 0;
3218				qlt_schedule_sess_for_deletion(fcport);
3219			}
3220			fcport->d_id.b24 = rp->id.b24;
3221			break;
3222		}
3223
3224		if (!found) {
3225			ql_dbg(ql_dbg_disc, vha, 0xffff,
3226			    "%s %d %8phC post new sess\n",
3227			    __func__, __LINE__, rp->port_name);
3228			qla24xx_post_newsess_work(vha, &rp->id, rp->port_name,
3229			    rp->node_name, NULL, rp->fc4type);
3230		}
3231	}
3232
3233	if (dup) {
3234		ql_log(ql_log_warn, vha, 0xffff,
3235		    "Detected %d duplicate NPORT ID(s) from switch data base\n",
3236		    dup_cnt);
3237	}
3238
3239login_logout:
3240	/*
3241	 * Logout all previous fabric dev marked lost, except FCP2 devices.
3242	 */
3243	list_for_each_entry(fcport, &vha->vp_fcports, list) {
3244		if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
3245			fcport->scan_needed = 0;
3246			continue;
3247		}
3248
3249		if (fcport->scan_state != QLA_FCPORT_FOUND) {
3250			bool do_delete = false;
3251
3252			if (fcport->scan_needed &&
3253			    fcport->disc_state == DSC_LOGIN_PEND) {
3254				/* Cable got disconnected after we sent
3255				 * a login. Do delete to prevent timeout.
3256				 */
3257				fcport->logout_on_delete = 1;
3258				do_delete = true;
3259			}
3260
3261			if (qla_ok_to_clear_rscn(vha, fcport))
3262				fcport->scan_needed = 0;
3263
3264			if (((qla_dual_mode_enabled(vha) ||
3265			      qla_ini_mode_enabled(vha)) &&
3266			    atomic_read(&fcport->state) == FCS_ONLINE) ||
3267				do_delete) {
3268				if (fcport->loop_id != FC_NO_LOOP_ID) {
3269					ql_log(ql_log_warn, vha, 0x20f0,
3270					       "%s %d %8phC post del sess\n",
3271					       __func__, __LINE__,
3272					       fcport->port_name);
3273
3274					fcport->tgt_link_down_time = 0;
3275					qlt_schedule_sess_for_deletion(fcport);
3276					continue;
3277				}
3278			}
3279		} else {
3280			if (fcport->scan_needed ||
3281			    fcport->disc_state != DSC_LOGIN_COMPLETE) {
3282				if (fcport->login_retry == 0) {
3283					fcport->login_retry =
3284						vha->hw->login_retry_count;
3285					ql_dbg(ql_dbg_disc, vha, 0x20a3,
3286					    "Port login retry %8phN, lid 0x%04x retry cnt=%d.\n",
3287					    fcport->port_name, fcport->loop_id,
3288					    fcport->login_retry);
3289				}
3290
3291				if (qla_ok_to_clear_rscn(vha, fcport))
3292					fcport->scan_needed = 0;
3293				qla24xx_fcport_handle_login(vha, fcport);
3294			}
3295		}
3296	}
3297
3298	recheck = 1;
3299out:
3300	qla24xx_sp_unmap(vha, sp);
3301	spin_lock_irqsave(&vha->work_lock, flags);
3302	vha->scan.scan_flags &= ~SF_SCANNING;
3303	spin_unlock_irqrestore(&vha->work_lock, flags);
3304
3305	if (recheck) {
3306		list_for_each_entry(fcport, &vha->vp_fcports, list) {
3307			if (fcport->scan_needed) {
3308				set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3309				set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3310				break;
3311			}
3312		}
3313	}
3314}
3315
3316static int qla2x00_post_next_scan_work(struct scsi_qla_host *vha,
3317    srb_t *sp, int cmd)
3318{
3319	struct qla_work_evt *e;
3320
3321	e = qla2x00_alloc_work(vha, cmd);
3322	if (!e)
3323		return QLA_FUNCTION_FAILED;
3324
3325	e->u.iosb.sp = sp;
3326
3327	return qla2x00_post_work(vha, e);
3328}
3329
3330static void qla2x00_find_free_fcp_nvme_slot(struct scsi_qla_host *vha,
3331	struct srb *sp)
3332{
3333	struct qla_hw_data *ha = vha->hw;
3334	int num_fibre_dev = ha->max_fibre_devices;
3335	struct ct_sns_gpnft_rsp *ct_rsp =
3336		(struct ct_sns_gpnft_rsp *)sp->u.iocb_cmd.u.ctarg.rsp;
3337	struct ct_sns_gpn_ft_data *d;
3338	struct fab_scan_rp *rp;
3339	int i, j, k;
3340	port_id_t id;
3341	u8 found;
3342	u64 wwn;
3343
3344	j = 0;
3345	for (i = 0; i < num_fibre_dev; i++) {
3346		d  = &ct_rsp->entries[i];
3347
3348		id.b.rsvd_1 = 0;
3349		id.b.domain = d->port_id[0];
3350		id.b.area   = d->port_id[1];
3351		id.b.al_pa  = d->port_id[2];
3352		wwn = wwn_to_u64(d->port_name);
3353
3354		if (id.b24 == 0 || wwn == 0)
3355			continue;
3356
3357		ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0x2025,
3358		       "%s %06x %8ph \n",
3359		       __func__, id.b24, d->port_name);
3360
3361		switch (vha->scan.step) {
3362		case FAB_SCAN_GPNFT_FCP:
3363			rp = &vha->scan.l[j];
3364			rp->id = id;
3365			memcpy(rp->port_name, d->port_name, 8);
3366			j++;
3367			rp->fc4type = FS_FC4TYPE_FCP;
3368			break;
3369		case FAB_SCAN_GNNFT_FCP:
3370			for (k = 0; k < num_fibre_dev; k++) {
3371				rp = &vha->scan.l[k];
3372				if (id.b24 == rp->id.b24) {
3373					memcpy(rp->node_name,
3374					    d->port_name, 8);
3375					break;
3376				}
3377			}
3378			break;
3379		case FAB_SCAN_GPNFT_NVME:
3380			found = 0;
3381
3382			for (k = 0; k < num_fibre_dev; k++) {
3383				rp = &vha->scan.l[k];
3384				if (!memcmp(rp->port_name, d->port_name, 8)) {
3385					/*
3386					 * Supports FC-NVMe & FCP
3387					 */
3388					rp->fc4type |= FS_FC4TYPE_NVME;
3389					found = 1;
3390					break;
3391				}
3392			}
3393
3394			/* We found new FC-NVMe only port */
3395			if (!found) {
3396				for (k = 0; k < num_fibre_dev; k++) {
3397					rp = &vha->scan.l[k];
3398					if (wwn_to_u64(rp->port_name)) {
3399						continue;
3400					} else {
3401						rp->id = id;
3402						memcpy(rp->port_name, d->port_name, 8);
3403						rp->fc4type = FS_FC4TYPE_NVME;
3404						break;
3405					}
3406				}
3407			}
3408			break;
3409		case FAB_SCAN_GNNFT_NVME:
3410			for (k = 0; k < num_fibre_dev; k++) {
3411				rp = &vha->scan.l[k];
3412				if (id.b24 == rp->id.b24) {
3413					memcpy(rp->node_name, d->port_name, 8);
3414					break;
3415				}
3416			}
3417			break;
3418		default:
3419			break;
3420		}
3421	}
3422}
3423
3424static void qla_async_scan_sp_done(srb_t *sp, int res)
3425{
3426	struct scsi_qla_host *vha = sp->vha;
3427	unsigned long flags;
3428	int rc;
3429
3430	/* gen2 field is holding the fc4type */
3431	ql_dbg(ql_dbg_disc, vha, 0x2026,
3432	    "Async done-%s res %x step %x\n",
3433	    sp->name, res, vha->scan.step);
3434
3435	sp->rc = res;
3436	if (res) {
3437		unsigned long flags;
3438		const char *name = sp->name;
3439
3440		if (res == QLA_OS_TIMER_EXPIRED) {
3441			/* switch is ignoring all commands.
3442			 * This might be a zone disable behavior.
3443			 * This means we hit 64s timeout.
3444			 * 22s GPNFT + 44s Abort = 64s
3445			 */
3446			ql_dbg(ql_dbg_disc, vha, 0xffff,
3447			       "%s: Switch Zone check please .\n",
3448			       name);
3449			qla2x00_mark_all_devices_lost(vha);
3450		}
3451
3452		/*
3453		 * We are in an Interrupt context, queue up this
3454		 * sp for GNNFT_DONE work. This will allow all
3455		 * the resource to get freed up.
3456		 */
3457		rc = qla2x00_post_next_scan_work(vha, sp, QLA_EVT_SCAN_FINISH);
3458		if (rc) {
3459			/* Cleanup here to prevent memory leak */
3460			qla24xx_sp_unmap(vha, sp);
3461
3462			spin_lock_irqsave(&vha->work_lock, flags);
3463			vha->scan.scan_flags &= ~SF_SCANNING;
3464			vha->scan.scan_retry++;
3465			spin_unlock_irqrestore(&vha->work_lock, flags);
3466
3467			if (vha->scan.scan_retry < MAX_SCAN_RETRIES) {
3468				set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3469				set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3470				qla2xxx_wake_dpc(vha);
3471			} else {
3472				ql_dbg(ql_dbg_disc, vha, 0xffff,
3473				    "Async done-%s rescan failed on all retries.\n",
3474				    name);
3475			}
3476		}
3477		return;
3478	}
3479
3480	qla2x00_find_free_fcp_nvme_slot(vha, sp);
3481
3482	spin_lock_irqsave(&vha->work_lock, flags);
3483	vha->scan.scan_flags &= ~SF_SCANNING;
3484	spin_unlock_irqrestore(&vha->work_lock, flags);
3485
3486	switch (vha->scan.step) {
3487	case FAB_SCAN_GPNFT_FCP:
3488	case FAB_SCAN_GPNFT_NVME:
3489		rc = qla2x00_post_next_scan_work(vha, sp, QLA_EVT_SCAN_CMD);
3490		break;
3491	case  FAB_SCAN_GNNFT_FCP:
3492		if (vha->flags.nvme_enabled)
3493			rc = qla2x00_post_next_scan_work(vha, sp, QLA_EVT_SCAN_CMD);
3494		else
3495			rc = qla2x00_post_next_scan_work(vha, sp, QLA_EVT_SCAN_FINISH);
3496
3497		break;
3498	case  FAB_SCAN_GNNFT_NVME:
3499		rc = qla2x00_post_next_scan_work(vha, sp, QLA_EVT_SCAN_FINISH);
3500		break;
3501	default:
3502		/* should not be here */
3503		WARN_ON(1);
3504		rc = QLA_FUNCTION_FAILED;
3505		break;
3506	}
3507
3508	if (rc) {
3509		qla24xx_sp_unmap(vha, sp);
3510		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3511		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3512		return;
3513	}
3514}
3515
3516/* Get WWPN list for certain fc4_type */
3517int qla_fab_async_scan(scsi_qla_host_t *vha, srb_t *sp)
3518{
3519	int rval = QLA_FUNCTION_FAILED;
3520	struct ct_sns_req       *ct_req;
3521	struct ct_sns_pkt *ct_sns;
3522	u32 rspsz = 0;
3523	unsigned long flags;
3524
3525	ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0x200c,
3526	    "%s enter\n", __func__);
3527
3528	if (!vha->flags.online)
3529		return rval;
3530
3531	spin_lock_irqsave(&vha->work_lock, flags);
3532	if (vha->scan.scan_flags & SF_SCANNING) {
3533		spin_unlock_irqrestore(&vha->work_lock, flags);
3534		ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0x2012,
3535		    "%s: scan active for sp:%p\n", __func__, sp);
3536		goto done_free_sp;
3537	}
3538	vha->scan.scan_flags |= SF_SCANNING;
3539	if (!sp)
3540		vha->scan.step = FAB_SCAN_START;
3541
3542	spin_unlock_irqrestore(&vha->work_lock, flags);
3543
3544	switch (vha->scan.step) {
3545	case FAB_SCAN_START:
3546		ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0x2018,
3547		    "%s: Performing FCP Scan\n", __func__);
3548
3549		/* ref: INIT */
3550		sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
3551		if (!sp) {
3552			spin_lock_irqsave(&vha->work_lock, flags);
3553			vha->scan.scan_flags &= ~SF_SCANNING;
3554			spin_unlock_irqrestore(&vha->work_lock, flags);
3555			return rval;
3556		}
3557
3558		sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
3559								sizeof(struct ct_sns_pkt),
3560								&sp->u.iocb_cmd.u.ctarg.req_dma,
3561								GFP_KERNEL);
3562		sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
3563		if (!sp->u.iocb_cmd.u.ctarg.req) {
3564			ql_log(ql_log_warn, vha, 0x201a,
3565			    "Failed to allocate ct_sns request.\n");
3566			spin_lock_irqsave(&vha->work_lock, flags);
3567			vha->scan.scan_flags &= ~SF_SCANNING;
3568			spin_unlock_irqrestore(&vha->work_lock, flags);
3569			qla2x00_rel_sp(sp);
3570			return rval;
3571		}
3572
3573		rspsz = sizeof(struct ct_sns_gpnft_rsp) +
3574			vha->hw->max_fibre_devices *
3575			    sizeof(struct ct_sns_gpn_ft_data);
3576
3577		sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
3578								rspsz,
3579								&sp->u.iocb_cmd.u.ctarg.rsp_dma,
3580								GFP_KERNEL);
3581		sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = rspsz;
3582		if (!sp->u.iocb_cmd.u.ctarg.rsp) {
3583			ql_log(ql_log_warn, vha, 0x201b,
3584			    "Failed to allocate ct_sns request.\n");
3585			spin_lock_irqsave(&vha->work_lock, flags);
3586			vha->scan.scan_flags &= ~SF_SCANNING;
3587			spin_unlock_irqrestore(&vha->work_lock, flags);
3588			dma_free_coherent(&vha->hw->pdev->dev,
3589			    sp->u.iocb_cmd.u.ctarg.req_allocated_size,
3590			    sp->u.iocb_cmd.u.ctarg.req,
3591			    sp->u.iocb_cmd.u.ctarg.req_dma);
3592			sp->u.iocb_cmd.u.ctarg.req = NULL;
3593			/* ref: INIT */
3594			qla2x00_rel_sp(sp);
3595			return rval;
3596		}
3597		sp->u.iocb_cmd.u.ctarg.rsp_size = rspsz;
3598
3599		ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0xffff,
3600		    "%s scan list size %d\n", __func__, vha->scan.size);
3601
3602		memset(vha->scan.l, 0, vha->scan.size);
3603
3604		vha->scan.step = FAB_SCAN_GPNFT_FCP;
3605		break;
3606	case FAB_SCAN_GPNFT_FCP:
3607		vha->scan.step = FAB_SCAN_GNNFT_FCP;
3608		break;
3609	case FAB_SCAN_GNNFT_FCP:
3610		vha->scan.step = FAB_SCAN_GPNFT_NVME;
3611		break;
3612	case FAB_SCAN_GPNFT_NVME:
3613		vha->scan.step = FAB_SCAN_GNNFT_NVME;
3614		break;
3615	case FAB_SCAN_GNNFT_NVME:
3616	default:
3617		/* should not be here */
3618		WARN_ON(1);
3619		goto done_free_sp;
3620	}
3621
3622	if (!sp) {
3623		ql_dbg(ql_dbg_disc, vha, 0x201c,
3624		    "scan did not provide SP\n");
3625		return rval;
3626	}
3627	if (!sp->u.iocb_cmd.u.ctarg.req || !sp->u.iocb_cmd.u.ctarg.rsp) {
3628		ql_log(ql_log_warn, vha, 0x201d,
3629		    "%s: req %p rsp %p are not setup\n",
3630		    __func__, sp->u.iocb_cmd.u.ctarg.req,
3631		    sp->u.iocb_cmd.u.ctarg.rsp);
3632		spin_lock_irqsave(&vha->work_lock, flags);
3633		vha->scan.scan_flags &= ~SF_SCANNING;
3634		spin_unlock_irqrestore(&vha->work_lock, flags);
3635		WARN_ON(1);
3636		set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3637		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3638		goto done_free_sp;
3639	}
3640
3641	rspsz = sp->u.iocb_cmd.u.ctarg.rsp_size;
3642	memset(sp->u.iocb_cmd.u.ctarg.req, 0, sp->u.iocb_cmd.u.ctarg.req_size);
3643	memset(sp->u.iocb_cmd.u.ctarg.rsp, 0, sp->u.iocb_cmd.u.ctarg.rsp_size);
3644
3645
3646	sp->type = SRB_CT_PTHRU_CMD;
3647	sp->gen1 = vha->hw->base_qpair->chip_reset;
3648	qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
3649			      qla_async_scan_sp_done);
3650
3651	ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
3652
3653	/* CT_IU preamble  */
3654	switch (vha->scan.step) {
3655	case FAB_SCAN_GPNFT_FCP:
3656		sp->name = "gpnft";
3657		ct_req = qla2x00_prep_ct_req(ct_sns, GPN_FT_CMD, rspsz);
3658		ct_req->req.gpn_ft.port_type = FC4_TYPE_FCP_SCSI;
3659		sp->u.iocb_cmd.u.ctarg.req_size = GPN_FT_REQ_SIZE;
3660		break;
3661	case FAB_SCAN_GNNFT_FCP:
3662		sp->name = "gnnft";
3663		ct_req = qla2x00_prep_ct_req(ct_sns, GNN_FT_CMD, rspsz);
3664		ct_req->req.gpn_ft.port_type = FC4_TYPE_FCP_SCSI;
3665		sp->u.iocb_cmd.u.ctarg.req_size = GNN_FT_REQ_SIZE;
3666		break;
3667	case FAB_SCAN_GPNFT_NVME:
3668		sp->name = "gpnft";
3669		ct_req = qla2x00_prep_ct_req(ct_sns, GPN_FT_CMD, rspsz);
3670		ct_req->req.gpn_ft.port_type = FC4_TYPE_NVME;
3671		sp->u.iocb_cmd.u.ctarg.req_size = GPN_FT_REQ_SIZE;
3672		break;
3673	case FAB_SCAN_GNNFT_NVME:
3674		sp->name = "gnnft";
3675		ct_req = qla2x00_prep_ct_req(ct_sns, GNN_FT_CMD, rspsz);
3676		ct_req->req.gpn_ft.port_type = FC4_TYPE_NVME;
3677		sp->u.iocb_cmd.u.ctarg.req_size = GNN_FT_REQ_SIZE;
3678		break;
3679	default:
3680		/* should not be here */
3681		WARN_ON(1);
3682		goto done_free_sp;
3683	}
3684
3685	sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3686
3687	ql_dbg(ql_dbg_disc, vha, 0x2003,
3688	       "%s: step %d, rsp size %d, req size %d hdl %x %s FC4TYPE %x \n",
3689	       __func__, vha->scan.step, sp->u.iocb_cmd.u.ctarg.rsp_size,
3690	       sp->u.iocb_cmd.u.ctarg.req_size, sp->handle, sp->name,
3691	       ct_req->req.gpn_ft.port_type);
3692
3693	rval = qla2x00_start_sp(sp);
3694	if (rval != QLA_SUCCESS) {
3695		goto done_free_sp;
3696	}
3697
3698	return rval;
3699
3700done_free_sp:
3701	if (sp) {
3702		if (sp->u.iocb_cmd.u.ctarg.req) {
3703			dma_free_coherent(&vha->hw->pdev->dev,
3704			    sp->u.iocb_cmd.u.ctarg.req_allocated_size,
3705			    sp->u.iocb_cmd.u.ctarg.req,
3706			    sp->u.iocb_cmd.u.ctarg.req_dma);
3707			sp->u.iocb_cmd.u.ctarg.req = NULL;
3708		}
3709		if (sp->u.iocb_cmd.u.ctarg.rsp) {
3710			dma_free_coherent(&vha->hw->pdev->dev,
3711			    sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
3712			    sp->u.iocb_cmd.u.ctarg.rsp,
3713			    sp->u.iocb_cmd.u.ctarg.rsp_dma);
3714			sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3715		}
3716
3717		/* ref: INIT */
3718		kref_put(&sp->cmd_kref, qla2x00_sp_release);
3719	}
3720
3721	spin_lock_irqsave(&vha->work_lock, flags);
3722	vha->scan.scan_flags &= ~SF_SCANNING;
3723	if (vha->scan.scan_flags == 0) {
3724		ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0x2007,
3725		    "%s: Scan scheduled.\n", __func__);
3726		vha->scan.scan_flags |= SF_QUEUED;
3727		schedule_delayed_work(&vha->scan.scan_work, 5);
3728	}
3729	spin_unlock_irqrestore(&vha->work_lock, flags);
3730
3731
3732	return rval;
3733}
3734
3735void qla_fab_scan_start(struct scsi_qla_host *vha)
3736{
3737	int rval;
3738
3739	rval = qla_fab_async_scan(vha, NULL);
3740	if (rval)
3741		set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3742}
3743
3744void qla_scan_work_fn(struct work_struct *work)
3745{
3746	struct fab_scan *s = container_of(to_delayed_work(work),
3747	    struct fab_scan, scan_work);
3748	struct scsi_qla_host *vha = container_of(s, struct scsi_qla_host,
3749	    scan);
3750	unsigned long flags;
3751
3752	ql_dbg(ql_dbg_disc, vha, 0xffff,
3753	    "%s: schedule loop resync\n", __func__);
3754	set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3755	set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3756	qla2xxx_wake_dpc(vha);
3757	spin_lock_irqsave(&vha->work_lock, flags);
3758	vha->scan.scan_flags &= ~SF_QUEUED;
3759	spin_unlock_irqrestore(&vha->work_lock, flags);
3760}
3761
3762/* GPFN_ID */
3763void qla24xx_handle_gfpnid_event(scsi_qla_host_t *vha, struct event_arg *ea)
3764{
3765	fc_port_t *fcport = ea->fcport;
3766
3767	ql_dbg(ql_dbg_disc, vha, 0xffff,
3768	    "%s %8phC DS %d LS %d rc %d login %d|%d rscn %d|%d fcpcnt %d\n",
3769	    __func__, fcport->port_name, fcport->disc_state,
3770	    fcport->fw_login_state, ea->rc, fcport->login_gen, ea->sp->gen2,
3771	    fcport->rscn_gen, ea->sp->gen1, vha->fcport_count);
3772
3773	if (fcport->disc_state == DSC_DELETE_PEND)
3774		return;
3775
3776	if (ea->sp->gen2 != fcport->login_gen) {
3777		/* target side must have changed it. */
3778		ql_dbg(ql_dbg_disc, vha, 0x20d3,
3779		    "%s %8phC generation changed\n",
3780		    __func__, fcport->port_name);
3781		return;
3782	} else if (ea->sp->gen1 != fcport->rscn_gen) {
3783		return;
3784	}
3785
3786	qla24xx_post_gpsc_work(vha, fcport);
3787}
3788
3789static void qla2x00_async_gfpnid_sp_done(srb_t *sp, int res)
3790{
3791	struct scsi_qla_host *vha = sp->vha;
3792	fc_port_t *fcport = sp->fcport;
3793	u8 *fpn = fcport->ct_desc.ct_sns->p.rsp.rsp.gfpn_id.port_name;
3794	struct event_arg ea;
3795	u64 wwn;
3796
3797	wwn = wwn_to_u64(fpn);
3798	if (wwn)
3799		memcpy(fcport->fabric_port_name, fpn, WWN_SIZE);
3800
3801	memset(&ea, 0, sizeof(ea));
3802	ea.fcport = fcport;
3803	ea.sp = sp;
3804	ea.rc = res;
3805
3806	ql_dbg(ql_dbg_disc, vha, 0x204f,
3807	    "Async done-%s res %x, WWPN %8phC %8phC\n",
3808	    sp->name, res, fcport->port_name, fcport->fabric_port_name);
3809
3810	qla24xx_handle_gfpnid_event(vha, &ea);
3811
3812	/* ref: INIT */
3813	kref_put(&sp->cmd_kref, qla2x00_sp_release);
3814}
3815
3816int qla24xx_async_gfpnid(scsi_qla_host_t *vha, fc_port_t *fcport)
3817{
3818	int rval = QLA_FUNCTION_FAILED;
3819	struct ct_sns_req       *ct_req;
3820	srb_t *sp;
3821
3822	if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
3823		return rval;
3824
3825	/* ref: INIT */
3826	sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
3827	if (!sp)
3828		goto done;
3829
3830	sp->type = SRB_CT_PTHRU_CMD;
3831	sp->name = "gfpnid";
3832	sp->gen1 = fcport->rscn_gen;
3833	sp->gen2 = fcport->login_gen;
3834	qla2x00_init_async_sp(sp, qla2x00_get_async_timeout(vha) + 2,
3835			      qla2x00_async_gfpnid_sp_done);
3836
3837	/* CT_IU preamble  */
3838	ct_req = qla2x00_prep_ct_req(fcport->ct_desc.ct_sns, GFPN_ID_CMD,
3839	    GFPN_ID_RSP_SIZE);
3840
3841	/* GFPN_ID req */
3842	ct_req->req.port_id.port_id = port_id_to_be_id(fcport->d_id);
3843
3844
3845	/* req & rsp use the same buffer */
3846	sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
3847	sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
3848	sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
3849	sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
3850	sp->u.iocb_cmd.u.ctarg.req_size = GFPN_ID_REQ_SIZE;
3851	sp->u.iocb_cmd.u.ctarg.rsp_size = GFPN_ID_RSP_SIZE;
3852	sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3853
3854	ql_dbg(ql_dbg_disc, vha, 0xffff,
3855	    "Async-%s - %8phC hdl=%x loopid=%x portid %06x.\n",
3856	    sp->name, fcport->port_name,
3857	    sp->handle, fcport->loop_id, fcport->d_id.b24);
3858
3859	rval = qla2x00_start_sp(sp);
3860	if (rval != QLA_SUCCESS)
3861		goto done_free_sp;
3862
3863	return rval;
3864
3865done_free_sp:
3866	/* ref: INIT */
3867	kref_put(&sp->cmd_kref, qla2x00_sp_release);
3868done:
3869	return rval;
3870}
3871
3872int qla24xx_post_gfpnid_work(struct scsi_qla_host *vha, fc_port_t *fcport)
3873{
3874	struct qla_work_evt *e;
3875	int ls;
3876
3877	ls = atomic_read(&vha->loop_state);
3878	if (((ls != LOOP_READY) && (ls != LOOP_UP)) ||
3879		test_bit(UNLOADING, &vha->dpc_flags))
3880		return 0;
3881
3882	e = qla2x00_alloc_work(vha, QLA_EVT_GFPNID);
3883	if (!e)
3884		return QLA_FUNCTION_FAILED;
3885
3886	e->u.fcport.fcport = fcport;
3887	return qla2x00_post_work(vha, e);
3888}