~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,8 +1,7 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* QLogic Fibre Channel HBA Driver
3	4	* Copyright (c) 2003-2014 QLogic Corporation
4		- *
5		- * See LICENSE.qla2xxx for copyright and licensing details.
6	5	*/
7	6	#include "qla_def.h"
8	7	#include "qla_target.h"
..	..	@@ -18,6 +17,8 @@
18	17	static int qla_async_rffid(scsi_qla_host_t , port_id_t , u8, u8);
19	18	static int qla_async_rnnid(scsi_qla_host_t , port_id_t , u8*);
20	19	static int qla_async_rsnn_nn(scsi_qla_host_t *);
	20	+
	21	+
21	22
22	23	/**
23	24	* qla2x00_prep_ms_iocb() - Prepare common MS/CT IOCB fields for SNS CT query.
..	..	@@ -45,13 +46,11 @@
45	46	ms_pkt->rsp_bytecount = cpu_to_le32(arg->rsp_size);
46	47	ms_pkt->req_bytecount = cpu_to_le32(arg->req_size);
47	48
48		- ms_pkt->dseg_req_address[0] = cpu_to_le32(LSD(arg->req_dma));
49		- ms_pkt->dseg_req_address[1] = cpu_to_le32(MSD(arg->req_dma));
50		- ms_pkt->dseg_req_length = ms_pkt->req_bytecount;
	49	+ put_unaligned_le64(arg->req_dma, &ms_pkt->req_dsd.address);
	50	+ ms_pkt->req_dsd.length = ms_pkt->req_bytecount;
51	51
52		- ms_pkt->dseg_rsp_address[0] = cpu_to_le32(LSD(arg->rsp_dma));
53		- ms_pkt->dseg_rsp_address[1] = cpu_to_le32(MSD(arg->rsp_dma));
54		- ms_pkt->dseg_rsp_length = ms_pkt->rsp_bytecount;
	52	+ put_unaligned_le64(arg->rsp_dma, &ms_pkt->rsp_dsd.address);
	53	+ ms_pkt->rsp_dsd.length = ms_pkt->rsp_bytecount;
55	54
56	55	vha->qla_stats.control_requests++;
57	56
..	..	@@ -83,13 +82,11 @@
83	82	ct_pkt->rsp_byte_count = cpu_to_le32(arg->rsp_size);
84	83	ct_pkt->cmd_byte_count = cpu_to_le32(arg->req_size);
85	84
86		- ct_pkt->dseg_0_address[0] = cpu_to_le32(LSD(arg->req_dma));
87		- ct_pkt->dseg_0_address[1] = cpu_to_le32(MSD(arg->req_dma));
88		- ct_pkt->dseg_0_len = ct_pkt->cmd_byte_count;
	85	+ put_unaligned_le64(arg->req_dma, &ct_pkt->dsd[0].address);
	86	+ ct_pkt->dsd[0].length = ct_pkt->cmd_byte_count;
89	87
90		- ct_pkt->dseg_1_address[0] = cpu_to_le32(LSD(arg->rsp_dma));
91		- ct_pkt->dseg_1_address[1] = cpu_to_le32(MSD(arg->rsp_dma));
92		- ct_pkt->dseg_1_len = ct_pkt->rsp_byte_count;
	88	+ put_unaligned_le64(arg->rsp_dma, &ct_pkt->dsd[1].address);
	89	+ ct_pkt->dsd[1].length = ct_pkt->rsp_byte_count;
93	90	ct_pkt->vp_index = vha->vp_idx;
94	91
95	92	vha->qla_stats.control_requests++;
..	..	@@ -152,8 +149,8 @@
152	149	vha->d_id.b.area, vha->d_id.b.al_pa,
153	150	comp_status, ct_rsp->header.response);
154	151	ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha,
155		- 0x2078, (uint8_t *)&ct_rsp->header,
156		- sizeof(struct ct_rsp_hdr));
	152	+ 0x2078, ct_rsp,
	153	+ offsetof(typeof(*ct_rsp), rsp));
157	154	rval = QLA_INVALID_COMMAND;
158	155	} else
159	156	rval = QLA_SUCCESS;
..	..	@@ -179,7 +176,7 @@
179	176	break;
180	177	case CS_TIMEOUT:
181	178	rval = QLA_FUNCTION_TIMEOUT;
182		- /* fall through */
	179	+ fallthrough;
183	180	default:
184	181	ql_dbg(ql_dbg_disc, vha, 0x2033,
185	182	"%s failed, completion status (%x) on port_id: "
..	..	@@ -230,9 +227,7 @@
230	227	ct_rsp = &ha->ct_sns->p.rsp;
231	228
232	229	/* Prepare CT arguments -- port_id */
233		- ct_req->req.port_id.port_id[0] = fcport->d_id.b.domain;
234		- ct_req->req.port_id.port_id[1] = fcport->d_id.b.area;
235		- ct_req->req.port_id.port_id[2] = fcport->d_id.b.al_pa;
	230	+ ct_req->req.port_id.port_id = port_id_to_be_id(fcport->d_id);
236	231
237	232	/* Execute MS IOCB */
238	233	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
..	..	@@ -246,9 +241,7 @@
246	241	rval = QLA_FUNCTION_FAILED;
247	242	} else {
248	243	/* Populate fc_port_t entry. */
249		- fcport->d_id.b.domain = ct_rsp->rsp.ga_nxt.port_id[0];
250		- fcport->d_id.b.area = ct_rsp->rsp.ga_nxt.port_id[1];
251		- fcport->d_id.b.al_pa = ct_rsp->rsp.ga_nxt.port_id[2];
	244	+ fcport->d_id = be_to_port_id(ct_rsp->rsp.ga_nxt.port_id);
252	245
253	246	memcpy(fcport->node_name, ct_rsp->rsp.ga_nxt.node_name,
254	247	WWN_SIZE);
..	..	@@ -256,7 +249,7 @@
256	249	WWN_SIZE);
257	250
258	251	fcport->fc4_type = (ct_rsp->rsp.ga_nxt.fc4_types[2] & BIT_0) ?
259		- FC4_TYPE_FCP_SCSI : FC4_TYPE_OTHER;
	252	+ FS_FC4TYPE_FCP : FC4_TYPE_OTHER;
260	253
261	254	if (ct_rsp->rsp.ga_nxt.port_type != NS_N_PORT_TYPE &&
262	255	ct_rsp->rsp.ga_nxt.port_type != NS_NL_PORT_TYPE)
..	..	@@ -341,9 +334,7 @@
341	334	/* Set port IDs in switch info list. */
342	335	for (i = 0; i < ha->max_fibre_devices; i++) {
343	336	gid_data = &ct_rsp->rsp.gid_pt.entries[i];
344		- list[i].d_id.b.domain = gid_data->port_id[0];
345		- list[i].d_id.b.area = gid_data->port_id[1];
346		- list[i].d_id.b.al_pa = gid_data->port_id[2];
	337	+ list[i].d_id = be_to_port_id(gid_data->port_id);
347	338	memset(list[i].fabric_port_name, 0, WWN_SIZE);
348	339	list[i].fp_speed = PORT_SPEED_UNKNOWN;
349	340
..	..	@@ -407,9 +398,7 @@
407	398	ct_rsp = &ha->ct_sns->p.rsp;
408	399
409	400	/* Prepare CT arguments -- port_id */
410		- ct_req->req.port_id.port_id[0] = list[i].d_id.b.domain;
411		- ct_req->req.port_id.port_id[1] = list[i].d_id.b.area;
412		- ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
	401	+ ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
413	402
414	403	/* Execute MS IOCB */
415	404	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
..	..	@@ -476,9 +465,7 @@
476	465	ct_rsp = &ha->ct_sns->p.rsp;
477	466
478	467	/* Prepare CT arguments -- port_id */
479		- ct_req->req.port_id.port_id[0] = list[i].d_id.b.domain;
480		- ct_req->req.port_id.port_id[1] = list[i].d_id.b.area;
481		- ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
	468	+ ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
482	469
483	470	/* Execute MS IOCB */
484	471	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
..	..	@@ -513,9 +500,8 @@
513	500	return (rval);
514	501	}
515	502
516		-static void qla2x00_async_sns_sp_done(void *s, int rc)
	503	+static void qla2x00_async_sns_sp_done(srb_t *sp, int rc)
517	504	{
518		- struct srb *sp = s;
519	505	struct scsi_qla_host *vha = sp->vha;
520	506	struct ct_sns_pkt *ct_sns;
521	507	struct qla_work_evt *e;
..	..	@@ -643,9 +629,7 @@
643	629	ct_req = qla2x00_prep_ct_req(ct_sns, RFT_ID_CMD, RFT_ID_RSP_SIZE);
644	630
645	631	/* Prepare CT arguments -- port_id, FC-4 types */
646		- ct_req->req.rft_id.port_id[0] = vha->d_id.b.domain;
647		- ct_req->req.rft_id.port_id[1] = vha->d_id.b.area;
648		- ct_req->req.rft_id.port_id[2] = vha->d_id.b.al_pa;
	632	+ ct_req->req.rft_id.port_id = port_id_to_be_id(vha->d_id);
649	633	ct_req->req.rft_id.fc4_types[2] = 0x01; /* FCP-3 */
650	634
651	635	if (vha->flags.nvme_enabled)
..	..	@@ -657,15 +641,16 @@
657	641	sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
658	642	sp->done = qla2x00_async_sns_sp_done;
659	643
	644	+ ql_dbg(ql_dbg_disc, vha, 0xffff,
	645	+ "Async-%s - hdl=%x portid %06x.\n",
	646	+ sp->name, sp->handle, d_id->b24);
	647	+
660	648	rval = qla2x00_start_sp(sp);
661	649	if (rval != QLA_SUCCESS) {
662	650	ql_dbg(ql_dbg_disc, vha, 0x2043,
663	651	"RFT_ID issue IOCB failed (%d).\n", rval);
664	652	goto done_free_sp;
665	653	}
666		- ql_dbg(ql_dbg_disc, vha, 0xffff,
667		- "Async-%s - hdl=%x portid %06x.\n",
668		- sp->name, sp->handle, d_id->b24);
669	654	return rval;
670	655	done_free_sp:
671	656	sp->free(sp);
..	..	@@ -691,8 +676,7 @@
691	676	return (QLA_SUCCESS);
692	677	}
693	678
694		- return qla_async_rffid(vha, &vha->d_id, qlt_rff_id(vha),
695		- FC4_TYPE_FCP_SCSI);
	679	+ return qla_async_rffid(vha, &vha->d_id, qlt_rff_id(vha), type);
696	680	}
697	681
698	682	static int qla_async_rffid(scsi_qla_host_t vha, port_id_t d_id,
..	..	@@ -740,17 +724,19 @@
740	724	ct_req = qla2x00_prep_ct_req(ct_sns, RFF_ID_CMD, RFF_ID_RSP_SIZE);
741	725
742	726	/* Prepare CT arguments -- port_id, FC-4 feature, FC-4 type */
743		- ct_req->req.rff_id.port_id[0] = d_id->b.domain;
744		- ct_req->req.rff_id.port_id[1] = d_id->b.area;
745		- ct_req->req.rff_id.port_id[2] = d_id->b.al_pa;
	727	+ ct_req->req.rff_id.port_id = port_id_to_be_id(*d_id);
746	728	ct_req->req.rff_id.fc4_feature = fc4feature;
747		- ct_req->req.rff_id.fc4_type = fc4type; /* SCSI - FCP */
	729	+ ct_req->req.rff_id.fc4_type = fc4type; /* SCSI-FCP or FC-NVMe */
748	730
749	731	sp->u.iocb_cmd.u.ctarg.req_size = RFF_ID_REQ_SIZE;
750	732	sp->u.iocb_cmd.u.ctarg.rsp_size = RFF_ID_RSP_SIZE;
751	733	sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
752	734	sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
753	735	sp->done = qla2x00_async_sns_sp_done;
	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);
754	740
755	741	rval = qla2x00_start_sp(sp);
756	742	if (rval != QLA_SUCCESS) {
..	..	@@ -759,9 +745,6 @@
759	745	goto done_free_sp;
760	746	}
761	747
762		- ql_dbg(ql_dbg_disc, vha, 0xffff,
763		- "Async-%s - hdl=%x portid %06x feature %x type %x.\n",
764		- sp->name, sp->handle, d_id->b24, fc4feature, fc4type);
765	748	return rval;
766	749
767	750	done_free_sp:
..	..	@@ -832,9 +815,7 @@
832	815	ct_req = qla2x00_prep_ct_req(ct_sns, RNN_ID_CMD, RNN_ID_RSP_SIZE);
833	816
834	817	/* Prepare CT arguments -- port_id, node_name */
835		- ct_req->req.rnn_id.port_id[0] = vha->d_id.b.domain;
836		- ct_req->req.rnn_id.port_id[1] = vha->d_id.b.area;
837		- ct_req->req.rnn_id.port_id[2] = vha->d_id.b.al_pa;
	818	+ ct_req->req.rnn_id.port_id = port_id_to_be_id(vha->d_id);
838	819	memcpy(ct_req->req.rnn_id.node_name, vha->node_name, WWN_SIZE);
839	820
840	821	sp->u.iocb_cmd.u.ctarg.req_size = RNN_ID_REQ_SIZE;
..	..	@@ -844,15 +825,16 @@
844	825	sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
845	826	sp->done = qla2x00_async_sns_sp_done;
846	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	+
847	832	rval = qla2x00_start_sp(sp);
848	833	if (rval != QLA_SUCCESS) {
849	834	ql_dbg(ql_dbg_disc, vha, 0x204d,
850	835	"RNN_ID issue IOCB failed (%d).\n", rval);
851	836	goto done_free_sp;
852	837	}
853		- ql_dbg(ql_dbg_disc, vha, 0xffff,
854		- "Async-%s - hdl=%x portid %06x\n",
855		- sp->name, sp->handle, d_id->b24);
856	838
857	839	return rval;
858	840
..	..	@@ -862,19 +844,18 @@
862	844	return rval;
863	845	}
864	846
865		-void
	847	+size_t
866	848	qla2x00_get_sym_node_name(scsi_qla_host_t vha, uint8_t snn, size_t size)
867	849	{
868	850	struct qla_hw_data *ha = vha->hw;
869	851
870	852	if (IS_QLAFX00(ha))
871		- snprintf(snn, size, "%s FW:v%s DVR:v%s", ha->model_number,
872		- ha->mr.fw_version, qla2x00_version_str);
873		- else
874		- snprintf(snn, size,
875		- "%s FW:v%d.%02d.%02d DVR:v%s", ha->model_number,
876		- ha->fw_major_version, ha->fw_minor_version,
877		- ha->fw_subminor_version, qla2x00_version_str);
	853	+ return scnprintf(snn, size, "%s FW:v%s DVR:v%s",
	854	+ ha->model_number, ha->mr.fw_version, qla2x00_version_str);
	855	+
	856	+ return scnprintf(snn, size, "%s FW:v%d.%02d.%02d DVR:v%s",
	857	+ ha->model_number, ha->fw_major_version, ha->fw_minor_version,
	858	+ ha->fw_subminor_version, qla2x00_version_str);
878	859	}
879	860
880	861	/**
..	..	@@ -957,15 +938,16 @@
957	938	sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
958	939	sp->done = qla2x00_async_sns_sp_done;
959	940
	941	+ ql_dbg(ql_dbg_disc, vha, 0xffff,
	942	+ "Async-%s - hdl=%x.\n",
	943	+ sp->name, sp->handle);
	944	+
960	945	rval = qla2x00_start_sp(sp);
961	946	if (rval != QLA_SUCCESS) {
962	947	ql_dbg(ql_dbg_disc, vha, 0x2043,
963	948	"RFT_ID issue IOCB failed (%d).\n", rval);
964	949	goto done_free_sp;
965	950	}
966		- ql_dbg(ql_dbg_disc, vha, 0xffff,
967		- "Async-%s - hdl=%x.\n",
968		- sp->name, sp->handle);
969	951
970	952	return rval;
971	953
..	..	@@ -996,8 +978,7 @@
996	978	memset(sns_cmd, 0, sizeof(struct sns_cmd_pkt));
997	979	wc = data_size / 2; /* Size in 16bit words. */
998	980	sns_cmd->p.cmd.buffer_length = cpu_to_le16(wc);
999		- sns_cmd->p.cmd.buffer_address[0] = cpu_to_le32(LSD(ha->sns_cmd_dma));
1000		- sns_cmd->p.cmd.buffer_address[1] = cpu_to_le32(MSD(ha->sns_cmd_dma));
	981	+ put_unaligned_le64(ha->sns_cmd_dma, &sns_cmd->p.cmd.buffer_address);
1001	982	sns_cmd->p.cmd.subcommand_length = cpu_to_le16(scmd_len);
1002	983	sns_cmd->p.cmd.subcommand = cpu_to_le16(cmd);
1003	984	wc = (data_size - 16) / 4; /* Size in 32bit words. */
..	..	@@ -1381,6 +1362,7 @@
1381	1362	int ret, rval;
1382	1363	uint16_t mb[MAILBOX_REGISTER_COUNT];
1383	1364	struct qla_hw_data *ha = vha->hw;
	1365	+
1384	1366	ret = QLA_SUCCESS;
1385	1367	if (vha->flags.management_server_logged_in)
1386	1368	return ret;
..	..	@@ -1419,6 +1401,7 @@
1419	1401	{
1420	1402	ms_iocb_entry_t *ms_pkt;
1421	1403	struct qla_hw_data *ha = vha->hw;
	1404	+
1422	1405	ms_pkt = ha->ms_iocb;
1423	1406	memset(ms_pkt, 0, sizeof(ms_iocb_entry_t));
1424	1407
..	..	@@ -1432,13 +1415,11 @@
1432	1415	ms_pkt->rsp_bytecount = cpu_to_le32(rsp_size);
1433	1416	ms_pkt->req_bytecount = cpu_to_le32(req_size);
1434	1417
1435		- ms_pkt->dseg_req_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma));
1436		- ms_pkt->dseg_req_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma));
1437		- ms_pkt->dseg_req_length = ms_pkt->req_bytecount;
	1418	+ put_unaligned_le64(ha->ct_sns_dma, &ms_pkt->req_dsd.address);
	1419	+ ms_pkt->req_dsd.length = ms_pkt->req_bytecount;
1438	1420
1439		- ms_pkt->dseg_rsp_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma));
1440		- ms_pkt->dseg_rsp_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma));
1441		- ms_pkt->dseg_rsp_length = ms_pkt->rsp_bytecount;
	1421	+ put_unaligned_le64(ha->ct_sns_dma, &ms_pkt->rsp_dsd.address);
	1422	+ ms_pkt->rsp_dsd.length = ms_pkt->rsp_bytecount;
1442	1423
1443	1424	return ms_pkt;
1444	1425	}
..	..	@@ -1470,19 +1451,17 @@
1470	1451	ct_pkt->rsp_byte_count = cpu_to_le32(rsp_size);
1471	1452	ct_pkt->cmd_byte_count = cpu_to_le32(req_size);
1472	1453
1473		- ct_pkt->dseg_0_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma));
1474		- ct_pkt->dseg_0_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma));
1475		- ct_pkt->dseg_0_len = ct_pkt->cmd_byte_count;
	1454	+ put_unaligned_le64(ha->ct_sns_dma, &ct_pkt->dsd[0].address);
	1455	+ ct_pkt->dsd[0].length = ct_pkt->cmd_byte_count;
1476	1456
1477		- ct_pkt->dseg_1_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma));
1478		- ct_pkt->dseg_1_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma));
1479		- ct_pkt->dseg_1_len = ct_pkt->rsp_byte_count;
	1457	+ put_unaligned_le64(ha->ct_sns_dma, &ct_pkt->dsd[1].address);
	1458	+ ct_pkt->dsd[1].length = ct_pkt->rsp_byte_count;
1480	1459	ct_pkt->vp_index = vha->vp_idx;
1481	1460
1482	1461	return ct_pkt;
1483	1462	}
1484	1463
1485		-static inline ms_iocb_entry_t *
	1464	+static void
1486	1465	qla2x00_update_ms_fdmi_iocb(scsi_qla_host_t *vha, uint32_t req_size)
1487	1466	{
1488	1467	struct qla_hw_data *ha = vha->hw;
..	..	@@ -1491,13 +1470,11 @@
1491	1470
1492	1471	if (IS_FWI2_CAPABLE(ha)) {
1493	1472	ct_pkt->cmd_byte_count = cpu_to_le32(req_size);
1494		- ct_pkt->dseg_0_len = ct_pkt->cmd_byte_count;
	1473	+ ct_pkt->dsd[0].length = ct_pkt->cmd_byte_count;
1495	1474	} else {
1496	1475	ms_pkt->req_bytecount = cpu_to_le32(req_size);
1497		- ms_pkt->dseg_req_length = ms_pkt->req_bytecount;
	1476	+ ms_pkt->req_dsd.length = ms_pkt->req_bytecount;
1498	1477	}
1499		-
1500		- return ms_pkt;
1501	1478	}
1502	1479
1503	1480	/**
..	..	@@ -1523,747 +1500,737 @@
1523	1500	return &p->p.req;
1524	1501	}
1525	1502
1526		-/**
1527		- * qla2x00_fdmi_rhba() - perform RHBA FDMI registration
1528		- * @vha: HA context
1529		- *
1530		- * Returns 0 on success.
1531		- */
1532		-static int
1533		-qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
	1503	+uint
	1504	+qla25xx_fdmi_port_speed_capability(struct qla_hw_data *ha)
1534	1505	{
1535		- int rval, alen;
1536		- uint32_t size, sn;
	1506	+ uint speeds = 0;
1537	1507
1538		- ms_iocb_entry_t *ms_pkt;
1539		- struct ct_sns_req *ct_req;
1540		- struct ct_sns_rsp *ct_rsp;
1541		- void *entries;
1542		- struct ct_fdmi_hba_attr *eiter;
1543		- struct qla_hw_data *ha = vha->hw;
1544		-
1545		- /* Issue RHBA */
1546		- /* Prepare common MS IOCB */
1547		- /* Request size adjusted after CT preparation */
1548		- ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RHBA_RSP_SIZE);
1549		-
1550		- /* Prepare CT request */
1551		- ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RHBA_CMD, RHBA_RSP_SIZE);
1552		- ct_rsp = &ha->ct_sns->p.rsp;
1553		-
1554		- /* Prepare FDMI command arguments -- attribute block, attributes. */
1555		- memcpy(ct_req->req.rhba.hba_identifier, vha->port_name, WWN_SIZE);
1556		- ct_req->req.rhba.entry_count = cpu_to_be32(1);
1557		- memcpy(ct_req->req.rhba.port_name, vha->port_name, WWN_SIZE);
1558		- size = 2 * WWN_SIZE + 4 + 4;
1559		-
1560		- /* Attributes */
1561		- ct_req->req.rhba.attrs.count =
1562		- cpu_to_be32(FDMI_HBA_ATTR_COUNT);
1563		- entries = ct_req->req.rhba.hba_identifier;
1564		-
1565		- /* Nodename. */
1566		- eiter = entries + size;
1567		- eiter->type = cpu_to_be16(FDMI_HBA_NODE_NAME);
1568		- eiter->len = cpu_to_be16(4 + WWN_SIZE);
1569		- memcpy(eiter->a.node_name, vha->node_name, WWN_SIZE);
1570		- size += 4 + WWN_SIZE;
1571		-
1572		- ql_dbg(ql_dbg_disc, vha, 0x2025,
1573		- "NodeName = %8phN.\n", eiter->a.node_name);
1574		-
1575		- /* Manufacturer. */
1576		- eiter = entries + size;
1577		- eiter->type = cpu_to_be16(FDMI_HBA_MANUFACTURER);
1578		- alen = strlen(QLA2XXX_MANUFACTURER);
1579		- snprintf(eiter->a.manufacturer, sizeof(eiter->a.manufacturer),
1580		- "%s", "QLogic Corporation");
1581		- alen += 4 - (alen & 3);
1582		- eiter->len = cpu_to_be16(4 + alen);
1583		- size += 4 + alen;
1584		-
1585		- ql_dbg(ql_dbg_disc, vha, 0x2026,
1586		- "Manufacturer = %s.\n", eiter->a.manufacturer);
1587		-
1588		- /* Serial number. */
1589		- eiter = entries + size;
1590		- eiter->type = cpu_to_be16(FDMI_HBA_SERIAL_NUMBER);
1591		- if (IS_FWI2_CAPABLE(ha))
1592		- qla2xxx_get_vpd_field(vha, "SN", eiter->a.serial_num,
1593		- sizeof(eiter->a.serial_num));
1594		- else {
1595		- sn = ((ha->serial0 & 0x1f) << 16) \|
1596		- (ha->serial2 << 8) \| ha->serial1;
1597		- snprintf(eiter->a.serial_num, sizeof(eiter->a.serial_num),
1598		- "%c%05d", 'A' + sn / 100000, sn % 100000);
1599		- }
1600		- alen = strlen(eiter->a.serial_num);
1601		- alen += 4 - (alen & 3);
1602		- eiter->len = cpu_to_be16(4 + alen);
1603		- size += 4 + alen;
1604		-
1605		- ql_dbg(ql_dbg_disc, vha, 0x2027,
1606		- "Serial no. = %s.\n", eiter->a.serial_num);
1607		-
1608		- /* Model name. */
1609		- eiter = entries + size;
1610		- eiter->type = cpu_to_be16(FDMI_HBA_MODEL);
1611		- snprintf(eiter->a.model, sizeof(eiter->a.model),
1612		- "%s", ha->model_number);
1613		- alen = strlen(eiter->a.model);
1614		- alen += 4 - (alen & 3);
1615		- eiter->len = cpu_to_be16(4 + alen);
1616		- size += 4 + alen;
1617		-
1618		- ql_dbg(ql_dbg_disc, vha, 0x2028,
1619		- "Model Name = %s.\n", eiter->a.model);
1620		-
1621		- /* Model description. */
1622		- eiter = entries + size;
1623		- eiter->type = cpu_to_be16(FDMI_HBA_MODEL_DESCRIPTION);
1624		- snprintf(eiter->a.model_desc, sizeof(eiter->a.model_desc),
1625		- "%s", ha->model_desc);
1626		- alen = strlen(eiter->a.model_desc);
1627		- alen += 4 - (alen & 3);
1628		- eiter->len = cpu_to_be16(4 + alen);
1629		- size += 4 + alen;
1630		-
1631		- ql_dbg(ql_dbg_disc, vha, 0x2029,
1632		- "Model Desc = %s.\n", eiter->a.model_desc);
1633		-
1634		- /* Hardware version. */
1635		- eiter = entries + size;
1636		- eiter->type = cpu_to_be16(FDMI_HBA_HARDWARE_VERSION);
1637		- if (!IS_FWI2_CAPABLE(ha)) {
1638		- snprintf(eiter->a.hw_version, sizeof(eiter->a.hw_version),
1639		- "HW:%s", ha->adapter_id);
1640		- } else if (qla2xxx_get_vpd_field(vha, "MN", eiter->a.hw_version,
1641		- sizeof(eiter->a.hw_version))) {
1642		- ;
1643		- } else if (qla2xxx_get_vpd_field(vha, "EC", eiter->a.hw_version,
1644		- sizeof(eiter->a.hw_version))) {
1645		- ;
1646		- } else {
1647		- snprintf(eiter->a.hw_version, sizeof(eiter->a.hw_version),
1648		- "HW:%s", ha->adapter_id);
1649		- }
1650		- alen = strlen(eiter->a.hw_version);
1651		- alen += 4 - (alen & 3);
1652		- eiter->len = cpu_to_be16(4 + alen);
1653		- size += 4 + alen;
1654		-
1655		- ql_dbg(ql_dbg_disc, vha, 0x202a,
1656		- "Hardware ver = %s.\n", eiter->a.hw_version);
1657		-
1658		- /* Driver version. */
1659		- eiter = entries + size;
1660		- eiter->type = cpu_to_be16(FDMI_HBA_DRIVER_VERSION);
1661		- snprintf(eiter->a.driver_version, sizeof(eiter->a.driver_version),
1662		- "%s", qla2x00_version_str);
1663		- alen = strlen(eiter->a.driver_version);
1664		- alen += 4 - (alen & 3);
1665		- eiter->len = cpu_to_be16(4 + alen);
1666		- size += 4 + alen;
1667		-
1668		- ql_dbg(ql_dbg_disc, vha, 0x202b,
1669		- "Driver ver = %s.\n", eiter->a.driver_version);
1670		-
1671		- /* Option ROM version. */
1672		- eiter = entries + size;
1673		- eiter->type = cpu_to_be16(FDMI_HBA_OPTION_ROM_VERSION);
1674		- snprintf(eiter->a.orom_version, sizeof(eiter->a.orom_version),
1675		- "%d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
1676		- alen = strlen(eiter->a.orom_version);
1677		- alen += 4 - (alen & 3);
1678		- eiter->len = cpu_to_be16(4 + alen);
1679		- size += 4 + alen;
1680		-
1681		- ql_dbg(ql_dbg_disc, vha , 0x202c,
1682		- "Optrom vers = %s.\n", eiter->a.orom_version);
1683		-
1684		- /* Firmware version */
1685		- eiter = entries + size;
1686		- eiter->type = cpu_to_be16(FDMI_HBA_FIRMWARE_VERSION);
1687		- ha->isp_ops->fw_version_str(vha, eiter->a.fw_version,
1688		- sizeof(eiter->a.fw_version));
1689		- alen = strlen(eiter->a.fw_version);
1690		- alen += 4 - (alen & 3);
1691		- eiter->len = cpu_to_be16(4 + alen);
1692		- size += 4 + alen;
1693		-
1694		- ql_dbg(ql_dbg_disc, vha, 0x202d,
1695		- "Firmware vers = %s.\n", eiter->a.fw_version);
1696		-
1697		- /* Update MS request size. */
1698		- qla2x00_update_ms_fdmi_iocb(vha, size + 16);
1699		-
1700		- ql_dbg(ql_dbg_disc, vha, 0x202e,
1701		- "RHBA identifier = %8phN size=%d.\n",
1702		- ct_req->req.rhba.hba_identifier, size);
1703		- ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2076,
1704		- entries, size);
1705		-
1706		- /* Execute MS IOCB */
1707		- rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
1708		- sizeof(ms_iocb_entry_t));
1709		- if (rval != QLA_SUCCESS) {
1710		- /EMPTY/
1711		- ql_dbg(ql_dbg_disc, vha, 0x2030,
1712		- "RHBA issue IOCB failed (%d).\n", rval);
1713		- } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RHBA") !=
1714		- QLA_SUCCESS) {
1715		- rval = QLA_FUNCTION_FAILED;
1716		- if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
1717		- ct_rsp->header.explanation_code ==
1718		- CT_EXPL_ALREADY_REGISTERED) {
1719		- ql_dbg(ql_dbg_disc, vha, 0x2034,
1720		- "HBA already registered.\n");
1721		- rval = QLA_ALREADY_REGISTERED;
1722		- } else {
1723		- ql_dbg(ql_dbg_disc, vha, 0x20ad,
1724		- "RHBA FDMI registration failed, CT Reason code: 0x%x, CT Explanation 0x%x\n",
1725		- ct_rsp->header.reason_code,
1726		- ct_rsp->header.explanation_code);
	1508	+ if (IS_CNA_CAPABLE(ha))
	1509	+ return FDMI_PORT_SPEED_10GB;
	1510	+ if (IS_QLA28XX(ha) \|\| IS_QLA27XX(ha)) {
	1511	+ if (ha->max_supported_speed == 2) {
	1512	+ if (ha->min_supported_speed <= 6)
	1513	+ speeds \|= FDMI_PORT_SPEED_64GB;
1727	1514	}
1728		- } else {
1729		- ql_dbg(ql_dbg_disc, vha, 0x2035,
1730		- "RHBA exiting normally.\n");
	1515	+ if (ha->max_supported_speed == 2 \|\|
	1516	+ ha->max_supported_speed == 1) {
	1517	+ if (ha->min_supported_speed <= 5)
	1518	+ speeds \|= FDMI_PORT_SPEED_32GB;
	1519	+ }
	1520	+ if (ha->max_supported_speed == 2 \|\|
	1521	+ ha->max_supported_speed == 1 \|\|
	1522	+ ha->max_supported_speed == 0) {
	1523	+ if (ha->min_supported_speed <= 4)
	1524	+ speeds \|= FDMI_PORT_SPEED_16GB;
	1525	+ }
	1526	+ if (ha->max_supported_speed == 1 \|\|
	1527	+ ha->max_supported_speed == 0) {
	1528	+ if (ha->min_supported_speed <= 3)
	1529	+ speeds \|= FDMI_PORT_SPEED_8GB;
	1530	+ }
	1531	+ if (ha->max_supported_speed == 0) {
	1532	+ if (ha->min_supported_speed <= 2)
	1533	+ speeds \|= FDMI_PORT_SPEED_4GB;
	1534	+ }
	1535	+ return speeds;
1731	1536	}
1732		-
1733		- return rval;
	1537	+ if (IS_QLA2031(ha)) {
	1538	+ if ((ha->pdev->subsystem_vendor == 0x103C) &&
	1539	+ (ha->pdev->subsystem_device == 0x8002)) {
	1540	+ speeds = FDMI_PORT_SPEED_16GB;
	1541	+ } else {
	1542	+ speeds = FDMI_PORT_SPEED_16GB\|FDMI_PORT_SPEED_8GB\|
	1543	+ FDMI_PORT_SPEED_4GB;
	1544	+ }
	1545	+ return speeds;
	1546	+ }
	1547	+ if (IS_QLA25XX(ha) \|\| IS_QLAFX00(ha))
	1548	+ return FDMI_PORT_SPEED_8GB\|FDMI_PORT_SPEED_4GB\|
	1549	+ FDMI_PORT_SPEED_2GB\|FDMI_PORT_SPEED_1GB;
	1550	+ if (IS_QLA24XX_TYPE(ha))
	1551	+ return FDMI_PORT_SPEED_4GB\|FDMI_PORT_SPEED_2GB\|
	1552	+ FDMI_PORT_SPEED_1GB;
	1553	+ if (IS_QLA23XX(ha))
	1554	+ return FDMI_PORT_SPEED_2GB\|FDMI_PORT_SPEED_1GB;
	1555	+ return FDMI_PORT_SPEED_1GB;
1734	1556	}
1735	1557
1736		-/**
1737		- * qla2x00_fdmi_rpa() - perform RPA registration
1738		- * @vha: HA context
1739		- *
1740		- * Returns 0 on success.
1741		- */
1742		-static int
1743		-qla2x00_fdmi_rpa(scsi_qla_host_t *vha)
	1558	+uint
	1559	+qla25xx_fdmi_port_speed_currently(struct qla_hw_data *ha)
1744	1560	{
1745		- int rval, alen;
1746		- uint32_t size;
1747		- struct qla_hw_data *ha = vha->hw;
1748		- ms_iocb_entry_t *ms_pkt;
1749		- struct ct_sns_req *ct_req;
1750		- struct ct_sns_rsp *ct_rsp;
1751		- void *entries;
1752		- struct ct_fdmi_port_attr *eiter;
1753		- struct init_cb_24xx icb24 = (struct init_cb_24xx )ha->init_cb;
1754		- struct new_utsname *p_sysid = NULL;
1755		-
1756		- /* Issue RPA */
1757		- /* Prepare common MS IOCB */
1758		- /* Request size adjusted after CT preparation */
1759		- ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RPA_RSP_SIZE);
1760		-
1761		- /* Prepare CT request */
1762		- ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RPA_CMD,
1763		- RPA_RSP_SIZE);
1764		- ct_rsp = &ha->ct_sns->p.rsp;
1765		-
1766		- /* Prepare FDMI command arguments -- attribute block, attributes. */
1767		- memcpy(ct_req->req.rpa.port_name, vha->port_name, WWN_SIZE);
1768		- size = WWN_SIZE + 4;
1769		-
1770		- /* Attributes */
1771		- ct_req->req.rpa.attrs.count = cpu_to_be32(FDMI_PORT_ATTR_COUNT);
1772		- entries = ct_req->req.rpa.port_name;
1773		-
1774		- /* FC4 types. */
1775		- eiter = entries + size;
1776		- eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPES);
1777		- eiter->len = cpu_to_be16(4 + 32);
1778		- eiter->a.fc4_types[2] = 0x01;
1779		- size += 4 + 32;
1780		-
1781		- ql_dbg(ql_dbg_disc, vha, 0x2039,
1782		- "FC4_TYPES=%02x %02x.\n",
1783		- eiter->a.fc4_types[2],
1784		- eiter->a.fc4_types[1]);
1785		-
1786		- /* Supported speed. */
1787		- eiter = entries + size;
1788		- eiter->type = cpu_to_be16(FDMI_PORT_SUPPORT_SPEED);
1789		- eiter->len = cpu_to_be16(4 + 4);
1790		- if (IS_CNA_CAPABLE(ha))
1791		- eiter->a.sup_speed = cpu_to_be32(
1792		- FDMI_PORT_SPEED_10GB);
1793		- else if (IS_QLA27XX(ha))
1794		- eiter->a.sup_speed = cpu_to_be32(
1795		- FDMI_PORT_SPEED_32GB\|
1796		- FDMI_PORT_SPEED_16GB\|
1797		- FDMI_PORT_SPEED_8GB);
1798		- else if (IS_QLA2031(ha))
1799		- eiter->a.sup_speed = cpu_to_be32(
1800		- FDMI_PORT_SPEED_16GB\|
1801		- FDMI_PORT_SPEED_8GB\|
1802		- FDMI_PORT_SPEED_4GB);
1803		- else if (IS_QLA25XX(ha))
1804		- eiter->a.sup_speed = cpu_to_be32(
1805		- FDMI_PORT_SPEED_8GB\|
1806		- FDMI_PORT_SPEED_4GB\|
1807		- FDMI_PORT_SPEED_2GB\|
1808		- FDMI_PORT_SPEED_1GB);
1809		- else if (IS_QLA24XX_TYPE(ha))
1810		- eiter->a.sup_speed = cpu_to_be32(
1811		- FDMI_PORT_SPEED_4GB\|
1812		- FDMI_PORT_SPEED_2GB\|
1813		- FDMI_PORT_SPEED_1GB);
1814		- else if (IS_QLA23XX(ha))
1815		- eiter->a.sup_speed = cpu_to_be32(
1816		- FDMI_PORT_SPEED_2GB\|
1817		- FDMI_PORT_SPEED_1GB);
1818		- else
1819		- eiter->a.sup_speed = cpu_to_be32(
1820		- FDMI_PORT_SPEED_1GB);
1821		- size += 4 + 4;
1822		-
1823		- ql_dbg(ql_dbg_disc, vha, 0x203a,
1824		- "Supported_Speed=%x.\n", eiter->a.sup_speed);
1825		-
1826		- /* Current speed. */
1827		- eiter = entries + size;
1828		- eiter->type = cpu_to_be16(FDMI_PORT_CURRENT_SPEED);
1829		- eiter->len = cpu_to_be16(4 + 4);
1830	1561	switch (ha->link_data_rate) {
1831	1562	case PORT_SPEED_1GB:
1832		- eiter->a.cur_speed =
1833		- cpu_to_be32(FDMI_PORT_SPEED_1GB);
1834		- break;
	1563	+ return FDMI_PORT_SPEED_1GB;
1835	1564	case PORT_SPEED_2GB:
1836		- eiter->a.cur_speed =
1837		- cpu_to_be32(FDMI_PORT_SPEED_2GB);
1838		- break;
	1565	+ return FDMI_PORT_SPEED_2GB;
1839	1566	case PORT_SPEED_4GB:
1840		- eiter->a.cur_speed =
1841		- cpu_to_be32(FDMI_PORT_SPEED_4GB);
1842		- break;
	1567	+ return FDMI_PORT_SPEED_4GB;
1843	1568	case PORT_SPEED_8GB:
1844		- eiter->a.cur_speed =
1845		- cpu_to_be32(FDMI_PORT_SPEED_8GB);
1846		- break;
	1569	+ return FDMI_PORT_SPEED_8GB;
1847	1570	case PORT_SPEED_10GB:
1848		- eiter->a.cur_speed =
1849		- cpu_to_be32(FDMI_PORT_SPEED_10GB);
1850		- break;
	1571	+ return FDMI_PORT_SPEED_10GB;
1851	1572	case PORT_SPEED_16GB:
1852		- eiter->a.cur_speed =
1853		- cpu_to_be32(FDMI_PORT_SPEED_16GB);
1854		- break;
	1573	+ return FDMI_PORT_SPEED_16GB;
1855	1574	case PORT_SPEED_32GB:
1856		- eiter->a.cur_speed =
1857		- cpu_to_be32(FDMI_PORT_SPEED_32GB);
1858		- break;
	1575	+ return FDMI_PORT_SPEED_32GB;
	1576	+ case PORT_SPEED_64GB:
	1577	+ return FDMI_PORT_SPEED_64GB;
1859	1578	default:
1860		- eiter->a.cur_speed =
1861		- cpu_to_be32(FDMI_PORT_SPEED_UNKNOWN);
1862		- break;
	1579	+ return FDMI_PORT_SPEED_UNKNOWN;
1863	1580	}
1864		- size += 4 + 4;
1865		-
1866		- ql_dbg(ql_dbg_disc, vha, 0x203b,
1867		- "Current_Speed=%x.\n", eiter->a.cur_speed);
1868		-
1869		- /* Max frame size. */
1870		- eiter = entries + size;
1871		- eiter->type = cpu_to_be16(FDMI_PORT_MAX_FRAME_SIZE);
1872		- eiter->len = cpu_to_be16(4 + 4);
1873		- eiter->a.max_frame_size = IS_FWI2_CAPABLE(ha) ?
1874		- le16_to_cpu(icb24->frame_payload_size) :
1875		- le16_to_cpu(ha->init_cb->frame_payload_size);
1876		- eiter->a.max_frame_size = cpu_to_be32(eiter->a.max_frame_size);
1877		- size += 4 + 4;
1878		-
1879		- ql_dbg(ql_dbg_disc, vha, 0x203c,
1880		- "Max_Frame_Size=%x.\n", eiter->a.max_frame_size);
1881		-
1882		- /* OS device name. */
1883		- eiter = entries + size;
1884		- eiter->type = cpu_to_be16(FDMI_PORT_OS_DEVICE_NAME);
1885		- snprintf(eiter->a.os_dev_name, sizeof(eiter->a.os_dev_name),
1886		- "%s:host%lu", QLA2XXX_DRIVER_NAME, vha->host_no);
1887		- alen = strlen(eiter->a.os_dev_name);
1888		- alen += 4 - (alen & 3);
1889		- eiter->len = cpu_to_be16(4 + alen);
1890		- size += 4 + alen;
1891		-
1892		- ql_dbg(ql_dbg_disc, vha, 0x204b,
1893		- "OS_Device_Name=%s.\n", eiter->a.os_dev_name);
1894		-
1895		- /* Hostname. */
1896		- eiter = entries + size;
1897		- eiter->type = cpu_to_be16(FDMI_PORT_HOST_NAME);
1898		- p_sysid = utsname();
1899		- if (p_sysid) {
1900		- snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
1901		- "%s", p_sysid->nodename);
1902		- } else {
1903		- snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
1904		- "%s", fc_host_system_hostname(vha->host));
1905		- }
1906		- alen = strlen(eiter->a.host_name);
1907		- alen += 4 - (alen & 3);
1908		- eiter->len = cpu_to_be16(4 + alen);
1909		- size += 4 + alen;
1910		-
1911		- ql_dbg(ql_dbg_disc, vha, 0x203d, "HostName=%s.\n", eiter->a.host_name);
1912		-
1913		- /* Update MS request size. */
1914		- qla2x00_update_ms_fdmi_iocb(vha, size + 16);
1915		-
1916		- ql_dbg(ql_dbg_disc, vha, 0x203e,
1917		- "RPA portname %016llx, size = %d.\n",
1918		- wwn_to_u64(ct_req->req.rpa.port_name), size);
1919		- ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2079,
1920		- entries, size);
1921		-
1922		- /* Execute MS IOCB */
1923		- rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
1924		- sizeof(ms_iocb_entry_t));
1925		- if (rval != QLA_SUCCESS) {
1926		- /EMPTY/
1927		- ql_dbg(ql_dbg_disc, vha, 0x2040,
1928		- "RPA issue IOCB failed (%d).\n", rval);
1929		- } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPA") !=
1930		- QLA_SUCCESS) {
1931		- rval = QLA_FUNCTION_FAILED;
1932		- if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
1933		- ct_rsp->header.explanation_code ==
1934		- CT_EXPL_ALREADY_REGISTERED) {
1935		- ql_dbg(ql_dbg_disc, vha, 0x20cd,
1936		- "RPA already registered.\n");
1937		- rval = QLA_ALREADY_REGISTERED;
1938		- }
1939		-
1940		- } else {
1941		- ql_dbg(ql_dbg_disc, vha, 0x2041,
1942		- "RPA exiting normally.\n");
1943		- }
1944		-
1945		- return rval;
1946	1581	}
1947	1582
1948	1583	/**
1949		- * qla2x00_fdmiv2_rhba() - perform RHBA FDMI v2 registration
	1584	+ * qla2x00_hba_attributes() perform HBA attributes registration
1950	1585	* @vha: HA context
	1586	+ * @entries: number of entries to use
	1587	+ * @callopt: Option to issue extended or standard FDMI
	1588	+ * command parameter
1951	1589	*
1952	1590	* Returns 0 on success.
1953	1591	*/
1954		-static int
1955		-qla2x00_fdmiv2_rhba(scsi_qla_host_t *vha)
	1592	+static unsigned long
	1593	+qla2x00_hba_attributes(scsi_qla_host_t vha, void entries,
	1594	+ unsigned int callopt)
1956	1595	{
1957		- int rval, alen;
1958		- uint32_t size, sn;
1959		- ms_iocb_entry_t *ms_pkt;
1960		- struct ct_sns_req *ct_req;
1961		- struct ct_sns_rsp *ct_rsp;
1962		- void *entries;
1963		- struct ct_fdmiv2_hba_attr *eiter;
1964	1596	struct qla_hw_data *ha = vha->hw;
1965		- struct new_utsname *p_sysid = NULL;
1966		-
1967		- /* Issue RHBA */
1968		- /* Prepare common MS IOCB */
1969		- /* Request size adjusted after CT preparation */
1970		- ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RHBA_RSP_SIZE);
1971		-
1972		- /* Prepare CT request */
1973		- ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RHBA_CMD,
1974		- RHBA_RSP_SIZE);
1975		- ct_rsp = &ha->ct_sns->p.rsp;
1976		-
1977		- /* Prepare FDMI command arguments -- attribute block, attributes. */
1978		- memcpy(ct_req->req.rhba2.hba_identifier, vha->port_name, WWN_SIZE);
1979		- ct_req->req.rhba2.entry_count = cpu_to_be32(1);
1980		- memcpy(ct_req->req.rhba2.port_name, vha->port_name, WWN_SIZE);
1981		- size = 2 * WWN_SIZE + 4 + 4;
1982		-
1983		- /* Attributes */
1984		- ct_req->req.rhba2.attrs.count = cpu_to_be32(FDMIV2_HBA_ATTR_COUNT);
1985		- entries = ct_req->req.rhba2.hba_identifier;
	1597	+ struct new_utsname *p_sysid = utsname();
	1598	+ struct ct_fdmi_hba_attr *eiter;
	1599	+ uint16_t alen;
	1600	+ unsigned long size = 0;
1986	1601
1987	1602	/* Nodename. */
1988	1603	eiter = entries + size;
1989	1604	eiter->type = cpu_to_be16(FDMI_HBA_NODE_NAME);
1990		- eiter->len = cpu_to_be16(4 + WWN_SIZE);
1991		- memcpy(eiter->a.node_name, vha->node_name, WWN_SIZE);
1992		- size += 4 + WWN_SIZE;
1993		-
1994		- ql_dbg(ql_dbg_disc, vha, 0x207d,
1995		- "NodeName = %016llx.\n", wwn_to_u64(eiter->a.node_name));
1996		-
	1605	+ memcpy(eiter->a.node_name, vha->node_name, sizeof(eiter->a.node_name));
	1606	+ alen = sizeof(eiter->a.node_name);
	1607	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1608	+ eiter->len = cpu_to_be16(alen);
	1609	+ size += alen;
	1610	+ ql_dbg(ql_dbg_disc, vha, 0x20a0,
	1611	+ "NODENAME = %016llx.\n", wwn_to_u64(eiter->a.node_name));
1997	1612	/* Manufacturer. */
1998	1613	eiter = entries + size;
1999	1614	eiter->type = cpu_to_be16(FDMI_HBA_MANUFACTURER);
2000		- snprintf(eiter->a.manufacturer, sizeof(eiter->a.manufacturer),
2001		- "%s", "QLogic Corporation");
2002		- eiter->a.manufacturer[strlen("QLogic Corporation")] = '\0';
2003		- alen = strlen(eiter->a.manufacturer);
2004		- alen += 4 - (alen & 3);
2005		- eiter->len = cpu_to_be16(4 + alen);
2006		- size += 4 + alen;
2007		-
2008		- ql_dbg(ql_dbg_disc, vha, 0x20a5,
2009		- "Manufacturer = %s.\n", eiter->a.manufacturer);
2010		-
	1615	+ alen = scnprintf(
	1616	+ eiter->a.manufacturer, sizeof(eiter->a.manufacturer),
	1617	+ "%s", "QLogic Corporation");
	1618	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1619	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1620	+ eiter->len = cpu_to_be16(alen);
	1621	+ size += alen;
	1622	+ ql_dbg(ql_dbg_disc, vha, 0x20a1,
	1623	+ "MANUFACTURER = %s.\n", eiter->a.manufacturer);
2011	1624	/* Serial number. */
2012	1625	eiter = entries + size;
2013	1626	eiter->type = cpu_to_be16(FDMI_HBA_SERIAL_NUMBER);
2014		- if (IS_FWI2_CAPABLE(ha))
2015		- qla2xxx_get_vpd_field(vha, "SN", eiter->a.serial_num,
2016		- sizeof(eiter->a.serial_num));
2017		- else {
2018		- sn = ((ha->serial0 & 0x1f) << 16) \|
2019		- (ha->serial2 << 8) \| ha->serial1;
2020		- snprintf(eiter->a.serial_num, sizeof(eiter->a.serial_num),
2021		- "%c%05d", 'A' + sn / 100000, sn % 100000);
	1627	+ alen = 0;
	1628	+ if (IS_FWI2_CAPABLE(ha)) {
	1629	+ alen = qla2xxx_get_vpd_field(vha, "SN",
	1630	+ eiter->a.serial_num, sizeof(eiter->a.serial_num));
2022	1631	}
2023		- alen = strlen(eiter->a.serial_num);
2024		- alen += 4 - (alen & 3);
2025		- eiter->len = cpu_to_be16(4 + alen);
2026		- size += 4 + alen;
2027		-
2028		- ql_dbg(ql_dbg_disc, vha, 0x20a6,
2029		- "Serial no. = %s.\n", eiter->a.serial_num);
2030		-
	1632	+ if (!alen) {
	1633	+ uint32_t sn = ((ha->serial0 & 0x1f) << 16) \|
	1634	+ (ha->serial2 << 8) \| ha->serial1;
	1635	+ alen = scnprintf(
	1636	+ eiter->a.serial_num, sizeof(eiter->a.serial_num),
	1637	+ "%c%05d", 'A' + sn / 100000, sn % 100000);
	1638	+ }
	1639	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1640	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1641	+ eiter->len = cpu_to_be16(alen);
	1642	+ size += alen;
	1643	+ ql_dbg(ql_dbg_disc, vha, 0x20a2,
	1644	+ "SERIAL NUMBER = %s.\n", eiter->a.serial_num);
2031	1645	/* Model name. */
2032	1646	eiter = entries + size;
2033	1647	eiter->type = cpu_to_be16(FDMI_HBA_MODEL);
2034		- snprintf(eiter->a.model, sizeof(eiter->a.model),
2035		- "%s", ha->model_number);
2036		- alen = strlen(eiter->a.model);
2037		- alen += 4 - (alen & 3);
2038		- eiter->len = cpu_to_be16(4 + alen);
2039		- size += 4 + alen;
2040		-
2041		- ql_dbg(ql_dbg_disc, vha, 0x20a7,
2042		- "Model Name = %s.\n", eiter->a.model);
2043		-
	1648	+ alen = scnprintf(
	1649	+ eiter->a.model, sizeof(eiter->a.model),
	1650	+ "%s", ha->model_number);
	1651	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1652	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1653	+ eiter->len = cpu_to_be16(alen);
	1654	+ size += alen;
	1655	+ ql_dbg(ql_dbg_disc, vha, 0x20a3,
	1656	+ "MODEL NAME = %s.\n", eiter->a.model);
2044	1657	/* Model description. */
2045	1658	eiter = entries + size;
2046	1659	eiter->type = cpu_to_be16(FDMI_HBA_MODEL_DESCRIPTION);
2047		- snprintf(eiter->a.model_desc, sizeof(eiter->a.model_desc),
2048		- "%s", ha->model_desc);
2049		- alen = strlen(eiter->a.model_desc);
2050		- alen += 4 - (alen & 3);
2051		- eiter->len = cpu_to_be16(4 + alen);
2052		- size += 4 + alen;
2053		-
2054		- ql_dbg(ql_dbg_disc, vha, 0x20a8,
2055		- "Model Desc = %s.\n", eiter->a.model_desc);
2056		-
	1660	+ alen = scnprintf(
	1661	+ eiter->a.model_desc, sizeof(eiter->a.model_desc),
	1662	+ "%s", ha->model_desc);
	1663	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1664	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1665	+ eiter->len = cpu_to_be16(alen);
	1666	+ size += alen;
	1667	+ ql_dbg(ql_dbg_disc, vha, 0x20a4,
	1668	+ "MODEL DESCRIPTION = %s.\n", eiter->a.model_desc);
2057	1669	/* Hardware version. */
2058	1670	eiter = entries + size;
2059	1671	eiter->type = cpu_to_be16(FDMI_HBA_HARDWARE_VERSION);
2060		- if (!IS_FWI2_CAPABLE(ha)) {
2061		- snprintf(eiter->a.hw_version, sizeof(eiter->a.hw_version),
2062		- "HW:%s", ha->adapter_id);
2063		- } else if (qla2xxx_get_vpd_field(vha, "MN", eiter->a.hw_version,
2064		- sizeof(eiter->a.hw_version))) {
2065		- ;
2066		- } else if (qla2xxx_get_vpd_field(vha, "EC", eiter->a.hw_version,
2067		- sizeof(eiter->a.hw_version))) {
2068		- ;
2069		- } else {
2070		- snprintf(eiter->a.hw_version, sizeof(eiter->a.hw_version),
2071		- "HW:%s", ha->adapter_id);
	1672	+ alen = 0;
	1673	+ if (IS_FWI2_CAPABLE(ha)) {
	1674	+ if (!alen) {
	1675	+ alen = qla2xxx_get_vpd_field(vha, "MN",
	1676	+ eiter->a.hw_version, sizeof(eiter->a.hw_version));
	1677	+ }
	1678	+ if (!alen) {
	1679	+ alen = qla2xxx_get_vpd_field(vha, "EC",
	1680	+ eiter->a.hw_version, sizeof(eiter->a.hw_version));
	1681	+ }
2072	1682	}
2073		- alen = strlen(eiter->a.hw_version);
2074		- alen += 4 - (alen & 3);
2075		- eiter->len = cpu_to_be16(4 + alen);
2076		- size += 4 + alen;
2077		-
2078		- ql_dbg(ql_dbg_disc, vha, 0x20a9,
2079		- "Hardware ver = %s.\n", eiter->a.hw_version);
2080		-
	1683	+ if (!alen) {
	1684	+ alen = scnprintf(
	1685	+ eiter->a.hw_version, sizeof(eiter->a.hw_version),
	1686	+ "HW:%s", ha->adapter_id);
	1687	+ }
	1688	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1689	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1690	+ eiter->len = cpu_to_be16(alen);
	1691	+ size += alen;
	1692	+ ql_dbg(ql_dbg_disc, vha, 0x20a5,
	1693	+ "HARDWARE VERSION = %s.\n", eiter->a.hw_version);
2081	1694	/* Driver version. */
2082	1695	eiter = entries + size;
2083	1696	eiter->type = cpu_to_be16(FDMI_HBA_DRIVER_VERSION);
2084		- snprintf(eiter->a.driver_version, sizeof(eiter->a.driver_version),
2085		- "%s", qla2x00_version_str);
2086		- alen = strlen(eiter->a.driver_version);
2087		- alen += 4 - (alen & 3);
2088		- eiter->len = cpu_to_be16(4 + alen);
2089		- size += 4 + alen;
2090		-
2091		- ql_dbg(ql_dbg_disc, vha, 0x20aa,
2092		- "Driver ver = %s.\n", eiter->a.driver_version);
2093		-
	1697	+ alen = scnprintf(
	1698	+ eiter->a.driver_version, sizeof(eiter->a.driver_version),
	1699	+ "%s", qla2x00_version_str);
	1700	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1701	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1702	+ eiter->len = cpu_to_be16(alen);
	1703	+ size += alen;
	1704	+ ql_dbg(ql_dbg_disc, vha, 0x20a6,
	1705	+ "DRIVER VERSION = %s.\n", eiter->a.driver_version);
2094	1706	/* Option ROM version. */
2095	1707	eiter = entries + size;
2096	1708	eiter->type = cpu_to_be16(FDMI_HBA_OPTION_ROM_VERSION);
2097		- snprintf(eiter->a.orom_version, sizeof(eiter->a.orom_version),
2098		- "%d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
2099		- alen = strlen(eiter->a.orom_version);
2100		- alen += 4 - (alen & 3);
2101		- eiter->len = cpu_to_be16(4 + alen);
2102		- size += 4 + alen;
	1709	+ alen = scnprintf(
	1710	+ eiter->a.orom_version, sizeof(eiter->a.orom_version),
	1711	+ "%d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
	1712	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1713	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1714	+ eiter->len = cpu_to_be16(alen);
	1715	+ size += alen;
2103	1716
2104		- ql_dbg(ql_dbg_disc, vha , 0x20ab,
2105		- "Optrom version = %d.%02d.\n", eiter->a.orom_version[1],
2106		- eiter->a.orom_version[0]);
2107		-
	1717	+ ql_dbg(ql_dbg_disc, vha, 0x20a7,
	1718	+ "OPTROM VERSION = %d.%02d.\n",
	1719	+ eiter->a.orom_version[1], eiter->a.orom_version[0]);
2108	1720	/* Firmware version */
2109	1721	eiter = entries + size;
2110	1722	eiter->type = cpu_to_be16(FDMI_HBA_FIRMWARE_VERSION);
2111	1723	ha->isp_ops->fw_version_str(vha, eiter->a.fw_version,
2112	1724	sizeof(eiter->a.fw_version));
2113		- alen = strlen(eiter->a.fw_version);
2114		- alen += 4 - (alen & 3);
2115		- eiter->len = cpu_to_be16(4 + alen);
2116		- size += 4 + alen;
2117		-
2118		- ql_dbg(ql_dbg_disc, vha, 0x20ac,
2119		- "Firmware vers = %s.\n", eiter->a.fw_version);
2120		-
	1725	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1726	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1727	+ eiter->len = cpu_to_be16(alen);
	1728	+ size += alen;
	1729	+ ql_dbg(ql_dbg_disc, vha, 0x20a8,
	1730	+ "FIRMWARE VERSION = %s.\n", eiter->a.fw_version);
	1731	+ if (callopt == CALLOPT_FDMI1)
	1732	+ goto done;
2121	1733	/* OS Name and Version */
2122	1734	eiter = entries + size;
2123	1735	eiter->type = cpu_to_be16(FDMI_HBA_OS_NAME_AND_VERSION);
2124		- p_sysid = utsname();
	1736	+ alen = 0;
2125	1737	if (p_sysid) {
2126		- snprintf(eiter->a.os_version, sizeof(eiter->a.os_version),
2127		- "%s %s %s",
2128		- p_sysid->sysname, p_sysid->release, p_sysid->version);
2129		- } else {
2130		- snprintf(eiter->a.os_version, sizeof(eiter->a.os_version),
2131		- "%s %s", "Linux", fc_host_system_hostname(vha->host));
	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);
2132	1742	}
2133		- alen = strlen(eiter->a.os_version);
2134		- alen += 4 - (alen & 3);
2135		- eiter->len = cpu_to_be16(4 + alen);
2136		- size += 4 + alen;
2137		-
2138		- ql_dbg(ql_dbg_disc, vha, 0x20ae,
2139		- "OS Name and Version = %s.\n", eiter->a.os_version);
2140		-
	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);
2141	1755	/* MAX CT Payload Length */
2142	1756	eiter = entries + size;
2143	1757	eiter->type = cpu_to_be16(FDMI_HBA_MAXIMUM_CT_PAYLOAD_LENGTH);
2144		- eiter->a.max_ct_len = cpu_to_be32(ha->frame_payload_size);
2145		- eiter->a.max_ct_len = cpu_to_be32(eiter->a.max_ct_len);
2146		- eiter->len = cpu_to_be16(4 + 4);
2147		- size += 4 + 4;
	1758	+ eiter->a.max_ct_len = cpu_to_be32(ha->frame_payload_size >> 2);
2148	1759
2149		- ql_dbg(ql_dbg_disc, vha, 0x20af,
2150		- "CT Payload Length = 0x%x.\n", eiter->a.max_ct_len);
2151		-
	1760	+ alen = sizeof(eiter->a.max_ct_len);
	1761	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1762	+ eiter->len = cpu_to_be16(alen);
	1763	+ size += alen;
	1764	+ ql_dbg(ql_dbg_disc, vha, 0x20aa,
	1765	+ "CT PAYLOAD LENGTH = 0x%x.\n", be32_to_cpu(eiter->a.max_ct_len));
2152	1766	/* Node Sybolic Name */
2153	1767	eiter = entries + size;
2154	1768	eiter->type = cpu_to_be16(FDMI_HBA_NODE_SYMBOLIC_NAME);
2155		- qla2x00_get_sym_node_name(vha, eiter->a.sym_name,
	1769	+ alen = qla2x00_get_sym_node_name(vha, eiter->a.sym_name,
2156	1770	sizeof(eiter->a.sym_name));
2157		- alen = strlen(eiter->a.sym_name);
2158		- alen += 4 - (alen & 3);
2159		- eiter->len = cpu_to_be16(4 + alen);
2160		- size += 4 + alen;
2161		-
2162		- ql_dbg(ql_dbg_disc, vha, 0x20b0,
2163		- "Symbolic Name = %s.\n", eiter->a.sym_name);
2164		-
2165		- /* Vendor Id */
	1771	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1772	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1773	+ eiter->len = cpu_to_be16(alen);
	1774	+ size += alen;
	1775	+ ql_dbg(ql_dbg_disc, vha, 0x20ab,
	1776	+ "SYMBOLIC NAME = %s.\n", eiter->a.sym_name);
	1777	+ /* Vendor Specific information */
2166	1778	eiter = entries + size;
2167		- eiter->type = cpu_to_be16(FDMI_HBA_VENDOR_ID);
2168		- eiter->a.vendor_id = cpu_to_be32(0x1077);
2169		- eiter->len = cpu_to_be16(4 + 4);
2170		- size += 4 + 4;
2171		-
2172		- ql_dbg(ql_dbg_disc, vha, 0x20b1,
2173		- "Vendor Id = %x.\n", eiter->a.vendor_id);
2174		-
	1779	+ eiter->type = cpu_to_be16(FDMI_HBA_VENDOR_SPECIFIC_INFO);
	1780	+ eiter->a.vendor_specific_info = cpu_to_be32(PCI_VENDOR_ID_QLOGIC);
	1781	+ alen = sizeof(eiter->a.vendor_specific_info);
	1782	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1783	+ eiter->len = cpu_to_be16(alen);
	1784	+ size += alen;
	1785	+ ql_dbg(ql_dbg_disc, vha, 0x20ac,
	1786	+ "VENDOR SPECIFIC INFO = 0x%x.\n",
	1787	+ be32_to_cpu(eiter->a.vendor_specific_info));
2175	1788	/* Num Ports */
2176	1789	eiter = entries + size;
2177	1790	eiter->type = cpu_to_be16(FDMI_HBA_NUM_PORTS);
2178	1791	eiter->a.num_ports = cpu_to_be32(1);
2179		- eiter->len = cpu_to_be16(4 + 4);
2180		- size += 4 + 4;
2181		-
2182		- ql_dbg(ql_dbg_disc, vha, 0x20b2,
2183		- "Port Num = %x.\n", eiter->a.num_ports);
2184		-
	1792	+ alen = sizeof(eiter->a.num_ports);
	1793	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1794	+ eiter->len = cpu_to_be16(alen);
	1795	+ size += alen;
	1796	+ ql_dbg(ql_dbg_disc, vha, 0x20ad,
	1797	+ "PORT COUNT = %x.\n", be32_to_cpu(eiter->a.num_ports));
2185	1798	/* Fabric Name */
2186	1799	eiter = entries + size;
2187	1800	eiter->type = cpu_to_be16(FDMI_HBA_FABRIC_NAME);
2188		- memcpy(eiter->a.fabric_name, vha->fabric_node_name, WWN_SIZE);
2189		- eiter->len = cpu_to_be16(4 + WWN_SIZE);
2190		- size += 4 + WWN_SIZE;
2191		-
2192		- ql_dbg(ql_dbg_disc, vha, 0x20b3,
2193		- "Fabric Name = %016llx.\n", wwn_to_u64(eiter->a.fabric_name));
2194		-
	1801	+ memcpy(eiter->a.fabric_name, vha->fabric_node_name,
	1802	+ sizeof(eiter->a.fabric_name));
	1803	+ alen = sizeof(eiter->a.fabric_name);
	1804	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1805	+ eiter->len = cpu_to_be16(alen);
	1806	+ size += alen;
	1807	+ ql_dbg(ql_dbg_disc, vha, 0x20ae,
	1808	+ "FABRIC NAME = %016llx.\n", wwn_to_u64(eiter->a.fabric_name));
2195	1809	/* BIOS Version */
2196	1810	eiter = entries + size;
2197	1811	eiter->type = cpu_to_be16(FDMI_HBA_BOOT_BIOS_NAME);
2198		- snprintf(eiter->a.bios_name, sizeof(eiter->a.bios_name),
2199		- "BIOS %d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
2200		- alen = strlen(eiter->a.bios_name);
2201		- alen += 4 - (alen & 3);
2202		- eiter->len = cpu_to_be16(4 + alen);
2203		- size += 4 + alen;
2204		-
2205		- ql_dbg(ql_dbg_disc, vha, 0x20b4,
2206		- "BIOS Name = %s\n", eiter->a.bios_name);
2207		-
	1812	+ alen = scnprintf(
	1813	+ eiter->a.bios_name, sizeof(eiter->a.bios_name),
	1814	+ "BIOS %d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
	1815	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1816	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1817	+ eiter->len = cpu_to_be16(alen);
	1818	+ size += alen;
	1819	+ ql_dbg(ql_dbg_disc, vha, 0x20af,
	1820	+ "BIOS NAME = %s\n", eiter->a.bios_name);
2208	1821	/* Vendor Identifier */
2209	1822	eiter = entries + size;
2210		- eiter->type = cpu_to_be16(FDMI_HBA_TYPE_VENDOR_IDENTIFIER);
2211		- snprintf(eiter->a.vendor_identifier, sizeof(eiter->a.vendor_identifier),
2212		- "%s", "QLGC");
2213		- alen = strlen(eiter->a.vendor_identifier);
2214		- alen += 4 - (alen & 3);
2215		- eiter->len = cpu_to_be16(4 + alen);
2216		- size += 4 + alen;
	1823	+ eiter->type = cpu_to_be16(FDMI_HBA_VENDOR_IDENTIFIER);
	1824	+ alen = scnprintf(
	1825	+ eiter->a.vendor_identifier, sizeof(eiter->a.vendor_identifier),
	1826	+ "%s", "QLGC");
	1827	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1828	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1829	+ eiter->len = cpu_to_be16(alen);
	1830	+ size += alen;
	1831	+ ql_dbg(ql_dbg_disc, vha, 0x20b0,
	1832	+ "VENDOR IDENTIFIER = %s.\n", eiter->a.vendor_identifier);
	1833	+done:
	1834	+ return size;
	1835	+}
2217	1836
2218		- ql_dbg(ql_dbg_disc, vha, 0x201b,
2219		- "Vendor Identifier = %s.\n", eiter->a.vendor_identifier);
	1837	+/**
	1838	+ * qla2x00_port_attributes() perform Port attributes registration
	1839	+ * @vha: HA context
	1840	+ * @entries: number of entries to use
	1841	+ * @callopt: Option to issue extended or standard FDMI
	1842	+ * command parameter
	1843	+ *
	1844	+ * Returns 0 on success.
	1845	+ */
	1846	+static unsigned long
	1847	+qla2x00_port_attributes(scsi_qla_host_t vha, void entries,
	1848	+ unsigned int callopt)
	1849	+{
	1850	+ struct qla_hw_data *ha = vha->hw;
	1851	+ struct new_utsname *p_sysid = utsname();
	1852	+ char *hostname = p_sysid ?
	1853	+ p_sysid->nodename : fc_host_system_hostname(vha->host);
	1854	+ struct ct_fdmi_port_attr *eiter;
	1855	+ uint16_t alen;
	1856	+ unsigned long size = 0;
	1857	+
	1858	+ /* FC4 types. */
	1859	+ eiter = entries + size;
	1860	+ eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPES);
	1861	+ eiter->a.fc4_types[0] = 0x00;
	1862	+ eiter->a.fc4_types[1] = 0x00;
	1863	+ eiter->a.fc4_types[2] = 0x01;
	1864	+ eiter->a.fc4_types[3] = 0x00;
	1865	+ alen = sizeof(eiter->a.fc4_types);
	1866	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1867	+ eiter->len = cpu_to_be16(alen);
	1868	+ size += alen;
	1869	+ ql_dbg(ql_dbg_disc, vha, 0x20c0,
	1870	+ "FC4 TYPES = %016llx.\n", (uint64_t )eiter->a.fc4_types);
	1871	+ if (vha->flags.nvme_enabled) {
	1872	+ eiter->a.fc4_types[6] = 1; /* NVMe type 28h */
	1873	+ ql_dbg(ql_dbg_disc, vha, 0x211f,
	1874	+ "NVME FC4 Type = %02x 0x0 0x0 0x0 0x0 0x0.\n",
	1875	+ eiter->a.fc4_types[6]);
	1876	+ }
	1877	+ /* Supported speed. */
	1878	+ eiter = entries + size;
	1879	+ eiter->type = cpu_to_be16(FDMI_PORT_SUPPORT_SPEED);
	1880	+ eiter->a.sup_speed = cpu_to_be32(
	1881	+ qla25xx_fdmi_port_speed_capability(ha));
	1882	+ alen = sizeof(eiter->a.sup_speed);
	1883	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1884	+ eiter->len = cpu_to_be16(alen);
	1885	+ size += alen;
	1886	+ ql_dbg(ql_dbg_disc, vha, 0x20c1,
	1887	+ "SUPPORTED SPEED = %x.\n", be32_to_cpu(eiter->a.sup_speed));
	1888	+ /* Current speed. */
	1889	+ eiter = entries + size;
	1890	+ eiter->type = cpu_to_be16(FDMI_PORT_CURRENT_SPEED);
	1891	+ eiter->a.cur_speed = cpu_to_be32(
	1892	+ qla25xx_fdmi_port_speed_currently(ha));
	1893	+ alen = sizeof(eiter->a.cur_speed);
	1894	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1895	+ eiter->len = cpu_to_be16(alen);
	1896	+ size += alen;
	1897	+ ql_dbg(ql_dbg_disc, vha, 0x20c2,
	1898	+ "CURRENT SPEED = %x.\n", be32_to_cpu(eiter->a.cur_speed));
	1899	+ /* Max frame size. */
	1900	+ eiter = entries + size;
	1901	+ eiter->type = cpu_to_be16(FDMI_PORT_MAX_FRAME_SIZE);
	1902	+ eiter->a.max_frame_size = cpu_to_be32(ha->frame_payload_size);
	1903	+ alen = sizeof(eiter->a.max_frame_size);
	1904	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1905	+ eiter->len = cpu_to_be16(alen);
	1906	+ size += alen;
	1907	+ ql_dbg(ql_dbg_disc, vha, 0x20c3,
	1908	+ "MAX FRAME SIZE = %x.\n", be32_to_cpu(eiter->a.max_frame_size));
	1909	+ /* OS device name. */
	1910	+ eiter = entries + size;
	1911	+ eiter->type = cpu_to_be16(FDMI_PORT_OS_DEVICE_NAME);
	1912	+ alen = scnprintf(
	1913	+ eiter->a.os_dev_name, sizeof(eiter->a.os_dev_name),
	1914	+ "%s:host%lu", QLA2XXX_DRIVER_NAME, vha->host_no);
	1915	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1916	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1917	+ eiter->len = cpu_to_be16(alen);
	1918	+ size += alen;
	1919	+ ql_dbg(ql_dbg_disc, vha, 0x20c4,
	1920	+ "OS DEVICE NAME = %s.\n", eiter->a.os_dev_name);
	1921	+ /* Hostname. */
	1922	+ eiter = entries + size;
	1923	+ eiter->type = cpu_to_be16(FDMI_PORT_HOST_NAME);
	1924	+ if (!*hostname \|\| !strncmp(hostname, "(none)", 6))
	1925	+ hostname = "Linux-default";
	1926	+ alen = scnprintf(
	1927	+ eiter->a.host_name, sizeof(eiter->a.host_name),
	1928	+ "%s", hostname);
	1929	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1930	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1931	+ eiter->len = cpu_to_be16(alen);
	1932	+ size += alen;
	1933	+ ql_dbg(ql_dbg_disc, vha, 0x20c5,
	1934	+ "HOSTNAME = %s.\n", eiter->a.host_name);
	1935	+
	1936	+ if (callopt == CALLOPT_FDMI1)
	1937	+ goto done;
	1938	+
	1939	+ /* Node Name */
	1940	+ eiter = entries + size;
	1941	+ eiter->type = cpu_to_be16(FDMI_PORT_NODE_NAME);
	1942	+ memcpy(eiter->a.node_name, vha->node_name, sizeof(eiter->a.node_name));
	1943	+ alen = sizeof(eiter->a.node_name);
	1944	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1945	+ eiter->len = cpu_to_be16(alen);
	1946	+ size += alen;
	1947	+ ql_dbg(ql_dbg_disc, vha, 0x20c6,
	1948	+ "NODENAME = %016llx.\n", wwn_to_u64(eiter->a.node_name));
	1949	+
	1950	+ /* Port Name */
	1951	+ eiter = entries + size;
	1952	+ eiter->type = cpu_to_be16(FDMI_PORT_NAME);
	1953	+ memcpy(eiter->a.port_name, vha->port_name, sizeof(eiter->a.port_name));
	1954	+ alen = sizeof(eiter->a.port_name);
	1955	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1956	+ eiter->len = cpu_to_be16(alen);
	1957	+ size += alen;
	1958	+ ql_dbg(ql_dbg_disc, vha, 0x20c7,
	1959	+ "PORTNAME = %016llx.\n", wwn_to_u64(eiter->a.port_name));
	1960	+
	1961	+ /* Port Symbolic Name */
	1962	+ eiter = entries + size;
	1963	+ eiter->type = cpu_to_be16(FDMI_PORT_SYM_NAME);
	1964	+ alen = qla2x00_get_sym_node_name(vha, eiter->a.port_sym_name,
	1965	+ sizeof(eiter->a.port_sym_name));
	1966	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	1967	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1968	+ eiter->len = cpu_to_be16(alen);
	1969	+ size += alen;
	1970	+ ql_dbg(ql_dbg_disc, vha, 0x20c8,
	1971	+ "PORT SYMBOLIC NAME = %s\n", eiter->a.port_sym_name);
	1972	+
	1973	+ /* Port Type */
	1974	+ eiter = entries + size;
	1975	+ eiter->type = cpu_to_be16(FDMI_PORT_TYPE);
	1976	+ eiter->a.port_type = cpu_to_be32(NS_NX_PORT_TYPE);
	1977	+ alen = sizeof(eiter->a.port_type);
	1978	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1979	+ eiter->len = cpu_to_be16(alen);
	1980	+ size += alen;
	1981	+ ql_dbg(ql_dbg_disc, vha, 0x20c9,
	1982	+ "PORT TYPE = %x.\n", be32_to_cpu(eiter->a.port_type));
	1983	+
	1984	+ /* Supported Class of Service */
	1985	+ eiter = entries + size;
	1986	+ eiter->type = cpu_to_be16(FDMI_PORT_SUPP_COS);
	1987	+ eiter->a.port_supported_cos = cpu_to_be32(FC_CLASS_3);
	1988	+ alen = sizeof(eiter->a.port_supported_cos);
	1989	+ alen += FDMI_ATTR_TYPELEN(eiter);
	1990	+ eiter->len = cpu_to_be16(alen);
	1991	+ size += alen;
	1992	+ ql_dbg(ql_dbg_disc, vha, 0x20ca,
	1993	+ "SUPPORTED COS = %08x\n", be32_to_cpu(eiter->a.port_supported_cos));
	1994	+
	1995	+ /* Port Fabric Name */
	1996	+ eiter = entries + size;
	1997	+ eiter->type = cpu_to_be16(FDMI_PORT_FABRIC_NAME);
	1998	+ memcpy(eiter->a.fabric_name, vha->fabric_node_name,
	1999	+ sizeof(eiter->a.fabric_name));
	2000	+ alen = sizeof(eiter->a.fabric_name);
	2001	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2002	+ eiter->len = cpu_to_be16(alen);
	2003	+ size += alen;
	2004	+ ql_dbg(ql_dbg_disc, vha, 0x20cb,
	2005	+ "FABRIC NAME = %016llx.\n", wwn_to_u64(eiter->a.fabric_name));
	2006	+
	2007	+ /* FC4_type */
	2008	+ eiter = entries + size;
	2009	+ eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPE);
	2010	+ eiter->a.port_fc4_type[0] = 0x00;
	2011	+ eiter->a.port_fc4_type[1] = 0x00;
	2012	+ eiter->a.port_fc4_type[2] = 0x01;
	2013	+ eiter->a.port_fc4_type[3] = 0x00;
	2014	+ alen = sizeof(eiter->a.port_fc4_type);
	2015	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2016	+ eiter->len = cpu_to_be16(alen);
	2017	+ size += alen;
	2018	+ ql_dbg(ql_dbg_disc, vha, 0x20cc,
	2019	+ "PORT ACTIVE FC4 TYPE = %016llx.\n",
	2020	+ (uint64_t )eiter->a.port_fc4_type);
	2021	+
	2022	+ /* Port State */
	2023	+ eiter = entries + size;
	2024	+ eiter->type = cpu_to_be16(FDMI_PORT_STATE);
	2025	+ eiter->a.port_state = cpu_to_be32(2);
	2026	+ alen = sizeof(eiter->a.port_state);
	2027	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2028	+ eiter->len = cpu_to_be16(alen);
	2029	+ size += alen;
	2030	+ ql_dbg(ql_dbg_disc, vha, 0x20cd,
	2031	+ "PORT_STATE = %x.\n", be32_to_cpu(eiter->a.port_state));
	2032	+
	2033	+ /* Number of Ports */
	2034	+ eiter = entries + size;
	2035	+ eiter->type = cpu_to_be16(FDMI_PORT_COUNT);
	2036	+ eiter->a.num_ports = cpu_to_be32(1);
	2037	+ alen = sizeof(eiter->a.num_ports);
	2038	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2039	+ eiter->len = cpu_to_be16(alen);
	2040	+ size += alen;
	2041	+ ql_dbg(ql_dbg_disc, vha, 0x20ce,
	2042	+ "PORT COUNT = %x.\n", be32_to_cpu(eiter->a.num_ports));
	2043	+
	2044	+ /* Port Identifier */
	2045	+ eiter = entries + size;
	2046	+ eiter->type = cpu_to_be16(FDMI_PORT_IDENTIFIER);
	2047	+ eiter->a.port_id = cpu_to_be32(vha->d_id.b24);
	2048	+ alen = sizeof(eiter->a.port_id);
	2049	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2050	+ eiter->len = cpu_to_be16(alen);
	2051	+ size += alen;
	2052	+ ql_dbg(ql_dbg_disc, vha, 0x20cf,
	2053	+ "PORT ID = %x.\n", be32_to_cpu(eiter->a.port_id));
	2054	+
	2055	+ if (callopt == CALLOPT_FDMI2 \|\| !ql2xsmartsan)
	2056	+ goto done;
	2057	+
	2058	+ /* Smart SAN Service Category (Populate Smart SAN Initiator)*/
	2059	+ eiter = entries + size;
	2060	+ eiter->type = cpu_to_be16(FDMI_SMARTSAN_SERVICE);
	2061	+ alen = scnprintf(
	2062	+ eiter->a.smartsan_service, sizeof(eiter->a.smartsan_service),
	2063	+ "%s", "Smart SAN Initiator");
	2064	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	2065	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2066	+ eiter->len = cpu_to_be16(alen);
	2067	+ size += alen;
	2068	+ ql_dbg(ql_dbg_disc, vha, 0x20d0,
	2069	+ "SMARTSAN SERVICE CATEGORY = %s.\n", eiter->a.smartsan_service);
	2070	+
	2071	+ /* Smart SAN GUID (NWWN+PWWN) */
	2072	+ eiter = entries + size;
	2073	+ eiter->type = cpu_to_be16(FDMI_SMARTSAN_GUID);
	2074	+ memcpy(eiter->a.smartsan_guid, vha->node_name, WWN_SIZE);
	2075	+ memcpy(eiter->a.smartsan_guid + WWN_SIZE, vha->port_name, WWN_SIZE);
	2076	+ alen = sizeof(eiter->a.smartsan_guid);
	2077	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2078	+ eiter->len = cpu_to_be16(alen);
	2079	+ size += alen;
	2080	+ ql_dbg(ql_dbg_disc, vha, 0x20d1,
	2081	+ "Smart SAN GUID = %016llx-%016llx\n",
	2082	+ wwn_to_u64(eiter->a.smartsan_guid),
	2083	+ wwn_to_u64(eiter->a.smartsan_guid + WWN_SIZE));
	2084	+
	2085	+ /* Smart SAN Version (populate "Smart SAN Version 1.0") */
	2086	+ eiter = entries + size;
	2087	+ eiter->type = cpu_to_be16(FDMI_SMARTSAN_VERSION);
	2088	+ alen = scnprintf(
	2089	+ eiter->a.smartsan_version, sizeof(eiter->a.smartsan_version),
	2090	+ "%s", "Smart SAN Version 2.0");
	2091	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	2092	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2093	+ eiter->len = cpu_to_be16(alen);
	2094	+ size += alen;
	2095	+ ql_dbg(ql_dbg_disc, vha, 0x20d2,
	2096	+ "SMARTSAN VERSION = %s\n", eiter->a.smartsan_version);
	2097	+
	2098	+ /* Smart SAN Product Name (Specify Adapter Model No) */
	2099	+ eiter = entries + size;
	2100	+ eiter->type = cpu_to_be16(FDMI_SMARTSAN_PROD_NAME);
	2101	+ alen = scnprintf(eiter->a.smartsan_prod_name,
	2102	+ sizeof(eiter->a.smartsan_prod_name),
	2103	+ "ISP%04x", ha->pdev->device);
	2104	+ alen += FDMI_ATTR_ALIGNMENT(alen);
	2105	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2106	+ eiter->len = cpu_to_be16(alen);
	2107	+ size += alen;
	2108	+ ql_dbg(ql_dbg_disc, vha, 0x20d3,
	2109	+ "SMARTSAN PRODUCT NAME = %s\n", eiter->a.smartsan_prod_name);
	2110	+
	2111	+ /* Smart SAN Port Info (specify: 1=Physical, 2=NPIV, 3=SRIOV) */
	2112	+ eiter = entries + size;
	2113	+ eiter->type = cpu_to_be16(FDMI_SMARTSAN_PORT_INFO);
	2114	+ eiter->a.smartsan_port_info = cpu_to_be32(vha->vp_idx ? 2 : 1);
	2115	+ alen = sizeof(eiter->a.smartsan_port_info);
	2116	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2117	+ eiter->len = cpu_to_be16(alen);
	2118	+ size += alen;
	2119	+ ql_dbg(ql_dbg_disc, vha, 0x20d4,
	2120	+ "SMARTSAN PORT INFO = %x\n", eiter->a.smartsan_port_info);
	2121	+
	2122	+ /* Smart SAN Security Support */
	2123	+ eiter = entries + size;
	2124	+ eiter->type = cpu_to_be16(FDMI_SMARTSAN_SECURITY_SUPPORT);
	2125	+ eiter->a.smartsan_security_support = cpu_to_be32(1);
	2126	+ alen = sizeof(eiter->a.smartsan_security_support);
	2127	+ alen += FDMI_ATTR_TYPELEN(eiter);
	2128	+ eiter->len = cpu_to_be16(alen);
	2129	+ size += alen;
	2130	+ ql_dbg(ql_dbg_disc, vha, 0x20d6,
	2131	+ "SMARTSAN SECURITY SUPPORT = %d\n",
	2132	+ be32_to_cpu(eiter->a.smartsan_security_support));
	2133	+
	2134	+done:
	2135	+ return size;
	2136	+}
	2137	+
	2138	+/**
	2139	+ * qla2x00_fdmi_rhba() - perform RHBA FDMI registration
	2140	+ * @vha: HA context
	2141	+ * @callopt: Option to issue FDMI registration
	2142	+ *
	2143	+ * Returns 0 on success.
	2144	+ */
	2145	+static int
	2146	+qla2x00_fdmi_rhba(scsi_qla_host_t *vha, unsigned int callopt)
	2147	+{
	2148	+ struct qla_hw_data *ha = vha->hw;
	2149	+ unsigned long size = 0;
	2150	+ unsigned int rval, count;
	2151	+ ms_iocb_entry_t *ms_pkt;
	2152	+ struct ct_sns_req *ct_req;
	2153	+ struct ct_sns_rsp *ct_rsp;
	2154	+ void *entries;
	2155	+
	2156	+ count = callopt != CALLOPT_FDMI1 ?
	2157	+ FDMI2_HBA_ATTR_COUNT : FDMI1_HBA_ATTR_COUNT;
	2158	+
	2159	+ size = RHBA_RSP_SIZE;
	2160	+
	2161	+ ql_dbg(ql_dbg_disc, vha, 0x20e0,
	2162	+ "RHBA (callopt=%x count=%u size=%lu).\n", callopt, count, size);
	2163	+
	2164	+ /* Request size adjusted after CT preparation */
	2165	+ ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, size);
	2166	+
	2167	+ /* Prepare CT request */
	2168	+ ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RHBA_CMD, size);
	2169	+ ct_rsp = &ha->ct_sns->p.rsp;
	2170	+
	2171	+ /* Prepare FDMI command entries */
	2172	+ memcpy(ct_req->req.rhba.hba_identifier, vha->port_name,
	2173	+ sizeof(ct_req->req.rhba.hba_identifier));
	2174	+ size += sizeof(ct_req->req.rhba.hba_identifier);
	2175	+
	2176	+ ct_req->req.rhba.entry_count = cpu_to_be32(1);
	2177	+ size += sizeof(ct_req->req.rhba.entry_count);
	2178	+
	2179	+ memcpy(ct_req->req.rhba.port_name, vha->port_name,
	2180	+ sizeof(ct_req->req.rhba.port_name));
	2181	+ size += sizeof(ct_req->req.rhba.port_name);
	2182	+
	2183	+ /* Attribute count */
	2184	+ ct_req->req.rhba.attrs.count = cpu_to_be32(count);
	2185	+ size += sizeof(ct_req->req.rhba.attrs.count);
	2186	+
	2187	+ /* Attribute block */
	2188	+ entries = &ct_req->req.rhba.attrs.entry;
	2189	+
	2190	+ size += qla2x00_hba_attributes(vha, entries, callopt);
2220	2191
2221	2192	/* Update MS request size. */
2222	2193	qla2x00_update_ms_fdmi_iocb(vha, size + 16);
2223	2194
2224		- ql_dbg(ql_dbg_disc, vha, 0x20b5,
2225		- "RHBA identifier = %016llx.\n",
2226		- wwn_to_u64(ct_req->req.rhba2.hba_identifier));
2227		- ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20b6,
	2195	+ ql_dbg(ql_dbg_disc, vha, 0x20e1,
	2196	+ "RHBA %016llx %016llx.\n",
	2197	+ wwn_to_u64(ct_req->req.rhba.hba_identifier),
	2198	+ wwn_to_u64(ct_req->req.rhba.port_name));
	2199	+
	2200	+ ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20e2,
2228	2201	entries, size);
2229	2202
2230	2203	/* Execute MS IOCB */
2231	2204	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2232		- sizeof(ms_iocb_entry_t));
2233		- if (rval != QLA_SUCCESS) {
2234		- /EMPTY/
2235		- ql_dbg(ql_dbg_disc, vha, 0x20b7,
2236		- "RHBA issue IOCB failed (%d).\n", rval);
2237		- } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RHBA") !=
2238		- QLA_SUCCESS) {
2239		- rval = QLA_FUNCTION_FAILED;
	2205	+ sizeof(*ha->ms_iocb));
	2206	+ if (rval) {
	2207	+ ql_dbg(ql_dbg_disc, vha, 0x20e3,
	2208	+ "RHBA iocb failed (%d).\n", rval);
	2209	+ return rval;
	2210	+ }
2240	2211
	2212	+ rval = qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RHBA");
	2213	+ if (rval) {
2241	2214	if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
2242	2215	ct_rsp->header.explanation_code ==
2243	2216	CT_EXPL_ALREADY_REGISTERED) {
2244		- ql_dbg(ql_dbg_disc, vha, 0x20b8,
2245		- "HBA already registered.\n");
2246		- rval = QLA_ALREADY_REGISTERED;
2247		- } else {
2248		- ql_dbg(ql_dbg_disc, vha, 0x2016,
2249		- "RHBA FDMI v2 failed, CT Reason code: 0x%x, CT Explanation 0x%x\n",
2250		- ct_rsp->header.reason_code,
2251		- ct_rsp->header.explanation_code);
	2217	+ ql_dbg(ql_dbg_disc, vha, 0x20e4,
	2218	+ "RHBA already registered.\n");
	2219	+ return QLA_ALREADY_REGISTERED;
2252	2220	}
2253		- } else {
2254		- ql_dbg(ql_dbg_disc, vha, 0x20b9,
2255		- "RHBA FDMI V2 exiting normally.\n");
	2221	+
	2222	+ ql_dbg(ql_dbg_disc, vha, 0x20e5,
	2223	+ "RHBA failed, CT Reason %#x, CT Explanation %#x\n",
	2224	+ ct_rsp->header.reason_code,
	2225	+ ct_rsp->header.explanation_code);
	2226	+ return rval;
2256	2227	}
2257	2228
	2229	+ ql_dbg(ql_dbg_disc, vha, 0x20e6, "RHBA exiting normally.\n");
2258	2230	return rval;
2259	2231	}
2260	2232
2261		-/**
2262		- * qla2x00_fdmi_dhba() -
2263		- * @vha: HA context
2264		- *
2265		- * Returns 0 on success.
2266		- */
	2233	+
2267	2234	static int
2268	2235	qla2x00_fdmi_dhba(scsi_qla_host_t *vha)
2269	2236	{
..	..	@@ -2272,22 +2239,17 @@
2272	2239	ms_iocb_entry_t *ms_pkt;
2273	2240	struct ct_sns_req *ct_req;
2274	2241	struct ct_sns_rsp *ct_rsp;
2275		-
2276	2242	/* Issue RPA */
2277	2243	/* Prepare common MS IOCB */
2278	2244	ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, DHBA_REQ_SIZE,
2279	2245	DHBA_RSP_SIZE);
2280		-
2281	2246	/* Prepare CT request */
2282	2247	ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, DHBA_CMD, DHBA_RSP_SIZE);
2283	2248	ct_rsp = &ha->ct_sns->p.rsp;
2284		-
2285	2249	/* Prepare FDMI command arguments -- portname. */
2286	2250	memcpy(ct_req->req.dhba.port_name, vha->port_name, WWN_SIZE);
2287		-
2288	2251	ql_dbg(ql_dbg_disc, vha, 0x2036,
2289	2252	"DHBA portname = %8phN.\n", ct_req->req.dhba.port_name);
2290		-
2291	2253	/* Execute MS IOCB */
2292	2254	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2293	2255	sizeof(ms_iocb_entry_t));
..	..	@@ -2302,337 +2264,178 @@
2302	2264	ql_dbg(ql_dbg_disc, vha, 0x2038,
2303	2265	"DHBA exiting normally.\n");
2304	2266	}
2305		-
2306	2267	return rval;
2307	2268	}
2308	2269
2309	2270	/**
2310		- * qla2x00_fdmiv2_rpa() -
	2271	+ * qla2x00_fdmi_rprt() perform RPRT registration
2311	2272	* @vha: HA context
	2273	+ * @callopt: Option to issue extended or standard FDMI
	2274	+ * command parameter
2312	2275	*
2313	2276	* Returns 0 on success.
2314	2277	*/
2315	2278	static int
2316		-qla2x00_fdmiv2_rpa(scsi_qla_host_t *vha)
	2279	+qla2x00_fdmi_rprt(scsi_qla_host_t *vha, int callopt)
2317	2280	{
2318		- int rval, alen;
2319		- uint32_t size;
	2281	+ struct scsi_qla_host *base_vha = pci_get_drvdata(vha->hw->pdev);
2320	2282	struct qla_hw_data *ha = vha->hw;
	2283	+ ulong size = 0;
	2284	+ uint rval, count;
2321	2285	ms_iocb_entry_t *ms_pkt;
2322	2286	struct ct_sns_req *ct_req;
2323	2287	struct ct_sns_rsp *ct_rsp;
2324	2288	void *entries;
2325		- struct ct_fdmiv2_port_attr *eiter;
2326		- struct init_cb_24xx icb24 = (struct init_cb_24xx )ha->init_cb;
2327		- struct new_utsname *p_sysid = NULL;
	2289	+ count = callopt == CALLOPT_FDMI2_SMARTSAN && ql2xsmartsan ?
	2290	+ FDMI2_SMARTSAN_PORT_ATTR_COUNT :
	2291	+ callopt != CALLOPT_FDMI1 ?
	2292	+ FDMI2_PORT_ATTR_COUNT : FDMI1_PORT_ATTR_COUNT;
2328	2293
2329		- /* Issue RPA */
2330		- /* Prepare common MS IOCB */
2331		- /* Request size adjusted after CT preparation */
2332		- ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RPA_RSP_SIZE);
	2294	+ size = RPRT_RSP_SIZE;
	2295	+ ql_dbg(ql_dbg_disc, vha, 0x20e8,
	2296	+ "RPRT (callopt=%x count=%u size=%lu).\n", callopt, count, size);
	2297	+ /* Request size adjusted after CT preparation */
	2298	+ ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, size);
	2299	+ /* Prepare CT request */
	2300	+ ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RPRT_CMD, size);
	2301	+ ct_rsp = &ha->ct_sns->p.rsp;
	2302	+ /* Prepare FDMI command entries */
	2303	+ memcpy(ct_req->req.rprt.hba_identifier, base_vha->port_name,
	2304	+ sizeof(ct_req->req.rprt.hba_identifier));
	2305	+ size += sizeof(ct_req->req.rprt.hba_identifier);
	2306	+ memcpy(ct_req->req.rprt.port_name, vha->port_name,
	2307	+ sizeof(ct_req->req.rprt.port_name));
	2308	+ size += sizeof(ct_req->req.rprt.port_name);
	2309	+ /* Attribute count */
	2310	+ ct_req->req.rprt.attrs.count = cpu_to_be32(count);
	2311	+ size += sizeof(ct_req->req.rprt.attrs.count);
	2312	+ /* Attribute block */
	2313	+ entries = ct_req->req.rprt.attrs.entry;
	2314	+ size += qla2x00_port_attributes(vha, entries, callopt);
	2315	+ /* Update MS request size. */
	2316	+ qla2x00_update_ms_fdmi_iocb(vha, size + 16);
	2317	+ ql_dbg(ql_dbg_disc, vha, 0x20e9,
	2318	+ "RPRT %016llx %016llx.\n",
	2319	+ wwn_to_u64(ct_req->req.rprt.port_name),
	2320	+ wwn_to_u64(ct_req->req.rprt.port_name));
	2321	+ ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20ea,
	2322	+ entries, size);
	2323	+ /* Execute MS IOCB */
	2324	+ rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
	2325	+ sizeof(*ha->ms_iocb));
	2326	+ if (rval) {
	2327	+ ql_dbg(ql_dbg_disc, vha, 0x20eb,
	2328	+ "RPRT iocb failed (%d).\n", rval);
	2329	+ return rval;
	2330	+ }
	2331	+ rval = qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPRT");
	2332	+ if (rval) {
	2333	+ if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
	2334	+ ct_rsp->header.explanation_code ==
	2335	+ CT_EXPL_ALREADY_REGISTERED) {
	2336	+ ql_dbg(ql_dbg_disc, vha, 0x20ec,
	2337	+ "RPRT already registered.\n");
	2338	+ return QLA_ALREADY_REGISTERED;
	2339	+ }
	2340	+
	2341	+ ql_dbg(ql_dbg_disc, vha, 0x20ed,
	2342	+ "RPRT failed, CT Reason code: %#x, CT Explanation %#x\n",
	2343	+ ct_rsp->header.reason_code,
	2344	+ ct_rsp->header.explanation_code);
	2345	+ return rval;
	2346	+ }
	2347	+ ql_dbg(ql_dbg_disc, vha, 0x20ee, "RPRT exiting normally.\n");
	2348	+ return rval;
	2349	+}
	2350	+
	2351	+/**
	2352	+ * qla2x00_fdmi_rpa() - perform RPA registration
	2353	+ * @vha: HA context
	2354	+ * @callopt: Option to issue FDMI registration
	2355	+ *
	2356	+ * Returns 0 on success.
	2357	+ */
	2358	+static int
	2359	+qla2x00_fdmi_rpa(scsi_qla_host_t *vha, uint callopt)
	2360	+{
	2361	+ struct qla_hw_data *ha = vha->hw;
	2362	+ ulong size = 0;
	2363	+ uint rval, count;
	2364	+ ms_iocb_entry_t *ms_pkt;
	2365	+ struct ct_sns_req *ct_req;
	2366	+ struct ct_sns_rsp *ct_rsp;
	2367	+ void *entries;
	2368	+
	2369	+ count =
	2370	+ callopt == CALLOPT_FDMI2_SMARTSAN && ql2xsmartsan ?
	2371	+ FDMI2_SMARTSAN_PORT_ATTR_COUNT :
	2372	+ callopt != CALLOPT_FDMI1 ?
	2373	+ FDMI2_PORT_ATTR_COUNT : FDMI1_PORT_ATTR_COUNT;
	2374	+
	2375	+ size =
	2376	+ callopt != CALLOPT_FDMI1 ?
	2377	+ SMARTSAN_RPA_RSP_SIZE : RPA_RSP_SIZE;
	2378	+
	2379	+ ql_dbg(ql_dbg_disc, vha, 0x20f0,
	2380	+ "RPA (callopt=%x count=%u size=%lu).\n", callopt, count, size);
	2381	+
	2382	+ /* Request size adjusted after CT preparation */
	2383	+ ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, size);
2333	2384
2334	2385	/* Prepare CT request */
2335		- ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RPA_CMD, RPA_RSP_SIZE);
	2386	+ ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RPA_CMD, size);
2336	2387	ct_rsp = &ha->ct_sns->p.rsp;
2337	2388
2338		- /* Prepare FDMI command arguments -- attribute block, attributes. */
2339		- memcpy(ct_req->req.rpa2.port_name, vha->port_name, WWN_SIZE);
2340		- size = WWN_SIZE + 4;
	2389	+ /* Prepare FDMI command entries. */
	2390	+ memcpy(ct_req->req.rpa.port_name, vha->port_name,
	2391	+ sizeof(ct_req->req.rpa.port_name));
	2392	+ size += sizeof(ct_req->req.rpa.port_name);
2341	2393
2342		- /* Attributes */
2343		- ct_req->req.rpa2.attrs.count = cpu_to_be32(FDMIV2_PORT_ATTR_COUNT);
2344		- entries = ct_req->req.rpa2.port_name;
	2394	+ /* Attribute count */
	2395	+ ct_req->req.rpa.attrs.count = cpu_to_be32(count);
	2396	+ size += sizeof(ct_req->req.rpa.attrs.count);
2345	2397
2346		- /* FC4 types. */
2347		- eiter = entries + size;
2348		- eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPES);
2349		- eiter->len = cpu_to_be16(4 + 32);
2350		- eiter->a.fc4_types[2] = 0x01;
2351		- size += 4 + 32;
	2398	+ /* Attribute block */
	2399	+ entries = ct_req->req.rpa.attrs.entry;
2352	2400
2353		- ql_dbg(ql_dbg_disc, vha, 0x20ba,
2354		- "FC4_TYPES=%02x %02x.\n",
2355		- eiter->a.fc4_types[2],
2356		- eiter->a.fc4_types[1]);
2357		-
2358		- if (vha->flags.nvme_enabled) {
2359		- eiter->a.fc4_types[6] = 1; /* NVMe type 28h */
2360		- ql_dbg(ql_dbg_disc, vha, 0x211f,
2361		- "NVME FC4 Type = %02x 0x0 0x0 0x0 0x0 0x0.\n",
2362		- eiter->a.fc4_types[6]);
2363		- }
2364		-
2365		- /* Supported speed. */
2366		- eiter = entries + size;
2367		- eiter->type = cpu_to_be16(FDMI_PORT_SUPPORT_SPEED);
2368		- eiter->len = cpu_to_be16(4 + 4);
2369		- if (IS_CNA_CAPABLE(ha))
2370		- eiter->a.sup_speed = cpu_to_be32(
2371		- FDMI_PORT_SPEED_10GB);
2372		- else if (IS_QLA27XX(ha))
2373		- eiter->a.sup_speed = cpu_to_be32(
2374		- FDMI_PORT_SPEED_32GB\|
2375		- FDMI_PORT_SPEED_16GB\|
2376		- FDMI_PORT_SPEED_8GB);
2377		- else if (IS_QLA2031(ha))
2378		- eiter->a.sup_speed = cpu_to_be32(
2379		- FDMI_PORT_SPEED_16GB\|
2380		- FDMI_PORT_SPEED_8GB\|
2381		- FDMI_PORT_SPEED_4GB);
2382		- else if (IS_QLA25XX(ha))
2383		- eiter->a.sup_speed = cpu_to_be32(
2384		- FDMI_PORT_SPEED_8GB\|
2385		- FDMI_PORT_SPEED_4GB\|
2386		- FDMI_PORT_SPEED_2GB\|
2387		- FDMI_PORT_SPEED_1GB);
2388		- else if (IS_QLA24XX_TYPE(ha))
2389		- eiter->a.sup_speed = cpu_to_be32(
2390		- FDMI_PORT_SPEED_4GB\|
2391		- FDMI_PORT_SPEED_2GB\|
2392		- FDMI_PORT_SPEED_1GB);
2393		- else if (IS_QLA23XX(ha))
2394		- eiter->a.sup_speed = cpu_to_be32(
2395		- FDMI_PORT_SPEED_2GB\|
2396		- FDMI_PORT_SPEED_1GB);
2397		- else
2398		- eiter->a.sup_speed = cpu_to_be32(
2399		- FDMI_PORT_SPEED_1GB);
2400		- size += 4 + 4;
2401		-
2402		- ql_dbg(ql_dbg_disc, vha, 0x20bb,
2403		- "Supported Port Speed = %x.\n", eiter->a.sup_speed);
2404		-
2405		- /* Current speed. */
2406		- eiter = entries + size;
2407		- eiter->type = cpu_to_be16(FDMI_PORT_CURRENT_SPEED);
2408		- eiter->len = cpu_to_be16(4 + 4);
2409		- switch (ha->link_data_rate) {
2410		- case PORT_SPEED_1GB:
2411		- eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_1GB);
2412		- break;
2413		- case PORT_SPEED_2GB:
2414		- eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_2GB);
2415		- break;
2416		- case PORT_SPEED_4GB:
2417		- eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_4GB);
2418		- break;
2419		- case PORT_SPEED_8GB:
2420		- eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_8GB);
2421		- break;
2422		- case PORT_SPEED_10GB:
2423		- eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_10GB);
2424		- break;
2425		- case PORT_SPEED_16GB:
2426		- eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_16GB);
2427		- break;
2428		- case PORT_SPEED_32GB:
2429		- eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_32GB);
2430		- break;
2431		- default:
2432		- eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_UNKNOWN);
2433		- break;
2434		- }
2435		- size += 4 + 4;
2436		-
2437		- ql_dbg(ql_dbg_disc, vha, 0x2017,
2438		- "Current_Speed = %x.\n", eiter->a.cur_speed);
2439		-
2440		- /* Max frame size. */
2441		- eiter = entries + size;
2442		- eiter->type = cpu_to_be16(FDMI_PORT_MAX_FRAME_SIZE);
2443		- eiter->len = cpu_to_be16(4 + 4);
2444		- eiter->a.max_frame_size = IS_FWI2_CAPABLE(ha) ?
2445		- le16_to_cpu(icb24->frame_payload_size):
2446		- le16_to_cpu(ha->init_cb->frame_payload_size);
2447		- eiter->a.max_frame_size = cpu_to_be32(eiter->a.max_frame_size);
2448		- size += 4 + 4;
2449		-
2450		- ql_dbg(ql_dbg_disc, vha, 0x20bc,
2451		- "Max_Frame_Size = %x.\n", eiter->a.max_frame_size);
2452		-
2453		- /* OS device name. */
2454		- eiter = entries + size;
2455		- eiter->type = cpu_to_be16(FDMI_PORT_OS_DEVICE_NAME);
2456		- alen = strlen(QLA2XXX_DRIVER_NAME);
2457		- snprintf(eiter->a.os_dev_name, sizeof(eiter->a.os_dev_name),
2458		- "%s:host%lu", QLA2XXX_DRIVER_NAME, vha->host_no);
2459		- alen += 4 - (alen & 3);
2460		- eiter->len = cpu_to_be16(4 + alen);
2461		- size += 4 + alen;
2462		-
2463		- ql_dbg(ql_dbg_disc, vha, 0x20be,
2464		- "OS_Device_Name = %s.\n", eiter->a.os_dev_name);
2465		-
2466		- /* Hostname. */
2467		- eiter = entries + size;
2468		- eiter->type = cpu_to_be16(FDMI_PORT_HOST_NAME);
2469		- p_sysid = utsname();
2470		- if (p_sysid) {
2471		- snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
2472		- "%s", p_sysid->nodename);
2473		- } else {
2474		- snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
2475		- "%s", fc_host_system_hostname(vha->host));
2476		- }
2477		- alen = strlen(eiter->a.host_name);
2478		- alen += 4 - (alen & 3);
2479		- eiter->len = cpu_to_be16(4 + alen);
2480		- size += 4 + alen;
2481		-
2482		- ql_dbg(ql_dbg_disc, vha, 0x201a,
2483		- "HostName=%s.\n", eiter->a.host_name);
2484		-
2485		- /* Node Name */
2486		- eiter = entries + size;
2487		- eiter->type = cpu_to_be16(FDMI_PORT_NODE_NAME);
2488		- memcpy(eiter->a.node_name, vha->node_name, WWN_SIZE);
2489		- eiter->len = cpu_to_be16(4 + WWN_SIZE);
2490		- size += 4 + WWN_SIZE;
2491		-
2492		- ql_dbg(ql_dbg_disc, vha, 0x20c0,
2493		- "Node Name = %016llx.\n", wwn_to_u64(eiter->a.node_name));
2494		-
2495		- /* Port Name */
2496		- eiter = entries + size;
2497		- eiter->type = cpu_to_be16(FDMI_PORT_NAME);
2498		- memcpy(eiter->a.port_name, vha->port_name, WWN_SIZE);
2499		- eiter->len = cpu_to_be16(4 + WWN_SIZE);
2500		- size += 4 + WWN_SIZE;
2501		-
2502		- ql_dbg(ql_dbg_disc, vha, 0x20c1,
2503		- "Port Name = %016llx.\n", wwn_to_u64(eiter->a.port_name));
2504		-
2505		- /* Port Symbolic Name */
2506		- eiter = entries + size;
2507		- eiter->type = cpu_to_be16(FDMI_PORT_SYM_NAME);
2508		- qla2x00_get_sym_node_name(vha, eiter->a.port_sym_name,
2509		- sizeof(eiter->a.port_sym_name));
2510		- alen = strlen(eiter->a.port_sym_name);
2511		- alen += 4 - (alen & 3);
2512		- eiter->len = cpu_to_be16(4 + alen);
2513		- size += 4 + alen;
2514		-
2515		- ql_dbg(ql_dbg_disc, vha, 0x20c2,
2516		- "port symbolic name = %s\n", eiter->a.port_sym_name);
2517		-
2518		- /* Port Type */
2519		- eiter = entries + size;
2520		- eiter->type = cpu_to_be16(FDMI_PORT_TYPE);
2521		- eiter->a.port_type = cpu_to_be32(NS_NX_PORT_TYPE);
2522		- eiter->len = cpu_to_be16(4 + 4);
2523		- size += 4 + 4;
2524		-
2525		- ql_dbg(ql_dbg_disc, vha, 0x20c3,
2526		- "Port Type = %x.\n", eiter->a.port_type);
2527		-
2528		- /* Class of Service */
2529		- eiter = entries + size;
2530		- eiter->type = cpu_to_be16(FDMI_PORT_SUPP_COS);
2531		- eiter->a.port_supported_cos = cpu_to_be32(FC_CLASS_3);
2532		- eiter->len = cpu_to_be16(4 + 4);
2533		- size += 4 + 4;
2534		-
2535		- ql_dbg(ql_dbg_disc, vha, 0x20c4,
2536		- "Supported COS = %08x\n", eiter->a.port_supported_cos);
2537		-
2538		- /* Port Fabric Name */
2539		- eiter = entries + size;
2540		- eiter->type = cpu_to_be16(FDMI_PORT_FABRIC_NAME);
2541		- memcpy(eiter->a.fabric_name, vha->fabric_node_name, WWN_SIZE);
2542		- eiter->len = cpu_to_be16(4 + WWN_SIZE);
2543		- size += 4 + WWN_SIZE;
2544		-
2545		- ql_dbg(ql_dbg_disc, vha, 0x20c5,
2546		- "Fabric Name = %016llx.\n", wwn_to_u64(eiter->a.fabric_name));
2547		-
2548		- /* FC4_type */
2549		- eiter = entries + size;
2550		- eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPE);
2551		- eiter->a.port_fc4_type[0] = 0;
2552		- eiter->a.port_fc4_type[1] = 0;
2553		- eiter->a.port_fc4_type[2] = 1;
2554		- eiter->a.port_fc4_type[3] = 0;
2555		- eiter->len = cpu_to_be16(4 + 32);
2556		- size += 4 + 32;
2557		-
2558		- ql_dbg(ql_dbg_disc, vha, 0x20c6,
2559		- "Port Active FC4 Type = %02x %02x.\n",
2560		- eiter->a.port_fc4_type[2], eiter->a.port_fc4_type[1]);
2561		-
2562		- if (vha->flags.nvme_enabled) {
2563		- eiter->a.port_fc4_type[4] = 0;
2564		- eiter->a.port_fc4_type[5] = 0;
2565		- eiter->a.port_fc4_type[6] = 1; /* NVMe type 28h */
2566		- ql_dbg(ql_dbg_disc, vha, 0x2120,
2567		- "NVME Port Active FC4 Type = %02x 0x0 0x0 0x0 0x0 0x0.\n",
2568		- eiter->a.port_fc4_type[6]);
2569		- }
2570		-
2571		- /* Port State */
2572		- eiter = entries + size;
2573		- eiter->type = cpu_to_be16(FDMI_PORT_STATE);
2574		- eiter->a.port_state = cpu_to_be32(1);
2575		- eiter->len = cpu_to_be16(4 + 4);
2576		- size += 4 + 4;
2577		-
2578		- ql_dbg(ql_dbg_disc, vha, 0x20c7,
2579		- "Port State = %x.\n", eiter->a.port_state);
2580		-
2581		- /* Number of Ports */
2582		- eiter = entries + size;
2583		- eiter->type = cpu_to_be16(FDMI_PORT_COUNT);
2584		- eiter->a.num_ports = cpu_to_be32(1);
2585		- eiter->len = cpu_to_be16(4 + 4);
2586		- size += 4 + 4;
2587		-
2588		- ql_dbg(ql_dbg_disc, vha, 0x20c8,
2589		- "Number of ports = %x.\n", eiter->a.num_ports);
2590		-
2591		- /* Port Id */
2592		- eiter = entries + size;
2593		- eiter->type = cpu_to_be16(FDMI_PORT_ID);
2594		- eiter->a.port_id = cpu_to_be32(vha->d_id.b24);
2595		- eiter->len = cpu_to_be16(4 + 4);
2596		- size += 4 + 4;
2597		-
2598		- ql_dbg(ql_dbg_disc, vha, 0x201c,
2599		- "Port Id = %x.\n", eiter->a.port_id);
	2401	+ size += qla2x00_port_attributes(vha, entries, callopt);
2600	2402
2601	2403	/* Update MS request size. */
2602	2404	qla2x00_update_ms_fdmi_iocb(vha, size + 16);
2603	2405
2604		- ql_dbg(ql_dbg_disc, vha, 0x2018,
2605		- "RPA portname= %8phN size=%d.\n", ct_req->req.rpa.port_name, size);
2606		- ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20ca,
	2406	+ ql_dbg(ql_dbg_disc, vha, 0x20f1,
	2407	+ "RPA %016llx.\n", wwn_to_u64(ct_req->req.rpa.port_name));
	2408	+
	2409	+ ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20f2,
2607	2410	entries, size);
2608	2411
2609	2412	/* Execute MS IOCB */
2610	2413	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2611		- sizeof(ms_iocb_entry_t));
2612		- if (rval != QLA_SUCCESS) {
2613		- /EMPTY/
2614		- ql_dbg(ql_dbg_disc, vha, 0x20cb,
2615		- "RPA FDMI v2 issue IOCB failed (%d).\n", rval);
2616		- } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPA") !=
2617		- QLA_SUCCESS) {
2618		- rval = QLA_FUNCTION_FAILED;
	2414	+ sizeof(*ha->ms_iocb));
	2415	+ if (rval) {
	2416	+ ql_dbg(ql_dbg_disc, vha, 0x20f3,
	2417	+ "RPA iocb failed (%d).\n", rval);
	2418	+ return rval;
	2419	+ }
	2420	+
	2421	+ rval = qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPA");
	2422	+ if (rval) {
2619	2423	if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
2620	2424	ct_rsp->header.explanation_code ==
2621	2425	CT_EXPL_ALREADY_REGISTERED) {
2622		- ql_dbg(ql_dbg_disc, vha, 0x20ce,
2623		- "RPA FDMI v2 already registered\n");
2624		- rval = QLA_ALREADY_REGISTERED;
2625		- } else {
2626		- ql_dbg(ql_dbg_disc, vha, 0x2020,
2627		- "RPA FDMI v2 failed, CT Reason code: 0x%x, CT Explanation 0x%x\n",
2628		- ct_rsp->header.reason_code,
2629		- ct_rsp->header.explanation_code);
	2426	+ ql_dbg(ql_dbg_disc, vha, 0x20f4,
	2427	+ "RPA already registered.\n");
	2428	+ return QLA_ALREADY_REGISTERED;
2630	2429	}
2631		- } else {
2632		- ql_dbg(ql_dbg_disc, vha, 0x20cc,
2633		- "RPA FDMI V2 exiting normally.\n");
	2430	+
	2431	+ ql_dbg(ql_dbg_disc, vha, 0x20f5,
	2432	+ "RPA failed, CT Reason code: %#x, CT Explanation %#x\n",
	2433	+ ct_rsp->header.reason_code,
	2434	+ ct_rsp->header.explanation_code);
	2435	+ return rval;
2634	2436	}
2635	2437
	2438	+ ql_dbg(ql_dbg_disc, vha, 0x20f6, "RPA exiting normally.\n");
2636	2439	return rval;
2637	2440	}
2638	2441
..	..	@@ -2645,18 +2448,31 @@
2645	2448	int
2646	2449	qla2x00_fdmi_register(scsi_qla_host_t *vha)
2647	2450	{
2648		- int rval = QLA_FUNCTION_FAILED;
	2451	+ int rval = QLA_SUCCESS;
2649	2452	struct qla_hw_data *ha = vha->hw;
2650	2453
2651	2454	if (IS_QLA2100(ha) \|\| IS_QLA2200(ha) \|\|
2652	2455	IS_QLAFX00(ha))
2653		- return QLA_FUNCTION_FAILED;
	2456	+ return rval;
2654	2457
2655	2458	rval = qla2x00_mgmt_svr_login(vha);
2656	2459	if (rval)
2657	2460	return rval;
2658	2461
2659		- rval = qla2x00_fdmiv2_rhba(vha);
	2462	+ /* For npiv/vport send rprt only */
	2463	+ if (vha->vp_idx) {
	2464	+ if (ql2xsmartsan)
	2465	+ rval = qla2x00_fdmi_rprt(vha, CALLOPT_FDMI2_SMARTSAN);
	2466	+ if (rval \|\| !ql2xsmartsan)
	2467	+ rval = qla2x00_fdmi_rprt(vha, CALLOPT_FDMI2);
	2468	+ if (rval)
	2469	+ rval = qla2x00_fdmi_rprt(vha, CALLOPT_FDMI1);
	2470	+
	2471	+ return rval;
	2472	+ }
	2473	+
	2474	+ /* Try fdmi2 first, if fails then try fdmi1 */
	2475	+ rval = qla2x00_fdmi_rhba(vha, CALLOPT_FDMI2);
2660	2476	if (rval) {
2661	2477	if (rval != QLA_ALREADY_REGISTERED)
2662	2478	goto try_fdmi;
..	..	@@ -2665,18 +2481,22 @@
2665	2481	if (rval)
2666	2482	goto try_fdmi;
2667	2483
2668		- rval = qla2x00_fdmiv2_rhba(vha);
	2484	+ rval = qla2x00_fdmi_rhba(vha, CALLOPT_FDMI2);
2669	2485	if (rval)
2670	2486	goto try_fdmi;
2671	2487	}
2672		- rval = qla2x00_fdmiv2_rpa(vha);
	2488	+
	2489	+ if (ql2xsmartsan)
	2490	+ rval = qla2x00_fdmi_rpa(vha, CALLOPT_FDMI2_SMARTSAN);
	2491	+ if (rval \|\| !ql2xsmartsan)
	2492	+ rval = qla2x00_fdmi_rpa(vha, CALLOPT_FDMI2);
2673	2493	if (rval)
2674	2494	goto try_fdmi;
2675	2495
2676		- goto out;
	2496	+ return rval;
2677	2497
2678	2498	try_fdmi:
2679		- rval = qla2x00_fdmi_rhba(vha);
	2499	+ rval = qla2x00_fdmi_rhba(vha, CALLOPT_FDMI1);
2680	2500	if (rval) {
2681	2501	if (rval != QLA_ALREADY_REGISTERED)
2682	2502	return rval;
..	..	@@ -2685,12 +2505,13 @@
2685	2505	if (rval)
2686	2506	return rval;
2687	2507
2688		- rval = qla2x00_fdmi_rhba(vha);
	2508	+ rval = qla2x00_fdmi_rhba(vha, CALLOPT_FDMI1);
2689	2509	if (rval)
2690	2510	return rval;
2691	2511	}
2692		- rval = qla2x00_fdmi_rpa(vha);
2693		-out:
	2512	+
	2513	+ rval = qla2x00_fdmi_rpa(vha, CALLOPT_FDMI1);
	2514	+
2694	2515	return rval;
2695	2516	}
2696	2517
..	..	@@ -2733,9 +2554,7 @@
2733	2554	ct_rsp = &ha->ct_sns->p.rsp;
2734	2555
2735	2556	/* Prepare CT arguments -- port_id */
2736		- ct_req->req.port_id.port_id[0] = list[i].d_id.b.domain;
2737		- ct_req->req.port_id.port_id[1] = list[i].d_id.b.area;
2738		- ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
	2557	+ ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
2739	2558
2740	2559	/* Execute MS IOCB */
2741	2560	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
..	..	@@ -2777,6 +2596,31 @@
2777	2596	p->p.req.max_rsp_size = cpu_to_be16((rsp_size - 16) / 4);
2778	2597
2779	2598	return &p->p.req;
	2599	+}
	2600	+
	2601	+static uint16_t
	2602	+qla2x00_port_speed_capability(uint16_t speed)
	2603	+{
	2604	+ switch (speed) {
	2605	+ case BIT_15:
	2606	+ return PORT_SPEED_1GB;
	2607	+ case BIT_14:
	2608	+ return PORT_SPEED_2GB;
	2609	+ case BIT_13:
	2610	+ return PORT_SPEED_4GB;
	2611	+ case BIT_12:
	2612	+ return PORT_SPEED_10GB;
	2613	+ case BIT_11:
	2614	+ return PORT_SPEED_8GB;
	2615	+ case BIT_10:
	2616	+ return PORT_SPEED_16GB;
	2617	+ case BIT_8:
	2618	+ return PORT_SPEED_32GB;
	2619	+ case BIT_7:
	2620	+ return PORT_SPEED_64GB;
	2621	+ default:
	2622	+ return PORT_SPEED_UNKNOWN;
	2623	+ }
2780	2624	}
2781	2625
2782	2626	/**
..	..	@@ -2851,31 +2695,8 @@
2851	2695	}
2852	2696	rval = QLA_FUNCTION_FAILED;
2853	2697	} else {
2854		- /* Save port-speed */
2855		- switch (be16_to_cpu(ct_rsp->rsp.gpsc.speed)) {
2856		- case BIT_15:
2857		- list[i].fp_speed = PORT_SPEED_1GB;
2858		- break;
2859		- case BIT_14:
2860		- list[i].fp_speed = PORT_SPEED_2GB;
2861		- break;
2862		- case BIT_13:
2863		- list[i].fp_speed = PORT_SPEED_4GB;
2864		- break;
2865		- case BIT_12:
2866		- list[i].fp_speed = PORT_SPEED_10GB;
2867		- break;
2868		- case BIT_11:
2869		- list[i].fp_speed = PORT_SPEED_8GB;
2870		- break;
2871		- case BIT_10:
2872		- list[i].fp_speed = PORT_SPEED_16GB;
2873		- break;
2874		- case BIT_8:
2875		- list[i].fp_speed = PORT_SPEED_32GB;
2876		- break;
2877		- }
2878		-
	2698	+ list->fp_speed = qla2x00_port_speed_capability(
	2699	+ be16_to_cpu(ct_rsp->rsp.gpsc.speed));
2879	2700	ql_dbg(ql_dbg_disc, vha, 0x205b,
2880	2701	"GPSC ext entry - fpn "
2881	2702	"%8phN speeds=%04x speed=%04x.\n",
..	..	@@ -2909,13 +2730,13 @@
2909	2730	struct ct_sns_req *ct_req;
2910	2731	struct ct_sns_rsp *ct_rsp;
2911	2732	struct qla_hw_data *ha = vha->hw;
2912		- uint8_t fcp_scsi_features = 0;
	2733	+ uint8_t fcp_scsi_features = 0, nvme_features = 0;
2913	2734	struct ct_arg arg;
2914	2735
2915	2736	for (i = 0; i < ha->max_fibre_devices; i++) {
2916	2737	/* Set default FC4 Type as UNKNOWN so the default is to
2917	2738	* Process this port */
2918		- list[i].fc4_type = FC4_TYPE_UNKNOWN;
	2739	+ list[i].fc4_type = 0;
2919	2740
2920	2741	/* Do not attempt GFF_ID if we are not FWI_2 capable */
2921	2742	if (!IS_FWI2_CAPABLE(ha))
..	..	@@ -2937,9 +2758,7 @@
2937	2758	ct_rsp = &ha->ct_sns->p.rsp;
2938	2759
2939	2760	/* Prepare CT arguments -- port_id */
2940		- ct_req->req.port_id.port_id[0] = list[i].d_id.b.domain;
2941		- ct_req->req.port_id.port_id[1] = list[i].d_id.b.area;
2942		- ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
	2761	+ ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
2943	2762
2944	2763	/* Execute MS IOCB */
2945	2764	rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
..	..	@@ -2957,251 +2776,25 @@
2957	2776	ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET];
2958	2777	fcp_scsi_features &= 0x0f;
2959	2778
2960		- if (fcp_scsi_features)
2961		- list[i].fc4_type = FC4_TYPE_FCP_SCSI;
2962		- else
2963		- list[i].fc4_type = FC4_TYPE_OTHER;
	2779	+ if (fcp_scsi_features) {
	2780	+ list[i].fc4_type = FS_FC4TYPE_FCP;
	2781	+ list[i].fc4_features = fcp_scsi_features;
	2782	+ }
2964	2783
2965		- list[i].fc4f_nvme =
	2784	+ nvme_features =
2966	2785	ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET];
2967		- list[i].fc4f_nvme &= 0xf;
	2786	+ nvme_features &= 0xf;
	2787	+
	2788	+ if (nvme_features) {
	2789	+ list[i].fc4_type \|= FS_FC4TYPE_NVME;
	2790	+ list[i].fc4_features = nvme_features;
	2791	+ }
2968	2792	}
2969	2793
2970	2794	/* Last device exit. */
2971	2795	if (list[i].d_id.b.rsvd_1 != 0)
2972	2796	break;
2973	2797	}
2974		-}
2975		-
2976		-/* GID_PN completion processing. */
2977		-void qla24xx_handle_gidpn_event(scsi_qla_host_t vha, struct event_arg ea)
2978		-{
2979		- fc_port_t *fcport = ea->fcport;
2980		-
2981		- ql_dbg(ql_dbg_disc, vha, 0x201d,
2982		- "%s %8phC DS %d LS %d rc %d login %d\|%d rscn %d\|%d lid %d\n",
2983		- __func__, fcport->port_name, fcport->disc_state,
2984		- fcport->fw_login_state, ea->rc, fcport->login_gen, ea->sp->gen2,
2985		- fcport->rscn_gen, ea->sp->gen1, fcport->loop_id);
2986		-
2987		- if (fcport->disc_state == DSC_DELETE_PEND)
2988		- return;
2989		-
2990		- if (ea->sp->gen2 != fcport->login_gen) {
2991		- /* PLOGI/PRLI/LOGO came in while cmd was out.*/
2992		- ql_dbg(ql_dbg_disc, vha, 0x201e,
2993		- "%s %8phC generation changed rscn %d\|%d n",
2994		- __func__, fcport->port_name, fcport->last_rscn_gen,
2995		- fcport->rscn_gen);
2996		- return;
2997		- }
2998		-
2999		- if (!ea->rc) {
3000		- if (ea->sp->gen1 == fcport->rscn_gen) {
3001		- fcport->scan_state = QLA_FCPORT_FOUND;
3002		- fcport->flags \|= FCF_FABRIC_DEVICE;
3003		-
3004		- if (fcport->d_id.b24 == ea->id.b24) {
3005		- /* cable plugged into the same place */
3006		- switch (vha->host->active_mode) {
3007		- case MODE_TARGET:
3008		- if (fcport->fw_login_state ==
3009		- DSC_LS_PRLI_COMP) {
3010		- u16 data[2];
3011		- /*
3012		- * Late RSCN was delivered.
3013		- * Remote port already login'ed.
3014		- */
3015		- ql_dbg(ql_dbg_disc, vha, 0x201f,
3016		- "%s %d %8phC post adisc\n",
3017		- __func__, __LINE__,
3018		- fcport->port_name);
3019		- data[0] = data[1] = 0;
3020		- qla2x00_post_async_adisc_work(
3021		- vha, fcport, data);
3022		- }
3023		- break;
3024		- case MODE_INITIATOR:
3025		- case MODE_DUAL:
3026		- default:
3027		- ql_dbg(ql_dbg_disc, vha, 0x201f,
3028		- "%s %d %8phC post %s\n", __func__,
3029		- __LINE__, fcport->port_name,
3030		- (atomic_read(&fcport->state) ==
3031		- FCS_ONLINE) ? "adisc" : "gnl");
3032		-
3033		- if (atomic_read(&fcport->state) ==
3034		- FCS_ONLINE) {
3035		- u16 data[2];
3036		-
3037		- data[0] = data[1] = 0;
3038		- qla2x00_post_async_adisc_work(
3039		- vha, fcport, data);
3040		- } else {
3041		- qla24xx_post_gnl_work(vha,
3042		- fcport);
3043		- }
3044		- break;
3045		- }
3046		- } else { /* fcport->d_id.b24 != ea->id.b24 */
3047		- fcport->d_id.b24 = ea->id.b24;
3048		- fcport->id_changed = 1;
3049		- if (fcport->deleted != QLA_SESS_DELETED) {
3050		- ql_dbg(ql_dbg_disc, vha, 0x2021,
3051		- "%s %d %8phC post del sess\n",
3052		- __func__, __LINE__, fcport->port_name);
3053		- qlt_schedule_sess_for_deletion(fcport);
3054		- }
3055		- }
3056		- } else { /* ea->sp->gen1 != fcport->rscn_gen */
3057		- ql_dbg(ql_dbg_disc, vha, 0x2022,
3058		- "%s %d %8phC post gidpn\n",
3059		- __func__, __LINE__, fcport->port_name);
3060		- /* rscn came in while cmd was out */
3061		- qla24xx_post_gidpn_work(vha, fcport);
3062		- }
3063		- } else { /* ea->rc */
3064		- /* cable pulled */
3065		- if (ea->sp->gen1 == fcport->rscn_gen) {
3066		- if (ea->sp->gen2 == fcport->login_gen) {
3067		- ql_dbg(ql_dbg_disc, vha, 0x2042,
3068		- "%s %d %8phC post del sess\n", __func__,
3069		- __LINE__, fcport->port_name);
3070		- qlt_schedule_sess_for_deletion(fcport);
3071		- } else {
3072		- ql_dbg(ql_dbg_disc, vha, 0x2045,
3073		- "%s %d %8phC login\n", __func__, __LINE__,
3074		- fcport->port_name);
3075		- qla24xx_fcport_handle_login(vha, fcport);
3076		- }
3077		- } else {
3078		- ql_dbg(ql_dbg_disc, vha, 0x2049,
3079		- "%s %d %8phC post gidpn\n", __func__, __LINE__,
3080		- fcport->port_name);
3081		- qla24xx_post_gidpn_work(vha, fcport);
3082		- }
3083		- }
3084		-} /* gidpn_event */
3085		-
3086		-static void qla2x00_async_gidpn_sp_done(void *s, int res)
3087		-{
3088		- struct srb *sp = s;
3089		- struct scsi_qla_host *vha = sp->vha;
3090		- fc_port_t *fcport = sp->fcport;
3091		- u8 *id = fcport->ct_desc.ct_sns->p.rsp.rsp.gid_pn.port_id;
3092		- struct event_arg ea;
3093		-
3094		- fcport->flags &= ~(FCF_ASYNC_SENT \| FCF_ASYNC_ACTIVE);
3095		-
3096		- memset(&ea, 0, sizeof(ea));
3097		- ea.fcport = fcport;
3098		- ea.id.b.domain = id[0];
3099		- ea.id.b.area = id[1];
3100		- ea.id.b.al_pa = id[2];
3101		- ea.sp = sp;
3102		- ea.rc = res;
3103		- ea.event = FCME_GIDPN_DONE;
3104		-
3105		- if (res == QLA_FUNCTION_TIMEOUT) {
3106		- ql_dbg(ql_dbg_disc, sp->vha, 0xffff,
3107		- "Async done-%s WWPN %8phC timed out.\n",
3108		- sp->name, fcport->port_name);
3109		- qla24xx_post_gidpn_work(sp->vha, fcport);
3110		- sp->free(sp);
3111		- return;
3112		- } else if (res) {
3113		- ql_dbg(ql_dbg_disc, sp->vha, 0xffff,
3114		- "Async done-%s fail res %x, WWPN %8phC\n",
3115		- sp->name, res, fcport->port_name);
3116		- } else {
3117		- ql_dbg(ql_dbg_disc, vha, 0x204f,
3118		- "Async done-%s good WWPN %8phC ID %3phC\n",
3119		- sp->name, fcport->port_name, id);
3120		- }
3121		-
3122		- qla2x00_fcport_event_handler(vha, &ea);
3123		-
3124		- sp->free(sp);
3125		-}
3126		-
3127		-int qla24xx_async_gidpn(scsi_qla_host_t vha, fc_port_t fcport)
3128		-{
3129		- int rval = QLA_FUNCTION_FAILED;
3130		- struct ct_sns_req *ct_req;
3131		- srb_t *sp;
3132		-
3133		- if (!vha->flags.online \|\| (fcport->flags & FCF_ASYNC_SENT))
3134		- return rval;
3135		-
3136		- fcport->disc_state = DSC_GID_PN;
3137		- fcport->scan_state = QLA_FCPORT_SCAN;
3138		- sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
3139		- if (!sp)
3140		- goto done;
3141		-
3142		- fcport->flags \|= FCF_ASYNC_SENT;
3143		- sp->type = SRB_CT_PTHRU_CMD;
3144		- sp->name = "gidpn";
3145		- sp->gen1 = fcport->rscn_gen;
3146		- sp->gen2 = fcport->login_gen;
3147		-
3148		- qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
3149		-
3150		- /* CT_IU preamble */
3151		- ct_req = qla2x00_prep_ct_req(fcport->ct_desc.ct_sns, GID_PN_CMD,
3152		- GID_PN_RSP_SIZE);
3153		-
3154		- /* GIDPN req */
3155		- memcpy(ct_req->req.gid_pn.port_name, fcport->port_name,
3156		- WWN_SIZE);
3157		-
3158		- /* req & rsp use the same buffer */
3159		- sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
3160		- sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
3161		- sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
3162		- sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
3163		- sp->u.iocb_cmd.u.ctarg.req_size = GID_PN_REQ_SIZE;
3164		- sp->u.iocb_cmd.u.ctarg.rsp_size = GID_PN_RSP_SIZE;
3165		- sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3166		-
3167		- sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
3168		- sp->done = qla2x00_async_gidpn_sp_done;
3169		-
3170		- rval = qla2x00_start_sp(sp);
3171		- if (rval != QLA_SUCCESS)
3172		- goto done_free_sp;
3173		-
3174		- ql_dbg(ql_dbg_disc, vha, 0x20a4,
3175		- "Async-%s - %8phC hdl=%x loopid=%x portid %02x%02x%02x.\n",
3176		- sp->name, fcport->port_name,
3177		- sp->handle, fcport->loop_id, fcport->d_id.b.domain,
3178		- fcport->d_id.b.area, fcport->d_id.b.al_pa);
3179		- return rval;
3180		-
3181		-done_free_sp:
3182		- sp->free(sp);
3183		-done:
3184		- fcport->flags &= ~FCF_ASYNC_ACTIVE;
3185		- return rval;
3186		-}
3187		-
3188		-int qla24xx_post_gidpn_work(struct scsi_qla_host vha, fc_port_t fcport)
3189		-{
3190		- struct qla_work_evt *e;
3191		- int ls;
3192		-
3193		- ls = atomic_read(&vha->loop_state);
3194		- if (((ls != LOOP_READY) && (ls != LOOP_UP)) \|\|
3195		- test_bit(UNLOADING, &vha->dpc_flags))
3196		- return 0;
3197		-
3198		- e = qla2x00_alloc_work(vha, QLA_EVT_GIDPN);
3199		- if (!e)
3200		- return QLA_FUNCTION_FAILED;
3201		-
3202		- e->u.fcport.fcport = fcport;
3203		- fcport->flags \|= FCF_ASYNC_ACTIVE;
3204		- return qla2x00_post_work(vha, e);
3205	2798	}
3206	2799
3207	2800	int qla24xx_post_gpsc_work(struct scsi_qla_host vha, fc_port_t fcport)
..	..	@@ -3213,7 +2806,6 @@
3213	2806	return QLA_FUNCTION_FAILED;
3214	2807
3215	2808	e->u.fcport.fcport = fcport;
3216		- fcport->flags \|= FCF_ASYNC_ACTIVE;
3217	2809	return qla2x00_post_work(vha, e);
3218	2810	}
3219	2811
..	..	@@ -3237,18 +2829,14 @@
3237	2829	__func__, fcport->port_name);
3238	2830	return;
3239	2831	} else if (ea->sp->gen1 != fcport->rscn_gen) {
3240		- ql_dbg(ql_dbg_disc, vha, 0x20d4, "%s %d %8phC post gidpn\n",
3241		- __func__, __LINE__, fcport->port_name);
3242		- qla24xx_post_gidpn_work(vha, fcport);
3243	2832	return;
3244	2833	}
3245	2834
3246	2835	qla_post_iidma_work(vha, fcport);
3247	2836	}
3248	2837
3249		-static void qla24xx_async_gpsc_sp_done(void *s, int res)
	2838	+static void qla24xx_async_gpsc_sp_done(srb_t *sp, int res)
3250	2839	{
3251		- struct srb *sp = s;
3252	2840	struct scsi_qla_host *vha = sp->vha;
3253	2841	struct qla_hw_data *ha = vha->hw;
3254	2842	fc_port_t *fcport = sp->fcport;
..	..	@@ -3280,29 +2868,8 @@
3280	2868	goto done;
3281	2869	}
3282	2870	} else {
3283		- switch (be16_to_cpu(ct_rsp->rsp.gpsc.speed)) {
3284		- case BIT_15:
3285		- fcport->fp_speed = PORT_SPEED_1GB;
3286		- break;
3287		- case BIT_14:
3288		- fcport->fp_speed = PORT_SPEED_2GB;
3289		- break;
3290		- case BIT_13:
3291		- fcport->fp_speed = PORT_SPEED_4GB;
3292		- break;
3293		- case BIT_12:
3294		- fcport->fp_speed = PORT_SPEED_10GB;
3295		- break;
3296		- case BIT_11:
3297		- fcport->fp_speed = PORT_SPEED_8GB;
3298		- break;
3299		- case BIT_10:
3300		- fcport->fp_speed = PORT_SPEED_16GB;
3301		- break;
3302		- case BIT_8:
3303		- fcport->fp_speed = PORT_SPEED_32GB;
3304		- break;
3305		- }
	2871	+ fcport->fp_speed = qla2x00_port_speed_capability(
	2872	+ be16_to_cpu(ct_rsp->rsp.gpsc.speed));
3306	2873
3307	2874	ql_dbg(ql_dbg_disc, vha, 0x2054,
3308	2875	"Async-%s OUT WWPN %8phC speeds=%04x speed=%04x.\n",
..	..	@@ -3311,11 +2878,10 @@
3311	2878	be16_to_cpu(ct_rsp->rsp.gpsc.speed));
3312	2879	}
3313	2880	memset(&ea, 0, sizeof(ea));
3314		- ea.event = FCME_GPSC_DONE;
3315	2881	ea.rc = res;
3316	2882	ea.fcport = fcport;
3317	2883	ea.sp = sp;
3318		- qla2x00_fcport_event_handler(vha, &ea);
	2884	+ qla24xx_handle_gpsc_event(vha, &ea);
3319	2885
3320	2886	done:
3321	2887	sp->free(sp);
..	..	@@ -3373,9 +2939,7 @@
3373	2939
3374	2940	done_free_sp:
3375	2941	sp->free(sp);
3376		- fcport->flags &= ~FCF_ASYNC_SENT;
3377	2942	done:
3378		- fcport->flags &= ~FCF_ASYNC_ACTIVE;
3379	2943	return rval;
3380	2944	}
3381	2945
..	..	@@ -3383,7 +2947,8 @@
3383	2947	{
3384	2948	struct qla_work_evt *e;
3385	2949
3386		- if (test_bit(UNLOADING, &vha->dpc_flags))
	2950	+ if (test_bit(UNLOADING, &vha->dpc_flags) \|\|
	2951	+ (vha->vp_idx && test_bit(VPORT_DELETE, &vha->dpc_flags)))
3387	2952	return 0;
3388	2953
3389	2954	e = qla2x00_alloc_work(vha, QLA_EVT_GPNID);
..	..	@@ -3400,17 +2965,7 @@
3400	2965
3401	2966	switch (sp->type) {
3402	2967	case SRB_ELS_DCMD:
3403		- if (c->u.els_plogi.els_plogi_pyld)
3404		- dma_free_coherent(&vha->hw->pdev->dev,
3405		- c->u.els_plogi.tx_size,
3406		- c->u.els_plogi.els_plogi_pyld,
3407		- c->u.els_plogi.els_plogi_pyld_dma);
3408		-
3409		- if (c->u.els_plogi.els_resp_pyld)
3410		- dma_free_coherent(&vha->hw->pdev->dev,
3411		- c->u.els_plogi.rx_size,
3412		- c->u.els_plogi.els_resp_pyld,
3413		- c->u.els_plogi.els_resp_pyld_dma);
	2968	+ qla2x00_els_dcmd2_free(vha, &c->u.els_plogi);
3414	2969	break;
3415	2970	case SRB_CT_PTHRU_CMD:
3416	2971	default:
..	..	@@ -3447,26 +3002,10 @@
3447	3002	if (ea->rc) {
3448	3003	/* cable is disconnected */
3449	3004	list_for_each_entry_safe(fcport, t, &vha->vp_fcports, list) {
3450		- if (fcport->d_id.b24 == ea->id.b24) {
3451		- ql_dbg(ql_dbg_disc, vha, 0xffff,
3452		- "%s %d %8phC DS %d\n",
3453		- __func__, __LINE__,
3454		- fcport->port_name,
3455		- fcport->disc_state);
	3005	+ if (fcport->d_id.b24 == ea->id.b24)
3456	3006	fcport->scan_state = QLA_FCPORT_SCAN;
3457		- switch (fcport->disc_state) {
3458		- case DSC_DELETED:
3459		- case DSC_DELETE_PEND:
3460		- break;
3461		- default:
3462		- ql_dbg(ql_dbg_disc, vha, 0xffff,
3463		- "%s %d %8phC post del sess\n",
3464		- __func__, __LINE__,
3465		- fcport->port_name);
3466		- qlt_schedule_sess_for_deletion(fcport);
3467		- break;
3468		- }
3469		- }
	3007	+
	3008	+ qlt_schedule_sess_for_deletion(fcport);
3470	3009	}
3471	3010	} else {
3472	3011	/* cable is connected */
..	..	@@ -3475,34 +3014,19 @@
3475	3014	list_for_each_entry_safe(conflict, t, &vha->vp_fcports,
3476	3015	list) {
3477	3016	if ((conflict->d_id.b24 == ea->id.b24) &&
3478		- (fcport != conflict)) {
3479		- /* 2 fcports with conflict Nport ID or
	3017	+ (fcport != conflict))
	3018	+ /*
	3019	+ * 2 fcports with conflict Nport ID or
3480	3020	* an existing fcport is having nport ID
3481	3021	* conflict with new fcport.
3482	3022	*/
3483	3023
3484		- ql_dbg(ql_dbg_disc, vha, 0xffff,
3485		- "%s %d %8phC DS %d\n",
3486		- __func__, __LINE__,
3487		- conflict->port_name,
3488		- conflict->disc_state);
3489	3024	conflict->scan_state = QLA_FCPORT_SCAN;
3490		- switch (conflict->disc_state) {
3491		- case DSC_DELETED:
3492		- case DSC_DELETE_PEND:
3493		- break;
3494		- default:
3495		- ql_dbg(ql_dbg_disc, vha, 0xffff,
3496		- "%s %d %8phC post del sess\n",
3497		- __func__, __LINE__,
3498		- conflict->port_name);
3499		- qlt_schedule_sess_for_deletion
3500		- (conflict);
3501		- break;
3502		- }
3503		- }
	3025	+
	3026	+ qlt_schedule_sess_for_deletion(conflict);
3504	3027	}
3505	3028
	3029	+ fcport->scan_needed = 0;
3506	3030	fcport->rscn_gen++;
3507	3031	fcport->scan_state = QLA_FCPORT_FOUND;
3508	3032	fcport->flags \|= FCF_FABRIC_DEVICE;
..	..	@@ -3553,19 +3077,7 @@
3553	3077	conflict->disc_state);
3554	3078
3555	3079	conflict->scan_state = QLA_FCPORT_SCAN;
3556		- switch (conflict->disc_state) {
3557		- case DSC_DELETED:
3558		- case DSC_DELETE_PEND:
3559		- break;
3560		- default:
3561		- ql_dbg(ql_dbg_disc, vha, 0xffff,
3562		- "%s %d %8phC post del sess\n",
3563		- __func__, __LINE__,
3564		- conflict->port_name);
3565		- qlt_schedule_sess_for_deletion
3566		- (conflict);
3567		- break;
3568		- }
	3080	+ qlt_schedule_sess_for_deletion(conflict);
3569	3081	}
3570	3082	}
3571	3083
..	..	@@ -3574,14 +3086,13 @@
3574	3086	"%s %d %8phC post new sess\n",
3575	3087	__func__, __LINE__, ea->port_name);
3576	3088	qla24xx_post_newsess_work(vha, &ea->id,
3577		- ea->port_name, NULL, NULL, FC4_TYPE_UNKNOWN);
	3089	+ ea->port_name, NULL, NULL, 0);
3578	3090	}
3579	3091	}
3580	3092	}
3581	3093
3582		-static void qla2x00_async_gpnid_sp_done(void *s, int res)
	3094	+static void qla2x00_async_gpnid_sp_done(srb_t *sp, int res)
3583	3095	{
3584		- struct srb *sp = s;
3585	3096	struct scsi_qla_host *vha = sp->vha;
3586	3097	struct ct_sns_req *ct_req =
3587	3098	(struct ct_sns_req *)sp->u.iocb_cmd.u.ctarg.req;
..	..	@@ -3594,22 +3105,19 @@
3594	3105	if (res)
3595	3106	ql_dbg(ql_dbg_disc, vha, 0x2066,
3596	3107	"Async done-%s fail res %x rscn gen %d ID %3phC. %8phC\n",
3597		- sp->name, res, sp->gen1, ct_req->req.port_id.port_id,
	3108	+ sp->name, res, sp->gen1, &ct_req->req.port_id.port_id,
3598	3109	ct_rsp->rsp.gpn_id.port_name);
3599	3110	else
3600	3111	ql_dbg(ql_dbg_disc, vha, 0x2066,
3601	3112	"Async done-%s good rscn gen %d ID %3phC. %8phC\n",
3602		- sp->name, sp->gen1, ct_req->req.port_id.port_id,
	3113	+ sp->name, sp->gen1, &ct_req->req.port_id.port_id,
3603	3114	ct_rsp->rsp.gpn_id.port_name);
3604	3115
3605	3116	memset(&ea, 0, sizeof(ea));
3606	3117	memcpy(ea.port_name, ct_rsp->rsp.gpn_id.port_name, WWN_SIZE);
3607	3118	ea.sp = sp;
3608		- ea.id.b.domain = ct_req->req.port_id.port_id[0];
3609		- ea.id.b.area = ct_req->req.port_id.port_id[1];
3610		- ea.id.b.al_pa = ct_req->req.port_id.port_id[2];
	3119	+ ea.id = be_to_port_id(ct_req->req.port_id.port_id);
3611	3120	ea.rc = res;
3612		- ea.event = FCME_GPNID_DONE;
3613	3121
3614	3122	spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
3615	3123	list_del(&sp->elem);
..	..	@@ -3628,25 +3136,22 @@
3628	3136	return;
3629	3137	}
3630	3138
3631		- qla2x00_fcport_event_handler(vha, &ea);
	3139	+ qla24xx_handle_gpnid_event(vha, &ea);
3632	3140
3633	3141	e = qla2x00_alloc_work(vha, QLA_EVT_UNMAP);
3634	3142	if (!e) {
3635	3143	/* please ignore kernel warning. otherwise, we have mem leak. */
3636		- if (sp->u.iocb_cmd.u.ctarg.req) {
3637		- dma_free_coherent(&vha->hw->pdev->dev,
3638		- sp->u.iocb_cmd.u.ctarg.req_allocated_size,
3639		- sp->u.iocb_cmd.u.ctarg.req,
3640		- sp->u.iocb_cmd.u.ctarg.req_dma);
3641		- sp->u.iocb_cmd.u.ctarg.req = NULL;
3642		- }
3643		- if (sp->u.iocb_cmd.u.ctarg.rsp) {
3644		- dma_free_coherent(&vha->hw->pdev->dev,
3645		- sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
3646		- sp->u.iocb_cmd.u.ctarg.rsp,
3647		- sp->u.iocb_cmd.u.ctarg.rsp_dma);
3648		- sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3649		- }
	3144	+ dma_free_coherent(&vha->hw->pdev->dev,
	3145	+ sp->u.iocb_cmd.u.ctarg.req_allocated_size,
	3146	+ sp->u.iocb_cmd.u.ctarg.req,
	3147	+ sp->u.iocb_cmd.u.ctarg.req_dma);
	3148	+ sp->u.iocb_cmd.u.ctarg.req = NULL;
	3149	+
	3150	+ dma_free_coherent(&vha->hw->pdev->dev,
	3151	+ sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
	3152	+ sp->u.iocb_cmd.u.ctarg.rsp,
	3153	+ sp->u.iocb_cmd.u.ctarg.rsp_dma);
	3154	+ sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3650	3155
3651	3156	sp->free(sp);
3652	3157	return;
..	..	@@ -3718,9 +3223,7 @@
3718	3223	ct_req = qla2x00_prep_ct_req(ct_sns, GPN_ID_CMD, GPN_ID_RSP_SIZE);
3719	3224
3720	3225	/* GPN_ID req */
3721		- ct_req->req.port_id.port_id[0] = id->b.domain;
3722		- ct_req->req.port_id.port_id[1] = id->b.area;
3723		- ct_req->req.port_id.port_id[2] = id->b.al_pa;
	3226	+ ct_req->req.port_id.port_id = port_id_to_be_id(*id);
3724	3227
3725	3228	sp->u.iocb_cmd.u.ctarg.req_size = GPN_ID_REQ_SIZE;
3726	3229	sp->u.iocb_cmd.u.ctarg.rsp_size = GPN_ID_RSP_SIZE;
..	..	@@ -3731,7 +3234,7 @@
3731	3234
3732	3235	ql_dbg(ql_dbg_disc, vha, 0x2067,
3733	3236	"Async-%s hdl=%x ID %3phC.\n", sp->name,
3734		- sp->handle, ct_req->req.port_id.port_id);
	3237	+ sp->handle, &ct_req->req.port_id.port_id);
3735	3238
3736	3239	rval = qla2x00_start_sp(sp);
3737	3240	if (rval != QLA_SUCCESS)
..	..	@@ -3766,54 +3269,55 @@
3766	3269
3767	3270	void qla24xx_handle_gffid_event(scsi_qla_host_t vha, struct event_arg ea)
3768	3271	{
3769		- fc_port_t *fcport = ea->fcport;
	3272	+ fc_port_t *fcport = ea->fcport;
3770	3273
3771		- qla24xx_post_gnl_work(vha, fcport);
	3274	+ qla24xx_post_gnl_work(vha, fcport);
3772	3275	}
3773	3276
3774		-void qla24xx_async_gffid_sp_done(void *s, int res)
	3277	+void qla24xx_async_gffid_sp_done(srb_t *sp, int res)
3775	3278	{
3776		- struct srb *sp = s;
3777		- struct scsi_qla_host *vha = sp->vha;
3778		- fc_port_t *fcport = sp->fcport;
3779		- struct ct_sns_rsp *ct_rsp;
3780		- struct event_arg ea;
	3279	+ struct scsi_qla_host *vha = sp->vha;
	3280	+ fc_port_t *fcport = sp->fcport;
	3281	+ struct ct_sns_rsp *ct_rsp;
	3282	+ struct event_arg ea;
	3283	+ uint8_t fc4_scsi_feat;
	3284	+ uint8_t fc4_nvme_feat;
3781	3285
3782		- ql_dbg(ql_dbg_disc, vha, 0x2133,
3783		- "Async done-%s res %x ID %x. %8phC\n",
3784		- sp->name, res, fcport->d_id.b24, fcport->port_name);
	3286	+ ql_dbg(ql_dbg_disc, vha, 0x2133,
	3287	+ "Async done-%s res %x ID %x. %8phC\n",
	3288	+ sp->name, res, fcport->d_id.b24, fcport->port_name);
3785	3289
3786		- fcport->flags &= ~FCF_ASYNC_SENT;
3787		- ct_rsp = &fcport->ct_desc.ct_sns->p.rsp;
3788		- /*
3789		- * FC-GS-7, 5.2.3.12 FC-4 Features - format
3790		- * The format of the FC-4 Features object, as defined by the FC-4,
3791		- * Shall be an array of 4-bit values, one for each type code value
3792		- */
3793		- if (!res) {
3794		- if (ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET] & 0xf) {
3795		- /* w1 b00:03 */
3796		- fcport->fc4_type =
3797		- ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET];
3798		- fcport->fc4_type &= 0xf;
3799		- }
	3290	+ fcport->flags &= ~FCF_ASYNC_SENT;
	3291	+ ct_rsp = &fcport->ct_desc.ct_sns->p.rsp;
	3292	+ fc4_scsi_feat = ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET];
	3293	+ fc4_nvme_feat = ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET];
3800	3294
3801		- if (ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET] & 0xf) {
3802		- /* w5 [00:03]/28h */
3803		- fcport->fc4f_nvme =
3804		- ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET];
3805		- fcport->fc4f_nvme &= 0xf;
3806		- }
3807		- }
	3295	+ /*
	3296	+ * FC-GS-7, 5.2.3.12 FC-4 Features - format
	3297	+ * The format of the FC-4 Features object, as defined by the FC-4,
	3298	+ * Shall be an array of 4-bit values, one for each type code value
	3299	+ */
	3300	+ if (!res) {
	3301	+ if (fc4_scsi_feat & 0xf) {
	3302	+ /* w1 b00:03 */
	3303	+ fcport->fc4_type = FS_FC4TYPE_FCP;
	3304	+ fcport->fc4_features = fc4_scsi_feat & 0xf;
	3305	+ }
3808	3306
3809		- memset(&ea, 0, sizeof(ea));
3810		- ea.sp = sp;
3811		- ea.fcport = sp->fcport;
3812		- ea.rc = res;
3813		- ea.event = FCME_GFFID_DONE;
	3307	+ if (fc4_nvme_feat & 0xf) {
	3308	+ /* w5 [00:03]/28h */
	3309	+ fcport->fc4_type \|= FS_FC4TYPE_NVME;
	3310	+ fcport->fc4_features = fc4_nvme_feat & 0xf;
	3311	+ }
	3312	+ }
3814	3313
3815		- qla2x00_fcport_event_handler(vha, &ea);
3816		- sp->free(sp);
	3314	+ memset(&ea, 0, sizeof(ea));
	3315	+ ea.sp = sp;
	3316	+ ea.fcport = sp->fcport;
	3317	+ ea.rc = res;
	3318	+
	3319	+ qla24xx_handle_gffid_event(vha, &ea);
	3320	+ sp->free(sp);
3817	3321	}
3818	3322
3819	3323	/* Get FC4 Feature with Nport ID. */
..	..	@@ -3857,13 +3361,13 @@
3857	3361
3858	3362	sp->done = qla24xx_async_gffid_sp_done;
3859	3363
3860		- rval = qla2x00_start_sp(sp);
3861		- if (rval != QLA_SUCCESS)
3862		- goto done_free_sp;
3863		-
3864	3364	ql_dbg(ql_dbg_disc, vha, 0x2132,
3865	3365	"Async-%s hdl=%x %8phC.\n", sp->name,
3866	3366	sp->handle, fcport->port_name);
	3367	+
	3368	+ rval = qla2x00_start_sp(sp);
	3369	+ if (rval != QLA_SUCCESS)
	3370	+ goto done_free_sp;
3867	3371
3868	3372	return rval;
3869	3373	done_free_sp:
..	..	@@ -3907,7 +3411,7 @@
3907	3411	u8 recheck = 0;
3908	3412	u16 dup = 0, dup_cnt = 0;
3909	3413
3910		- ql_dbg(ql_dbg_disc, vha, 0xffff,
	3414	+ ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0xffff,
3911	3415	"%s enter\n", __func__);
3912	3416
3913	3417	if (sp->gen1 != vha->hw->base_qpair->chip_reset) {
..	..	@@ -3923,11 +3427,22 @@
3923	3427	if (vha->scan.scan_retry < MAX_SCAN_RETRIES) {
3924	3428	set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3925	3429	set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
	3430	+ goto out;
3926	3431	} else {
3927	3432	ql_dbg(ql_dbg_disc, vha, 0xffff,
3928		- "Fabric scan failed on all retries.\n");
	3433	+ "%s: Fabric scan failed for %d retries.\n",
	3434	+ __func__, vha->scan.scan_retry);
	3435	+ /*
	3436	+ * Unable to scan any rports. logout loop below
	3437	+ * will unregister all sessions.
	3438	+ */
	3439	+ list_for_each_entry(fcport, &vha->vp_fcports, list) {
	3440	+ if ((fcport->flags & FCF_FABRIC_DEVICE) != 0) {
	3441	+ fcport->scan_state = QLA_FCPORT_SCAN;
	3442	+ }
	3443	+ }
	3444	+ goto login_logout;
3929	3445	}
3930		- goto out;
3931	3446	}
3932	3447	vha->scan.scan_retry = 0;
3933	3448
..	..	@@ -3973,8 +3488,8 @@
3973	3488	list_for_each_entry(fcport, &vha->vp_fcports, list) {
3974	3489	if (memcmp(rp->port_name, fcport->port_name, WWN_SIZE))
3975	3490	continue;
3976		- fcport->scan_needed = 0;
3977	3491	fcport->scan_state = QLA_FCPORT_FOUND;
	3492	+ fcport->last_rscn_gen = fcport->rscn_gen;
3978	3493	found = true;
3979	3494	/*
3980	3495	* If device was not a fabric device before.
..	..	@@ -3982,10 +3497,14 @@
3982	3497	if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
3983	3498	qla2x00_clear_loop_id(fcport);
3984	3499	fcport->flags \|= FCF_FABRIC_DEVICE;
3985		- } else if (fcport->d_id.b24 != rp->id.b24) {
	3500	+ } else if (fcport->d_id.b24 != rp->id.b24 \|\|
	3501	+ (fcport->scan_needed &&
	3502	+ fcport->port_type != FCT_INITIATOR &&
	3503	+ fcport->port_type != FCT_NVME_INITIATOR)) {
3986	3504	qlt_schedule_sess_for_deletion(fcport);
3987	3505	}
3988	3506	fcport->d_id.b24 = rp->id.b24;
	3507	+ fcport->scan_needed = 0;
3989	3508	break;
3990	3509	}
3991	3510
..	..	@@ -4004,6 +3523,7 @@
4004	3523	dup_cnt);
4005	3524	}
4006	3525
	3526	+login_logout:
4007	3527	/*
4008	3528	* Logout all previous fabric dev marked lost, except FCP2 devices.
4009	3529	*/
..	..	@@ -4014,13 +3534,25 @@
4014	3534	}
4015	3535
4016	3536	if (fcport->scan_state != QLA_FCPORT_FOUND) {
	3537	+ bool do_delete = false;
	3538	+
	3539	+ if (fcport->scan_needed &&
	3540	+ fcport->disc_state == DSC_LOGIN_PEND) {
	3541	+ /* Cable got disconnected after we sent
	3542	+ * a login. Do delete to prevent timeout.
	3543	+ */
	3544	+ fcport->logout_on_delete = 1;
	3545	+ do_delete = true;
	3546	+ }
	3547	+
4017	3548	fcport->scan_needed = 0;
4018		- if ((qla_dual_mode_enabled(vha) \|\|
4019		- qla_ini_mode_enabled(vha)) &&
4020		- atomic_read(&fcport->state) == FCS_ONLINE) {
	3549	+ if (((qla_dual_mode_enabled(vha) \|\|
	3550	+ qla_ini_mode_enabled(vha)) &&
	3551	+ atomic_read(&fcport->state) == FCS_ONLINE) \|\|
	3552	+ do_delete) {
4021	3553	if (fcport->loop_id != FC_NO_LOOP_ID) {
4022	3554	if (fcport->flags & FCF_FCP2_DEVICE)
4023		- fcport->logout_on_delete = 0;
	3555	+ continue;
4024	3556
4025	3557	ql_dbg(ql_dbg_disc, vha, 0x20f0,
4026	3558	"%s %d %8phC post del sess\n",
..	..	@@ -4083,7 +3615,7 @@
4083	3615	return qla2x00_post_work(vha, e);
4084	3616	}
4085	3617
4086		-static int qla2x00_post_nvme_gpnft_done_work(struct scsi_qla_host *vha,
	3618	+static int qla2x00_post_nvme_gpnft_work(struct scsi_qla_host *vha,
4087	3619	srb_t *sp, int cmd)
4088	3620	{
4089	3621	struct qla_work_evt *e;
..	..	@@ -4197,9 +3729,8 @@
4197	3729	}
4198	3730	}
4199	3731
4200		-static void qla2x00_async_gpnft_gnnft_sp_done(void *s, int res)
	3732	+static void qla2x00_async_gpnft_gnnft_sp_done(srb_t *sp, int res)
4201	3733	{
4202		- struct srb *sp = s;
4203	3734	struct scsi_qla_host *vha = sp->vha;
4204	3735	struct ct_sns_req *ct_req =
4205	3736	(struct ct_sns_req *)sp->u.iocb_cmd.u.ctarg.req;
..	..	@@ -4213,10 +3744,23 @@
4213	3744	"Async done-%s res %x FC4Type %x\n",
4214	3745	sp->name, res, sp->gen2);
4215	3746
	3747	+ del_timer(&sp->u.iocb_cmd.timer);
4216	3748	sp->rc = res;
4217	3749	if (res) {
4218	3750	unsigned long flags;
4219	3751	const char *name = sp->name;
	3752	+
	3753	+ if (res == QLA_OS_TIMER_EXPIRED) {
	3754	+ /* switch is ignoring all commands.
	3755	+ * This might be a zone disable behavior.
	3756	+ * This means we hit 64s timeout.
	3757	+ * 22s GPNFT + 44s Abort = 64s
	3758	+ */
	3759	+ ql_dbg(ql_dbg_disc, vha, 0xffff,
	3760	+ "%s: Switch Zone check please .\n",
	3761	+ name);
	3762	+ qla2x00_mark_all_devices_lost(vha);
	3763	+ }
4220	3764
4221	3765	/*
4222	3766	* We are in an Interrupt context, queue up this
..	..	@@ -4228,49 +3772,44 @@
4228	3772	if (rc) {
4229	3773	/* Cleanup here to prevent memory leak */
4230	3774	qla24xx_sp_unmap(vha, sp);
4231		- sp->free(sp);
4232		- }
4233	3775
4234		- spin_lock_irqsave(&vha->work_lock, flags);
4235		- vha->scan.scan_flags &= ~SF_SCANNING;
4236		- vha->scan.scan_retry++;
4237		- spin_unlock_irqrestore(&vha->work_lock, flags);
	3776	+ spin_lock_irqsave(&vha->work_lock, flags);
	3777	+ vha->scan.scan_flags &= ~SF_SCANNING;
	3778	+ vha->scan.scan_retry++;
	3779	+ spin_unlock_irqrestore(&vha->work_lock, flags);
4238	3780
4239		- if (vha->scan.scan_retry < MAX_SCAN_RETRIES) {
4240		- set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
4241		- set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
4242		- qla2xxx_wake_dpc(vha);
4243		- } else {
4244		- ql_dbg(ql_dbg_disc, vha, 0xffff,
4245		- "Async done-%s rescan failed on all retries.\n",
4246		- name);
	3781	+ if (vha->scan.scan_retry < MAX_SCAN_RETRIES) {
	3782	+ set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
	3783	+ set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
	3784	+ qla2xxx_wake_dpc(vha);
	3785	+ } else {
	3786	+ ql_dbg(ql_dbg_disc, vha, 0xffff,
	3787	+ "Async done-%s rescan failed on all retries.\n",
	3788	+ name);
	3789	+ }
4247	3790	}
4248	3791	return;
4249	3792	}
4250	3793
4251		- if (!res)
4252		- qla2x00_find_free_fcp_nvme_slot(vha, sp);
	3794	+ qla2x00_find_free_fcp_nvme_slot(vha, sp);
4253	3795
4254	3796	if ((fc4_type == FC4_TYPE_FCP_SCSI) && vha->flags.nvme_enabled &&
4255	3797	cmd == GNN_FT_CMD) {
4256		- del_timer(&sp->u.iocb_cmd.timer);
4257	3798	spin_lock_irqsave(&vha->work_lock, flags);
4258	3799	vha->scan.scan_flags &= ~SF_SCANNING;
4259	3800	spin_unlock_irqrestore(&vha->work_lock, flags);
4260	3801
4261	3802	sp->rc = res;
4262		- rc = qla2x00_post_nvme_gpnft_done_work(vha, sp, QLA_EVT_GPNFT);
	3803	+ rc = qla2x00_post_nvme_gpnft_work(vha, sp, QLA_EVT_GPNFT);
4263	3804	if (rc) {
4264	3805	qla24xx_sp_unmap(vha, sp);
4265	3806	set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
4266	3807	set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
4267		- return;
4268	3808	}
4269	3809	return;
4270	3810	}
4271	3811
4272	3812	if (cmd == GPN_FT_CMD) {
4273		- del_timer(&sp->u.iocb_cmd.timer);
4274	3813	rc = qla2x00_post_gnnft_gpnft_done_work(vha, sp,
4275	3814	QLA_EVT_GPNFT_DONE);
4276	3815	} else {
..	..	@@ -4322,7 +3861,7 @@
4322	3861	}
4323	3862
4324	3863	ql_dbg(ql_dbg_disc, vha, 0xfffff,
4325		- "%s: FC4Type %x, CT-PASSTRHU %s command ctarg rsp size %d, ctarg req size %d\n",
	3864	+ "%s: FC4Type %x, CT-PASSTHRU %s command ctarg rsp size %d, ctarg req size %d\n",
4326	3865	__func__, fc4_type, sp->name, sp->u.iocb_cmd.u.ctarg.rsp_size,
4327	3866	sp->u.iocb_cmd.u.ctarg.req_size);
4328	3867
..	..	@@ -4350,17 +3889,15 @@
4350	3889
4351	3890	sp->done = qla2x00_async_gpnft_gnnft_sp_done;
4352	3891
4353		- rval = qla2x00_start_sp(sp);
4354		- if (rval != QLA_SUCCESS) {
4355		- spin_lock_irqsave(&vha->work_lock, flags);
4356		- vha->scan.scan_flags &= ~SF_SCANNING;
4357		- spin_unlock_irqrestore(&vha->work_lock, flags);
4358		- goto done_free_sp;
4359		- }
4360		-
4361	3892	ql_dbg(ql_dbg_disc, vha, 0xffff,
4362	3893	"Async-%s hdl=%x FC4Type %x.\n", sp->name,
4363	3894	sp->handle, ct_req->req.gpn_ft.port_type);
	3895	+
	3896	+ rval = qla2x00_start_sp(sp);
	3897	+ if (rval != QLA_SUCCESS) {
	3898	+ goto done_free_sp;
	3899	+ }
	3900	+
4364	3901	return rval;
4365	3902
4366	3903	done_free_sp:
..	..	@@ -4381,12 +3918,23 @@
4381	3918
4382	3919	sp->free(sp);
4383	3920
	3921	+ spin_lock_irqsave(&vha->work_lock, flags);
	3922	+ vha->scan.scan_flags &= ~SF_SCANNING;
	3923	+ if (vha->scan.scan_flags == 0) {
	3924	+ ql_dbg(ql_dbg_disc, vha, 0xffff,
	3925	+ "%s: schedule\n", __func__);
	3926	+ vha->scan.scan_flags \|= SF_QUEUED;
	3927	+ schedule_delayed_work(&vha->scan.scan_work, 5);
	3928	+ }
	3929	+ spin_unlock_irqrestore(&vha->work_lock, flags);
	3930	+
	3931	+
4384	3932	return rval;
4385	3933	} /* GNNFT */
4386	3934
4387	3935	void qla24xx_async_gpnft_done(scsi_qla_host_t vha, srb_t sp)
4388	3936	{
4389		- ql_dbg(ql_dbg_disc, vha, 0xffff,
	3937	+ ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0xffff,
4390	3938	"%s enter\n", __func__);
4391	3939	qla24xx_async_gnnft(vha, sp, sp->gen2);
4392	3940	}
..	..	@@ -4400,7 +3948,7 @@
4400	3948	u32 rspsz;
4401	3949	unsigned long flags;
4402	3950
4403		- ql_dbg(ql_dbg_disc, vha, 0xffff,
	3951	+ ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0xffff,
4404	3952	"%s enter\n", __func__);
4405	3953
4406	3954	if (!vha->flags.online)
..	..	@@ -4409,14 +3957,15 @@
4409	3957	spin_lock_irqsave(&vha->work_lock, flags);
4410	3958	if (vha->scan.scan_flags & SF_SCANNING) {
4411	3959	spin_unlock_irqrestore(&vha->work_lock, flags);
4412		- ql_dbg(ql_dbg_disc, vha, 0xffff, "scan active\n");
	3960	+ ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0xffff,
	3961	+ "%s: scan active\n", __func__);
4413	3962	return rval;
4414	3963	}
4415	3964	vha->scan.scan_flags \|= SF_SCANNING;
4416	3965	spin_unlock_irqrestore(&vha->work_lock, flags);
4417	3966
4418	3967	if (fc4_type == FC4_TYPE_FCP_SCSI) {
4419		- ql_dbg(ql_dbg_disc, vha, 0xffff,
	3968	+ ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0xffff,
4420	3969	"%s: Performing FCP Scan\n", __func__);
4421	3970
4422	3971	if (sp)
..	..	@@ -4430,9 +3979,10 @@
4430	3979	return rval;
4431	3980	}
4432	3981
4433		- sp->u.iocb_cmd.u.ctarg.req = dma_zalloc_coherent(
4434		- &vha->hw->pdev->dev, sizeof(struct ct_sns_pkt),
4435		- &sp->u.iocb_cmd.u.ctarg.req_dma, GFP_KERNEL);
	3982	+ sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
	3983	+ sizeof(struct ct_sns_pkt),
	3984	+ &sp->u.iocb_cmd.u.ctarg.req_dma,
	3985	+ GFP_KERNEL);
4436	3986	sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
4437	3987	if (!sp->u.iocb_cmd.u.ctarg.req) {
4438	3988	ql_log(ql_log_warn, vha, 0xffff,
..	..	@@ -4440,7 +3990,8 @@
4440	3990	spin_lock_irqsave(&vha->work_lock, flags);
4441	3991	vha->scan.scan_flags &= ~SF_SCANNING;
4442	3992	spin_unlock_irqrestore(&vha->work_lock, flags);
4443		- goto done_free_sp;
	3993	+ qla2x00_rel_sp(sp);
	3994	+ return rval;
4444	3995	}
4445	3996	sp->u.iocb_cmd.u.ctarg.req_size = GPN_FT_REQ_SIZE;
4446	3997
..	..	@@ -4448,21 +3999,28 @@
4448	3999	((vha->hw->max_fibre_devices - 1) *
4449	4000	sizeof(struct ct_sns_gpn_ft_data));
4450	4001
4451		- sp->u.iocb_cmd.u.ctarg.rsp = dma_zalloc_coherent(
4452		- &vha->hw->pdev->dev, rspsz,
4453		- &sp->u.iocb_cmd.u.ctarg.rsp_dma, GFP_KERNEL);
4454		- sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
	4002	+ sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
	4003	+ rspsz,
	4004	+ &sp->u.iocb_cmd.u.ctarg.rsp_dma,
	4005	+ GFP_KERNEL);
	4006	+ sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = rspsz;
4455	4007	if (!sp->u.iocb_cmd.u.ctarg.rsp) {
4456	4008	ql_log(ql_log_warn, vha, 0xffff,
4457	4009	"Failed to allocate ct_sns request.\n");
4458	4010	spin_lock_irqsave(&vha->work_lock, flags);
4459	4011	vha->scan.scan_flags &= ~SF_SCANNING;
4460	4012	spin_unlock_irqrestore(&vha->work_lock, flags);
4461		- goto done_free_sp;
	4013	+ dma_free_coherent(&vha->hw->pdev->dev,
	4014	+ sp->u.iocb_cmd.u.ctarg.req_allocated_size,
	4015	+ sp->u.iocb_cmd.u.ctarg.req,
	4016	+ sp->u.iocb_cmd.u.ctarg.req_dma);
	4017	+ sp->u.iocb_cmd.u.ctarg.req = NULL;
	4018	+ qla2x00_rel_sp(sp);
	4019	+ return rval;
4462	4020	}
4463	4021	sp->u.iocb_cmd.u.ctarg.rsp_size = rspsz;
4464	4022
4465		- ql_dbg(ql_dbg_disc, vha, 0xffff,
	4023	+ ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0xffff,
4466	4024	"%s scan list size %d\n", __func__, vha->scan.size);
4467	4025
4468	4026	memset(vha->scan.l, 0, vha->scan.size);
..	..	@@ -4495,17 +4053,15 @@
4495	4053
4496	4054	sp->done = qla2x00_async_gpnft_gnnft_sp_done;
4497	4055
4498		- rval = qla2x00_start_sp(sp);
4499		- if (rval != QLA_SUCCESS) {
4500		- spin_lock_irqsave(&vha->work_lock, flags);
4501		- vha->scan.scan_flags &= ~SF_SCANNING;
4502		- spin_unlock_irqrestore(&vha->work_lock, flags);
4503		- goto done_free_sp;
4504		- }
4505		-
4506	4056	ql_dbg(ql_dbg_disc, vha, 0xffff,
4507	4057	"Async-%s hdl=%x FC4Type %x.\n", sp->name,
4508	4058	sp->handle, ct_req->req.gpn_ft.port_type);
	4059	+
	4060	+ rval = qla2x00_start_sp(sp);
	4061	+ if (rval != QLA_SUCCESS) {
	4062	+ goto done_free_sp;
	4063	+ }
	4064	+
4509	4065	return rval;
4510	4066
4511	4067	done_free_sp:
..	..	@@ -4525,6 +4081,17 @@
4525	4081	}
4526	4082
4527	4083	sp->free(sp);
	4084	+
	4085	+ spin_lock_irqsave(&vha->work_lock, flags);
	4086	+ vha->scan.scan_flags &= ~SF_SCANNING;
	4087	+ if (vha->scan.scan_flags == 0) {
	4088	+ ql_dbg(ql_dbg_disc + ql_dbg_verbose, vha, 0xffff,
	4089	+ "%s: Scan scheduled.\n", __func__);
	4090	+ vha->scan.scan_flags \|= SF_QUEUED;
	4091	+ schedule_delayed_work(&vha->scan.scan_work, 5);
	4092	+ }
	4093	+ spin_unlock_irqrestore(&vha->work_lock, flags);
	4094	+
4528	4095
4529	4096	return rval;
4530	4097	}
..	..	@@ -4553,9 +4120,8 @@
4553	4120	qla24xx_post_gnl_work(vha, ea->fcport);
4554	4121	}
4555	4122
4556		-static void qla2x00_async_gnnid_sp_done(void *s, int res)
	4123	+static void qla2x00_async_gnnid_sp_done(srb_t *sp, int res)
4557	4124	{
4558		- struct srb *sp = s;
4559	4125	struct scsi_qla_host *vha = sp->vha;
4560	4126	fc_port_t *fcport = sp->fcport;
4561	4127	u8 *node_name = fcport->ct_desc.ct_sns->p.rsp.rsp.gnn_id.node_name;
..	..	@@ -4571,13 +4137,12 @@
4571	4137	ea.fcport = fcport;
4572	4138	ea.sp = sp;
4573	4139	ea.rc = res;
4574		- ea.event = FCME_GNNID_DONE;
4575	4140
4576	4141	ql_dbg(ql_dbg_disc, vha, 0x204f,
4577	4142	"Async done-%s res %x, WWPN %8phC %8phC\n",
4578	4143	sp->name, res, fcport->port_name, fcport->node_name);
4579	4144
4580		- qla2x00_fcport_event_handler(vha, &ea);
	4145	+ qla24xx_handle_gnnid_event(vha, &ea);
4581	4146
4582	4147	sp->free(sp);
4583	4148	}
..	..	@@ -4591,7 +4156,7 @@
4591	4156	if (!vha->flags.online \|\| (fcport->flags & FCF_ASYNC_SENT))
4592	4157	return rval;
4593	4158
4594		- fcport->disc_state = DSC_GNN_ID;
	4159	+ qla2x00_set_fcport_disc_state(fcport, DSC_GNN_ID);
4595	4160	sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
4596	4161	if (!sp)
4597	4162	goto done;
..	..	@@ -4610,9 +4175,7 @@
4610	4175	GNN_ID_RSP_SIZE);
4611	4176
4612	4177	/* GNN_ID req */
4613		- ct_req->req.port_id.port_id[0] = fcport->d_id.b.domain;
4614		- ct_req->req.port_id.port_id[1] = fcport->d_id.b.area;
4615		- ct_req->req.port_id.port_id[2] = fcport->d_id.b.al_pa;
	4178	+ ct_req->req.port_id.port_id = port_id_to_be_id(fcport->d_id);
4616	4179
4617	4180
4618	4181	/* req & rsp use the same buffer */
..	..	@@ -4626,13 +4189,14 @@
4626	4189
4627	4190	sp->done = qla2x00_async_gnnid_sp_done;
4628	4191
4629		- rval = qla2x00_start_sp(sp);
4630		- if (rval != QLA_SUCCESS)
4631		- goto done_free_sp;
4632	4192	ql_dbg(ql_dbg_disc, vha, 0xffff,
4633	4193	"Async-%s - %8phC hdl=%x loopid=%x portid %06x.\n",
4634	4194	sp->name, fcport->port_name,
4635	4195	sp->handle, fcport->loop_id, fcport->d_id.b24);
	4196	+
	4197	+ rval = qla2x00_start_sp(sp);
	4198	+ if (rval != QLA_SUCCESS)
	4199	+ goto done_free_sp;
4636	4200	return rval;
4637	4201
4638	4202	done_free_sp:
..	..	@@ -4681,18 +4245,14 @@
4681	4245	__func__, fcport->port_name);
4682	4246	return;
4683	4247	} else if (ea->sp->gen1 != fcport->rscn_gen) {
4684		- ql_dbg(ql_dbg_disc, vha, 0x20d4, "%s %d %8phC post gidpn\n",
4685		- __func__, __LINE__, fcport->port_name);
4686		- qla24xx_post_gidpn_work(vha, fcport);
4687	4248	return;
4688	4249	}
4689	4250
4690	4251	qla24xx_post_gpsc_work(vha, fcport);
4691	4252	}
4692	4253
4693		-static void qla2x00_async_gfpnid_sp_done(void *s, int res)
	4254	+static void qla2x00_async_gfpnid_sp_done(srb_t *sp, int res)
4694	4255	{
4695		- struct srb *sp = s;
4696	4256	struct scsi_qla_host *vha = sp->vha;
4697	4257	fc_port_t *fcport = sp->fcport;
4698	4258	u8 *fpn = fcport->ct_desc.ct_sns->p.rsp.rsp.gfpn_id.port_name;
..	..	@@ -4707,13 +4267,12 @@
4707	4267	ea.fcport = fcport;
4708	4268	ea.sp = sp;
4709	4269	ea.rc = res;
4710		- ea.event = FCME_GFPNID_DONE;
4711	4270
4712	4271	ql_dbg(ql_dbg_disc, vha, 0x204f,
4713	4272	"Async done-%s res %x, WWPN %8phC %8phC\n",
4714	4273	sp->name, res, fcport->port_name, fcport->fabric_port_name);
4715	4274
4716		- qla2x00_fcport_event_handler(vha, &ea);
	4275	+ qla24xx_handle_gfpnid_event(vha, &ea);
4717	4276
4718	4277	sp->free(sp);
4719	4278	}
..	..	@@ -4744,9 +4303,7 @@
4744	4303	GFPN_ID_RSP_SIZE);
4745	4304
4746	4305	/* GFPN_ID req */
4747		- ct_req->req.port_id.port_id[0] = fcport->d_id.b.domain;
4748		- ct_req->req.port_id.port_id[1] = fcport->d_id.b.area;
4749		- ct_req->req.port_id.port_id[2] = fcport->d_id.b.al_pa;
	4306	+ ct_req->req.port_id.port_id = port_id_to_be_id(fcport->d_id);
4750	4307
4751	4308
4752	4309	/* req & rsp use the same buffer */
..	..	@@ -4760,19 +4317,19 @@
4760	4317
4761	4318	sp->done = qla2x00_async_gfpnid_sp_done;
4762	4319
4763		- rval = qla2x00_start_sp(sp);
4764		- if (rval != QLA_SUCCESS)
4765		- goto done_free_sp;
4766		-
4767	4320	ql_dbg(ql_dbg_disc, vha, 0xffff,
4768	4321	"Async-%s - %8phC hdl=%x loopid=%x portid %06x.\n",
4769	4322	sp->name, fcport->port_name,
4770	4323	sp->handle, fcport->loop_id, fcport->d_id.b24);
	4324	+
	4325	+ rval = qla2x00_start_sp(sp);
	4326	+ if (rval != QLA_SUCCESS)
	4327	+ goto done_free_sp;
	4328	+
4771	4329	return rval;
4772	4330
4773	4331	done_free_sp:
4774	4332	sp->free(sp);
4775		- fcport->flags &= ~FCF_ASYNC_SENT;
4776	4333	done:
4777	4334	return rval;
4778	4335	}