xref: /openbmc/linux/drivers/scsi/lpfc/lpfc_ct.c (revision f762326b)
1 /*******************************************************************
2  * This file is part of the Emulex Linux Device Driver for         *
3  * Fibre Channel Host Bus Adapters.                                *
4  * Copyright (C) 2017-2023 Broadcom. All Rights Reserved. The term *
5  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.     *
6  * Copyright (C) 2004-2016 Emulex.  All rights reserved.           *
7  * EMULEX and SLI are trademarks of Emulex.                        *
8  * www.broadcom.com                                                *
9  *                                                                 *
10  * This program is free software; you can redistribute it and/or   *
11  * modify it under the terms of version 2 of the GNU General       *
12  * Public License as published by the Free Software Foundation.    *
13  * This program is distributed in the hope that it will be useful. *
14  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
15  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
16  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
17  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
18  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
19  * more details, a copy of which can be found in the file COPYING  *
20  * included with this package.                                     *
21  *******************************************************************/
22 
23 /*
24  * Fibre Channel SCSI LAN Device Driver CT support: FC Generic Services FC-GS
25  */
26 
27 #include <linux/blkdev.h>
28 #include <linux/pci.h>
29 #include <linux/interrupt.h>
30 #include <linux/slab.h>
31 #include <linux/utsname.h>
32 
33 #include <scsi/scsi.h>
34 #include <scsi/scsi_device.h>
35 #include <scsi/scsi_host.h>
36 #include <scsi/scsi_transport_fc.h>
37 #include <scsi/fc/fc_fs.h>
38 
39 #include "lpfc_hw4.h"
40 #include "lpfc_hw.h"
41 #include "lpfc_sli.h"
42 #include "lpfc_sli4.h"
43 #include "lpfc_nl.h"
44 #include "lpfc_disc.h"
45 #include "lpfc.h"
46 #include "lpfc_scsi.h"
47 #include "lpfc_logmsg.h"
48 #include "lpfc_crtn.h"
49 #include "lpfc_version.h"
50 #include "lpfc_vport.h"
51 #include "lpfc_debugfs.h"
52 
53 /* FDMI Port Speed definitions - FC-GS-7 */
54 #define HBA_PORTSPEED_1GFC		0x00000001	/* 1G FC */
55 #define HBA_PORTSPEED_2GFC		0x00000002	/* 2G FC */
56 #define HBA_PORTSPEED_4GFC		0x00000008	/* 4G FC */
57 #define HBA_PORTSPEED_10GFC		0x00000004	/* 10G FC */
58 #define HBA_PORTSPEED_8GFC		0x00000010	/* 8G FC */
59 #define HBA_PORTSPEED_16GFC		0x00000020	/* 16G FC */
60 #define HBA_PORTSPEED_32GFC		0x00000040	/* 32G FC */
61 #define HBA_PORTSPEED_20GFC		0x00000080	/* 20G FC */
62 #define HBA_PORTSPEED_40GFC		0x00000100	/* 40G FC */
63 #define HBA_PORTSPEED_128GFC		0x00000200	/* 128G FC */
64 #define HBA_PORTSPEED_64GFC		0x00000400	/* 64G FC */
65 #define HBA_PORTSPEED_256GFC		0x00000800	/* 256G FC */
66 #define HBA_PORTSPEED_UNKNOWN		0x00008000	/* Unknown */
67 #define HBA_PORTSPEED_10GE		0x00010000	/* 10G E */
68 #define HBA_PORTSPEED_40GE		0x00020000	/* 40G E */
69 #define HBA_PORTSPEED_100GE		0x00040000	/* 100G E */
70 #define HBA_PORTSPEED_25GE		0x00080000	/* 25G E */
71 #define HBA_PORTSPEED_50GE		0x00100000	/* 50G E */
72 #define HBA_PORTSPEED_400GE		0x00200000	/* 400G E */
73 
74 #define FOURBYTES	4
75 
76 
77 static char *lpfc_release_version = LPFC_DRIVER_VERSION;
78 static void
79 lpfc_cmpl_ct_cmd_vmid(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
80 		      struct lpfc_iocbq *rspiocb);
81 
82 static void
83 lpfc_ct_ignore_hbq_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
84 			  struct lpfc_dmabuf *mp, uint32_t size)
85 {
86 	if (!mp) {
87 		lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
88 				"0146 Ignoring unsolicited CT No HBQ "
89 				"status = x%x\n",
90 				get_job_ulpstatus(phba, piocbq));
91 	}
92 	lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
93 			"0145 Ignoring unsolicited CT HBQ Size:%d "
94 			"status = x%x\n",
95 			size, get_job_ulpstatus(phba, piocbq));
96 }
97 
98 static void
99 lpfc_ct_unsol_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
100 		     struct lpfc_dmabuf *mp, uint32_t size)
101 {
102 	lpfc_ct_ignore_hbq_buffer(phba, piocbq, mp, size);
103 }
104 
105 /**
106  * lpfc_ct_unsol_cmpl : Completion callback function for unsol ct commands
107  * @phba : pointer to lpfc hba data structure.
108  * @cmdiocb : pointer to lpfc command iocb data structure.
109  * @rspiocb : pointer to lpfc response iocb data structure.
110  *
111  * This routine is the callback function for issuing unsol ct reject command.
112  * The memory allocated in the reject command path is freed up here.
113  **/
114 static void
115 lpfc_ct_unsol_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
116 		   struct lpfc_iocbq *rspiocb)
117 {
118 	struct lpfc_nodelist *ndlp;
119 	struct lpfc_dmabuf *mp, *bmp;
120 
121 	ndlp = cmdiocb->ndlp;
122 	if (ndlp)
123 		lpfc_nlp_put(ndlp);
124 
125 	mp = cmdiocb->rsp_dmabuf;
126 	bmp = cmdiocb->bpl_dmabuf;
127 	if (mp) {
128 		lpfc_mbuf_free(phba, mp->virt, mp->phys);
129 		kfree(mp);
130 		cmdiocb->rsp_dmabuf = NULL;
131 	}
132 
133 	if (bmp) {
134 		lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
135 		kfree(bmp);
136 		cmdiocb->bpl_dmabuf = NULL;
137 	}
138 
139 	lpfc_sli_release_iocbq(phba, cmdiocb);
140 }
141 
142 /**
143  * lpfc_ct_reject_event - Issue reject for unhandled CT MIB commands
144  * @ndlp: pointer to a node-list data structure.
145  * @ct_req: pointer to the CT request data structure.
146  * @ulp_context: context of received UNSOL CT command
147  * @ox_id: ox_id of the UNSOL CT command
148  *
149  * This routine is invoked by the lpfc_ct_handle_mibreq routine for sending
150  * a reject response. Reject response is sent for the unhandled commands.
151  **/
152 static void
153 lpfc_ct_reject_event(struct lpfc_nodelist *ndlp,
154 		     struct lpfc_sli_ct_request *ct_req,
155 		     u16 ulp_context, u16 ox_id)
156 {
157 	struct lpfc_vport *vport = ndlp->vport;
158 	struct lpfc_hba *phba = vport->phba;
159 	struct lpfc_sli_ct_request *ct_rsp;
160 	struct lpfc_iocbq *cmdiocbq = NULL;
161 	struct lpfc_dmabuf *bmp = NULL;
162 	struct lpfc_dmabuf *mp = NULL;
163 	struct ulp_bde64 *bpl;
164 	u8 rc = 0;
165 	u32 tmo;
166 
167 	/* fill in BDEs for command */
168 	mp = kmalloc(sizeof(*mp), GFP_KERNEL);
169 	if (!mp) {
170 		rc = 1;
171 		goto ct_exit;
172 	}
173 
174 	mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp->phys);
175 	if (!mp->virt) {
176 		rc = 2;
177 		goto ct_free_mp;
178 	}
179 
180 	/* Allocate buffer for Buffer ptr list */
181 	bmp = kmalloc(sizeof(*bmp), GFP_KERNEL);
182 	if (!bmp) {
183 		rc = 3;
184 		goto ct_free_mpvirt;
185 	}
186 
187 	bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &bmp->phys);
188 	if (!bmp->virt) {
189 		rc = 4;
190 		goto ct_free_bmp;
191 	}
192 
193 	INIT_LIST_HEAD(&mp->list);
194 	INIT_LIST_HEAD(&bmp->list);
195 
196 	bpl = (struct ulp_bde64 *)bmp->virt;
197 	memset(bpl, 0, sizeof(struct ulp_bde64));
198 	bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys));
199 	bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys));
200 	bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
201 	bpl->tus.f.bdeSize = (LPFC_CT_PREAMBLE - 4);
202 	bpl->tus.w = le32_to_cpu(bpl->tus.w);
203 
204 	ct_rsp = (struct lpfc_sli_ct_request *)mp->virt;
205 	memset(ct_rsp, 0, sizeof(struct lpfc_sli_ct_request));
206 
207 	ct_rsp->RevisionId.bits.Revision = SLI_CT_REVISION;
208 	ct_rsp->RevisionId.bits.InId = 0;
209 	ct_rsp->FsType = ct_req->FsType;
210 	ct_rsp->FsSubType = ct_req->FsSubType;
211 	ct_rsp->CommandResponse.bits.Size = 0;
212 	ct_rsp->CommandResponse.bits.CmdRsp =
213 		cpu_to_be16(SLI_CT_RESPONSE_FS_RJT);
214 	ct_rsp->ReasonCode = SLI_CT_REQ_NOT_SUPPORTED;
215 	ct_rsp->Explanation = SLI_CT_NO_ADDITIONAL_EXPL;
216 
217 	cmdiocbq = lpfc_sli_get_iocbq(phba);
218 	if (!cmdiocbq) {
219 		rc = 5;
220 		goto ct_free_bmpvirt;
221 	}
222 
223 	if (phba->sli_rev == LPFC_SLI_REV4) {
224 		lpfc_sli_prep_xmit_seq64(phba, cmdiocbq, bmp,
225 					 phba->sli4_hba.rpi_ids[ndlp->nlp_rpi],
226 					 ox_id, 1, FC_RCTL_DD_SOL_CTL, 1,
227 					 CMD_XMIT_SEQUENCE64_WQE);
228 	} else {
229 		lpfc_sli_prep_xmit_seq64(phba, cmdiocbq, bmp, 0, ulp_context, 1,
230 					 FC_RCTL_DD_SOL_CTL, 1,
231 					 CMD_XMIT_SEQUENCE64_CX);
232 	}
233 
234 	/* Save for completion so we can release these resources */
235 	cmdiocbq->rsp_dmabuf = mp;
236 	cmdiocbq->bpl_dmabuf = bmp;
237 	cmdiocbq->cmd_cmpl = lpfc_ct_unsol_cmpl;
238 	tmo = (3 * phba->fc_ratov);
239 
240 	cmdiocbq->retry = 0;
241 	cmdiocbq->vport = vport;
242 	cmdiocbq->drvrTimeout = tmo + LPFC_DRVR_TIMEOUT;
243 
244 	cmdiocbq->ndlp = lpfc_nlp_get(ndlp);
245 	if (!cmdiocbq->ndlp)
246 		goto ct_no_ndlp;
247 
248 	rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
249 	if (rc) {
250 		lpfc_nlp_put(ndlp);
251 		goto ct_no_ndlp;
252 	}
253 	return;
254 
255 ct_no_ndlp:
256 	rc = 6;
257 	lpfc_sli_release_iocbq(phba, cmdiocbq);
258 ct_free_bmpvirt:
259 	lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
260 ct_free_bmp:
261 	kfree(bmp);
262 ct_free_mpvirt:
263 	lpfc_mbuf_free(phba, mp->virt, mp->phys);
264 ct_free_mp:
265 	kfree(mp);
266 ct_exit:
267 	lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
268 			 "6440 Unsol CT: Rsp err %d Data: x%x\n",
269 			 rc, vport->fc_flag);
270 }
271 
272 /**
273  * lpfc_ct_handle_mibreq - Process an unsolicited CT MIB request data buffer
274  * @phba: pointer to lpfc hba data structure.
275  * @ctiocbq: pointer to lpfc CT command iocb data structure.
276  *
277  * This routine is used for processing the IOCB associated with a unsolicited
278  * CT MIB request. It first determines whether there is an existing ndlp that
279  * matches the DID from the unsolicited IOCB. If not, it will return.
280  **/
281 static void
282 lpfc_ct_handle_mibreq(struct lpfc_hba *phba, struct lpfc_iocbq *ctiocbq)
283 {
284 	struct lpfc_sli_ct_request *ct_req;
285 	struct lpfc_nodelist *ndlp = NULL;
286 	struct lpfc_vport *vport = ctiocbq->vport;
287 	u32 ulp_status = get_job_ulpstatus(phba, ctiocbq);
288 	u32 ulp_word4 = get_job_word4(phba, ctiocbq);
289 	u32 did;
290 	u16 mi_cmd;
291 
292 	did = bf_get(els_rsp64_sid, &ctiocbq->wqe.xmit_els_rsp);
293 	if (ulp_status) {
294 		lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
295 				 "6438 Unsol CT: status:x%x/x%x did : x%x\n",
296 				 ulp_status, ulp_word4, did);
297 		return;
298 	}
299 
300 	/* Ignore traffic received during vport shutdown */
301 	if (vport->fc_flag & FC_UNLOADING)
302 		return;
303 
304 	ndlp = lpfc_findnode_did(vport, did);
305 	if (!ndlp) {
306 		lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
307 				 "6439 Unsol CT: NDLP Not Found for DID : x%x",
308 				 did);
309 		return;
310 	}
311 
312 	ct_req = (struct lpfc_sli_ct_request *)ctiocbq->cmd_dmabuf->virt;
313 
314 	mi_cmd = be16_to_cpu(ct_req->CommandResponse.bits.CmdRsp);
315 	lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
316 			 "6442 : MI Cmd : x%x Not Supported\n", mi_cmd);
317 	lpfc_ct_reject_event(ndlp, ct_req,
318 			     bf_get(wqe_ctxt_tag,
319 				    &ctiocbq->wqe.xmit_els_rsp.wqe_com),
320 			     bf_get(wqe_rcvoxid,
321 				    &ctiocbq->wqe.xmit_els_rsp.wqe_com));
322 }
323 
324 /**
325  * lpfc_ct_unsol_event - Process an unsolicited event from a ct sli ring
326  * @phba: pointer to lpfc hba data structure.
327  * @pring: pointer to a SLI ring.
328  * @ctiocbq: pointer to lpfc ct iocb data structure.
329  *
330  * This routine is used to process an unsolicited event received from a SLI
331  * (Service Level Interface) ring. The actual processing of the data buffer
332  * associated with the unsolicited event is done by invoking appropriate routine
333  * after properly set up the iocb buffer from the SLI ring on which the
334  * unsolicited event was received.
335  **/
336 void
337 lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
338 		    struct lpfc_iocbq *ctiocbq)
339 {
340 	struct lpfc_dmabuf *mp = NULL;
341 	IOCB_t *icmd = &ctiocbq->iocb;
342 	int i;
343 	struct lpfc_iocbq *iocbq;
344 	struct lpfc_iocbq *iocb;
345 	dma_addr_t dma_addr;
346 	uint32_t size;
347 	struct list_head head;
348 	struct lpfc_sli_ct_request *ct_req;
349 	struct lpfc_dmabuf *bdeBuf1 = ctiocbq->cmd_dmabuf;
350 	struct lpfc_dmabuf *bdeBuf2 = ctiocbq->bpl_dmabuf;
351 	u32 status, parameter, bde_count = 0;
352 	struct lpfc_wcqe_complete *wcqe_cmpl = NULL;
353 
354 	ctiocbq->cmd_dmabuf = NULL;
355 	ctiocbq->rsp_dmabuf = NULL;
356 	ctiocbq->bpl_dmabuf = NULL;
357 
358 	wcqe_cmpl = &ctiocbq->wcqe_cmpl;
359 	status = get_job_ulpstatus(phba, ctiocbq);
360 	parameter = get_job_word4(phba, ctiocbq);
361 	if (phba->sli_rev == LPFC_SLI_REV4)
362 		bde_count = wcqe_cmpl->word3;
363 	else
364 		bde_count = icmd->ulpBdeCount;
365 
366 	if (unlikely(status == IOSTAT_NEED_BUFFER)) {
367 		lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
368 	} else if ((status == IOSTAT_LOCAL_REJECT) &&
369 		   ((parameter & IOERR_PARAM_MASK) ==
370 		   IOERR_RCV_BUFFER_WAITING)) {
371 		/* Not enough posted buffers; Try posting more buffers */
372 		phba->fc_stat.NoRcvBuf++;
373 		if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
374 			lpfc_sli3_post_buffer(phba, pring, 2);
375 		return;
376 	}
377 
378 	/* If there are no BDEs associated
379 	 * with this IOCB, there is nothing to do.
380 	 */
381 	if (bde_count == 0)
382 		return;
383 
384 	ctiocbq->cmd_dmabuf = bdeBuf1;
385 	if (bde_count == 2)
386 		ctiocbq->bpl_dmabuf = bdeBuf2;
387 
388 	ct_req = (struct lpfc_sli_ct_request *)ctiocbq->cmd_dmabuf->virt;
389 
390 	if (ct_req->FsType == SLI_CT_MANAGEMENT_SERVICE &&
391 	    ct_req->FsSubType == SLI_CT_MIB_Subtypes) {
392 		lpfc_ct_handle_mibreq(phba, ctiocbq);
393 	} else {
394 		if (!lpfc_bsg_ct_unsol_event(phba, pring, ctiocbq))
395 			return;
396 	}
397 
398 	if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
399 		INIT_LIST_HEAD(&head);
400 		list_add_tail(&head, &ctiocbq->list);
401 		list_for_each_entry(iocb, &head, list) {
402 			if (phba->sli_rev == LPFC_SLI_REV4)
403 				bde_count = iocb->wcqe_cmpl.word3;
404 			else
405 				bde_count = iocb->iocb.ulpBdeCount;
406 
407 			if (!bde_count)
408 				continue;
409 			bdeBuf1 = iocb->cmd_dmabuf;
410 			iocb->cmd_dmabuf = NULL;
411 			if (phba->sli_rev == LPFC_SLI_REV4)
412 				size = iocb->wqe.gen_req.bde.tus.f.bdeSize;
413 			else
414 				size  = iocb->iocb.un.cont64[0].tus.f.bdeSize;
415 			lpfc_ct_unsol_buffer(phba, ctiocbq, bdeBuf1, size);
416 			lpfc_in_buf_free(phba, bdeBuf1);
417 			if (bde_count == 2) {
418 				bdeBuf2 = iocb->bpl_dmabuf;
419 				iocb->bpl_dmabuf = NULL;
420 				if (phba->sli_rev == LPFC_SLI_REV4)
421 					size = iocb->unsol_rcv_len;
422 				else
423 					size = iocb->iocb.unsli3.rcvsli3.bde2.tus.f.bdeSize;
424 				lpfc_ct_unsol_buffer(phba, ctiocbq, bdeBuf2,
425 						     size);
426 				lpfc_in_buf_free(phba, bdeBuf2);
427 			}
428 		}
429 		list_del(&head);
430 	} else {
431 		INIT_LIST_HEAD(&head);
432 		list_add_tail(&head, &ctiocbq->list);
433 		list_for_each_entry(iocbq, &head, list) {
434 			icmd = &iocbq->iocb;
435 			if (icmd->ulpBdeCount == 0)
436 				lpfc_ct_unsol_buffer(phba, iocbq, NULL, 0);
437 			for (i = 0; i < icmd->ulpBdeCount; i++) {
438 				dma_addr = getPaddr(icmd->un.cont64[i].addrHigh,
439 						    icmd->un.cont64[i].addrLow);
440 				mp = lpfc_sli_ringpostbuf_get(phba, pring,
441 							      dma_addr);
442 				size = icmd->un.cont64[i].tus.f.bdeSize;
443 				lpfc_ct_unsol_buffer(phba, iocbq, mp, size);
444 				lpfc_in_buf_free(phba, mp);
445 			}
446 			lpfc_sli3_post_buffer(phba, pring, i);
447 		}
448 		list_del(&head);
449 	}
450 }
451 
452 /**
453  * lpfc_ct_handle_unsol_abort - ct upper level protocol abort handler
454  * @phba: Pointer to HBA context object.
455  * @dmabuf: pointer to a dmabuf that describes the FC sequence
456  *
457  * This function serves as the upper level protocol abort handler for CT
458  * protocol.
459  *
460  * Return 1 if abort has been handled, 0 otherwise.
461  **/
462 int
463 lpfc_ct_handle_unsol_abort(struct lpfc_hba *phba, struct hbq_dmabuf *dmabuf)
464 {
465 	int handled;
466 
467 	/* CT upper level goes through BSG */
468 	handled = lpfc_bsg_ct_unsol_abort(phba, dmabuf);
469 
470 	return handled;
471 }
472 
473 static void
474 lpfc_free_ct_rsp(struct lpfc_hba *phba, struct lpfc_dmabuf *mlist)
475 {
476 	struct lpfc_dmabuf *mlast, *next_mlast;
477 
478 	list_for_each_entry_safe(mlast, next_mlast, &mlist->list, list) {
479 		list_del(&mlast->list);
480 		lpfc_mbuf_free(phba, mlast->virt, mlast->phys);
481 		kfree(mlast);
482 	}
483 	lpfc_mbuf_free(phba, mlist->virt, mlist->phys);
484 	kfree(mlist);
485 	return;
486 }
487 
488 static struct lpfc_dmabuf *
489 lpfc_alloc_ct_rsp(struct lpfc_hba *phba, __be16 cmdcode, struct ulp_bde64 *bpl,
490 		  uint32_t size, int *entries)
491 {
492 	struct lpfc_dmabuf *mlist = NULL;
493 	struct lpfc_dmabuf *mp;
494 	int cnt, i = 0;
495 
496 	/* We get chunks of FCELSSIZE */
497 	cnt = size > FCELSSIZE ? FCELSSIZE: size;
498 
499 	while (size) {
500 		/* Allocate buffer for rsp payload */
501 		mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
502 		if (!mp) {
503 			if (mlist)
504 				lpfc_free_ct_rsp(phba, mlist);
505 			return NULL;
506 		}
507 
508 		INIT_LIST_HEAD(&mp->list);
509 
510 		if (be16_to_cpu(cmdcode) == SLI_CTNS_GID_FT ||
511 		    be16_to_cpu(cmdcode) == SLI_CTNS_GFF_ID)
512 			mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
513 		else
514 			mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys));
515 
516 		if (!mp->virt) {
517 			kfree(mp);
518 			if (mlist)
519 				lpfc_free_ct_rsp(phba, mlist);
520 			return NULL;
521 		}
522 
523 		/* Queue it to a linked list */
524 		if (!mlist)
525 			mlist = mp;
526 		else
527 			list_add_tail(&mp->list, &mlist->list);
528 
529 		bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
530 		/* build buffer ptr list for IOCB */
531 		bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
532 		bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
533 		bpl->tus.f.bdeSize = (uint16_t) cnt;
534 		bpl->tus.w = le32_to_cpu(bpl->tus.w);
535 		bpl++;
536 
537 		i++;
538 		size -= cnt;
539 	}
540 
541 	*entries = i;
542 	return mlist;
543 }
544 
545 int
546 lpfc_ct_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *ctiocb)
547 {
548 	struct lpfc_dmabuf *buf_ptr;
549 
550 	/* IOCBQ job structure gets cleaned during release.  Just release
551 	 * the dma buffers here.
552 	 */
553 	if (ctiocb->cmd_dmabuf) {
554 		buf_ptr = ctiocb->cmd_dmabuf;
555 		lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
556 		kfree(buf_ptr);
557 		ctiocb->cmd_dmabuf = NULL;
558 	}
559 	if (ctiocb->rsp_dmabuf) {
560 		lpfc_free_ct_rsp(phba, ctiocb->rsp_dmabuf);
561 		ctiocb->rsp_dmabuf = NULL;
562 	}
563 
564 	if (ctiocb->bpl_dmabuf) {
565 		buf_ptr = ctiocb->bpl_dmabuf;
566 		lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
567 		kfree(buf_ptr);
568 		ctiocb->bpl_dmabuf = NULL;
569 	}
570 	lpfc_sli_release_iocbq(phba, ctiocb);
571 	return 0;
572 }
573 
574 /*
575  * lpfc_gen_req - Build and issue a GEN_REQUEST command  to the SLI Layer
576  * @vport: pointer to a host virtual N_Port data structure.
577  * @bmp: Pointer to BPL for SLI command
578  * @inp: Pointer to data buffer for response data.
579  * @outp: Pointer to data buffer that hold the CT command.
580  * @cmpl: completion routine to call when command completes
581  * @ndlp: Destination NPort nodelist entry
582  *
583  * This function as the final part for issuing a CT command.
584  */
585 static int
586 lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp,
587 	     struct lpfc_dmabuf *inp, struct lpfc_dmabuf *outp,
588 	     void (*cmpl)(struct lpfc_hba *, struct lpfc_iocbq *,
589 			  struct lpfc_iocbq *),
590 	     struct lpfc_nodelist *ndlp, uint32_t event_tag, uint32_t num_entry,
591 	     uint32_t tmo, uint8_t retry)
592 {
593 	struct lpfc_hba  *phba = vport->phba;
594 	struct lpfc_iocbq *geniocb;
595 	int rc;
596 	u16 ulp_context;
597 
598 	/* Allocate buffer for  command iocb */
599 	geniocb = lpfc_sli_get_iocbq(phba);
600 
601 	if (geniocb == NULL)
602 		return 1;
603 
604 	/* Update the num_entry bde count */
605 	geniocb->num_bdes = num_entry;
606 
607 	geniocb->bpl_dmabuf = bmp;
608 
609 	/* Save for completion so we can release these resources */
610 	geniocb->cmd_dmabuf = inp;
611 	geniocb->rsp_dmabuf = outp;
612 
613 	geniocb->event_tag = event_tag;
614 
615 	if (!tmo) {
616 		 /* FC spec states we need 3 * ratov for CT requests */
617 		tmo = (3 * phba->fc_ratov);
618 	}
619 
620 	if (phba->sli_rev == LPFC_SLI_REV4)
621 		ulp_context = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
622 	else
623 		ulp_context = ndlp->nlp_rpi;
624 
625 	lpfc_sli_prep_gen_req(phba, geniocb, bmp, ulp_context, num_entry, tmo);
626 
627 	/* Issue GEN REQ IOCB for NPORT <did> */
628 	lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
629 			 "0119 Issue GEN REQ IOCB to NPORT x%x "
630 			 "Data: x%x x%x\n",
631 			 ndlp->nlp_DID, geniocb->iotag,
632 			 vport->port_state);
633 	geniocb->cmd_cmpl = cmpl;
634 	geniocb->drvrTimeout = tmo + LPFC_DRVR_TIMEOUT;
635 	geniocb->vport = vport;
636 	geniocb->retry = retry;
637 	geniocb->ndlp = lpfc_nlp_get(ndlp);
638 	if (!geniocb->ndlp)
639 		goto out;
640 
641 	rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, geniocb, 0);
642 	if (rc == IOCB_ERROR) {
643 		lpfc_nlp_put(ndlp);
644 		goto out;
645 	}
646 
647 	return 0;
648 out:
649 	lpfc_sli_release_iocbq(phba, geniocb);
650 	return 1;
651 }
652 
653 /*
654  * lpfc_ct_cmd - Build and issue a CT command
655  * @vport: pointer to a host virtual N_Port data structure.
656  * @inmp: Pointer to data buffer for response data.
657  * @bmp: Pointer to BPL for SLI command
658  * @ndlp: Destination NPort nodelist entry
659  * @cmpl: completion routine to call when command completes
660  *
661  * This function is called for issuing a CT command.
662  */
663 static int
664 lpfc_ct_cmd(struct lpfc_vport *vport, struct lpfc_dmabuf *inmp,
665 	    struct lpfc_dmabuf *bmp, struct lpfc_nodelist *ndlp,
666 	    void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
667 			  struct lpfc_iocbq *),
668 	    uint32_t rsp_size, uint8_t retry)
669 {
670 	struct lpfc_hba  *phba = vport->phba;
671 	struct ulp_bde64 *bpl = (struct ulp_bde64 *) bmp->virt;
672 	struct lpfc_dmabuf *outmp;
673 	int cnt = 0, status;
674 	__be16 cmdcode = ((struct lpfc_sli_ct_request *)inmp->virt)->
675 		CommandResponse.bits.CmdRsp;
676 
677 	bpl++;			/* Skip past ct request */
678 
679 	/* Put buffer(s) for ct rsp in bpl */
680 	outmp = lpfc_alloc_ct_rsp(phba, cmdcode, bpl, rsp_size, &cnt);
681 	if (!outmp)
682 		return -ENOMEM;
683 	/*
684 	 * Form the CT IOCB.  The total number of BDEs in this IOCB
685 	 * is the single command plus response count from
686 	 * lpfc_alloc_ct_rsp.
687 	 */
688 	cnt += 1;
689 	status = lpfc_gen_req(vport, bmp, inmp, outmp, cmpl, ndlp,
690 			phba->fc_eventTag, cnt, 0, retry);
691 	if (status) {
692 		lpfc_free_ct_rsp(phba, outmp);
693 		return -ENOMEM;
694 	}
695 	return 0;
696 }
697 
698 struct lpfc_vport *
699 lpfc_find_vport_by_did(struct lpfc_hba *phba, uint32_t did) {
700 	struct lpfc_vport *vport_curr;
701 	unsigned long flags;
702 
703 	spin_lock_irqsave(&phba->port_list_lock, flags);
704 	list_for_each_entry(vport_curr, &phba->port_list, listentry) {
705 		if ((vport_curr->fc_myDID) && (vport_curr->fc_myDID == did)) {
706 			spin_unlock_irqrestore(&phba->port_list_lock, flags);
707 			return vport_curr;
708 		}
709 	}
710 	spin_unlock_irqrestore(&phba->port_list_lock, flags);
711 	return NULL;
712 }
713 
714 static void
715 lpfc_prep_node_fc4type(struct lpfc_vport *vport, uint32_t Did, uint8_t fc4_type)
716 {
717 	struct lpfc_nodelist *ndlp;
718 
719 	if ((vport->port_type != LPFC_NPIV_PORT) ||
720 	    !(vport->ct_flags & FC_CT_RFF_ID) || !vport->cfg_restrict_login) {
721 
722 		ndlp = lpfc_setup_disc_node(vport, Did);
723 
724 		if (ndlp) {
725 			lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
726 				"Parse GID_FTrsp: did:x%x flg:x%x x%x",
727 				Did, ndlp->nlp_flag, vport->fc_flag);
728 
729 			/* By default, the driver expects to support FCP FC4 */
730 			if (fc4_type == FC_TYPE_FCP)
731 				ndlp->nlp_fc4_type |= NLP_FC4_FCP;
732 
733 			if (fc4_type == FC_TYPE_NVME)
734 				ndlp->nlp_fc4_type |= NLP_FC4_NVME;
735 
736 			lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
737 					 "0238 Process x%06x NameServer Rsp "
738 					 "Data: x%x x%x x%x x%x x%x\n", Did,
739 					 ndlp->nlp_flag, ndlp->nlp_fc4_type,
740 					 ndlp->nlp_state, vport->fc_flag,
741 					 vport->fc_rscn_id_cnt);
742 
743 			/* if ndlp needs to be discovered and prior
744 			 * state of ndlp hit devloss, change state to
745 			 * allow rediscovery.
746 			 */
747 			if (ndlp->nlp_flag & NLP_NPR_2B_DISC &&
748 			    ndlp->nlp_state == NLP_STE_UNUSED_NODE) {
749 				lpfc_nlp_set_state(vport, ndlp,
750 						   NLP_STE_NPR_NODE);
751 			}
752 		} else {
753 			lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
754 				"Skip1 GID_FTrsp: did:x%x flg:x%x cnt:%d",
755 				Did, vport->fc_flag, vport->fc_rscn_id_cnt);
756 
757 			lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
758 					 "0239 Skip x%06x NameServer Rsp "
759 					 "Data: x%x x%x x%px\n",
760 					 Did, vport->fc_flag,
761 					 vport->fc_rscn_id_cnt, ndlp);
762 		}
763 	} else {
764 		if (!(vport->fc_flag & FC_RSCN_MODE) ||
765 		    lpfc_rscn_payload_check(vport, Did)) {
766 			lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
767 				"Query GID_FTrsp: did:x%x flg:x%x cnt:%d",
768 				Did, vport->fc_flag, vport->fc_rscn_id_cnt);
769 
770 			/*
771 			 * This NPortID was previously a FCP/NVMe target,
772 			 * Don't even bother to send GFF_ID.
773 			 */
774 			ndlp = lpfc_findnode_did(vport, Did);
775 			if (ndlp &&
776 			    (ndlp->nlp_type &
777 			    (NLP_FCP_TARGET | NLP_NVME_TARGET))) {
778 				if (fc4_type == FC_TYPE_FCP)
779 					ndlp->nlp_fc4_type |= NLP_FC4_FCP;
780 				if (fc4_type == FC_TYPE_NVME)
781 					ndlp->nlp_fc4_type |= NLP_FC4_NVME;
782 				lpfc_setup_disc_node(vport, Did);
783 			} else if (lpfc_ns_cmd(vport, SLI_CTNS_GFF_ID,
784 				   0, Did) == 0)
785 				vport->num_disc_nodes++;
786 			else
787 				lpfc_setup_disc_node(vport, Did);
788 		} else {
789 			lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
790 				"Skip2 GID_FTrsp: did:x%x flg:x%x cnt:%d",
791 				Did, vport->fc_flag, vport->fc_rscn_id_cnt);
792 
793 			lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
794 					 "0245 Skip x%06x NameServer Rsp "
795 					 "Data: x%x x%x\n", Did,
796 					 vport->fc_flag,
797 					 vport->fc_rscn_id_cnt);
798 		}
799 	}
800 }
801 
802 static void
803 lpfc_ns_rsp_audit_did(struct lpfc_vport *vport, uint32_t Did, uint8_t fc4_type)
804 {
805 	struct lpfc_hba *phba = vport->phba;
806 	struct lpfc_nodelist *ndlp = NULL;
807 	char *str;
808 
809 	if (phba->cfg_ns_query == LPFC_NS_QUERY_GID_FT)
810 		str = "GID_FT";
811 	else
812 		str = "GID_PT";
813 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
814 			 "6430 Process %s rsp for %08x type %x %s %s\n",
815 			 str, Did, fc4_type,
816 			 (fc4_type == FC_TYPE_FCP) ?  "FCP" : " ",
817 			 (fc4_type == FC_TYPE_NVME) ?  "NVME" : " ");
818 	/*
819 	 * To conserve rpi's, filter out addresses for other
820 	 * vports on the same physical HBAs.
821 	 */
822 	if (Did != vport->fc_myDID &&
823 	    (!lpfc_find_vport_by_did(phba, Did) ||
824 	     vport->cfg_peer_port_login)) {
825 		if (!phba->nvmet_support) {
826 			/* FCPI/NVMEI path. Process Did */
827 			lpfc_prep_node_fc4type(vport, Did, fc4_type);
828 			return;
829 		}
830 		/* NVMET path.  NVMET only cares about NVMEI nodes. */
831 		list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
832 			if (ndlp->nlp_type != NLP_NVME_INITIATOR ||
833 			    ndlp->nlp_state != NLP_STE_UNMAPPED_NODE)
834 				continue;
835 			spin_lock_irq(&ndlp->lock);
836 			if (ndlp->nlp_DID == Did)
837 				ndlp->nlp_flag &= ~NLP_NVMET_RECOV;
838 			else
839 				ndlp->nlp_flag |= NLP_NVMET_RECOV;
840 			spin_unlock_irq(&ndlp->lock);
841 		}
842 	}
843 }
844 
845 static int
846 lpfc_ns_rsp(struct lpfc_vport *vport, struct lpfc_dmabuf *mp, uint8_t fc4_type,
847 	    uint32_t Size)
848 {
849 	struct lpfc_sli_ct_request *Response =
850 		(struct lpfc_sli_ct_request *) mp->virt;
851 	struct lpfc_dmabuf *mlast, *next_mp;
852 	uint32_t *ctptr = (uint32_t *) & Response->un.gid.PortType;
853 	uint32_t Did, CTentry;
854 	int Cnt;
855 	struct list_head head;
856 	struct lpfc_nodelist *ndlp = NULL;
857 
858 	lpfc_set_disctmo(vport);
859 	vport->num_disc_nodes = 0;
860 	vport->fc_ns_retry = 0;
861 
862 
863 	list_add_tail(&head, &mp->list);
864 	list_for_each_entry_safe(mp, next_mp, &head, list) {
865 		mlast = mp;
866 
867 		Cnt = Size  > FCELSSIZE ? FCELSSIZE : Size;
868 
869 		Size -= Cnt;
870 
871 		if (!ctptr) {
872 			ctptr = (uint32_t *) mlast->virt;
873 		} else
874 			Cnt -= 16;	/* subtract length of CT header */
875 
876 		/* Loop through entire NameServer list of DIDs */
877 		while (Cnt >= sizeof(uint32_t)) {
878 			/* Get next DID from NameServer List */
879 			CTentry = *ctptr++;
880 			Did = ((be32_to_cpu(CTentry)) & Mask_DID);
881 			lpfc_ns_rsp_audit_did(vport, Did, fc4_type);
882 			if (CTentry & (cpu_to_be32(SLI_CT_LAST_ENTRY)))
883 				goto nsout1;
884 
885 			Cnt -= sizeof(uint32_t);
886 		}
887 		ctptr = NULL;
888 
889 	}
890 
891 	/* All GID_FT entries processed.  If the driver is running in
892 	 * in target mode, put impacted nodes into recovery and drop
893 	 * the RPI to flush outstanding IO.
894 	 */
895 	if (vport->phba->nvmet_support) {
896 		list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
897 			if (!(ndlp->nlp_flag & NLP_NVMET_RECOV))
898 				continue;
899 			lpfc_disc_state_machine(vport, ndlp, NULL,
900 						NLP_EVT_DEVICE_RECOVERY);
901 			spin_lock_irq(&ndlp->lock);
902 			ndlp->nlp_flag &= ~NLP_NVMET_RECOV;
903 			spin_unlock_irq(&ndlp->lock);
904 		}
905 	}
906 
907 nsout1:
908 	list_del(&head);
909 	return 0;
910 }
911 
912 static void
913 lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
914 			struct lpfc_iocbq *rspiocb)
915 {
916 	struct lpfc_vport *vport = cmdiocb->vport;
917 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
918 	struct lpfc_dmabuf *outp;
919 	struct lpfc_dmabuf *inp;
920 	struct lpfc_sli_ct_request *CTrsp;
921 	struct lpfc_sli_ct_request *CTreq;
922 	struct lpfc_nodelist *ndlp;
923 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
924 	u32 ulp_word4 = get_job_word4(phba, rspiocb);
925 	int rc, type;
926 
927 	/* First save ndlp, before we overwrite it */
928 	ndlp = cmdiocb->ndlp;
929 
930 	/* we pass cmdiocb to state machine which needs rspiocb as well */
931 	cmdiocb->rsp_iocb = rspiocb;
932 	inp = cmdiocb->cmd_dmabuf;
933 	outp = cmdiocb->rsp_dmabuf;
934 
935 	lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
936 		 "GID_FT cmpl:     status:x%x/x%x rtry:%d",
937 		ulp_status, ulp_word4, vport->fc_ns_retry);
938 
939 	/* Ignore response if link flipped after this request was made */
940 	if (cmdiocb->event_tag != phba->fc_eventTag) {
941 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
942 				 "9043 Event tag mismatch. Ignoring NS rsp\n");
943 		goto out;
944 	}
945 
946 	/* Don't bother processing response if vport is being torn down. */
947 	if (vport->load_flag & FC_UNLOADING) {
948 		if (vport->fc_flag & FC_RSCN_MODE)
949 			lpfc_els_flush_rscn(vport);
950 		goto out;
951 	}
952 
953 	if (lpfc_els_chk_latt(vport)) {
954 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
955 				 "0216 Link event during NS query\n");
956 		if (vport->fc_flag & FC_RSCN_MODE)
957 			lpfc_els_flush_rscn(vport);
958 		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
959 		goto out;
960 	}
961 	if (lpfc_error_lost_link(vport, ulp_status, ulp_word4)) {
962 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
963 				 "0226 NS query failed due to link event: "
964 				 "ulp_status x%x ulp_word4 x%x fc_flag x%x "
965 				 "port_state x%x gidft_inp x%x\n",
966 				 ulp_status, ulp_word4, vport->fc_flag,
967 				 vport->port_state, vport->gidft_inp);
968 		if (vport->fc_flag & FC_RSCN_MODE)
969 			lpfc_els_flush_rscn(vport);
970 		if (vport->gidft_inp)
971 			vport->gidft_inp--;
972 		goto out;
973 	}
974 
975 	spin_lock_irq(shost->host_lock);
976 	if (vport->fc_flag & FC_RSCN_DEFERRED) {
977 		vport->fc_flag &= ~FC_RSCN_DEFERRED;
978 		spin_unlock_irq(shost->host_lock);
979 
980 		/* This is a GID_FT completing so the gidft_inp counter was
981 		 * incremented before the GID_FT was issued to the wire.
982 		 */
983 		if (vport->gidft_inp)
984 			vport->gidft_inp--;
985 
986 		/*
987 		 * Skip processing the NS response
988 		 * Re-issue the NS cmd
989 		 */
990 		lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
991 				 "0151 Process Deferred RSCN Data: x%x x%x\n",
992 				 vport->fc_flag, vport->fc_rscn_id_cnt);
993 		lpfc_els_handle_rscn(vport);
994 
995 		goto out;
996 	}
997 	spin_unlock_irq(shost->host_lock);
998 
999 	if (ulp_status) {
1000 		/* Check for retry */
1001 		if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) {
1002 			if (ulp_status != IOSTAT_LOCAL_REJECT ||
1003 			    (ulp_word4 & IOERR_PARAM_MASK) !=
1004 			    IOERR_NO_RESOURCES)
1005 				vport->fc_ns_retry++;
1006 
1007 			type = lpfc_get_gidft_type(vport, cmdiocb);
1008 			if (type == 0)
1009 				goto out;
1010 
1011 			/* CT command is being retried */
1012 			rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT,
1013 					 vport->fc_ns_retry, type);
1014 			if (rc == 0)
1015 				goto out;
1016 			else { /* Unable to send NS cmd */
1017 				if (vport->gidft_inp)
1018 					vport->gidft_inp--;
1019 			}
1020 		}
1021 		if (vport->fc_flag & FC_RSCN_MODE)
1022 			lpfc_els_flush_rscn(vport);
1023 		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1024 		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1025 				 "0257 GID_FT Query error: 0x%x 0x%x\n",
1026 				 ulp_status, vport->fc_ns_retry);
1027 	} else {
1028 		/* Good status, continue checking */
1029 		CTreq = (struct lpfc_sli_ct_request *) inp->virt;
1030 		CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1031 		if (CTrsp->CommandResponse.bits.CmdRsp ==
1032 		    cpu_to_be16(SLI_CT_RESPONSE_FS_ACC)) {
1033 			lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1034 					 "0208 NameServer Rsp Data: x%x x%x "
1035 					 "x%x x%x sz x%x\n",
1036 					 vport->fc_flag,
1037 					 CTreq->un.gid.Fc4Type,
1038 					 vport->num_disc_nodes,
1039 					 vport->gidft_inp,
1040 					 get_job_data_placed(phba, rspiocb));
1041 
1042 			lpfc_ns_rsp(vport,
1043 				    outp,
1044 				    CTreq->un.gid.Fc4Type,
1045 				    get_job_data_placed(phba, rspiocb));
1046 		} else if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1047 			   SLI_CT_RESPONSE_FS_RJT) {
1048 			/* NameServer Rsp Error */
1049 			if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ)
1050 			    && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) {
1051 				lpfc_printf_vlog(vport, KERN_INFO,
1052 					LOG_DISCOVERY,
1053 					"0269 No NameServer Entries "
1054 					"Data: x%x x%x x%x x%x\n",
1055 					be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1056 					(uint32_t) CTrsp->ReasonCode,
1057 					(uint32_t) CTrsp->Explanation,
1058 					vport->fc_flag);
1059 
1060 				lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1061 				"GID_FT no entry  cmd:x%x rsn:x%x exp:x%x",
1062 				be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1063 				(uint32_t) CTrsp->ReasonCode,
1064 				(uint32_t) CTrsp->Explanation);
1065 			} else {
1066 				lpfc_printf_vlog(vport, KERN_INFO,
1067 					LOG_DISCOVERY,
1068 					"0240 NameServer Rsp Error "
1069 					"Data: x%x x%x x%x x%x\n",
1070 					be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1071 					(uint32_t) CTrsp->ReasonCode,
1072 					(uint32_t) CTrsp->Explanation,
1073 					vport->fc_flag);
1074 
1075 				lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1076 				"GID_FT rsp err1  cmd:x%x rsn:x%x exp:x%x",
1077 				be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1078 				(uint32_t) CTrsp->ReasonCode,
1079 				(uint32_t) CTrsp->Explanation);
1080 			}
1081 
1082 
1083 		} else {
1084 			/* NameServer Rsp Error */
1085 			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1086 					"0241 NameServer Rsp Error "
1087 					"Data: x%x x%x x%x x%x\n",
1088 					be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1089 					(uint32_t) CTrsp->ReasonCode,
1090 					(uint32_t) CTrsp->Explanation,
1091 					vport->fc_flag);
1092 
1093 			lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1094 				"GID_FT rsp err2  cmd:x%x rsn:x%x exp:x%x",
1095 				be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1096 				(uint32_t) CTrsp->ReasonCode,
1097 				(uint32_t) CTrsp->Explanation);
1098 		}
1099 		if (vport->gidft_inp)
1100 			vport->gidft_inp--;
1101 	}
1102 
1103 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1104 			 "4216 GID_FT cmpl inp %d disc %d\n",
1105 			 vport->gidft_inp, vport->num_disc_nodes);
1106 
1107 	/* Link up / RSCN discovery */
1108 	if ((vport->num_disc_nodes == 0) &&
1109 	    (vport->gidft_inp == 0)) {
1110 		/*
1111 		 * The driver has cycled through all Nports in the RSCN payload.
1112 		 * Complete the handling by cleaning up and marking the
1113 		 * current driver state.
1114 		 */
1115 		if (vport->port_state >= LPFC_DISC_AUTH) {
1116 			if (vport->fc_flag & FC_RSCN_MODE) {
1117 				lpfc_els_flush_rscn(vport);
1118 				spin_lock_irq(shost->host_lock);
1119 				vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */
1120 				spin_unlock_irq(shost->host_lock);
1121 			}
1122 			else
1123 				lpfc_els_flush_rscn(vport);
1124 		}
1125 
1126 		lpfc_disc_start(vport);
1127 	}
1128 out:
1129 	lpfc_ct_free_iocb(phba, cmdiocb);
1130 	lpfc_nlp_put(ndlp);
1131 	return;
1132 }
1133 
1134 static void
1135 lpfc_cmpl_ct_cmd_gid_pt(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1136 			struct lpfc_iocbq *rspiocb)
1137 {
1138 	struct lpfc_vport *vport = cmdiocb->vport;
1139 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1140 	struct lpfc_dmabuf *outp;
1141 	struct lpfc_dmabuf *inp;
1142 	struct lpfc_sli_ct_request *CTrsp;
1143 	struct lpfc_sli_ct_request *CTreq;
1144 	struct lpfc_nodelist *ndlp;
1145 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1146 	u32 ulp_word4 = get_job_word4(phba, rspiocb);
1147 	int rc;
1148 
1149 	/* First save ndlp, before we overwrite it */
1150 	ndlp = cmdiocb->ndlp;
1151 
1152 	/* we pass cmdiocb to state machine which needs rspiocb as well */
1153 	cmdiocb->rsp_iocb = rspiocb;
1154 	inp = cmdiocb->cmd_dmabuf;
1155 	outp = cmdiocb->rsp_dmabuf;
1156 
1157 	lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1158 			      "GID_PT cmpl:     status:x%x/x%x rtry:%d",
1159 			      ulp_status, ulp_word4,
1160 			      vport->fc_ns_retry);
1161 
1162 	/* Ignore response if link flipped after this request was made */
1163 	if (cmdiocb->event_tag != phba->fc_eventTag) {
1164 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1165 				 "9044 Event tag mismatch. Ignoring NS rsp\n");
1166 		goto out;
1167 	}
1168 
1169 	/* Don't bother processing response if vport is being torn down. */
1170 	if (vport->load_flag & FC_UNLOADING) {
1171 		if (vport->fc_flag & FC_RSCN_MODE)
1172 			lpfc_els_flush_rscn(vport);
1173 		goto out;
1174 	}
1175 
1176 	if (lpfc_els_chk_latt(vport)) {
1177 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1178 				 "4108 Link event during NS query\n");
1179 		if (vport->fc_flag & FC_RSCN_MODE)
1180 			lpfc_els_flush_rscn(vport);
1181 		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1182 		goto out;
1183 	}
1184 	if (lpfc_error_lost_link(vport, ulp_status, ulp_word4)) {
1185 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1186 				 "4166 NS query failed due to link event: "
1187 				 "ulp_status x%x ulp_word4 x%x fc_flag x%x "
1188 				 "port_state x%x gidft_inp x%x\n",
1189 				 ulp_status, ulp_word4, vport->fc_flag,
1190 				 vport->port_state, vport->gidft_inp);
1191 		if (vport->fc_flag & FC_RSCN_MODE)
1192 			lpfc_els_flush_rscn(vport);
1193 		if (vport->gidft_inp)
1194 			vport->gidft_inp--;
1195 		goto out;
1196 	}
1197 
1198 	spin_lock_irq(shost->host_lock);
1199 	if (vport->fc_flag & FC_RSCN_DEFERRED) {
1200 		vport->fc_flag &= ~FC_RSCN_DEFERRED;
1201 		spin_unlock_irq(shost->host_lock);
1202 
1203 		/* This is a GID_PT completing so the gidft_inp counter was
1204 		 * incremented before the GID_PT was issued to the wire.
1205 		 */
1206 		if (vport->gidft_inp)
1207 			vport->gidft_inp--;
1208 
1209 		/*
1210 		 * Skip processing the NS response
1211 		 * Re-issue the NS cmd
1212 		 */
1213 		lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1214 				 "4167 Process Deferred RSCN Data: x%x x%x\n",
1215 				 vport->fc_flag, vport->fc_rscn_id_cnt);
1216 		lpfc_els_handle_rscn(vport);
1217 
1218 		goto out;
1219 	}
1220 	spin_unlock_irq(shost->host_lock);
1221 
1222 	if (ulp_status) {
1223 		/* Check for retry */
1224 		if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) {
1225 			if (ulp_status != IOSTAT_LOCAL_REJECT ||
1226 			    (ulp_word4 & IOERR_PARAM_MASK) !=
1227 			    IOERR_NO_RESOURCES)
1228 				vport->fc_ns_retry++;
1229 
1230 			/* CT command is being retried */
1231 			rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_PT,
1232 					 vport->fc_ns_retry, GID_PT_N_PORT);
1233 			if (rc == 0)
1234 				goto out;
1235 			else { /* Unable to send NS cmd */
1236 				if (vport->gidft_inp)
1237 					vport->gidft_inp--;
1238 			}
1239 		}
1240 		if (vport->fc_flag & FC_RSCN_MODE)
1241 			lpfc_els_flush_rscn(vport);
1242 		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1243 		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1244 				 "4103 GID_FT Query error: 0x%x 0x%x\n",
1245 				 ulp_status, vport->fc_ns_retry);
1246 	} else {
1247 		/* Good status, continue checking */
1248 		CTreq = (struct lpfc_sli_ct_request *)inp->virt;
1249 		CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1250 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1251 		    SLI_CT_RESPONSE_FS_ACC) {
1252 			lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1253 					 "4105 NameServer Rsp Data: x%x x%x "
1254 					 "x%x x%x sz x%x\n",
1255 					 vport->fc_flag,
1256 					 CTreq->un.gid.Fc4Type,
1257 					 vport->num_disc_nodes,
1258 					 vport->gidft_inp,
1259 					 get_job_data_placed(phba, rspiocb));
1260 
1261 			lpfc_ns_rsp(vport,
1262 				    outp,
1263 				    CTreq->un.gid.Fc4Type,
1264 				    get_job_data_placed(phba, rspiocb));
1265 		} else if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1266 			   SLI_CT_RESPONSE_FS_RJT) {
1267 			/* NameServer Rsp Error */
1268 			if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ)
1269 			    && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) {
1270 				lpfc_printf_vlog(
1271 					vport, KERN_INFO, LOG_DISCOVERY,
1272 					"4106 No NameServer Entries "
1273 					"Data: x%x x%x x%x x%x\n",
1274 					be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1275 					(uint32_t)CTrsp->ReasonCode,
1276 					(uint32_t)CTrsp->Explanation,
1277 					vport->fc_flag);
1278 
1279 				lpfc_debugfs_disc_trc(
1280 				vport, LPFC_DISC_TRC_CT,
1281 				"GID_PT no entry  cmd:x%x rsn:x%x exp:x%x",
1282 				be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1283 				(uint32_t)CTrsp->ReasonCode,
1284 				(uint32_t)CTrsp->Explanation);
1285 			} else {
1286 				lpfc_printf_vlog(
1287 					vport, KERN_INFO, LOG_DISCOVERY,
1288 					"4107 NameServer Rsp Error "
1289 					"Data: x%x x%x x%x x%x\n",
1290 					be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1291 					(uint32_t)CTrsp->ReasonCode,
1292 					(uint32_t)CTrsp->Explanation,
1293 					vport->fc_flag);
1294 
1295 				lpfc_debugfs_disc_trc(
1296 				vport, LPFC_DISC_TRC_CT,
1297 				"GID_PT rsp err1  cmd:x%x rsn:x%x exp:x%x",
1298 				be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1299 				(uint32_t)CTrsp->ReasonCode,
1300 				(uint32_t)CTrsp->Explanation);
1301 			}
1302 		} else {
1303 			/* NameServer Rsp Error */
1304 			lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1305 					 "4109 NameServer Rsp Error "
1306 					 "Data: x%x x%x x%x x%x\n",
1307 					 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1308 					 (uint32_t)CTrsp->ReasonCode,
1309 					 (uint32_t)CTrsp->Explanation,
1310 					 vport->fc_flag);
1311 
1312 			lpfc_debugfs_disc_trc(
1313 				vport, LPFC_DISC_TRC_CT,
1314 				"GID_PT rsp err2  cmd:x%x rsn:x%x exp:x%x",
1315 				be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1316 				(uint32_t)CTrsp->ReasonCode,
1317 				(uint32_t)CTrsp->Explanation);
1318 		}
1319 		if (vport->gidft_inp)
1320 			vport->gidft_inp--;
1321 	}
1322 
1323 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1324 			 "6450 GID_PT cmpl inp %d disc %d\n",
1325 			 vport->gidft_inp, vport->num_disc_nodes);
1326 
1327 	/* Link up / RSCN discovery */
1328 	if ((vport->num_disc_nodes == 0) &&
1329 	    (vport->gidft_inp == 0)) {
1330 		/*
1331 		 * The driver has cycled through all Nports in the RSCN payload.
1332 		 * Complete the handling by cleaning up and marking the
1333 		 * current driver state.
1334 		 */
1335 		if (vport->port_state >= LPFC_DISC_AUTH) {
1336 			if (vport->fc_flag & FC_RSCN_MODE) {
1337 				lpfc_els_flush_rscn(vport);
1338 				spin_lock_irq(shost->host_lock);
1339 				vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */
1340 				spin_unlock_irq(shost->host_lock);
1341 			} else {
1342 				lpfc_els_flush_rscn(vport);
1343 			}
1344 		}
1345 
1346 		lpfc_disc_start(vport);
1347 	}
1348 out:
1349 	lpfc_ct_free_iocb(phba, cmdiocb);
1350 	lpfc_nlp_put(ndlp);
1351 }
1352 
1353 static void
1354 lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1355 			struct lpfc_iocbq *rspiocb)
1356 {
1357 	struct lpfc_vport *vport = cmdiocb->vport;
1358 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1359 	struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf;
1360 	struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf;
1361 	struct lpfc_sli_ct_request *CTrsp;
1362 	int did, rc, retry;
1363 	uint8_t fbits;
1364 	struct lpfc_nodelist *ndlp = NULL, *free_ndlp = NULL;
1365 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1366 	u32 ulp_word4 = get_job_word4(phba, rspiocb);
1367 
1368 	did = ((struct lpfc_sli_ct_request *) inp->virt)->un.gff.PortId;
1369 	did = be32_to_cpu(did);
1370 
1371 	lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1372 		"GFF_ID cmpl:     status:x%x/x%x did:x%x",
1373 		ulp_status, ulp_word4, did);
1374 
1375 	/* Ignore response if link flipped after this request was made */
1376 	if (cmdiocb->event_tag != phba->fc_eventTag) {
1377 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1378 				 "9045 Event tag mismatch. Ignoring NS rsp\n");
1379 		goto iocb_free;
1380 	}
1381 
1382 	if (ulp_status == IOSTAT_SUCCESS) {
1383 		/* Good status, continue checking */
1384 		CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1385 		fbits = CTrsp->un.gff_acc.fbits[FCP_TYPE_FEATURE_OFFSET];
1386 
1387 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1388 				 "6431 Process GFF_ID rsp for %08x "
1389 				 "fbits %02x %s %s\n",
1390 				 did, fbits,
1391 				 (fbits & FC4_FEATURE_INIT) ? "Initiator" : " ",
1392 				 (fbits & FC4_FEATURE_TARGET) ? "Target" : " ");
1393 
1394 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1395 		    SLI_CT_RESPONSE_FS_ACC) {
1396 			if ((fbits & FC4_FEATURE_INIT) &&
1397 			    !(fbits & FC4_FEATURE_TARGET)) {
1398 				lpfc_printf_vlog(vport, KERN_INFO,
1399 						 LOG_DISCOVERY,
1400 						 "0270 Skip x%x GFF "
1401 						 "NameServer Rsp Data: (init) "
1402 						 "x%x x%x\n", did, fbits,
1403 						 vport->fc_rscn_id_cnt);
1404 				goto out;
1405 			}
1406 		}
1407 	}
1408 	else {
1409 		/* Check for retry */
1410 		if (cmdiocb->retry < LPFC_MAX_NS_RETRY) {
1411 			retry = 1;
1412 			if (ulp_status == IOSTAT_LOCAL_REJECT) {
1413 				switch ((ulp_word4 &
1414 					IOERR_PARAM_MASK)) {
1415 
1416 				case IOERR_NO_RESOURCES:
1417 					/* We don't increment the retry
1418 					 * count for this case.
1419 					 */
1420 					break;
1421 				case IOERR_LINK_DOWN:
1422 				case IOERR_SLI_ABORTED:
1423 				case IOERR_SLI_DOWN:
1424 					retry = 0;
1425 					break;
1426 				default:
1427 					cmdiocb->retry++;
1428 				}
1429 			}
1430 			else
1431 				cmdiocb->retry++;
1432 
1433 			if (retry) {
1434 				/* CT command is being retried */
1435 				rc = lpfc_ns_cmd(vport, SLI_CTNS_GFF_ID,
1436 					 cmdiocb->retry, did);
1437 				if (rc == 0) {
1438 					/* success */
1439 					free_ndlp = cmdiocb->ndlp;
1440 					lpfc_ct_free_iocb(phba, cmdiocb);
1441 					lpfc_nlp_put(free_ndlp);
1442 					return;
1443 				}
1444 			}
1445 		}
1446 		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1447 				 "0267 NameServer GFF Rsp "
1448 				 "x%x Error (%d %d) Data: x%x x%x\n",
1449 				 did, ulp_status, ulp_word4,
1450 				 vport->fc_flag, vport->fc_rscn_id_cnt);
1451 	}
1452 
1453 	/* This is a target port, unregistered port, or the GFF_ID failed */
1454 	ndlp = lpfc_setup_disc_node(vport, did);
1455 	if (ndlp) {
1456 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1457 				 "0242 Process x%x GFF "
1458 				 "NameServer Rsp Data: x%x x%x x%x\n",
1459 				 did, ndlp->nlp_flag, vport->fc_flag,
1460 				 vport->fc_rscn_id_cnt);
1461 	} else {
1462 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1463 				 "0243 Skip x%x GFF "
1464 				 "NameServer Rsp Data: x%x x%x\n", did,
1465 				 vport->fc_flag, vport->fc_rscn_id_cnt);
1466 	}
1467 out:
1468 	/* Link up / RSCN discovery */
1469 	if (vport->num_disc_nodes)
1470 		vport->num_disc_nodes--;
1471 
1472 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1473 			 "6451 GFF_ID cmpl inp %d disc %d\n",
1474 			 vport->gidft_inp, vport->num_disc_nodes);
1475 
1476 	if (vport->num_disc_nodes == 0) {
1477 		/*
1478 		 * The driver has cycled through all Nports in the RSCN payload.
1479 		 * Complete the handling by cleaning up and marking the
1480 		 * current driver state.
1481 		 */
1482 		if (vport->port_state >= LPFC_DISC_AUTH) {
1483 			if (vport->fc_flag & FC_RSCN_MODE) {
1484 				lpfc_els_flush_rscn(vport);
1485 				spin_lock_irq(shost->host_lock);
1486 				vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */
1487 				spin_unlock_irq(shost->host_lock);
1488 			}
1489 			else
1490 				lpfc_els_flush_rscn(vport);
1491 		}
1492 		lpfc_disc_start(vport);
1493 	}
1494 
1495 iocb_free:
1496 	free_ndlp = cmdiocb->ndlp;
1497 	lpfc_ct_free_iocb(phba, cmdiocb);
1498 	lpfc_nlp_put(free_ndlp);
1499 	return;
1500 }
1501 
1502 static void
1503 lpfc_cmpl_ct_cmd_gft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1504 			struct lpfc_iocbq *rspiocb)
1505 {
1506 	struct lpfc_vport *vport = cmdiocb->vport;
1507 	struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf;
1508 	struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf;
1509 	struct lpfc_sli_ct_request *CTrsp;
1510 	int did;
1511 	struct lpfc_nodelist *ndlp = NULL;
1512 	struct lpfc_nodelist *ns_ndlp = cmdiocb->ndlp;
1513 	uint32_t fc4_data_0, fc4_data_1;
1514 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1515 	u32 ulp_word4 = get_job_word4(phba, rspiocb);
1516 
1517 	did = ((struct lpfc_sli_ct_request *)inp->virt)->un.gft.PortId;
1518 	did = be32_to_cpu(did);
1519 
1520 	lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1521 			      "GFT_ID cmpl: status:x%x/x%x did:x%x",
1522 			      ulp_status, ulp_word4, did);
1523 
1524 	/* Ignore response if link flipped after this request was made */
1525 	if ((uint32_t)cmdiocb->event_tag != phba->fc_eventTag) {
1526 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1527 				 "9046 Event tag mismatch. Ignoring NS rsp\n");
1528 		goto out;
1529 	}
1530 
1531 	if (ulp_status == IOSTAT_SUCCESS) {
1532 		/* Good status, continue checking */
1533 		CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1534 		fc4_data_0 = be32_to_cpu(CTrsp->un.gft_acc.fc4_types[0]);
1535 		fc4_data_1 = be32_to_cpu(CTrsp->un.gft_acc.fc4_types[1]);
1536 
1537 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1538 				 "6432 Process GFT_ID rsp for %08x "
1539 				 "Data %08x %08x %s %s\n",
1540 				 did, fc4_data_0, fc4_data_1,
1541 				 (fc4_data_0 & LPFC_FC4_TYPE_BITMASK) ?
1542 				  "FCP" : " ",
1543 				 (fc4_data_1 & LPFC_FC4_TYPE_BITMASK) ?
1544 				  "NVME" : " ");
1545 
1546 		/* Lookup the NPort_ID queried in the GFT_ID and find the
1547 		 * driver's local node.  It's an error if the driver
1548 		 * doesn't have one.
1549 		 */
1550 		ndlp = lpfc_findnode_did(vport, did);
1551 		if (ndlp) {
1552 			/* The bitmask value for FCP and NVME FCP types is
1553 			 * the same because they are 32 bits distant from
1554 			 * each other in word0 and word0.
1555 			 */
1556 			if (fc4_data_0 & LPFC_FC4_TYPE_BITMASK)
1557 				ndlp->nlp_fc4_type |= NLP_FC4_FCP;
1558 			if (fc4_data_1 &  LPFC_FC4_TYPE_BITMASK)
1559 				ndlp->nlp_fc4_type |= NLP_FC4_NVME;
1560 			lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1561 					 "3064 Setting ndlp x%px, DID x%06x "
1562 					 "with FC4 x%08x, Data: x%08x x%08x "
1563 					 "%d\n",
1564 					 ndlp, did, ndlp->nlp_fc4_type,
1565 					 FC_TYPE_FCP, FC_TYPE_NVME,
1566 					 ndlp->nlp_state);
1567 
1568 			if (ndlp->nlp_state == NLP_STE_REG_LOGIN_ISSUE &&
1569 			    ndlp->nlp_fc4_type) {
1570 				ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1571 
1572 				lpfc_nlp_set_state(vport, ndlp,
1573 						   NLP_STE_PRLI_ISSUE);
1574 				lpfc_issue_els_prli(vport, ndlp, 0);
1575 			} else if (!ndlp->nlp_fc4_type) {
1576 				/* If fc4 type is still unknown, then LOGO */
1577 				lpfc_printf_vlog(vport, KERN_INFO,
1578 						 LOG_DISCOVERY,
1579 						 "6443 Sending LOGO ndlp x%px,"
1580 						 "DID x%06x with fc4_type: "
1581 						 "x%08x, state: %d\n",
1582 						 ndlp, did, ndlp->nlp_fc4_type,
1583 						 ndlp->nlp_state);
1584 				lpfc_issue_els_logo(vport, ndlp, 0);
1585 				ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1586 				lpfc_nlp_set_state(vport, ndlp,
1587 						   NLP_STE_NPR_NODE);
1588 			}
1589 		}
1590 	} else
1591 		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1592 				 "3065 GFT_ID failed x%08x\n", ulp_status);
1593 
1594 out:
1595 	lpfc_ct_free_iocb(phba, cmdiocb);
1596 	lpfc_nlp_put(ns_ndlp);
1597 }
1598 
1599 static void
1600 lpfc_cmpl_ct(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1601 	     struct lpfc_iocbq *rspiocb)
1602 {
1603 	struct lpfc_vport *vport = cmdiocb->vport;
1604 	struct lpfc_dmabuf *inp;
1605 	struct lpfc_dmabuf *outp;
1606 	struct lpfc_sli_ct_request *CTrsp;
1607 	struct lpfc_nodelist *ndlp;
1608 	int cmdcode, rc;
1609 	uint8_t retry;
1610 	uint32_t latt;
1611 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1612 	u32 ulp_word4 = get_job_word4(phba, rspiocb);
1613 
1614 	/* First save ndlp, before we overwrite it */
1615 	ndlp = cmdiocb->ndlp;
1616 
1617 	/* we pass cmdiocb to state machine which needs rspiocb as well */
1618 	cmdiocb->rsp_iocb = rspiocb;
1619 
1620 	inp = cmdiocb->cmd_dmabuf;
1621 	outp = cmdiocb->rsp_dmabuf;
1622 
1623 	cmdcode = be16_to_cpu(((struct lpfc_sli_ct_request *) inp->virt)->
1624 					CommandResponse.bits.CmdRsp);
1625 	CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1626 
1627 	latt = lpfc_els_chk_latt(vport);
1628 
1629 	/* RFT request completes status <ulp_status> CmdRsp <CmdRsp> */
1630 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1631 			 "0209 CT Request completes, latt %d, "
1632 			 "ulp_status x%x CmdRsp x%x, Context x%x, Tag x%x\n",
1633 			 latt, ulp_status,
1634 			 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1635 			 get_job_ulpcontext(phba, cmdiocb), cmdiocb->iotag);
1636 
1637 	lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1638 		"CT cmd cmpl:     status:x%x/x%x cmd:x%x",
1639 		ulp_status, ulp_word4, cmdcode);
1640 
1641 	if (ulp_status) {
1642 		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1643 				 "0268 NS cmd x%x Error (x%x x%x)\n",
1644 				 cmdcode, ulp_status, ulp_word4);
1645 
1646 		if (ulp_status == IOSTAT_LOCAL_REJECT &&
1647 		    (((ulp_word4 & IOERR_PARAM_MASK) ==
1648 		      IOERR_SLI_DOWN) ||
1649 		     ((ulp_word4 & IOERR_PARAM_MASK) ==
1650 		      IOERR_SLI_ABORTED)))
1651 			goto out;
1652 
1653 		retry = cmdiocb->retry;
1654 		if (retry >= LPFC_MAX_NS_RETRY)
1655 			goto out;
1656 
1657 		retry++;
1658 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1659 				 "0250 Retrying NS cmd %x\n", cmdcode);
1660 		rc = lpfc_ns_cmd(vport, cmdcode, retry, 0);
1661 		if (rc == 0)
1662 			goto out;
1663 	}
1664 
1665 out:
1666 	lpfc_ct_free_iocb(phba, cmdiocb);
1667 	lpfc_nlp_put(ndlp);
1668 	return;
1669 }
1670 
1671 static void
1672 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1673 			struct lpfc_iocbq *rspiocb)
1674 {
1675 	struct lpfc_vport *vport = cmdiocb->vport;
1676 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1677 
1678 	if (ulp_status == IOSTAT_SUCCESS) {
1679 		struct lpfc_dmabuf *outp;
1680 		struct lpfc_sli_ct_request *CTrsp;
1681 
1682 		outp = cmdiocb->rsp_dmabuf;
1683 		CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1684 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1685 		    SLI_CT_RESPONSE_FS_ACC)
1686 			vport->ct_flags |= FC_CT_RFT_ID;
1687 	}
1688 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1689 	return;
1690 }
1691 
1692 static void
1693 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1694 			struct lpfc_iocbq *rspiocb)
1695 {
1696 	struct lpfc_vport *vport = cmdiocb->vport;
1697 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1698 
1699 	if (ulp_status == IOSTAT_SUCCESS) {
1700 		struct lpfc_dmabuf *outp;
1701 		struct lpfc_sli_ct_request *CTrsp;
1702 
1703 		outp = cmdiocb->rsp_dmabuf;
1704 		CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1705 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1706 		    SLI_CT_RESPONSE_FS_ACC)
1707 			vport->ct_flags |= FC_CT_RNN_ID;
1708 	}
1709 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1710 	return;
1711 }
1712 
1713 static void
1714 lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1715 			 struct lpfc_iocbq *rspiocb)
1716 {
1717 	struct lpfc_vport *vport = cmdiocb->vport;
1718 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1719 
1720 	if (ulp_status == IOSTAT_SUCCESS) {
1721 		struct lpfc_dmabuf *outp;
1722 		struct lpfc_sli_ct_request *CTrsp;
1723 
1724 		outp = cmdiocb->rsp_dmabuf;
1725 		CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1726 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1727 		    SLI_CT_RESPONSE_FS_ACC)
1728 			vport->ct_flags |= FC_CT_RSPN_ID;
1729 	}
1730 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1731 	return;
1732 }
1733 
1734 static void
1735 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1736 			 struct lpfc_iocbq *rspiocb)
1737 {
1738 	struct lpfc_vport *vport = cmdiocb->vport;
1739 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1740 
1741 	if (ulp_status == IOSTAT_SUCCESS) {
1742 		struct lpfc_dmabuf *outp;
1743 		struct lpfc_sli_ct_request *CTrsp;
1744 
1745 		outp = cmdiocb->rsp_dmabuf;
1746 		CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1747 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1748 		    SLI_CT_RESPONSE_FS_ACC)
1749 			vport->ct_flags |= FC_CT_RSNN_NN;
1750 	}
1751 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1752 	return;
1753 }
1754 
1755 static void
1756 lpfc_cmpl_ct_cmd_da_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1757  struct lpfc_iocbq *rspiocb)
1758 {
1759 	struct lpfc_vport *vport = cmdiocb->vport;
1760 
1761 	/* even if it fails we will act as though it succeeded. */
1762 	vport->ct_flags = 0;
1763 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1764 	return;
1765 }
1766 
1767 static void
1768 lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1769 			struct lpfc_iocbq *rspiocb)
1770 {
1771 	struct lpfc_vport *vport = cmdiocb->vport;
1772 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1773 
1774 	if (ulp_status == IOSTAT_SUCCESS) {
1775 		struct lpfc_dmabuf *outp;
1776 		struct lpfc_sli_ct_request *CTrsp;
1777 
1778 		outp = cmdiocb->rsp_dmabuf;
1779 		CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1780 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1781 		    SLI_CT_RESPONSE_FS_ACC)
1782 			vport->ct_flags |= FC_CT_RFF_ID;
1783 	}
1784 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1785 	return;
1786 }
1787 
1788 /*
1789  * Although the symbolic port name is thought to be an integer
1790  * as of January 18, 2016, leave it as a string until more of
1791  * the record state becomes defined.
1792  */
1793 int
1794 lpfc_vport_symbolic_port_name(struct lpfc_vport *vport, char *symbol,
1795 	size_t size)
1796 {
1797 	int n;
1798 
1799 	/*
1800 	 * Use the lpfc board number as the Symbolic Port
1801 	 * Name object.  NPIV is not in play so this integer
1802 	 * value is sufficient and unique per FC-ID.
1803 	 */
1804 	n = scnprintf(symbol, size, "%d", vport->phba->brd_no);
1805 	return n;
1806 }
1807 
1808 
1809 int
1810 lpfc_vport_symbolic_node_name(struct lpfc_vport *vport, char *symbol,
1811 	size_t size)
1812 {
1813 	char fwrev[FW_REV_STR_SIZE] = {0};
1814 	char tmp[MAXHOSTNAMELEN] = {0};
1815 
1816 	memset(symbol, 0, size);
1817 
1818 	scnprintf(tmp, sizeof(tmp), "Emulex %s", vport->phba->ModelName);
1819 	if (strlcat(symbol, tmp, size) >= size)
1820 		goto buffer_done;
1821 
1822 	lpfc_decode_firmware_rev(vport->phba, fwrev, 0);
1823 	scnprintf(tmp, sizeof(tmp), " FV%s", fwrev);
1824 	if (strlcat(symbol, tmp, size) >= size)
1825 		goto buffer_done;
1826 
1827 	scnprintf(tmp, sizeof(tmp), " DV%s", lpfc_release_version);
1828 	if (strlcat(symbol, tmp, size) >= size)
1829 		goto buffer_done;
1830 
1831 	scnprintf(tmp, sizeof(tmp), " HN:%s", vport->phba->os_host_name);
1832 	if (strlcat(symbol, tmp, size) >= size)
1833 		goto buffer_done;
1834 
1835 	/* Note :- OS name is "Linux" */
1836 	scnprintf(tmp, sizeof(tmp), " OS:%s", init_utsname()->sysname);
1837 	strlcat(symbol, tmp, size);
1838 
1839 buffer_done:
1840 	return strnlen(symbol, size);
1841 
1842 }
1843 
1844 static uint32_t
1845 lpfc_find_map_node(struct lpfc_vport *vport)
1846 {
1847 	struct lpfc_nodelist *ndlp, *next_ndlp;
1848 	struct Scsi_Host  *shost;
1849 	uint32_t cnt = 0;
1850 
1851 	shost = lpfc_shost_from_vport(vport);
1852 	spin_lock_irq(shost->host_lock);
1853 	list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
1854 		if (ndlp->nlp_type & NLP_FABRIC)
1855 			continue;
1856 		if ((ndlp->nlp_state == NLP_STE_MAPPED_NODE) ||
1857 		    (ndlp->nlp_state == NLP_STE_UNMAPPED_NODE))
1858 			cnt++;
1859 	}
1860 	spin_unlock_irq(shost->host_lock);
1861 	return cnt;
1862 }
1863 
1864 /*
1865  * This routine will return the FC4 Type associated with the CT
1866  * GID_FT command.
1867  */
1868 int
1869 lpfc_get_gidft_type(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb)
1870 {
1871 	struct lpfc_sli_ct_request *CtReq;
1872 	struct lpfc_dmabuf *mp;
1873 	uint32_t type;
1874 
1875 	mp = cmdiocb->cmd_dmabuf;
1876 	if (mp == NULL)
1877 		return 0;
1878 	CtReq = (struct lpfc_sli_ct_request *)mp->virt;
1879 	type = (uint32_t)CtReq->un.gid.Fc4Type;
1880 	if ((type != SLI_CTPT_FCP) && (type != SLI_CTPT_NVME))
1881 		return 0;
1882 	return type;
1883 }
1884 
1885 /*
1886  * lpfc_ns_cmd
1887  * Description:
1888  *    Issue Cmd to NameServer
1889  *       SLI_CTNS_GID_FT
1890  *       LI_CTNS_RFT_ID
1891  */
1892 int
1893 lpfc_ns_cmd(struct lpfc_vport *vport, int cmdcode,
1894 	    uint8_t retry, uint32_t context)
1895 {
1896 	struct lpfc_nodelist * ndlp;
1897 	struct lpfc_hba *phba = vport->phba;
1898 	struct lpfc_dmabuf *mp, *bmp;
1899 	struct lpfc_sli_ct_request *CtReq;
1900 	struct ulp_bde64 *bpl;
1901 	void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
1902 		      struct lpfc_iocbq *) = NULL;
1903 	uint32_t *ptr;
1904 	uint32_t rsp_size = 1024;
1905 	size_t   size;
1906 	int rc = 0;
1907 
1908 	ndlp = lpfc_findnode_did(vport, NameServer_DID);
1909 	if (!ndlp || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) {
1910 		rc=1;
1911 		goto ns_cmd_exit;
1912 	}
1913 
1914 	/* fill in BDEs for command */
1915 	/* Allocate buffer for command payload */
1916 	mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1917 	if (!mp) {
1918 		rc=2;
1919 		goto ns_cmd_exit;
1920 	}
1921 
1922 	INIT_LIST_HEAD(&mp->list);
1923 	mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
1924 	if (!mp->virt) {
1925 		rc=3;
1926 		goto ns_cmd_free_mp;
1927 	}
1928 
1929 	/* Allocate buffer for Buffer ptr list */
1930 	bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1931 	if (!bmp) {
1932 		rc=4;
1933 		goto ns_cmd_free_mpvirt;
1934 	}
1935 
1936 	INIT_LIST_HEAD(&bmp->list);
1937 	bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys));
1938 	if (!bmp->virt) {
1939 		rc=5;
1940 		goto ns_cmd_free_bmp;
1941 	}
1942 
1943 	/* NameServer Req */
1944 	lpfc_printf_vlog(vport, KERN_INFO ,LOG_DISCOVERY,
1945 			 "0236 NameServer Req Data: x%x x%x x%x x%x\n",
1946 			 cmdcode, vport->fc_flag, vport->fc_rscn_id_cnt,
1947 			 context);
1948 
1949 	bpl = (struct ulp_bde64 *) bmp->virt;
1950 	memset(bpl, 0, sizeof(struct ulp_bde64));
1951 	bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
1952 	bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
1953 	bpl->tus.f.bdeFlags = 0;
1954 	if (cmdcode == SLI_CTNS_GID_FT)
1955 		bpl->tus.f.bdeSize = GID_REQUEST_SZ;
1956 	else if (cmdcode == SLI_CTNS_GID_PT)
1957 		bpl->tus.f.bdeSize = GID_REQUEST_SZ;
1958 	else if (cmdcode == SLI_CTNS_GFF_ID)
1959 		bpl->tus.f.bdeSize = GFF_REQUEST_SZ;
1960 	else if (cmdcode == SLI_CTNS_GFT_ID)
1961 		bpl->tus.f.bdeSize = GFT_REQUEST_SZ;
1962 	else if (cmdcode == SLI_CTNS_RFT_ID)
1963 		bpl->tus.f.bdeSize = RFT_REQUEST_SZ;
1964 	else if (cmdcode == SLI_CTNS_RNN_ID)
1965 		bpl->tus.f.bdeSize = RNN_REQUEST_SZ;
1966 	else if (cmdcode == SLI_CTNS_RSPN_ID)
1967 		bpl->tus.f.bdeSize = RSPN_REQUEST_SZ;
1968 	else if (cmdcode == SLI_CTNS_RSNN_NN)
1969 		bpl->tus.f.bdeSize = RSNN_REQUEST_SZ;
1970 	else if (cmdcode == SLI_CTNS_DA_ID)
1971 		bpl->tus.f.bdeSize = DA_ID_REQUEST_SZ;
1972 	else if (cmdcode == SLI_CTNS_RFF_ID)
1973 		bpl->tus.f.bdeSize = RFF_REQUEST_SZ;
1974 	else
1975 		bpl->tus.f.bdeSize = 0;
1976 	bpl->tus.w = le32_to_cpu(bpl->tus.w);
1977 
1978 	CtReq = (struct lpfc_sli_ct_request *) mp->virt;
1979 	memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request));
1980 	CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
1981 	CtReq->RevisionId.bits.InId = 0;
1982 	CtReq->FsType = SLI_CT_DIRECTORY_SERVICE;
1983 	CtReq->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER;
1984 	CtReq->CommandResponse.bits.Size = 0;
1985 	switch (cmdcode) {
1986 	case SLI_CTNS_GID_FT:
1987 		CtReq->CommandResponse.bits.CmdRsp =
1988 		    cpu_to_be16(SLI_CTNS_GID_FT);
1989 		CtReq->un.gid.Fc4Type = context;
1990 
1991 		if (vport->port_state < LPFC_NS_QRY)
1992 			vport->port_state = LPFC_NS_QRY;
1993 		lpfc_set_disctmo(vport);
1994 		cmpl = lpfc_cmpl_ct_cmd_gid_ft;
1995 		rsp_size = FC_MAX_NS_RSP;
1996 		break;
1997 
1998 	case SLI_CTNS_GID_PT:
1999 		CtReq->CommandResponse.bits.CmdRsp =
2000 		    cpu_to_be16(SLI_CTNS_GID_PT);
2001 		CtReq->un.gid.PortType = context;
2002 
2003 		if (vport->port_state < LPFC_NS_QRY)
2004 			vport->port_state = LPFC_NS_QRY;
2005 		lpfc_set_disctmo(vport);
2006 		cmpl = lpfc_cmpl_ct_cmd_gid_pt;
2007 		rsp_size = FC_MAX_NS_RSP;
2008 		break;
2009 
2010 	case SLI_CTNS_GFF_ID:
2011 		CtReq->CommandResponse.bits.CmdRsp =
2012 			cpu_to_be16(SLI_CTNS_GFF_ID);
2013 		CtReq->un.gff.PortId = cpu_to_be32(context);
2014 		cmpl = lpfc_cmpl_ct_cmd_gff_id;
2015 		break;
2016 
2017 	case SLI_CTNS_GFT_ID:
2018 		CtReq->CommandResponse.bits.CmdRsp =
2019 			cpu_to_be16(SLI_CTNS_GFT_ID);
2020 		CtReq->un.gft.PortId = cpu_to_be32(context);
2021 		cmpl = lpfc_cmpl_ct_cmd_gft_id;
2022 		break;
2023 
2024 	case SLI_CTNS_RFT_ID:
2025 		vport->ct_flags &= ~FC_CT_RFT_ID;
2026 		CtReq->CommandResponse.bits.CmdRsp =
2027 		    cpu_to_be16(SLI_CTNS_RFT_ID);
2028 		CtReq->un.rft.port_id = cpu_to_be32(vport->fc_myDID);
2029 
2030 		/* Register Application Services type if vmid enabled. */
2031 		if (phba->cfg_vmid_app_header)
2032 			CtReq->un.rft.app_serv_reg =
2033 				cpu_to_be32(RFT_APP_SERV_REG);
2034 
2035 		/* Register FC4 FCP type if enabled.  */
2036 		if (vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH ||
2037 		    vport->cfg_enable_fc4_type == LPFC_ENABLE_FCP)
2038 			CtReq->un.rft.fcp_reg = cpu_to_be32(RFT_FCP_REG);
2039 
2040 		/* Register NVME type if enabled. */
2041 		if (vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH ||
2042 		    vport->cfg_enable_fc4_type == LPFC_ENABLE_NVME)
2043 			CtReq->un.rft.nvme_reg = cpu_to_be32(RFT_NVME_REG);
2044 
2045 		ptr = (uint32_t *)CtReq;
2046 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2047 				 "6433 Issue RFT (%s %s %s): %08x %08x %08x "
2048 				 "%08x %08x %08x %08x %08x\n",
2049 				 CtReq->un.rft.fcp_reg ? "FCP" : " ",
2050 				 CtReq->un.rft.nvme_reg ? "NVME" : " ",
2051 				 CtReq->un.rft.app_serv_reg ? "APPS" : " ",
2052 				 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3),
2053 				 *(ptr + 4), *(ptr + 5),
2054 				 *(ptr + 6), *(ptr + 7));
2055 		cmpl = lpfc_cmpl_ct_cmd_rft_id;
2056 		break;
2057 
2058 	case SLI_CTNS_RNN_ID:
2059 		vport->ct_flags &= ~FC_CT_RNN_ID;
2060 		CtReq->CommandResponse.bits.CmdRsp =
2061 		    cpu_to_be16(SLI_CTNS_RNN_ID);
2062 		CtReq->un.rnn.PortId = cpu_to_be32(vport->fc_myDID);
2063 		memcpy(CtReq->un.rnn.wwnn,  &vport->fc_nodename,
2064 		       sizeof(struct lpfc_name));
2065 		cmpl = lpfc_cmpl_ct_cmd_rnn_id;
2066 		break;
2067 
2068 	case SLI_CTNS_RSPN_ID:
2069 		vport->ct_flags &= ~FC_CT_RSPN_ID;
2070 		CtReq->CommandResponse.bits.CmdRsp =
2071 		    cpu_to_be16(SLI_CTNS_RSPN_ID);
2072 		CtReq->un.rspn.PortId = cpu_to_be32(vport->fc_myDID);
2073 		size = sizeof(CtReq->un.rspn.symbname);
2074 		CtReq->un.rspn.len =
2075 			lpfc_vport_symbolic_port_name(vport,
2076 			CtReq->un.rspn.symbname, size);
2077 		cmpl = lpfc_cmpl_ct_cmd_rspn_id;
2078 		break;
2079 	case SLI_CTNS_RSNN_NN:
2080 		vport->ct_flags &= ~FC_CT_RSNN_NN;
2081 		CtReq->CommandResponse.bits.CmdRsp =
2082 		    cpu_to_be16(SLI_CTNS_RSNN_NN);
2083 		memcpy(CtReq->un.rsnn.wwnn, &vport->fc_nodename,
2084 		       sizeof(struct lpfc_name));
2085 		size = sizeof(CtReq->un.rsnn.symbname);
2086 		CtReq->un.rsnn.len =
2087 			lpfc_vport_symbolic_node_name(vport,
2088 			CtReq->un.rsnn.symbname, size);
2089 		cmpl = lpfc_cmpl_ct_cmd_rsnn_nn;
2090 		break;
2091 	case SLI_CTNS_DA_ID:
2092 		/* Implement DA_ID Nameserver request */
2093 		CtReq->CommandResponse.bits.CmdRsp =
2094 			cpu_to_be16(SLI_CTNS_DA_ID);
2095 		CtReq->un.da_id.port_id = cpu_to_be32(vport->fc_myDID);
2096 		cmpl = lpfc_cmpl_ct_cmd_da_id;
2097 		break;
2098 	case SLI_CTNS_RFF_ID:
2099 		vport->ct_flags &= ~FC_CT_RFF_ID;
2100 		CtReq->CommandResponse.bits.CmdRsp =
2101 		    cpu_to_be16(SLI_CTNS_RFF_ID);
2102 		CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID);
2103 		CtReq->un.rff.fbits = FC4_FEATURE_INIT;
2104 
2105 		/* The driver always supports FC_TYPE_FCP.  However, the
2106 		 * caller can specify NVME (type x28) as well.  But only
2107 		 * these that FC4 type is supported.
2108 		 */
2109 		if (((vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) ||
2110 		     (vport->cfg_enable_fc4_type == LPFC_ENABLE_NVME)) &&
2111 		    (context == FC_TYPE_NVME)) {
2112 			if ((vport == phba->pport) && phba->nvmet_support) {
2113 				CtReq->un.rff.fbits = (FC4_FEATURE_TARGET |
2114 					FC4_FEATURE_NVME_DISC);
2115 				lpfc_nvmet_update_targetport(phba);
2116 			} else {
2117 				lpfc_nvme_update_localport(vport);
2118 			}
2119 			CtReq->un.rff.type_code = context;
2120 
2121 		} else if (((vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) ||
2122 			    (vport->cfg_enable_fc4_type == LPFC_ENABLE_FCP)) &&
2123 			   (context == FC_TYPE_FCP))
2124 			CtReq->un.rff.type_code = context;
2125 
2126 		else
2127 			goto ns_cmd_free_bmpvirt;
2128 
2129 		ptr = (uint32_t *)CtReq;
2130 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2131 				 "6434 Issue RFF (%s): %08x %08x %08x %08x "
2132 				 "%08x %08x %08x %08x\n",
2133 				 (context == FC_TYPE_NVME) ? "NVME" : "FCP",
2134 				 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3),
2135 				 *(ptr + 4), *(ptr + 5),
2136 				 *(ptr + 6), *(ptr + 7));
2137 		cmpl = lpfc_cmpl_ct_cmd_rff_id;
2138 		break;
2139 	}
2140 	/* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
2141 	 * to hold ndlp reference for the corresponding callback function.
2142 	 */
2143 	if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry)) {
2144 		/* On success, The cmpl function will free the buffers */
2145 		lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
2146 			"Issue CT cmd:    cmd:x%x did:x%x",
2147 			cmdcode, ndlp->nlp_DID, 0);
2148 		return 0;
2149 	}
2150 	rc=6;
2151 
2152 ns_cmd_free_bmpvirt:
2153 	lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
2154 ns_cmd_free_bmp:
2155 	kfree(bmp);
2156 ns_cmd_free_mpvirt:
2157 	lpfc_mbuf_free(phba, mp->virt, mp->phys);
2158 ns_cmd_free_mp:
2159 	kfree(mp);
2160 ns_cmd_exit:
2161 	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
2162 			 "0266 Issue NameServer Req x%x err %d Data: x%x x%x\n",
2163 			 cmdcode, rc, vport->fc_flag, vport->fc_rscn_id_cnt);
2164 	return 1;
2165 }
2166 
2167 /**
2168  * lpfc_fdmi_rprt_defer - Check for any deferred FDMI RPRT commands
2169  * @phba: Pointer to HBA context object.
2170  * @mask: Initial port attributes mask
2171  *
2172  * This function checks to see if any vports have deferred their FDMI RPRT.
2173  * A vports RPRT may be deferred if it is issued before the primary ports
2174  * RHBA completes.
2175  */
2176 static void
2177 lpfc_fdmi_rprt_defer(struct lpfc_hba *phba, uint32_t mask)
2178 {
2179 	struct lpfc_vport **vports;
2180 	struct lpfc_vport *vport;
2181 	struct lpfc_nodelist *ndlp;
2182 	int i;
2183 
2184 	phba->hba_flag |= HBA_RHBA_CMPL;
2185 	vports = lpfc_create_vport_work_array(phba);
2186 	if (vports) {
2187 		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2188 			vport = vports[i];
2189 			ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2190 			if (!ndlp)
2191 				continue;
2192 			if (vport->ct_flags & FC_CT_RPRT_DEFER) {
2193 				vport->ct_flags &= ~FC_CT_RPRT_DEFER;
2194 				vport->fdmi_port_mask = mask;
2195 				lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT, 0);
2196 			}
2197 		}
2198 	}
2199 	lpfc_destroy_vport_work_array(phba, vports);
2200 }
2201 
2202 /**
2203  * lpfc_cmpl_ct_disc_fdmi - Handle a discovery FDMI completion
2204  * @phba: Pointer to HBA context object.
2205  * @cmdiocb: Pointer to the command IOCBQ.
2206  * @rspiocb: Pointer to the response IOCBQ.
2207  *
2208  * This function to handle the completion of a driver initiated FDMI
2209  * CT command issued during discovery.
2210  */
2211 static void
2212 lpfc_cmpl_ct_disc_fdmi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2213 		       struct lpfc_iocbq *rspiocb)
2214 {
2215 	struct lpfc_vport *vport = cmdiocb->vport;
2216 	struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf;
2217 	struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf;
2218 	struct lpfc_sli_ct_request *CTcmd = inp->virt;
2219 	struct lpfc_sli_ct_request *CTrsp = outp->virt;
2220 	__be16 fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp;
2221 	__be16 fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp;
2222 	struct lpfc_nodelist *ndlp, *free_ndlp = NULL;
2223 	uint32_t latt, cmd, err;
2224 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
2225 	u32 ulp_word4 = get_job_word4(phba, rspiocb);
2226 
2227 	latt = lpfc_els_chk_latt(vport);
2228 	lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
2229 		"FDMI cmpl:       status:x%x/x%x latt:%d",
2230 		ulp_status, ulp_word4, latt);
2231 
2232 	if (latt || ulp_status) {
2233 
2234 		/* Look for a retryable error */
2235 		if (ulp_status == IOSTAT_LOCAL_REJECT) {
2236 			switch ((ulp_word4 & IOERR_PARAM_MASK)) {
2237 			case IOERR_SLI_ABORTED:
2238 			case IOERR_SLI_DOWN:
2239 				/* Driver aborted this IO.  No retry as error
2240 				 * is likely Offline->Online or some adapter
2241 				 * error.  Recovery will try again.
2242 				 */
2243 				break;
2244 			case IOERR_ABORT_IN_PROGRESS:
2245 			case IOERR_SEQUENCE_TIMEOUT:
2246 			case IOERR_ILLEGAL_FRAME:
2247 			case IOERR_NO_RESOURCES:
2248 			case IOERR_ILLEGAL_COMMAND:
2249 				cmdiocb->retry++;
2250 				if (cmdiocb->retry >= LPFC_FDMI_MAX_RETRY)
2251 					break;
2252 
2253 				/* Retry the same FDMI command */
2254 				err = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING,
2255 							  cmdiocb, 0);
2256 				if (err == IOCB_ERROR)
2257 					break;
2258 				return;
2259 			default:
2260 				break;
2261 			}
2262 		}
2263 
2264 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2265 				 "0229 FDMI cmd %04x failed, latt = %d "
2266 				 "ulp_status: x%x, rid x%x\n",
2267 				 be16_to_cpu(fdmi_cmd), latt, ulp_status,
2268 				 ulp_word4);
2269 	}
2270 
2271 	free_ndlp = cmdiocb->ndlp;
2272 	lpfc_ct_free_iocb(phba, cmdiocb);
2273 	lpfc_nlp_put(free_ndlp);
2274 
2275 	ndlp = lpfc_findnode_did(vport, FDMI_DID);
2276 	if (!ndlp)
2277 		return;
2278 
2279 	/* Check for a CT LS_RJT response */
2280 	cmd =  be16_to_cpu(fdmi_cmd);
2281 	if (be16_to_cpu(fdmi_rsp) == SLI_CT_RESPONSE_FS_RJT) {
2282 		/* FDMI rsp failed */
2283 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY | LOG_ELS,
2284 				 "0220 FDMI cmd failed FS_RJT Data: x%x", cmd);
2285 
2286 		/* Should we fallback to FDMI-2 / FDMI-1 ? */
2287 		switch (cmd) {
2288 		case SLI_MGMT_RHBA:
2289 			if (vport->fdmi_hba_mask == LPFC_FDMI2_HBA_ATTR) {
2290 				/* Fallback to FDMI-1 for HBA attributes */
2291 				vport->fdmi_hba_mask = LPFC_FDMI1_HBA_ATTR;
2292 
2293 				/* If HBA attributes are FDMI1, so should
2294 				 * port attributes be for consistency.
2295 				 */
2296 				vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
2297 				/* Start over */
2298 				lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
2299 			}
2300 			return;
2301 
2302 		case SLI_MGMT_RPRT:
2303 			if (vport->port_type != LPFC_PHYSICAL_PORT) {
2304 				ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2305 				if (!ndlp)
2306 					return;
2307 			}
2308 			if (vport->fdmi_port_mask == LPFC_FDMI2_PORT_ATTR) {
2309 				/* Fallback to FDMI-1 */
2310 				vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
2311 				/* Start over */
2312 				lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
2313 				return;
2314 			}
2315 			if (vport->fdmi_port_mask == LPFC_FDMI2_SMART_ATTR) {
2316 				vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
2317 				/* Retry the same command */
2318 				lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
2319 			}
2320 			return;
2321 
2322 		case SLI_MGMT_RPA:
2323 			/* No retry on Vendor, RPA only done on physical port */
2324 			if (phba->link_flag & LS_CT_VEN_RPA) {
2325 				phba->link_flag &= ~LS_CT_VEN_RPA;
2326 				if (phba->cmf_active_mode == LPFC_CFG_OFF)
2327 					return;
2328 				lpfc_printf_log(phba, KERN_WARNING,
2329 						LOG_DISCOVERY | LOG_ELS,
2330 						"6460 VEN FDMI RPA RJT\n");
2331 				return;
2332 			}
2333 			if (vport->fdmi_port_mask == LPFC_FDMI2_PORT_ATTR) {
2334 				/* Fallback to FDMI-1 */
2335 				vport->fdmi_hba_mask = LPFC_FDMI1_HBA_ATTR;
2336 				vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
2337 				/* Start over */
2338 				lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
2339 				return;
2340 			}
2341 			if (vport->fdmi_port_mask == LPFC_FDMI2_SMART_ATTR) {
2342 				vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
2343 				/* Retry the same command */
2344 				lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
2345 			}
2346 			return;
2347 		}
2348 	}
2349 
2350 	/*
2351 	 * On success, need to cycle thru FDMI registration for discovery
2352 	 * DHBA -> DPRT -> RHBA -> RPA  (physical port)
2353 	 * DPRT -> RPRT (vports)
2354 	 */
2355 	switch (cmd) {
2356 	case SLI_MGMT_RHBA:
2357 		/* Check for any RPRTs deferred till after RHBA completes */
2358 		lpfc_fdmi_rprt_defer(phba, vport->fdmi_port_mask);
2359 
2360 		lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA, 0);
2361 		break;
2362 
2363 	case SLI_MGMT_DHBA:
2364 		lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT, 0);
2365 		break;
2366 
2367 	case SLI_MGMT_DPRT:
2368 		if (vport->port_type == LPFC_PHYSICAL_PORT) {
2369 			lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RHBA, 0);
2370 		} else {
2371 			ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2372 			if (!ndlp)
2373 				return;
2374 
2375 			/* Only issue a RPRT for the vport if the RHBA
2376 			 * for the physical port completes successfully.
2377 			 * We may have to defer the RPRT accordingly.
2378 			 */
2379 			if (phba->hba_flag & HBA_RHBA_CMPL) {
2380 				lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT, 0);
2381 			} else {
2382 				lpfc_printf_vlog(vport, KERN_INFO,
2383 						 LOG_DISCOVERY,
2384 						 "6078 RPRT deferred\n");
2385 				vport->ct_flags |= FC_CT_RPRT_DEFER;
2386 			}
2387 		}
2388 		break;
2389 	case SLI_MGMT_RPA:
2390 		if (vport->port_type == LPFC_PHYSICAL_PORT &&
2391 		    phba->sli4_hba.pc_sli4_params.mi_ver) {
2392 			/* mi is only for the phyical port, no vports */
2393 			if (phba->link_flag & LS_CT_VEN_RPA) {
2394 				lpfc_printf_vlog(vport, KERN_INFO,
2395 						 LOG_DISCOVERY | LOG_ELS |
2396 						 LOG_CGN_MGMT,
2397 						 "6449 VEN RPA FDMI Success\n");
2398 				phba->link_flag &= ~LS_CT_VEN_RPA;
2399 				break;
2400 			}
2401 
2402 			lpfc_printf_log(phba, KERN_INFO,
2403 					LOG_DISCOVERY | LOG_CGN_MGMT,
2404 					"6210 Issue Vendor MI FDMI %x\n",
2405 					phba->sli4_hba.pc_sli4_params.mi_ver);
2406 
2407 			/* CGN is only for the physical port, no vports */
2408 			if (lpfc_fdmi_cmd(vport, ndlp, cmd,
2409 					  LPFC_FDMI_VENDOR_ATTR_mi) == 0)
2410 				phba->link_flag |= LS_CT_VEN_RPA;
2411 			lpfc_printf_log(phba, KERN_INFO,
2412 					LOG_DISCOVERY | LOG_ELS,
2413 					"6458 Send MI FDMI:%x Flag x%x\n",
2414 					phba->sli4_hba.pc_sli4_params.mi_ver,
2415 					phba->link_flag);
2416 		} else {
2417 			lpfc_printf_log(phba, KERN_INFO,
2418 					LOG_DISCOVERY | LOG_ELS,
2419 					"6459 No FDMI VEN MI support - "
2420 					"RPA Success\n");
2421 		}
2422 		break;
2423 	}
2424 	return;
2425 }
2426 
2427 
2428 /**
2429  * lpfc_fdmi_change_check - Check for changed FDMI parameters
2430  * @vport: pointer to a host virtual N_Port data structure.
2431  *
2432  * Check how many mapped NPorts we are connected to
2433  * Check if our hostname changed
2434  * Called from hbeat timeout routine to check if any FDMI parameters
2435  * changed. If so, re-register those Attributes.
2436  */
2437 void
2438 lpfc_fdmi_change_check(struct lpfc_vport *vport)
2439 {
2440 	struct lpfc_hba *phba = vport->phba;
2441 	struct lpfc_nodelist *ndlp;
2442 	uint16_t cnt;
2443 
2444 	if (!lpfc_is_link_up(phba))
2445 		return;
2446 
2447 	/* Must be connected to a Fabric */
2448 	if (!(vport->fc_flag & FC_FABRIC))
2449 		return;
2450 
2451 	ndlp = lpfc_findnode_did(vport, FDMI_DID);
2452 	if (!ndlp)
2453 		return;
2454 
2455 	/* Check if system hostname changed */
2456 	if (strcmp(phba->os_host_name, init_utsname()->nodename)) {
2457 		memset(phba->os_host_name, 0, sizeof(phba->os_host_name));
2458 		scnprintf(phba->os_host_name, sizeof(phba->os_host_name), "%s",
2459 			  init_utsname()->nodename);
2460 		lpfc_ns_cmd(vport, SLI_CTNS_RSNN_NN, 0, 0);
2461 
2462 		/* Since this effects multiple HBA and PORT attributes, we need
2463 		 * de-register and go thru the whole FDMI registration cycle.
2464 		 * DHBA -> DPRT -> RHBA -> RPA  (physical port)
2465 		 * DPRT -> RPRT (vports)
2466 		 */
2467 		if (vport->port_type == LPFC_PHYSICAL_PORT) {
2468 			/* For extra Vendor RPA */
2469 			phba->link_flag &= ~LS_CT_VEN_RPA;
2470 			lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
2471 		} else {
2472 			ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2473 			if (!ndlp)
2474 				return;
2475 			lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT, 0);
2476 		}
2477 
2478 		/* Since this code path registers all the port attributes
2479 		 * we can just return without further checking.
2480 		 */
2481 		return;
2482 	}
2483 
2484 	if (!(vport->fdmi_port_mask & LPFC_FDMI_PORT_ATTR_num_disc))
2485 		return;
2486 
2487 	/* Check if the number of mapped NPorts changed */
2488 	cnt = lpfc_find_map_node(vport);
2489 	if (cnt == vport->fdmi_num_disc)
2490 		return;
2491 
2492 	if (vport->port_type == LPFC_PHYSICAL_PORT) {
2493 		lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA,
2494 			      LPFC_FDMI_PORT_ATTR_num_disc);
2495 	} else {
2496 		ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2497 		if (!ndlp)
2498 			return;
2499 		lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT,
2500 			      LPFC_FDMI_PORT_ATTR_num_disc);
2501 	}
2502 }
2503 
2504 static inline int
2505 lpfc_fdmi_set_attr_u32(void *attr, uint16_t attrtype, uint32_t attrval)
2506 {
2507 	struct lpfc_fdmi_attr_u32 *ae = attr;
2508 	int size = sizeof(*ae);
2509 
2510 	ae->type = cpu_to_be16(attrtype);
2511 	ae->len = cpu_to_be16(size);
2512 	ae->value_u32 = cpu_to_be32(attrval);
2513 
2514 	return size;
2515 }
2516 
2517 static inline int
2518 lpfc_fdmi_set_attr_wwn(void *attr, uint16_t attrtype, struct lpfc_name *wwn)
2519 {
2520 	struct lpfc_fdmi_attr_wwn *ae = attr;
2521 	int size = sizeof(*ae);
2522 
2523 	ae->type = cpu_to_be16(attrtype);
2524 	ae->len = cpu_to_be16(size);
2525 	/* WWN's assumed to be bytestreams - Big Endian presentation */
2526 	memcpy(ae->name, wwn,
2527 	       min_t(size_t, sizeof(struct lpfc_name), sizeof(__be64)));
2528 
2529 	return size;
2530 }
2531 
2532 static inline int
2533 lpfc_fdmi_set_attr_fullwwn(void *attr, uint16_t attrtype,
2534 			   struct lpfc_name *wwnn, struct lpfc_name *wwpn)
2535 {
2536 	struct lpfc_fdmi_attr_fullwwn *ae = attr;
2537 	u8 *nname = ae->nname;
2538 	u8 *pname = ae->pname;
2539 	int size = sizeof(*ae);
2540 
2541 	ae->type = cpu_to_be16(attrtype);
2542 	ae->len = cpu_to_be16(size);
2543 	/* WWN's assumed to be bytestreams - Big Endian presentation */
2544 	memcpy(nname, wwnn,
2545 	       min_t(size_t, sizeof(struct lpfc_name), sizeof(__be64)));
2546 	memcpy(pname, wwpn,
2547 	       min_t(size_t, sizeof(struct lpfc_name), sizeof(__be64)));
2548 
2549 	return size;
2550 }
2551 
2552 static inline int
2553 lpfc_fdmi_set_attr_string(void *attr, uint16_t attrtype, char *attrstring)
2554 {
2555 	struct lpfc_fdmi_attr_string *ae = attr;
2556 	int len, size;
2557 
2558 	/*
2559 	 * We are trusting the caller that if a fdmi string field
2560 	 * is capped at 64 bytes, the caller passes in a string of
2561 	 * 64 bytes or less.
2562 	 */
2563 
2564 	strncpy(ae->value_string, attrstring, sizeof(ae->value_string));
2565 	len = strnlen(ae->value_string, sizeof(ae->value_string));
2566 	/* round string length to a 32bit boundary. Ensure there's a NULL */
2567 	len += (len & 3) ? (4 - (len & 3)) : 4;
2568 	/* size is Type/Len (4 bytes) plus string length */
2569 	size = FOURBYTES + len;
2570 
2571 	ae->type = cpu_to_be16(attrtype);
2572 	ae->len = cpu_to_be16(size);
2573 
2574 	return size;
2575 }
2576 
2577 /* Bitfields for FC4 Types that can be reported */
2578 #define ATTR_FC4_CT	0x00000001
2579 #define ATTR_FC4_FCP	0x00000002
2580 #define ATTR_FC4_NVME	0x00000004
2581 
2582 static inline int
2583 lpfc_fdmi_set_attr_fc4types(void *attr, uint16_t attrtype, uint32_t typemask)
2584 {
2585 	struct lpfc_fdmi_attr_fc4types *ae = attr;
2586 	int size = sizeof(*ae);
2587 
2588 	ae->type = cpu_to_be16(attrtype);
2589 	ae->len = cpu_to_be16(size);
2590 
2591 	if (typemask & ATTR_FC4_FCP)
2592 		ae->value_types[2] = 0x01; /* Type 0x8 - FCP */
2593 
2594 	if (typemask & ATTR_FC4_CT)
2595 		ae->value_types[7] = 0x01; /* Type 0x20 - CT */
2596 
2597 	if (typemask & ATTR_FC4_NVME)
2598 		ae->value_types[6] = 0x01; /* Type 0x28 - NVME */
2599 
2600 	return size;
2601 }
2602 
2603 /* Routines for all individual HBA attributes */
2604 static int
2605 lpfc_fdmi_hba_attr_wwnn(struct lpfc_vport *vport, void *attr)
2606 {
2607 	return lpfc_fdmi_set_attr_wwn(attr, RHBA_NODENAME,
2608 			&vport->fc_sparam.nodeName);
2609 }
2610 
2611 static int
2612 lpfc_fdmi_hba_attr_manufacturer(struct lpfc_vport *vport, void *attr)
2613 {
2614 	/* This string MUST be consistent with other FC platforms
2615 	 * supported by Broadcom.
2616 	 */
2617 	return lpfc_fdmi_set_attr_string(attr, RHBA_MANUFACTURER,
2618 			"Emulex Corporation");
2619 }
2620 
2621 static int
2622 lpfc_fdmi_hba_attr_sn(struct lpfc_vport *vport, void *attr)
2623 {
2624 	struct lpfc_hba *phba = vport->phba;
2625 
2626 	return lpfc_fdmi_set_attr_string(attr, RHBA_SERIAL_NUMBER,
2627 			phba->SerialNumber);
2628 }
2629 
2630 static int
2631 lpfc_fdmi_hba_attr_model(struct lpfc_vport *vport, void *attr)
2632 {
2633 	struct lpfc_hba *phba = vport->phba;
2634 
2635 	return lpfc_fdmi_set_attr_string(attr, RHBA_MODEL,
2636 			phba->ModelName);
2637 }
2638 
2639 static int
2640 lpfc_fdmi_hba_attr_description(struct lpfc_vport *vport, void *attr)
2641 {
2642 	struct lpfc_hba *phba = vport->phba;
2643 
2644 	return lpfc_fdmi_set_attr_string(attr, RHBA_MODEL_DESCRIPTION,
2645 			phba->ModelDesc);
2646 }
2647 
2648 static int
2649 lpfc_fdmi_hba_attr_hdw_ver(struct lpfc_vport *vport, void *attr)
2650 {
2651 	struct lpfc_hba *phba = vport->phba;
2652 	lpfc_vpd_t *vp = &phba->vpd;
2653 	char buf[16] = { 0 };
2654 
2655 	snprintf(buf, sizeof(buf), "%08x", vp->rev.biuRev);
2656 
2657 	return lpfc_fdmi_set_attr_string(attr, RHBA_HARDWARE_VERSION, buf);
2658 }
2659 
2660 static int
2661 lpfc_fdmi_hba_attr_drvr_ver(struct lpfc_vport *vport, void *attr)
2662 {
2663 	return lpfc_fdmi_set_attr_string(attr, RHBA_DRIVER_VERSION,
2664 			lpfc_release_version);
2665 }
2666 
2667 static int
2668 lpfc_fdmi_hba_attr_rom_ver(struct lpfc_vport *vport, void *attr)
2669 {
2670 	struct lpfc_hba *phba = vport->phba;
2671 	char buf[64] = { 0 };
2672 
2673 	if (phba->sli_rev == LPFC_SLI_REV4) {
2674 		lpfc_decode_firmware_rev(phba, buf, 1);
2675 
2676 		return lpfc_fdmi_set_attr_string(attr, RHBA_OPTION_ROM_VERSION,
2677 				buf);
2678 	}
2679 
2680 	return lpfc_fdmi_set_attr_string(attr, RHBA_OPTION_ROM_VERSION,
2681 			phba->OptionROMVersion);
2682 }
2683 
2684 static int
2685 lpfc_fdmi_hba_attr_fmw_ver(struct lpfc_vport *vport, void *attr)
2686 {
2687 	struct lpfc_hba *phba = vport->phba;
2688 	char buf[64] = { 0 };
2689 
2690 	lpfc_decode_firmware_rev(phba, buf, 1);
2691 
2692 	return lpfc_fdmi_set_attr_string(attr, RHBA_FIRMWARE_VERSION, buf);
2693 }
2694 
2695 static int
2696 lpfc_fdmi_hba_attr_os_ver(struct lpfc_vport *vport, void *attr)
2697 {
2698 	char buf[256] = { 0 };
2699 
2700 	snprintf(buf, sizeof(buf), "%s %s %s",
2701 		 init_utsname()->sysname,
2702 		 init_utsname()->release,
2703 		 init_utsname()->version);
2704 
2705 	return lpfc_fdmi_set_attr_string(attr, RHBA_OS_NAME_VERSION, buf);
2706 }
2707 
2708 static int
2709 lpfc_fdmi_hba_attr_ct_len(struct lpfc_vport *vport, void *attr)
2710 {
2711 	return lpfc_fdmi_set_attr_u32(attr, RHBA_MAX_CT_PAYLOAD_LEN,
2712 			LPFC_MAX_CT_SIZE);
2713 }
2714 
2715 static int
2716 lpfc_fdmi_hba_attr_symbolic_name(struct lpfc_vport *vport, void *attr)
2717 {
2718 	char buf[256] = { 0 };
2719 
2720 	lpfc_vport_symbolic_node_name(vport, buf, sizeof(buf));
2721 
2722 	return lpfc_fdmi_set_attr_string(attr, RHBA_SYM_NODENAME, buf);
2723 }
2724 
2725 static int
2726 lpfc_fdmi_hba_attr_vendor_info(struct lpfc_vport *vport, void *attr)
2727 {
2728 	return lpfc_fdmi_set_attr_u32(attr, RHBA_VENDOR_INFO, 0);
2729 }
2730 
2731 static int
2732 lpfc_fdmi_hba_attr_num_ports(struct lpfc_vport *vport, void *attr)
2733 {
2734 	/* Each driver instance corresponds to a single port */
2735 	return lpfc_fdmi_set_attr_u32(attr, RHBA_NUM_PORTS, 1);
2736 }
2737 
2738 static int
2739 lpfc_fdmi_hba_attr_fabric_wwnn(struct lpfc_vport *vport, void *attr)
2740 {
2741 	return lpfc_fdmi_set_attr_wwn(attr, RHBA_FABRIC_WWNN,
2742 			&vport->fabric_nodename);
2743 }
2744 
2745 static int
2746 lpfc_fdmi_hba_attr_bios_ver(struct lpfc_vport *vport, void *attr)
2747 {
2748 	struct lpfc_hba *phba = vport->phba;
2749 
2750 	return lpfc_fdmi_set_attr_string(attr, RHBA_BIOS_VERSION,
2751 			phba->BIOSVersion);
2752 }
2753 
2754 static int
2755 lpfc_fdmi_hba_attr_bios_state(struct lpfc_vport *vport, void *attr)
2756 {
2757 	/* Driver doesn't have access to this information */
2758 	return lpfc_fdmi_set_attr_u32(attr, RHBA_BIOS_STATE, 0);
2759 }
2760 
2761 static int
2762 lpfc_fdmi_hba_attr_vendor_id(struct lpfc_vport *vport, void *attr)
2763 {
2764 	return lpfc_fdmi_set_attr_string(attr, RHBA_VENDOR_ID, "EMULEX");
2765 }
2766 
2767 /*
2768  * Routines for all individual PORT attributes
2769  */
2770 
2771 static int
2772 lpfc_fdmi_port_attr_fc4type(struct lpfc_vport *vport, void *attr)
2773 {
2774 	struct lpfc_hba   *phba = vport->phba;
2775 	u32 fc4types;
2776 
2777 	fc4types = (ATTR_FC4_CT | ATTR_FC4_FCP);
2778 
2779 	/* Check to see if Firmware supports NVME and on physical port */
2780 	if ((phba->sli_rev == LPFC_SLI_REV4) && (vport == phba->pport) &&
2781 	    phba->sli4_hba.pc_sli4_params.nvme)
2782 		fc4types |= ATTR_FC4_NVME;
2783 
2784 	return lpfc_fdmi_set_attr_fc4types(attr, RPRT_SUPPORTED_FC4_TYPES,
2785 			fc4types);
2786 }
2787 
2788 static int
2789 lpfc_fdmi_port_attr_support_speed(struct lpfc_vport *vport, void *attr)
2790 {
2791 	struct lpfc_hba *phba = vport->phba;
2792 	u32 speeds = 0;
2793 	u32 tcfg;
2794 	u8 i, cnt;
2795 
2796 	if (!(phba->hba_flag & HBA_FCOE_MODE)) {
2797 		cnt = 0;
2798 		if (phba->sli_rev == LPFC_SLI_REV4) {
2799 			tcfg = phba->sli4_hba.conf_trunk;
2800 			for (i = 0; i < 4; i++, tcfg >>= 1)
2801 				if (tcfg & 1)
2802 					cnt++;
2803 		}
2804 
2805 		if (cnt > 2) { /* 4 lane trunk group */
2806 			if (phba->lmt & LMT_64Gb)
2807 				speeds |= HBA_PORTSPEED_256GFC;
2808 			if (phba->lmt & LMT_32Gb)
2809 				speeds |= HBA_PORTSPEED_128GFC;
2810 			if (phba->lmt & LMT_16Gb)
2811 				speeds |= HBA_PORTSPEED_64GFC;
2812 		} else if (cnt) { /* 2 lane trunk group */
2813 			if (phba->lmt & LMT_128Gb)
2814 				speeds |= HBA_PORTSPEED_256GFC;
2815 			if (phba->lmt & LMT_64Gb)
2816 				speeds |= HBA_PORTSPEED_128GFC;
2817 			if (phba->lmt & LMT_32Gb)
2818 				speeds |= HBA_PORTSPEED_64GFC;
2819 			if (phba->lmt & LMT_16Gb)
2820 				speeds |= HBA_PORTSPEED_32GFC;
2821 		} else {
2822 			if (phba->lmt & LMT_256Gb)
2823 				speeds |= HBA_PORTSPEED_256GFC;
2824 			if (phba->lmt & LMT_128Gb)
2825 				speeds |= HBA_PORTSPEED_128GFC;
2826 			if (phba->lmt & LMT_64Gb)
2827 				speeds |= HBA_PORTSPEED_64GFC;
2828 			if (phba->lmt & LMT_32Gb)
2829 				speeds |= HBA_PORTSPEED_32GFC;
2830 			if (phba->lmt & LMT_16Gb)
2831 				speeds |= HBA_PORTSPEED_16GFC;
2832 			if (phba->lmt & LMT_10Gb)
2833 				speeds |= HBA_PORTSPEED_10GFC;
2834 			if (phba->lmt & LMT_8Gb)
2835 				speeds |= HBA_PORTSPEED_8GFC;
2836 			if (phba->lmt & LMT_4Gb)
2837 				speeds |= HBA_PORTSPEED_4GFC;
2838 			if (phba->lmt & LMT_2Gb)
2839 				speeds |= HBA_PORTSPEED_2GFC;
2840 			if (phba->lmt & LMT_1Gb)
2841 				speeds |= HBA_PORTSPEED_1GFC;
2842 		}
2843 	} else {
2844 		/* FCoE links support only one speed */
2845 		switch (phba->fc_linkspeed) {
2846 		case LPFC_ASYNC_LINK_SPEED_10GBPS:
2847 			speeds = HBA_PORTSPEED_10GE;
2848 			break;
2849 		case LPFC_ASYNC_LINK_SPEED_25GBPS:
2850 			speeds = HBA_PORTSPEED_25GE;
2851 			break;
2852 		case LPFC_ASYNC_LINK_SPEED_40GBPS:
2853 			speeds = HBA_PORTSPEED_40GE;
2854 			break;
2855 		case LPFC_ASYNC_LINK_SPEED_100GBPS:
2856 			speeds = HBA_PORTSPEED_100GE;
2857 			break;
2858 		}
2859 	}
2860 
2861 	return lpfc_fdmi_set_attr_u32(attr, RPRT_SUPPORTED_SPEED, speeds);
2862 }
2863 
2864 static int
2865 lpfc_fdmi_port_attr_speed(struct lpfc_vport *vport, void *attr)
2866 {
2867 	struct lpfc_hba   *phba = vport->phba;
2868 	u32 speeds = 0;
2869 
2870 	if (!(phba->hba_flag & HBA_FCOE_MODE)) {
2871 		switch (phba->fc_linkspeed) {
2872 		case LPFC_LINK_SPEED_1GHZ:
2873 			speeds = HBA_PORTSPEED_1GFC;
2874 			break;
2875 		case LPFC_LINK_SPEED_2GHZ:
2876 			speeds = HBA_PORTSPEED_2GFC;
2877 			break;
2878 		case LPFC_LINK_SPEED_4GHZ:
2879 			speeds = HBA_PORTSPEED_4GFC;
2880 			break;
2881 		case LPFC_LINK_SPEED_8GHZ:
2882 			speeds = HBA_PORTSPEED_8GFC;
2883 			break;
2884 		case LPFC_LINK_SPEED_10GHZ:
2885 			speeds = HBA_PORTSPEED_10GFC;
2886 			break;
2887 		case LPFC_LINK_SPEED_16GHZ:
2888 			speeds = HBA_PORTSPEED_16GFC;
2889 			break;
2890 		case LPFC_LINK_SPEED_32GHZ:
2891 			speeds = HBA_PORTSPEED_32GFC;
2892 			break;
2893 		case LPFC_LINK_SPEED_64GHZ:
2894 			speeds = HBA_PORTSPEED_64GFC;
2895 			break;
2896 		case LPFC_LINK_SPEED_128GHZ:
2897 			speeds = HBA_PORTSPEED_128GFC;
2898 			break;
2899 		case LPFC_LINK_SPEED_256GHZ:
2900 			speeds = HBA_PORTSPEED_256GFC;
2901 			break;
2902 		default:
2903 			speeds = HBA_PORTSPEED_UNKNOWN;
2904 			break;
2905 		}
2906 	} else {
2907 		switch (phba->fc_linkspeed) {
2908 		case LPFC_ASYNC_LINK_SPEED_10GBPS:
2909 			speeds = HBA_PORTSPEED_10GE;
2910 			break;
2911 		case LPFC_ASYNC_LINK_SPEED_25GBPS:
2912 			speeds = HBA_PORTSPEED_25GE;
2913 			break;
2914 		case LPFC_ASYNC_LINK_SPEED_40GBPS:
2915 			speeds = HBA_PORTSPEED_40GE;
2916 			break;
2917 		case LPFC_ASYNC_LINK_SPEED_100GBPS:
2918 			speeds = HBA_PORTSPEED_100GE;
2919 			break;
2920 		default:
2921 			speeds = HBA_PORTSPEED_UNKNOWN;
2922 			break;
2923 		}
2924 	}
2925 
2926 	return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_SPEED, speeds);
2927 }
2928 
2929 static int
2930 lpfc_fdmi_port_attr_max_frame(struct lpfc_vport *vport, void *attr)
2931 {
2932 	struct serv_parm *hsp = (struct serv_parm *)&vport->fc_sparam;
2933 
2934 	return lpfc_fdmi_set_attr_u32(attr, RPRT_MAX_FRAME_SIZE,
2935 			(((uint32_t)hsp->cmn.bbRcvSizeMsb & 0x0F) << 8) |
2936 			  (uint32_t)hsp->cmn.bbRcvSizeLsb);
2937 }
2938 
2939 static int
2940 lpfc_fdmi_port_attr_os_devname(struct lpfc_vport *vport, void *attr)
2941 {
2942 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2943 	char buf[64] = { 0 };
2944 
2945 	snprintf(buf, sizeof(buf), "/sys/class/scsi_host/host%d",
2946 		 shost->host_no);
2947 
2948 	return lpfc_fdmi_set_attr_string(attr, RPRT_OS_DEVICE_NAME, buf);
2949 }
2950 
2951 static int
2952 lpfc_fdmi_port_attr_host_name(struct lpfc_vport *vport, void *attr)
2953 {
2954 	char buf[64] = { 0 };
2955 
2956 	scnprintf(buf, sizeof(buf), "%s", vport->phba->os_host_name);
2957 
2958 	return lpfc_fdmi_set_attr_string(attr, RPRT_HOST_NAME, buf);
2959 }
2960 
2961 static int
2962 lpfc_fdmi_port_attr_wwnn(struct lpfc_vport *vport, void *attr)
2963 {
2964 	return lpfc_fdmi_set_attr_wwn(attr, RPRT_NODENAME,
2965 			&vport->fc_sparam.nodeName);
2966 }
2967 
2968 static int
2969 lpfc_fdmi_port_attr_wwpn(struct lpfc_vport *vport, void *attr)
2970 {
2971 	return lpfc_fdmi_set_attr_wwn(attr, RPRT_PORTNAME,
2972 			&vport->fc_sparam.portName);
2973 }
2974 
2975 static int
2976 lpfc_fdmi_port_attr_symbolic_name(struct lpfc_vport *vport, void *attr)
2977 {
2978 	char buf[256] = { 0 };
2979 
2980 	lpfc_vport_symbolic_port_name(vport, buf, sizeof(buf));
2981 
2982 	return lpfc_fdmi_set_attr_string(attr, RPRT_SYM_PORTNAME, buf);
2983 }
2984 
2985 static int
2986 lpfc_fdmi_port_attr_port_type(struct lpfc_vport *vport, void *attr)
2987 {
2988 	struct lpfc_hba *phba = vport->phba;
2989 
2990 	return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_TYPE,
2991 			(phba->fc_topology == LPFC_TOPOLOGY_LOOP) ?
2992 				LPFC_FDMI_PORTTYPE_NLPORT :
2993 				LPFC_FDMI_PORTTYPE_NPORT);
2994 }
2995 
2996 static int
2997 lpfc_fdmi_port_attr_class(struct lpfc_vport *vport, void *attr)
2998 {
2999 	return lpfc_fdmi_set_attr_u32(attr, RPRT_SUPPORTED_CLASS,
3000 			FC_COS_CLASS2 | FC_COS_CLASS3);
3001 }
3002 
3003 static int
3004 lpfc_fdmi_port_attr_fabric_wwpn(struct lpfc_vport *vport, void *attr)
3005 {
3006 	return lpfc_fdmi_set_attr_wwn(attr, RPRT_FABRICNAME,
3007 			&vport->fabric_portname);
3008 }
3009 
3010 static int
3011 lpfc_fdmi_port_attr_active_fc4type(struct lpfc_vport *vport, void *attr)
3012 {
3013 	struct lpfc_hba *phba = vport->phba;
3014 	u32 fc4types;
3015 
3016 	fc4types = (ATTR_FC4_CT | ATTR_FC4_FCP);
3017 
3018 	/* Check to see if NVME is configured or not */
3019 	if (vport == phba->pport &&
3020 	    phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
3021 		fc4types |= ATTR_FC4_NVME;
3022 
3023 	return lpfc_fdmi_set_attr_fc4types(attr, RPRT_ACTIVE_FC4_TYPES,
3024 			fc4types);
3025 }
3026 
3027 static int
3028 lpfc_fdmi_port_attr_port_state(struct lpfc_vport *vport, void *attr)
3029 {
3030 	return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_STATE,
3031 			LPFC_FDMI_PORTSTATE_ONLINE);
3032 }
3033 
3034 static int
3035 lpfc_fdmi_port_attr_num_disc(struct lpfc_vport *vport, void *attr)
3036 {
3037 	vport->fdmi_num_disc = lpfc_find_map_node(vport);
3038 
3039 	return lpfc_fdmi_set_attr_u32(attr, RPRT_DISC_PORT,
3040 			vport->fdmi_num_disc);
3041 }
3042 
3043 static int
3044 lpfc_fdmi_port_attr_nportid(struct lpfc_vport *vport, void *attr)
3045 {
3046 	return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_ID, vport->fc_myDID);
3047 }
3048 
3049 static int
3050 lpfc_fdmi_smart_attr_service(struct lpfc_vport *vport, void *attr)
3051 {
3052 	return lpfc_fdmi_set_attr_string(attr, RPRT_SMART_SERVICE,
3053 			"Smart SAN Initiator");
3054 }
3055 
3056 static int
3057 lpfc_fdmi_smart_attr_guid(struct lpfc_vport *vport, void *attr)
3058 {
3059 	return lpfc_fdmi_set_attr_fullwwn(attr, RPRT_SMART_GUID,
3060 			&vport->fc_sparam.nodeName,
3061 			&vport->fc_sparam.portName);
3062 }
3063 
3064 static int
3065 lpfc_fdmi_smart_attr_version(struct lpfc_vport *vport, void *attr)
3066 {
3067 	return lpfc_fdmi_set_attr_string(attr, RPRT_SMART_VERSION,
3068 			"Smart SAN Version 2.0");
3069 }
3070 
3071 static int
3072 lpfc_fdmi_smart_attr_model(struct lpfc_vport *vport, void *attr)
3073 {
3074 	struct lpfc_hba *phba = vport->phba;
3075 
3076 	return lpfc_fdmi_set_attr_string(attr, RPRT_SMART_MODEL,
3077 			phba->ModelName);
3078 }
3079 
3080 static int
3081 lpfc_fdmi_smart_attr_port_info(struct lpfc_vport *vport, void *attr)
3082 {
3083 	/* SRIOV (type 3) is not supported */
3084 
3085 	return lpfc_fdmi_set_attr_u32(attr, RPRT_SMART_PORT_INFO,
3086 			(vport->vpi) ?  2 /* NPIV */ : 1 /* Physical */);
3087 }
3088 
3089 static int
3090 lpfc_fdmi_smart_attr_qos(struct lpfc_vport *vport, void *attr)
3091 {
3092 	return lpfc_fdmi_set_attr_u32(attr, RPRT_SMART_QOS, 0);
3093 }
3094 
3095 static int
3096 lpfc_fdmi_smart_attr_security(struct lpfc_vport *vport, void *attr)
3097 {
3098 	return lpfc_fdmi_set_attr_u32(attr, RPRT_SMART_SECURITY, 1);
3099 }
3100 
3101 static int
3102 lpfc_fdmi_vendor_attr_mi(struct lpfc_vport *vport, void *attr)
3103 {
3104 	struct lpfc_hba *phba = vport->phba;
3105 	char buf[32] = { 0 };
3106 
3107 	sprintf(buf, "ELXE2EM:%04d", phba->sli4_hba.pc_sli4_params.mi_ver);
3108 
3109 	return lpfc_fdmi_set_attr_string(attr, RPRT_VENDOR_MI, buf);
3110 }
3111 
3112 /* RHBA attribute jump table */
3113 static int (*lpfc_fdmi_hba_action[])
3114 	(struct lpfc_vport *vport, void *attrbuf) = {
3115 	/* Action routine                 Mask bit     Attribute type */
3116 	lpfc_fdmi_hba_attr_wwnn,	  /* bit0     RHBA_NODENAME           */
3117 	lpfc_fdmi_hba_attr_manufacturer,  /* bit1     RHBA_MANUFACTURER       */
3118 	lpfc_fdmi_hba_attr_sn,		  /* bit2     RHBA_SERIAL_NUMBER      */
3119 	lpfc_fdmi_hba_attr_model,	  /* bit3     RHBA_MODEL              */
3120 	lpfc_fdmi_hba_attr_description,	  /* bit4     RHBA_MODEL_DESCRIPTION  */
3121 	lpfc_fdmi_hba_attr_hdw_ver,	  /* bit5     RHBA_HARDWARE_VERSION   */
3122 	lpfc_fdmi_hba_attr_drvr_ver,	  /* bit6     RHBA_DRIVER_VERSION     */
3123 	lpfc_fdmi_hba_attr_rom_ver,	  /* bit7     RHBA_OPTION_ROM_VERSION */
3124 	lpfc_fdmi_hba_attr_fmw_ver,	  /* bit8     RHBA_FIRMWARE_VERSION   */
3125 	lpfc_fdmi_hba_attr_os_ver,	  /* bit9     RHBA_OS_NAME_VERSION    */
3126 	lpfc_fdmi_hba_attr_ct_len,	  /* bit10    RHBA_MAX_CT_PAYLOAD_LEN */
3127 	lpfc_fdmi_hba_attr_symbolic_name, /* bit11    RHBA_SYM_NODENAME       */
3128 	lpfc_fdmi_hba_attr_vendor_info,	  /* bit12    RHBA_VENDOR_INFO        */
3129 	lpfc_fdmi_hba_attr_num_ports,	  /* bit13    RHBA_NUM_PORTS          */
3130 	lpfc_fdmi_hba_attr_fabric_wwnn,	  /* bit14    RHBA_FABRIC_WWNN        */
3131 	lpfc_fdmi_hba_attr_bios_ver,	  /* bit15    RHBA_BIOS_VERSION       */
3132 	lpfc_fdmi_hba_attr_bios_state,	  /* bit16    RHBA_BIOS_STATE         */
3133 	lpfc_fdmi_hba_attr_vendor_id,	  /* bit17    RHBA_VENDOR_ID          */
3134 };
3135 
3136 /* RPA / RPRT attribute jump table */
3137 static int (*lpfc_fdmi_port_action[])
3138 	(struct lpfc_vport *vport, void *attrbuf) = {
3139 	/* Action routine                   Mask bit   Attribute type */
3140 	lpfc_fdmi_port_attr_fc4type,        /* bit0   RPRT_SUPPORT_FC4_TYPES  */
3141 	lpfc_fdmi_port_attr_support_speed,  /* bit1   RPRT_SUPPORTED_SPEED    */
3142 	lpfc_fdmi_port_attr_speed,          /* bit2   RPRT_PORT_SPEED         */
3143 	lpfc_fdmi_port_attr_max_frame,      /* bit3   RPRT_MAX_FRAME_SIZE     */
3144 	lpfc_fdmi_port_attr_os_devname,     /* bit4   RPRT_OS_DEVICE_NAME     */
3145 	lpfc_fdmi_port_attr_host_name,      /* bit5   RPRT_HOST_NAME          */
3146 	lpfc_fdmi_port_attr_wwnn,           /* bit6   RPRT_NODENAME           */
3147 	lpfc_fdmi_port_attr_wwpn,           /* bit7   RPRT_PORTNAME           */
3148 	lpfc_fdmi_port_attr_symbolic_name,  /* bit8   RPRT_SYM_PORTNAME       */
3149 	lpfc_fdmi_port_attr_port_type,      /* bit9   RPRT_PORT_TYPE          */
3150 	lpfc_fdmi_port_attr_class,          /* bit10  RPRT_SUPPORTED_CLASS    */
3151 	lpfc_fdmi_port_attr_fabric_wwpn,    /* bit11  RPRT_FABRICNAME         */
3152 	lpfc_fdmi_port_attr_active_fc4type, /* bit12  RPRT_ACTIVE_FC4_TYPES   */
3153 	lpfc_fdmi_port_attr_port_state,     /* bit13  RPRT_PORT_STATE         */
3154 	lpfc_fdmi_port_attr_num_disc,       /* bit14  RPRT_DISC_PORT          */
3155 	lpfc_fdmi_port_attr_nportid,        /* bit15  RPRT_PORT_ID            */
3156 	lpfc_fdmi_smart_attr_service,       /* bit16  RPRT_SMART_SERVICE      */
3157 	lpfc_fdmi_smart_attr_guid,          /* bit17  RPRT_SMART_GUID         */
3158 	lpfc_fdmi_smart_attr_version,       /* bit18  RPRT_SMART_VERSION      */
3159 	lpfc_fdmi_smart_attr_model,         /* bit19  RPRT_SMART_MODEL        */
3160 	lpfc_fdmi_smart_attr_port_info,     /* bit20  RPRT_SMART_PORT_INFO    */
3161 	lpfc_fdmi_smart_attr_qos,           /* bit21  RPRT_SMART_QOS          */
3162 	lpfc_fdmi_smart_attr_security,      /* bit22  RPRT_SMART_SECURITY     */
3163 	lpfc_fdmi_vendor_attr_mi,           /* bit23  RPRT_VENDOR_MI          */
3164 };
3165 
3166 /**
3167  * lpfc_fdmi_cmd - Build and send a FDMI cmd to the specified NPort
3168  * @vport: pointer to a host virtual N_Port data structure.
3169  * @ndlp: ndlp to send FDMI cmd to (if NULL use FDMI_DID)
3170  * @cmdcode: FDMI command to send
3171  * @new_mask: Mask of HBA or PORT Attributes to send
3172  *
3173  * Builds and sends a FDMI command using the CT subsystem.
3174  */
3175 int
3176 lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
3177 	      int cmdcode, uint32_t new_mask)
3178 {
3179 	struct lpfc_hba *phba = vport->phba;
3180 	struct lpfc_dmabuf *rq, *rsp;
3181 	struct lpfc_sli_ct_request *CtReq;
3182 	struct ulp_bde64_le *bde;
3183 	uint32_t bit_pos;
3184 	uint32_t size, addsz;
3185 	uint32_t rsp_size;
3186 	uint32_t mask;
3187 	struct lpfc_fdmi_reg_hba *rh;
3188 	struct lpfc_fdmi_port_entry *pe;
3189 	struct lpfc_fdmi_reg_portattr *pab = NULL, *base = NULL;
3190 	struct lpfc_fdmi_attr_block *ab = NULL;
3191 	int  (*func)(struct lpfc_vport *vport, void *attrbuf);
3192 	void (*cmpl)(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3193 		     struct lpfc_iocbq *rspiocb);
3194 
3195 	if (!ndlp)
3196 		return 0;
3197 
3198 	cmpl = lpfc_cmpl_ct_disc_fdmi; /* called from discovery */
3199 
3200 	/* fill in BDEs for command */
3201 	/* Allocate buffer for command payload */
3202 	rq = kmalloc(sizeof(*rq), GFP_KERNEL);
3203 	if (!rq)
3204 		goto fdmi_cmd_exit;
3205 
3206 	rq->virt = lpfc_mbuf_alloc(phba, 0, &rq->phys);
3207 	if (!rq->virt)
3208 		goto fdmi_cmd_free_rq;
3209 
3210 	/* Allocate buffer for Buffer ptr list */
3211 	rsp = kmalloc(sizeof(*rsp), GFP_KERNEL);
3212 	if (!rsp)
3213 		goto fdmi_cmd_free_rqvirt;
3214 
3215 	rsp->virt = lpfc_mbuf_alloc(phba, 0, &rsp->phys);
3216 	if (!rsp->virt)
3217 		goto fdmi_cmd_free_rsp;
3218 
3219 	INIT_LIST_HEAD(&rq->list);
3220 	INIT_LIST_HEAD(&rsp->list);
3221 
3222 	/* mbuf buffers are 1K in length - aka LPFC_BPL_SIZE */
3223 	memset(rq->virt, 0, LPFC_BPL_SIZE);
3224 	rsp_size = LPFC_BPL_SIZE;
3225 
3226 	/* FDMI request */
3227 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3228 			 "0218 FDMI Request x%x mask x%x Data: x%x x%x x%x\n",
3229 			 cmdcode, new_mask, vport->fdmi_port_mask,
3230 			 vport->fc_flag, vport->port_state);
3231 
3232 	CtReq = (struct lpfc_sli_ct_request *)rq->virt;
3233 
3234 	/* First populate the CT_IU preamble */
3235 	CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
3236 	CtReq->RevisionId.bits.InId = 0;
3237 
3238 	CtReq->FsType = SLI_CT_MANAGEMENT_SERVICE;
3239 	CtReq->FsSubType = SLI_CT_FDMI_Subtypes;
3240 
3241 	CtReq->CommandResponse.bits.CmdRsp = cpu_to_be16(cmdcode);
3242 
3243 	size = 0;
3244 
3245 	/* Next fill in the specific FDMI cmd information */
3246 	switch (cmdcode) {
3247 	case SLI_MGMT_RHAT:
3248 	case SLI_MGMT_RHBA:
3249 		rh = (struct lpfc_fdmi_reg_hba *)&CtReq->un;
3250 		/* HBA Identifier */
3251 		memcpy(&rh->hi.PortName, &phba->pport->fc_sparam.portName,
3252 		       sizeof(struct lpfc_name));
3253 		size += sizeof(struct lpfc_fdmi_hba_ident);
3254 
3255 		if (cmdcode == SLI_MGMT_RHBA) {
3256 			/* Registered Port List */
3257 			/* One entry (port) per adapter */
3258 			rh->rpl.EntryCnt = cpu_to_be32(1);
3259 			memcpy(&rh->rpl.pe.PortName,
3260 			       &phba->pport->fc_sparam.portName,
3261 			       sizeof(struct lpfc_name));
3262 			size += sizeof(struct lpfc_fdmi_reg_port_list);
3263 		}
3264 
3265 		ab = (struct lpfc_fdmi_attr_block *)((uint8_t *)rh + size);
3266 		ab->EntryCnt = 0;
3267 		size += FOURBYTES;	/* add length of EntryCnt field */
3268 
3269 		bit_pos = 0;
3270 		if (new_mask)
3271 			mask = new_mask;
3272 		else
3273 			mask = vport->fdmi_hba_mask;
3274 
3275 		/* Mask will dictate what attributes to build in the request */
3276 		while (mask) {
3277 			if (mask & 0x1) {
3278 				func = lpfc_fdmi_hba_action[bit_pos];
3279 				addsz = func(vport, ((uint8_t *)rh + size));
3280 				if (addsz) {
3281 					ab->EntryCnt++;
3282 					size += addsz;
3283 				}
3284 				/* check if another attribute fits */
3285 				if ((size + FDMI_MAX_ATTRLEN) >
3286 				    (LPFC_BPL_SIZE - LPFC_CT_PREAMBLE))
3287 					goto hba_out;
3288 			}
3289 			mask = mask >> 1;
3290 			bit_pos++;
3291 		}
3292 hba_out:
3293 		ab->EntryCnt = cpu_to_be32(ab->EntryCnt);
3294 		/* Total size */
3295 		size += GID_REQUEST_SZ - 4;
3296 		break;
3297 
3298 	case SLI_MGMT_RPRT:
3299 		if (vport->port_type != LPFC_PHYSICAL_PORT) {
3300 			ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
3301 			if (!ndlp)
3302 				return 0;
3303 		}
3304 		fallthrough;
3305 	case SLI_MGMT_RPA:
3306 		/* Store base ptr right after preamble */
3307 		base = (struct lpfc_fdmi_reg_portattr *)&CtReq->un;
3308 
3309 		if (cmdcode == SLI_MGMT_RPRT) {
3310 			rh = (struct lpfc_fdmi_reg_hba *)base;
3311 			/* HBA Identifier */
3312 			memcpy(&rh->hi.PortName,
3313 			       &phba->pport->fc_sparam.portName,
3314 			       sizeof(struct lpfc_name));
3315 			pab = (struct lpfc_fdmi_reg_portattr *)
3316 				((uint8_t *)base + sizeof(struct lpfc_name));
3317 			size += sizeof(struct lpfc_name);
3318 		} else {
3319 			pab = base;
3320 		}
3321 
3322 		memcpy((uint8_t *)&pab->PortName,
3323 		       (uint8_t *)&vport->fc_sparam.portName,
3324 		       sizeof(struct lpfc_name));
3325 		pab->ab.EntryCnt = 0;
3326 		/* add length of name and EntryCnt field */
3327 		size += sizeof(struct lpfc_name) + FOURBYTES;
3328 
3329 		bit_pos = 0;
3330 		if (new_mask)
3331 			mask = new_mask;
3332 		else
3333 			mask = vport->fdmi_port_mask;
3334 
3335 		/* Mask will dictate what attributes to build in the request */
3336 		while (mask) {
3337 			if (mask & 0x1) {
3338 				func = lpfc_fdmi_port_action[bit_pos];
3339 				addsz = func(vport, ((uint8_t *)base + size));
3340 				if (addsz) {
3341 					pab->ab.EntryCnt++;
3342 					size += addsz;
3343 				}
3344 				/* check if another attribute fits */
3345 				if ((size + FDMI_MAX_ATTRLEN) >
3346 				    (LPFC_BPL_SIZE - LPFC_CT_PREAMBLE))
3347 					goto port_out;
3348 			}
3349 			mask = mask >> 1;
3350 			bit_pos++;
3351 		}
3352 port_out:
3353 		pab->ab.EntryCnt = cpu_to_be32(pab->ab.EntryCnt);
3354 		size += GID_REQUEST_SZ - 4;
3355 		break;
3356 
3357 	case SLI_MGMT_GHAT:
3358 	case SLI_MGMT_GRPL:
3359 		rsp_size = FC_MAX_NS_RSP;
3360 		fallthrough;
3361 	case SLI_MGMT_DHBA:
3362 	case SLI_MGMT_DHAT:
3363 		pe = (struct lpfc_fdmi_port_entry *)&CtReq->un;
3364 		memcpy((uint8_t *)&pe->PortName,
3365 		       (uint8_t *)&vport->fc_sparam.portName,
3366 		       sizeof(struct lpfc_name));
3367 		size = GID_REQUEST_SZ - 4 + sizeof(struct lpfc_name);
3368 		break;
3369 
3370 	case SLI_MGMT_GPAT:
3371 	case SLI_MGMT_GPAS:
3372 		rsp_size = FC_MAX_NS_RSP;
3373 		fallthrough;
3374 	case SLI_MGMT_DPRT:
3375 		if (vport->port_type != LPFC_PHYSICAL_PORT) {
3376 			ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
3377 			if (!ndlp)
3378 				return 0;
3379 		}
3380 		fallthrough;
3381 	case SLI_MGMT_DPA:
3382 		pe = (struct lpfc_fdmi_port_entry *)&CtReq->un;
3383 		memcpy((uint8_t *)&pe->PortName,
3384 		       (uint8_t *)&vport->fc_sparam.portName,
3385 		       sizeof(struct lpfc_name));
3386 		size = GID_REQUEST_SZ - 4 + sizeof(struct lpfc_name);
3387 		break;
3388 	case SLI_MGMT_GRHL:
3389 		size = GID_REQUEST_SZ - 4;
3390 		break;
3391 	default:
3392 		lpfc_printf_vlog(vport, KERN_WARNING, LOG_DISCOVERY,
3393 				 "0298 FDMI cmdcode x%x not supported\n",
3394 				 cmdcode);
3395 		goto fdmi_cmd_free_rspvirt;
3396 	}
3397 	CtReq->CommandResponse.bits.Size = cpu_to_be16(rsp_size);
3398 
3399 	bde = (struct ulp_bde64_le *)rsp->virt;
3400 	bde->addr_high = cpu_to_le32(putPaddrHigh(rq->phys));
3401 	bde->addr_low = cpu_to_le32(putPaddrLow(rq->phys));
3402 	bde->type_size = cpu_to_le32(ULP_BDE64_TYPE_BDE_64 <<
3403 				     ULP_BDE64_TYPE_SHIFT);
3404 	bde->type_size |= cpu_to_le32(size);
3405 
3406 	/*
3407 	 * The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
3408 	 * to hold ndlp reference for the corresponding callback function.
3409 	 */
3410 	if (!lpfc_ct_cmd(vport, rq, rsp, ndlp, cmpl, rsp_size, 0))
3411 		return 0;
3412 
3413 fdmi_cmd_free_rspvirt:
3414 	lpfc_mbuf_free(phba, rsp->virt, rsp->phys);
3415 fdmi_cmd_free_rsp:
3416 	kfree(rsp);
3417 fdmi_cmd_free_rqvirt:
3418 	lpfc_mbuf_free(phba, rq->virt, rq->phys);
3419 fdmi_cmd_free_rq:
3420 	kfree(rq);
3421 fdmi_cmd_exit:
3422 	/* Issue FDMI request failed */
3423 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3424 			 "0244 Issue FDMI request failed Data: x%x\n",
3425 			 cmdcode);
3426 	return 1;
3427 }
3428 
3429 /**
3430  * lpfc_delayed_disc_tmo - Timeout handler for delayed discovery timer.
3431  * @t: Context object of the timer.
3432  *
3433  * This function set the WORKER_DELAYED_DISC_TMO flag and wake up
3434  * the worker thread.
3435  **/
3436 void
3437 lpfc_delayed_disc_tmo(struct timer_list *t)
3438 {
3439 	struct lpfc_vport *vport = from_timer(vport, t, delayed_disc_tmo);
3440 	struct lpfc_hba   *phba = vport->phba;
3441 	uint32_t tmo_posted;
3442 	unsigned long iflag;
3443 
3444 	spin_lock_irqsave(&vport->work_port_lock, iflag);
3445 	tmo_posted = vport->work_port_events & WORKER_DELAYED_DISC_TMO;
3446 	if (!tmo_posted)
3447 		vport->work_port_events |= WORKER_DELAYED_DISC_TMO;
3448 	spin_unlock_irqrestore(&vport->work_port_lock, iflag);
3449 
3450 	if (!tmo_posted)
3451 		lpfc_worker_wake_up(phba);
3452 	return;
3453 }
3454 
3455 /**
3456  * lpfc_delayed_disc_timeout_handler - Function called by worker thread to
3457  *      handle delayed discovery.
3458  * @vport: pointer to a host virtual N_Port data structure.
3459  *
3460  * This function start nport discovery of the vport.
3461  **/
3462 void
3463 lpfc_delayed_disc_timeout_handler(struct lpfc_vport *vport)
3464 {
3465 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3466 
3467 	spin_lock_irq(shost->host_lock);
3468 	if (!(vport->fc_flag & FC_DISC_DELAYED)) {
3469 		spin_unlock_irq(shost->host_lock);
3470 		return;
3471 	}
3472 	vport->fc_flag &= ~FC_DISC_DELAYED;
3473 	spin_unlock_irq(shost->host_lock);
3474 
3475 	lpfc_do_scr_ns_plogi(vport->phba, vport);
3476 }
3477 
3478 void
3479 lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag)
3480 {
3481 	struct lpfc_sli *psli = &phba->sli;
3482 	lpfc_vpd_t *vp = &phba->vpd;
3483 	uint32_t b1, b2, b3, b4, i, rev;
3484 	char c;
3485 	uint32_t *ptr, str[4];
3486 	uint8_t *fwname;
3487 
3488 	if (phba->sli_rev == LPFC_SLI_REV4)
3489 		snprintf(fwrevision, FW_REV_STR_SIZE, "%s", vp->rev.opFwName);
3490 	else if (vp->rev.rBit) {
3491 		if (psli->sli_flag & LPFC_SLI_ACTIVE)
3492 			rev = vp->rev.sli2FwRev;
3493 		else
3494 			rev = vp->rev.sli1FwRev;
3495 
3496 		b1 = (rev & 0x0000f000) >> 12;
3497 		b2 = (rev & 0x00000f00) >> 8;
3498 		b3 = (rev & 0x000000c0) >> 6;
3499 		b4 = (rev & 0x00000030) >> 4;
3500 
3501 		switch (b4) {
3502 		case 0:
3503 			c = 'N';
3504 			break;
3505 		case 1:
3506 			c = 'A';
3507 			break;
3508 		case 2:
3509 			c = 'B';
3510 			break;
3511 		case 3:
3512 			c = 'X';
3513 			break;
3514 		default:
3515 			c = 0;
3516 			break;
3517 		}
3518 		b4 = (rev & 0x0000000f);
3519 
3520 		if (psli->sli_flag & LPFC_SLI_ACTIVE)
3521 			fwname = vp->rev.sli2FwName;
3522 		else
3523 			fwname = vp->rev.sli1FwName;
3524 
3525 		for (i = 0; i < 16; i++)
3526 			if (fwname[i] == 0x20)
3527 				fwname[i] = 0;
3528 
3529 		ptr = (uint32_t*)fwname;
3530 
3531 		for (i = 0; i < 3; i++)
3532 			str[i] = be32_to_cpu(*ptr++);
3533 
3534 		if (c == 0) {
3535 			if (flag)
3536 				sprintf(fwrevision, "%d.%d%d (%s)",
3537 					b1, b2, b3, (char *)str);
3538 			else
3539 				sprintf(fwrevision, "%d.%d%d", b1,
3540 					b2, b3);
3541 		} else {
3542 			if (flag)
3543 				sprintf(fwrevision, "%d.%d%d%c%d (%s)",
3544 					b1, b2, b3, c,
3545 					b4, (char *)str);
3546 			else
3547 				sprintf(fwrevision, "%d.%d%d%c%d",
3548 					b1, b2, b3, c, b4);
3549 		}
3550 	} else {
3551 		rev = vp->rev.smFwRev;
3552 
3553 		b1 = (rev & 0xff000000) >> 24;
3554 		b2 = (rev & 0x00f00000) >> 20;
3555 		b3 = (rev & 0x000f0000) >> 16;
3556 		c  = (rev & 0x0000ff00) >> 8;
3557 		b4 = (rev & 0x000000ff);
3558 
3559 		sprintf(fwrevision, "%d.%d%d%c%d", b1, b2, b3, c, b4);
3560 	}
3561 	return;
3562 }
3563 
3564 static void
3565 lpfc_cmpl_ct_cmd_vmid(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3566 		      struct lpfc_iocbq *rspiocb)
3567 {
3568 	struct lpfc_vport *vport = cmdiocb->vport;
3569 	struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf;
3570 	struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf;
3571 	struct lpfc_sli_ct_request *ctcmd = inp->virt;
3572 	struct lpfc_sli_ct_request *ctrsp = outp->virt;
3573 	__be16 rsp = ctrsp->CommandResponse.bits.CmdRsp;
3574 	struct app_id_object *app;
3575 	struct lpfc_nodelist *ndlp = cmdiocb->ndlp;
3576 	u32 cmd, hash, bucket;
3577 	struct lpfc_vmid *vmp, *cur;
3578 	u8 *data = outp->virt;
3579 	int i;
3580 
3581 	cmd = be16_to_cpu(ctcmd->CommandResponse.bits.CmdRsp);
3582 	if (cmd == SLI_CTAS_DALLAPP_ID)
3583 		lpfc_ct_free_iocb(phba, cmdiocb);
3584 
3585 	if (lpfc_els_chk_latt(vport) || get_job_ulpstatus(phba, rspiocb)) {
3586 		if (cmd != SLI_CTAS_DALLAPP_ID)
3587 			goto free_res;
3588 	}
3589 	/* Check for a CT LS_RJT response */
3590 	if (be16_to_cpu(rsp) == SLI_CT_RESPONSE_FS_RJT) {
3591 		if (cmd != SLI_CTAS_DALLAPP_ID)
3592 			lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3593 					 "3306 VMID FS_RJT Data: x%x x%x x%x\n",
3594 					 cmd, ctrsp->ReasonCode,
3595 					 ctrsp->Explanation);
3596 		if ((cmd != SLI_CTAS_DALLAPP_ID) ||
3597 		    (ctrsp->ReasonCode != SLI_CT_UNABLE_TO_PERFORM_REQ) ||
3598 		    (ctrsp->Explanation != SLI_CT_APP_ID_NOT_AVAILABLE)) {
3599 			/* If DALLAPP_ID failed retry later */
3600 			if (cmd == SLI_CTAS_DALLAPP_ID)
3601 				vport->load_flag |= FC_DEREGISTER_ALL_APP_ID;
3602 			goto free_res;
3603 		}
3604 	}
3605 
3606 	switch (cmd) {
3607 	case SLI_CTAS_RAPP_IDENT:
3608 		app = (struct app_id_object *)(RAPP_IDENT_OFFSET + data);
3609 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3610 				 "6712 RAPP_IDENT app id %d  port id x%x id "
3611 				 "len %d\n", be32_to_cpu(app->app_id),
3612 				 be32_to_cpu(app->port_id),
3613 				 app->obj.entity_id_len);
3614 
3615 		if (app->obj.entity_id_len == 0 || app->port_id == 0)
3616 			goto free_res;
3617 
3618 		hash = lpfc_vmid_hash_fn(app->obj.entity_id,
3619 					 app->obj.entity_id_len);
3620 		vmp = lpfc_get_vmid_from_hashtable(vport, hash,
3621 						  app->obj.entity_id);
3622 		if (vmp) {
3623 			write_lock(&vport->vmid_lock);
3624 			vmp->un.app_id = be32_to_cpu(app->app_id);
3625 			vmp->flag |= LPFC_VMID_REGISTERED;
3626 			vmp->flag &= ~LPFC_VMID_REQ_REGISTER;
3627 			write_unlock(&vport->vmid_lock);
3628 			/* Set IN USE flag */
3629 			vport->vmid_flag |= LPFC_VMID_IN_USE;
3630 		} else {
3631 			lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3632 					 "6901 No entry found %s hash %d\n",
3633 					 app->obj.entity_id, hash);
3634 		}
3635 		break;
3636 	case SLI_CTAS_DAPP_IDENT:
3637 		app = (struct app_id_object *)(DAPP_IDENT_OFFSET + data);
3638 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3639 				 "6713 DAPP_IDENT app id %d  port id x%x\n",
3640 				 be32_to_cpu(app->app_id),
3641 				 be32_to_cpu(app->port_id));
3642 		break;
3643 	case SLI_CTAS_DALLAPP_ID:
3644 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3645 				 "8856 Deregistered all app ids\n");
3646 		read_lock(&vport->vmid_lock);
3647 		for (i = 0; i < phba->cfg_max_vmid; i++) {
3648 			vmp = &vport->vmid[i];
3649 			if (vmp->flag != LPFC_VMID_SLOT_FREE)
3650 				memset(vmp, 0, sizeof(struct lpfc_vmid));
3651 		}
3652 		read_unlock(&vport->vmid_lock);
3653 		/* for all elements in the hash table */
3654 		if (!hash_empty(vport->hash_table))
3655 			hash_for_each(vport->hash_table, bucket, cur, hnode)
3656 				hash_del(&cur->hnode);
3657 		vport->load_flag |= FC_ALLOW_VMID;
3658 		break;
3659 	default:
3660 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3661 				 "8857 Invalid command code\n");
3662 	}
3663 free_res:
3664 	lpfc_ct_free_iocb(phba, cmdiocb);
3665 	lpfc_nlp_put(ndlp);
3666 }
3667 
3668 /**
3669  * lpfc_vmid_cmd - Build and send a FDMI cmd to the specified NPort
3670  * @vport: pointer to a host virtual N_Port data structure.
3671  * @cmdcode: application server command code to send
3672  * @vmid: pointer to vmid info structure
3673  *
3674  * Builds and sends a FDMI command using the CT subsystem.
3675  */
3676 int
3677 lpfc_vmid_cmd(struct lpfc_vport *vport,
3678 	      int cmdcode, struct lpfc_vmid *vmid)
3679 {
3680 	struct lpfc_hba *phba = vport->phba;
3681 	struct lpfc_dmabuf *mp, *bmp;
3682 	struct lpfc_sli_ct_request *ctreq;
3683 	struct ulp_bde64 *bpl;
3684 	u32 size;
3685 	u32 rsp_size;
3686 	u8 *data;
3687 	struct lpfc_vmid_rapp_ident_list *rap;
3688 	struct lpfc_vmid_dapp_ident_list *dap;
3689 	u8 retry = 0;
3690 	struct lpfc_nodelist *ndlp;
3691 
3692 	void (*cmpl)(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3693 		     struct lpfc_iocbq *rspiocb);
3694 
3695 	ndlp = lpfc_findnode_did(vport, FDMI_DID);
3696 	if (!ndlp || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE)
3697 		return 0;
3698 
3699 	cmpl = lpfc_cmpl_ct_cmd_vmid;
3700 
3701 	/* fill in BDEs for command */
3702 	/* Allocate buffer for command payload */
3703 	mp = kmalloc(sizeof(*mp), GFP_KERNEL);
3704 	if (!mp)
3705 		goto vmid_free_mp_exit;
3706 
3707 	mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
3708 	if (!mp->virt)
3709 		goto vmid_free_mp_virt_exit;
3710 
3711 	/* Allocate buffer for Buffer ptr list */
3712 	bmp = kmalloc(sizeof(*bmp), GFP_KERNEL);
3713 	if (!bmp)
3714 		goto vmid_free_bmp_exit;
3715 
3716 	bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
3717 	if (!bmp->virt)
3718 		goto vmid_free_bmp_virt_exit;
3719 
3720 	INIT_LIST_HEAD(&mp->list);
3721 	INIT_LIST_HEAD(&bmp->list);
3722 
3723 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3724 			 "3275 VMID Request Data: x%x x%x x%x\n",
3725 			 vport->fc_flag, vport->port_state, cmdcode);
3726 	ctreq = (struct lpfc_sli_ct_request *)mp->virt;
3727 	data = mp->virt;
3728 	/* First populate the CT_IU preamble */
3729 	memset(data, 0, LPFC_BPL_SIZE);
3730 	ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
3731 	ctreq->RevisionId.bits.InId = 0;
3732 
3733 	ctreq->FsType = SLI_CT_MANAGEMENT_SERVICE;
3734 	ctreq->FsSubType = SLI_CT_APP_SEV_Subtypes;
3735 
3736 	ctreq->CommandResponse.bits.CmdRsp = cpu_to_be16(cmdcode);
3737 	rsp_size = LPFC_BPL_SIZE;
3738 	size = 0;
3739 
3740 	switch (cmdcode) {
3741 	case SLI_CTAS_RAPP_IDENT:
3742 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3743 				 "1329 RAPP_IDENT for %s\n", vmid->host_vmid);
3744 		ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3745 		rap = (struct lpfc_vmid_rapp_ident_list *)
3746 			(DAPP_IDENT_OFFSET + data);
3747 		rap->no_of_objects = cpu_to_be32(1);
3748 		rap->obj[0].entity_id_len = vmid->vmid_len;
3749 		memcpy(rap->obj[0].entity_id, vmid->host_vmid, vmid->vmid_len);
3750 		size = RAPP_IDENT_OFFSET +
3751 			sizeof(struct lpfc_vmid_rapp_ident_list) +
3752 			sizeof(struct entity_id_object);
3753 		retry = 1;
3754 		break;
3755 
3756 	case SLI_CTAS_GALLAPPIA_ID:
3757 		ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3758 		size = GALLAPPIA_ID_SIZE;
3759 		break;
3760 
3761 	case SLI_CTAS_DAPP_IDENT:
3762 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3763 				 "1469 DAPP_IDENT for %s\n", vmid->host_vmid);
3764 		ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3765 		dap = (struct lpfc_vmid_dapp_ident_list *)
3766 			(DAPP_IDENT_OFFSET + data);
3767 		dap->no_of_objects = cpu_to_be32(1);
3768 		dap->obj[0].entity_id_len = vmid->vmid_len;
3769 		memcpy(dap->obj[0].entity_id, vmid->host_vmid, vmid->vmid_len);
3770 		size = DAPP_IDENT_OFFSET +
3771 			sizeof(struct lpfc_vmid_dapp_ident_list) +
3772 			sizeof(struct entity_id_object);
3773 		write_lock(&vport->vmid_lock);
3774 		vmid->flag &= ~LPFC_VMID_REGISTERED;
3775 		write_unlock(&vport->vmid_lock);
3776 		retry = 1;
3777 		break;
3778 
3779 	case SLI_CTAS_DALLAPP_ID:
3780 		ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3781 		size = DALLAPP_ID_SIZE;
3782 		break;
3783 
3784 	default:
3785 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3786 				 "7062 VMID cmdcode x%x not supported\n",
3787 				 cmdcode);
3788 		goto vmid_free_all_mem;
3789 	}
3790 
3791 	ctreq->CommandResponse.bits.Size = cpu_to_be16(rsp_size);
3792 
3793 	bpl = (struct ulp_bde64 *)bmp->virt;
3794 	bpl->addrHigh = putPaddrHigh(mp->phys);
3795 	bpl->addrLow = putPaddrLow(mp->phys);
3796 	bpl->tus.f.bdeFlags = 0;
3797 	bpl->tus.f.bdeSize = size;
3798 
3799 	/* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
3800 	 * to hold ndlp reference for the corresponding callback function.
3801 	 */
3802 	if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry))
3803 		return 0;
3804 
3805  vmid_free_all_mem:
3806 	lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
3807  vmid_free_bmp_virt_exit:
3808 	kfree(bmp);
3809  vmid_free_bmp_exit:
3810 	lpfc_mbuf_free(phba, mp->virt, mp->phys);
3811  vmid_free_mp_virt_exit:
3812 	kfree(mp);
3813  vmid_free_mp_exit:
3814 
3815 	/* Issue CT request failed */
3816 	lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3817 			 "3276 VMID CT request failed Data: x%x\n", cmdcode);
3818 	return -EIO;
3819 }
3820