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
lpfc_ct_ignore_hbq_buffer(struct lpfc_hba * phba,struct lpfc_iocbq * piocbq,struct lpfc_dmabuf * mp,uint32_t size)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
lpfc_ct_unsol_buffer(struct lpfc_hba * phba,struct lpfc_iocbq * piocbq,struct lpfc_dmabuf * mp,uint32_t size)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
lpfc_ct_unsol_cmpl(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)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
lpfc_ct_reject_event(struct lpfc_nodelist * ndlp,struct lpfc_sli_ct_request * ct_req,u16 ulp_context,u16 ox_id)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
lpfc_ct_handle_mibreq(struct lpfc_hba * phba,struct lpfc_iocbq * ctiocbq)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
lpfc_ct_unsol_event(struct lpfc_hba * phba,struct lpfc_sli_ring * pring,struct lpfc_iocbq * ctiocbq)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
lpfc_ct_handle_unsol_abort(struct lpfc_hba * phba,struct hbq_dmabuf * dmabuf)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
lpfc_free_ct_rsp(struct lpfc_hba * phba,struct lpfc_dmabuf * mlist)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 *
lpfc_alloc_ct_rsp(struct lpfc_hba * phba,__be16 cmdcode,struct ulp_bde64 * bpl,uint32_t size,int * entries)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
lpfc_ct_free_iocb(struct lpfc_hba * phba,struct lpfc_iocbq * ctiocb)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
lpfc_gen_req(struct lpfc_vport * vport,struct lpfc_dmabuf * bmp,struct lpfc_dmabuf * inp,struct lpfc_dmabuf * outp,void (* cmpl)(struct lpfc_hba *,struct lpfc_iocbq *,struct lpfc_iocbq *),struct lpfc_nodelist * ndlp,uint32_t event_tag,uint32_t num_entry,uint32_t tmo,uint8_t retry)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
lpfc_ct_cmd(struct lpfc_vport * vport,struct lpfc_dmabuf * inmp,struct lpfc_dmabuf * bmp,struct lpfc_nodelist * ndlp,void (* cmpl)(struct lpfc_hba *,struct lpfc_iocbq *,struct lpfc_iocbq *),uint32_t rsp_size,uint8_t retry)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 *
lpfc_find_vport_by_did(struct lpfc_hba * phba,uint32_t did)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
lpfc_prep_node_fc4type(struct lpfc_vport * vport,uint32_t Did,uint8_t fc4_type)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
lpfc_ns_rsp_audit_did(struct lpfc_vport * vport,uint32_t Did,uint8_t fc4_type)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
lpfc_ns_rsp(struct lpfc_vport * vport,struct lpfc_dmabuf * mp,uint8_t fc4_type,uint32_t Size)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
lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)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
lpfc_cmpl_ct_cmd_gid_pt(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)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
lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)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
lpfc_cmpl_ct_cmd_gft_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)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,
1561 					 LOG_DISCOVERY | LOG_NODE,
1562 					 "3064 Setting ndlp x%px, DID x%06x "
1563 					 "with FC4 x%08x, Data: x%08x x%08x "
1564 					 "%d\n",
1565 					 ndlp, did, ndlp->nlp_fc4_type,
1566 					 FC_TYPE_FCP, FC_TYPE_NVME,
1567 					 ndlp->nlp_state);
1568 
1569 			if (ndlp->nlp_state == NLP_STE_REG_LOGIN_ISSUE &&
1570 			    ndlp->nlp_fc4_type) {
1571 				ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1572 				/* This is a fabric topology so if discovery
1573 				 * started with an unsolicited PLOGI, don't
1574 				 * send a PRLI.  Targets don't issue PLOGI or
1575 				 * PRLI when acting as a target. Likely this is
1576 				 * an initiator function.
1577 				 */
1578 				if (!(ndlp->nlp_flag & NLP_RCV_PLOGI)) {
1579 					lpfc_nlp_set_state(vport, ndlp,
1580 							   NLP_STE_PRLI_ISSUE);
1581 					lpfc_issue_els_prli(vport, ndlp, 0);
1582 				}
1583 			} else if (!ndlp->nlp_fc4_type) {
1584 				/* If fc4 type is still unknown, then LOGO */
1585 				lpfc_printf_vlog(vport, KERN_INFO,
1586 						 LOG_DISCOVERY | LOG_NODE,
1587 						 "6443 Sending LOGO ndlp x%px,"
1588 						 "DID x%06x with fc4_type: "
1589 						 "x%08x, state: %d\n",
1590 						 ndlp, did, ndlp->nlp_fc4_type,
1591 						 ndlp->nlp_state);
1592 				lpfc_issue_els_logo(vport, ndlp, 0);
1593 				ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1594 				lpfc_nlp_set_state(vport, ndlp,
1595 						   NLP_STE_NPR_NODE);
1596 			}
1597 		}
1598 	} else
1599 		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1600 				 "3065 GFT_ID failed x%08x\n", ulp_status);
1601 
1602 out:
1603 	lpfc_ct_free_iocb(phba, cmdiocb);
1604 	lpfc_nlp_put(ns_ndlp);
1605 }
1606 
1607 static void
lpfc_cmpl_ct(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1608 lpfc_cmpl_ct(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1609 	     struct lpfc_iocbq *rspiocb)
1610 {
1611 	struct lpfc_vport *vport = cmdiocb->vport;
1612 	struct lpfc_dmabuf *inp;
1613 	struct lpfc_dmabuf *outp;
1614 	struct lpfc_sli_ct_request *CTrsp;
1615 	struct lpfc_nodelist *ndlp;
1616 	int cmdcode, rc;
1617 	uint8_t retry;
1618 	uint32_t latt;
1619 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1620 	u32 ulp_word4 = get_job_word4(phba, rspiocb);
1621 
1622 	/* First save ndlp, before we overwrite it */
1623 	ndlp = cmdiocb->ndlp;
1624 
1625 	/* we pass cmdiocb to state machine which needs rspiocb as well */
1626 	cmdiocb->rsp_iocb = rspiocb;
1627 
1628 	inp = cmdiocb->cmd_dmabuf;
1629 	outp = cmdiocb->rsp_dmabuf;
1630 
1631 	cmdcode = be16_to_cpu(((struct lpfc_sli_ct_request *) inp->virt)->
1632 					CommandResponse.bits.CmdRsp);
1633 	CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1634 
1635 	latt = lpfc_els_chk_latt(vport);
1636 
1637 	/* RFT request completes status <ulp_status> CmdRsp <CmdRsp> */
1638 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1639 			 "0209 CT Request completes, latt %d, "
1640 			 "ulp_status x%x CmdRsp x%x, Context x%x, Tag x%x\n",
1641 			 latt, ulp_status,
1642 			 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1643 			 get_job_ulpcontext(phba, cmdiocb), cmdiocb->iotag);
1644 
1645 	lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1646 		"CT cmd cmpl:     status:x%x/x%x cmd:x%x",
1647 		ulp_status, ulp_word4, cmdcode);
1648 
1649 	if (ulp_status) {
1650 		lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1651 				 "0268 NS cmd x%x Error (x%x x%x)\n",
1652 				 cmdcode, ulp_status, ulp_word4);
1653 
1654 		if (ulp_status == IOSTAT_LOCAL_REJECT &&
1655 		    (((ulp_word4 & IOERR_PARAM_MASK) ==
1656 		      IOERR_SLI_DOWN) ||
1657 		     ((ulp_word4 & IOERR_PARAM_MASK) ==
1658 		      IOERR_SLI_ABORTED)))
1659 			goto out;
1660 
1661 		retry = cmdiocb->retry;
1662 		if (retry >= LPFC_MAX_NS_RETRY)
1663 			goto out;
1664 
1665 		retry++;
1666 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1667 				 "0250 Retrying NS cmd %x\n", cmdcode);
1668 		rc = lpfc_ns_cmd(vport, cmdcode, retry, 0);
1669 		if (rc == 0)
1670 			goto out;
1671 	}
1672 
1673 out:
1674 	lpfc_ct_free_iocb(phba, cmdiocb);
1675 	lpfc_nlp_put(ndlp);
1676 	return;
1677 }
1678 
1679 static void
lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1680 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1681 			struct lpfc_iocbq *rspiocb)
1682 {
1683 	struct lpfc_vport *vport = cmdiocb->vport;
1684 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1685 
1686 	if (ulp_status == IOSTAT_SUCCESS) {
1687 		struct lpfc_dmabuf *outp;
1688 		struct lpfc_sli_ct_request *CTrsp;
1689 
1690 		outp = cmdiocb->rsp_dmabuf;
1691 		CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1692 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1693 		    SLI_CT_RESPONSE_FS_ACC)
1694 			vport->ct_flags |= FC_CT_RFT_ID;
1695 	}
1696 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1697 	return;
1698 }
1699 
1700 static void
lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1701 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1702 			struct lpfc_iocbq *rspiocb)
1703 {
1704 	struct lpfc_vport *vport = cmdiocb->vport;
1705 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1706 
1707 	if (ulp_status == IOSTAT_SUCCESS) {
1708 		struct lpfc_dmabuf *outp;
1709 		struct lpfc_sli_ct_request *CTrsp;
1710 
1711 		outp = cmdiocb->rsp_dmabuf;
1712 		CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1713 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1714 		    SLI_CT_RESPONSE_FS_ACC)
1715 			vport->ct_flags |= FC_CT_RNN_ID;
1716 	}
1717 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1718 	return;
1719 }
1720 
1721 static void
lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1722 lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1723 			 struct lpfc_iocbq *rspiocb)
1724 {
1725 	struct lpfc_vport *vport = cmdiocb->vport;
1726 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1727 
1728 	if (ulp_status == IOSTAT_SUCCESS) {
1729 		struct lpfc_dmabuf *outp;
1730 		struct lpfc_sli_ct_request *CTrsp;
1731 
1732 		outp = cmdiocb->rsp_dmabuf;
1733 		CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1734 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1735 		    SLI_CT_RESPONSE_FS_ACC)
1736 			vport->ct_flags |= FC_CT_RSPN_ID;
1737 	}
1738 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1739 	return;
1740 }
1741 
1742 static void
lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1743 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1744 			 struct lpfc_iocbq *rspiocb)
1745 {
1746 	struct lpfc_vport *vport = cmdiocb->vport;
1747 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1748 
1749 	if (ulp_status == IOSTAT_SUCCESS) {
1750 		struct lpfc_dmabuf *outp;
1751 		struct lpfc_sli_ct_request *CTrsp;
1752 
1753 		outp = cmdiocb->rsp_dmabuf;
1754 		CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1755 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1756 		    SLI_CT_RESPONSE_FS_ACC)
1757 			vport->ct_flags |= FC_CT_RSNN_NN;
1758 	}
1759 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1760 	return;
1761 }
1762 
1763 static void
lpfc_cmpl_ct_cmd_da_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1764 lpfc_cmpl_ct_cmd_da_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1765  struct lpfc_iocbq *rspiocb)
1766 {
1767 	struct lpfc_vport *vport = cmdiocb->vport;
1768 
1769 	/* even if it fails we will act as though it succeeded. */
1770 	vport->ct_flags = 0;
1771 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1772 	return;
1773 }
1774 
1775 static void
lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1776 lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1777 			struct lpfc_iocbq *rspiocb)
1778 {
1779 	struct lpfc_vport *vport = cmdiocb->vport;
1780 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1781 
1782 	if (ulp_status == IOSTAT_SUCCESS) {
1783 		struct lpfc_dmabuf *outp;
1784 		struct lpfc_sli_ct_request *CTrsp;
1785 
1786 		outp = cmdiocb->rsp_dmabuf;
1787 		CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1788 		if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1789 		    SLI_CT_RESPONSE_FS_ACC)
1790 			vport->ct_flags |= FC_CT_RFF_ID;
1791 	}
1792 	lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1793 	return;
1794 }
1795 
1796 /*
1797  * Although the symbolic port name is thought to be an integer
1798  * as of January 18, 2016, leave it as a string until more of
1799  * the record state becomes defined.
1800  */
1801 int
lpfc_vport_symbolic_port_name(struct lpfc_vport * vport,char * symbol,size_t size)1802 lpfc_vport_symbolic_port_name(struct lpfc_vport *vport, char *symbol,
1803 	size_t size)
1804 {
1805 	int n;
1806 
1807 	/*
1808 	 * Use the lpfc board number as the Symbolic Port
1809 	 * Name object.  NPIV is not in play so this integer
1810 	 * value is sufficient and unique per FC-ID.
1811 	 */
1812 	n = scnprintf(symbol, size, "%d", vport->phba->brd_no);
1813 	return n;
1814 }
1815 
1816 
1817 int
lpfc_vport_symbolic_node_name(struct lpfc_vport * vport,char * symbol,size_t size)1818 lpfc_vport_symbolic_node_name(struct lpfc_vport *vport, char *symbol,
1819 	size_t size)
1820 {
1821 	char fwrev[FW_REV_STR_SIZE] = {0};
1822 	char tmp[MAXHOSTNAMELEN] = {0};
1823 
1824 	memset(symbol, 0, size);
1825 
1826 	scnprintf(tmp, sizeof(tmp), "Emulex %s", vport->phba->ModelName);
1827 	if (strlcat(symbol, tmp, size) >= size)
1828 		goto buffer_done;
1829 
1830 	lpfc_decode_firmware_rev(vport->phba, fwrev, 0);
1831 	scnprintf(tmp, sizeof(tmp), " FV%s", fwrev);
1832 	if (strlcat(symbol, tmp, size) >= size)
1833 		goto buffer_done;
1834 
1835 	scnprintf(tmp, sizeof(tmp), " DV%s", lpfc_release_version);
1836 	if (strlcat(symbol, tmp, size) >= size)
1837 		goto buffer_done;
1838 
1839 	scnprintf(tmp, sizeof(tmp), " HN:%s", vport->phba->os_host_name);
1840 	if (strlcat(symbol, tmp, size) >= size)
1841 		goto buffer_done;
1842 
1843 	/* Note :- OS name is "Linux" */
1844 	scnprintf(tmp, sizeof(tmp), " OS:%s", init_utsname()->sysname);
1845 	strlcat(symbol, tmp, size);
1846 
1847 buffer_done:
1848 	return strnlen(symbol, size);
1849 
1850 }
1851 
1852 static uint32_t
lpfc_find_map_node(struct lpfc_vport * vport)1853 lpfc_find_map_node(struct lpfc_vport *vport)
1854 {
1855 	struct lpfc_nodelist *ndlp, *next_ndlp;
1856 	struct Scsi_Host  *shost;
1857 	uint32_t cnt = 0;
1858 
1859 	shost = lpfc_shost_from_vport(vport);
1860 	spin_lock_irq(shost->host_lock);
1861 	list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
1862 		if (ndlp->nlp_type & NLP_FABRIC)
1863 			continue;
1864 		if ((ndlp->nlp_state == NLP_STE_MAPPED_NODE) ||
1865 		    (ndlp->nlp_state == NLP_STE_UNMAPPED_NODE))
1866 			cnt++;
1867 	}
1868 	spin_unlock_irq(shost->host_lock);
1869 	return cnt;
1870 }
1871 
1872 /*
1873  * This routine will return the FC4 Type associated with the CT
1874  * GID_FT command.
1875  */
1876 int
lpfc_get_gidft_type(struct lpfc_vport * vport,struct lpfc_iocbq * cmdiocb)1877 lpfc_get_gidft_type(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb)
1878 {
1879 	struct lpfc_sli_ct_request *CtReq;
1880 	struct lpfc_dmabuf *mp;
1881 	uint32_t type;
1882 
1883 	mp = cmdiocb->cmd_dmabuf;
1884 	if (mp == NULL)
1885 		return 0;
1886 	CtReq = (struct lpfc_sli_ct_request *)mp->virt;
1887 	type = (uint32_t)CtReq->un.gid.Fc4Type;
1888 	if ((type != SLI_CTPT_FCP) && (type != SLI_CTPT_NVME))
1889 		return 0;
1890 	return type;
1891 }
1892 
1893 /*
1894  * lpfc_ns_cmd
1895  * Description:
1896  *    Issue Cmd to NameServer
1897  *       SLI_CTNS_GID_FT
1898  *       LI_CTNS_RFT_ID
1899  */
1900 int
lpfc_ns_cmd(struct lpfc_vport * vport,int cmdcode,uint8_t retry,uint32_t context)1901 lpfc_ns_cmd(struct lpfc_vport *vport, int cmdcode,
1902 	    uint8_t retry, uint32_t context)
1903 {
1904 	struct lpfc_nodelist * ndlp;
1905 	struct lpfc_hba *phba = vport->phba;
1906 	struct lpfc_dmabuf *mp, *bmp;
1907 	struct lpfc_sli_ct_request *CtReq;
1908 	struct ulp_bde64 *bpl;
1909 	void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
1910 		      struct lpfc_iocbq *) = NULL;
1911 	uint32_t *ptr;
1912 	uint32_t rsp_size = 1024;
1913 	size_t   size;
1914 	int rc = 0;
1915 
1916 	ndlp = lpfc_findnode_did(vport, NameServer_DID);
1917 	if (!ndlp || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) {
1918 		rc=1;
1919 		goto ns_cmd_exit;
1920 	}
1921 
1922 	/* fill in BDEs for command */
1923 	/* Allocate buffer for command payload */
1924 	mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1925 	if (!mp) {
1926 		rc=2;
1927 		goto ns_cmd_exit;
1928 	}
1929 
1930 	INIT_LIST_HEAD(&mp->list);
1931 	mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
1932 	if (!mp->virt) {
1933 		rc=3;
1934 		goto ns_cmd_free_mp;
1935 	}
1936 
1937 	/* Allocate buffer for Buffer ptr list */
1938 	bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1939 	if (!bmp) {
1940 		rc=4;
1941 		goto ns_cmd_free_mpvirt;
1942 	}
1943 
1944 	INIT_LIST_HEAD(&bmp->list);
1945 	bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys));
1946 	if (!bmp->virt) {
1947 		rc=5;
1948 		goto ns_cmd_free_bmp;
1949 	}
1950 
1951 	/* NameServer Req */
1952 	lpfc_printf_vlog(vport, KERN_INFO ,LOG_DISCOVERY,
1953 			 "0236 NameServer Req Data: x%x x%x x%x x%x\n",
1954 			 cmdcode, vport->fc_flag, vport->fc_rscn_id_cnt,
1955 			 context);
1956 
1957 	bpl = (struct ulp_bde64 *) bmp->virt;
1958 	memset(bpl, 0, sizeof(struct ulp_bde64));
1959 	bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
1960 	bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
1961 	bpl->tus.f.bdeFlags = 0;
1962 	if (cmdcode == SLI_CTNS_GID_FT)
1963 		bpl->tus.f.bdeSize = GID_REQUEST_SZ;
1964 	else if (cmdcode == SLI_CTNS_GID_PT)
1965 		bpl->tus.f.bdeSize = GID_REQUEST_SZ;
1966 	else if (cmdcode == SLI_CTNS_GFF_ID)
1967 		bpl->tus.f.bdeSize = GFF_REQUEST_SZ;
1968 	else if (cmdcode == SLI_CTNS_GFT_ID)
1969 		bpl->tus.f.bdeSize = GFT_REQUEST_SZ;
1970 	else if (cmdcode == SLI_CTNS_RFT_ID)
1971 		bpl->tus.f.bdeSize = RFT_REQUEST_SZ;
1972 	else if (cmdcode == SLI_CTNS_RNN_ID)
1973 		bpl->tus.f.bdeSize = RNN_REQUEST_SZ;
1974 	else if (cmdcode == SLI_CTNS_RSPN_ID)
1975 		bpl->tus.f.bdeSize = RSPN_REQUEST_SZ;
1976 	else if (cmdcode == SLI_CTNS_RSNN_NN)
1977 		bpl->tus.f.bdeSize = RSNN_REQUEST_SZ;
1978 	else if (cmdcode == SLI_CTNS_DA_ID)
1979 		bpl->tus.f.bdeSize = DA_ID_REQUEST_SZ;
1980 	else if (cmdcode == SLI_CTNS_RFF_ID)
1981 		bpl->tus.f.bdeSize = RFF_REQUEST_SZ;
1982 	else
1983 		bpl->tus.f.bdeSize = 0;
1984 	bpl->tus.w = le32_to_cpu(bpl->tus.w);
1985 
1986 	CtReq = (struct lpfc_sli_ct_request *) mp->virt;
1987 	memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request));
1988 	CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
1989 	CtReq->RevisionId.bits.InId = 0;
1990 	CtReq->FsType = SLI_CT_DIRECTORY_SERVICE;
1991 	CtReq->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER;
1992 	CtReq->CommandResponse.bits.Size = 0;
1993 	switch (cmdcode) {
1994 	case SLI_CTNS_GID_FT:
1995 		CtReq->CommandResponse.bits.CmdRsp =
1996 		    cpu_to_be16(SLI_CTNS_GID_FT);
1997 		CtReq->un.gid.Fc4Type = context;
1998 
1999 		if (vport->port_state < LPFC_NS_QRY)
2000 			vport->port_state = LPFC_NS_QRY;
2001 		lpfc_set_disctmo(vport);
2002 		cmpl = lpfc_cmpl_ct_cmd_gid_ft;
2003 		rsp_size = FC_MAX_NS_RSP;
2004 		break;
2005 
2006 	case SLI_CTNS_GID_PT:
2007 		CtReq->CommandResponse.bits.CmdRsp =
2008 		    cpu_to_be16(SLI_CTNS_GID_PT);
2009 		CtReq->un.gid.PortType = context;
2010 
2011 		if (vport->port_state < LPFC_NS_QRY)
2012 			vport->port_state = LPFC_NS_QRY;
2013 		lpfc_set_disctmo(vport);
2014 		cmpl = lpfc_cmpl_ct_cmd_gid_pt;
2015 		rsp_size = FC_MAX_NS_RSP;
2016 		break;
2017 
2018 	case SLI_CTNS_GFF_ID:
2019 		CtReq->CommandResponse.bits.CmdRsp =
2020 			cpu_to_be16(SLI_CTNS_GFF_ID);
2021 		CtReq->un.gff.PortId = cpu_to_be32(context);
2022 		cmpl = lpfc_cmpl_ct_cmd_gff_id;
2023 		break;
2024 
2025 	case SLI_CTNS_GFT_ID:
2026 		CtReq->CommandResponse.bits.CmdRsp =
2027 			cpu_to_be16(SLI_CTNS_GFT_ID);
2028 		CtReq->un.gft.PortId = cpu_to_be32(context);
2029 		cmpl = lpfc_cmpl_ct_cmd_gft_id;
2030 		break;
2031 
2032 	case SLI_CTNS_RFT_ID:
2033 		vport->ct_flags &= ~FC_CT_RFT_ID;
2034 		CtReq->CommandResponse.bits.CmdRsp =
2035 		    cpu_to_be16(SLI_CTNS_RFT_ID);
2036 		CtReq->un.rft.port_id = cpu_to_be32(vport->fc_myDID);
2037 
2038 		/* Register Application Services type if vmid enabled. */
2039 		if (phba->cfg_vmid_app_header)
2040 			CtReq->un.rft.app_serv_reg =
2041 				cpu_to_be32(RFT_APP_SERV_REG);
2042 
2043 		/* Register FC4 FCP type if enabled.  */
2044 		if (vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH ||
2045 		    vport->cfg_enable_fc4_type == LPFC_ENABLE_FCP)
2046 			CtReq->un.rft.fcp_reg = cpu_to_be32(RFT_FCP_REG);
2047 
2048 		/* Register NVME type if enabled. */
2049 		if (vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH ||
2050 		    vport->cfg_enable_fc4_type == LPFC_ENABLE_NVME)
2051 			CtReq->un.rft.nvme_reg = cpu_to_be32(RFT_NVME_REG);
2052 
2053 		ptr = (uint32_t *)CtReq;
2054 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2055 				 "6433 Issue RFT (%s %s %s): %08x %08x %08x "
2056 				 "%08x %08x %08x %08x %08x\n",
2057 				 CtReq->un.rft.fcp_reg ? "FCP" : " ",
2058 				 CtReq->un.rft.nvme_reg ? "NVME" : " ",
2059 				 CtReq->un.rft.app_serv_reg ? "APPS" : " ",
2060 				 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3),
2061 				 *(ptr + 4), *(ptr + 5),
2062 				 *(ptr + 6), *(ptr + 7));
2063 		cmpl = lpfc_cmpl_ct_cmd_rft_id;
2064 		break;
2065 
2066 	case SLI_CTNS_RNN_ID:
2067 		vport->ct_flags &= ~FC_CT_RNN_ID;
2068 		CtReq->CommandResponse.bits.CmdRsp =
2069 		    cpu_to_be16(SLI_CTNS_RNN_ID);
2070 		CtReq->un.rnn.PortId = cpu_to_be32(vport->fc_myDID);
2071 		memcpy(CtReq->un.rnn.wwnn,  &vport->fc_nodename,
2072 		       sizeof(struct lpfc_name));
2073 		cmpl = lpfc_cmpl_ct_cmd_rnn_id;
2074 		break;
2075 
2076 	case SLI_CTNS_RSPN_ID:
2077 		vport->ct_flags &= ~FC_CT_RSPN_ID;
2078 		CtReq->CommandResponse.bits.CmdRsp =
2079 		    cpu_to_be16(SLI_CTNS_RSPN_ID);
2080 		CtReq->un.rspn.PortId = cpu_to_be32(vport->fc_myDID);
2081 		size = sizeof(CtReq->un.rspn.symbname);
2082 		CtReq->un.rspn.len =
2083 			lpfc_vport_symbolic_port_name(vport,
2084 			CtReq->un.rspn.symbname, size);
2085 		cmpl = lpfc_cmpl_ct_cmd_rspn_id;
2086 		break;
2087 	case SLI_CTNS_RSNN_NN:
2088 		vport->ct_flags &= ~FC_CT_RSNN_NN;
2089 		CtReq->CommandResponse.bits.CmdRsp =
2090 		    cpu_to_be16(SLI_CTNS_RSNN_NN);
2091 		memcpy(CtReq->un.rsnn.wwnn, &vport->fc_nodename,
2092 		       sizeof(struct lpfc_name));
2093 		size = sizeof(CtReq->un.rsnn.symbname);
2094 		CtReq->un.rsnn.len =
2095 			lpfc_vport_symbolic_node_name(vport,
2096 			CtReq->un.rsnn.symbname, size);
2097 		cmpl = lpfc_cmpl_ct_cmd_rsnn_nn;
2098 		break;
2099 	case SLI_CTNS_DA_ID:
2100 		/* Implement DA_ID Nameserver request */
2101 		CtReq->CommandResponse.bits.CmdRsp =
2102 			cpu_to_be16(SLI_CTNS_DA_ID);
2103 		CtReq->un.da_id.port_id = cpu_to_be32(vport->fc_myDID);
2104 		cmpl = lpfc_cmpl_ct_cmd_da_id;
2105 		break;
2106 	case SLI_CTNS_RFF_ID:
2107 		vport->ct_flags &= ~FC_CT_RFF_ID;
2108 		CtReq->CommandResponse.bits.CmdRsp =
2109 		    cpu_to_be16(SLI_CTNS_RFF_ID);
2110 		CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID);
2111 		CtReq->un.rff.fbits = FC4_FEATURE_INIT;
2112 
2113 		/* The driver always supports FC_TYPE_FCP.  However, the
2114 		 * caller can specify NVME (type x28) as well.  But only
2115 		 * these that FC4 type is supported.
2116 		 */
2117 		if (((vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) ||
2118 		     (vport->cfg_enable_fc4_type == LPFC_ENABLE_NVME)) &&
2119 		    (context == FC_TYPE_NVME)) {
2120 			if ((vport == phba->pport) && phba->nvmet_support) {
2121 				CtReq->un.rff.fbits = (FC4_FEATURE_TARGET |
2122 					FC4_FEATURE_NVME_DISC);
2123 				lpfc_nvmet_update_targetport(phba);
2124 			} else {
2125 				lpfc_nvme_update_localport(vport);
2126 			}
2127 			CtReq->un.rff.type_code = context;
2128 
2129 		} else if (((vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) ||
2130 			    (vport->cfg_enable_fc4_type == LPFC_ENABLE_FCP)) &&
2131 			   (context == FC_TYPE_FCP))
2132 			CtReq->un.rff.type_code = context;
2133 
2134 		else
2135 			goto ns_cmd_free_bmpvirt;
2136 
2137 		ptr = (uint32_t *)CtReq;
2138 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2139 				 "6434 Issue RFF (%s): %08x %08x %08x %08x "
2140 				 "%08x %08x %08x %08x\n",
2141 				 (context == FC_TYPE_NVME) ? "NVME" : "FCP",
2142 				 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3),
2143 				 *(ptr + 4), *(ptr + 5),
2144 				 *(ptr + 6), *(ptr + 7));
2145 		cmpl = lpfc_cmpl_ct_cmd_rff_id;
2146 		break;
2147 	}
2148 	/* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
2149 	 * to hold ndlp reference for the corresponding callback function.
2150 	 */
2151 	if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry)) {
2152 		/* On success, The cmpl function will free the buffers */
2153 		lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
2154 			"Issue CT cmd:    cmd:x%x did:x%x",
2155 			cmdcode, ndlp->nlp_DID, 0);
2156 		return 0;
2157 	}
2158 	rc=6;
2159 
2160 ns_cmd_free_bmpvirt:
2161 	lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
2162 ns_cmd_free_bmp:
2163 	kfree(bmp);
2164 ns_cmd_free_mpvirt:
2165 	lpfc_mbuf_free(phba, mp->virt, mp->phys);
2166 ns_cmd_free_mp:
2167 	kfree(mp);
2168 ns_cmd_exit:
2169 	lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
2170 			 "0266 Issue NameServer Req x%x err %d Data: x%x x%x\n",
2171 			 cmdcode, rc, vport->fc_flag, vport->fc_rscn_id_cnt);
2172 	return 1;
2173 }
2174 
2175 /**
2176  * lpfc_fdmi_rprt_defer - Check for any deferred FDMI RPRT commands
2177  * @phba: Pointer to HBA context object.
2178  * @mask: Initial port attributes mask
2179  *
2180  * This function checks to see if any vports have deferred their FDMI RPRT.
2181  * A vports RPRT may be deferred if it is issued before the primary ports
2182  * RHBA completes.
2183  */
2184 static void
lpfc_fdmi_rprt_defer(struct lpfc_hba * phba,uint32_t mask)2185 lpfc_fdmi_rprt_defer(struct lpfc_hba *phba, uint32_t mask)
2186 {
2187 	struct lpfc_vport **vports;
2188 	struct lpfc_vport *vport;
2189 	struct lpfc_nodelist *ndlp;
2190 	int i;
2191 
2192 	phba->hba_flag |= HBA_RHBA_CMPL;
2193 	vports = lpfc_create_vport_work_array(phba);
2194 	if (vports) {
2195 		for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2196 			vport = vports[i];
2197 			ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2198 			if (!ndlp)
2199 				continue;
2200 			if (vport->ct_flags & FC_CT_RPRT_DEFER) {
2201 				vport->ct_flags &= ~FC_CT_RPRT_DEFER;
2202 				vport->fdmi_port_mask = mask;
2203 				lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT, 0);
2204 			}
2205 		}
2206 	}
2207 	lpfc_destroy_vport_work_array(phba, vports);
2208 }
2209 
2210 /**
2211  * lpfc_cmpl_ct_disc_fdmi - Handle a discovery FDMI completion
2212  * @phba: Pointer to HBA context object.
2213  * @cmdiocb: Pointer to the command IOCBQ.
2214  * @rspiocb: Pointer to the response IOCBQ.
2215  *
2216  * This function to handle the completion of a driver initiated FDMI
2217  * CT command issued during discovery.
2218  */
2219 static void
lpfc_cmpl_ct_disc_fdmi(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)2220 lpfc_cmpl_ct_disc_fdmi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2221 		       struct lpfc_iocbq *rspiocb)
2222 {
2223 	struct lpfc_vport *vport = cmdiocb->vport;
2224 	struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf;
2225 	struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf;
2226 	struct lpfc_sli_ct_request *CTcmd = inp->virt;
2227 	struct lpfc_sli_ct_request *CTrsp = outp->virt;
2228 	__be16 fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp;
2229 	__be16 fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp;
2230 	struct lpfc_nodelist *ndlp, *free_ndlp = NULL;
2231 	uint32_t latt, cmd, err;
2232 	u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
2233 	u32 ulp_word4 = get_job_word4(phba, rspiocb);
2234 
2235 	latt = lpfc_els_chk_latt(vport);
2236 	lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
2237 		"FDMI cmpl:       status:x%x/x%x latt:%d",
2238 		ulp_status, ulp_word4, latt);
2239 
2240 	if (latt || ulp_status) {
2241 
2242 		/* Look for a retryable error */
2243 		if (ulp_status == IOSTAT_LOCAL_REJECT) {
2244 			switch ((ulp_word4 & IOERR_PARAM_MASK)) {
2245 			case IOERR_SLI_ABORTED:
2246 			case IOERR_SLI_DOWN:
2247 				/* Driver aborted this IO.  No retry as error
2248 				 * is likely Offline->Online or some adapter
2249 				 * error.  Recovery will try again.
2250 				 */
2251 				break;
2252 			case IOERR_ABORT_IN_PROGRESS:
2253 			case IOERR_SEQUENCE_TIMEOUT:
2254 			case IOERR_ILLEGAL_FRAME:
2255 			case IOERR_NO_RESOURCES:
2256 			case IOERR_ILLEGAL_COMMAND:
2257 				cmdiocb->retry++;
2258 				if (cmdiocb->retry >= LPFC_FDMI_MAX_RETRY)
2259 					break;
2260 
2261 				/* Retry the same FDMI command */
2262 				err = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING,
2263 							  cmdiocb, 0);
2264 				if (err == IOCB_ERROR)
2265 					break;
2266 				return;
2267 			default:
2268 				break;
2269 			}
2270 		}
2271 
2272 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2273 				 "0229 FDMI cmd %04x failed, latt = %d "
2274 				 "ulp_status: x%x, rid x%x\n",
2275 				 be16_to_cpu(fdmi_cmd), latt, ulp_status,
2276 				 ulp_word4);
2277 	}
2278 
2279 	free_ndlp = cmdiocb->ndlp;
2280 	lpfc_ct_free_iocb(phba, cmdiocb);
2281 	lpfc_nlp_put(free_ndlp);
2282 
2283 	ndlp = lpfc_findnode_did(vport, FDMI_DID);
2284 	if (!ndlp)
2285 		return;
2286 
2287 	/* Check for a CT LS_RJT response */
2288 	cmd =  be16_to_cpu(fdmi_cmd);
2289 	if (be16_to_cpu(fdmi_rsp) == SLI_CT_RESPONSE_FS_RJT) {
2290 		/* FDMI rsp failed */
2291 		lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY | LOG_ELS,
2292 				 "0220 FDMI cmd failed FS_RJT Data: x%x", cmd);
2293 
2294 		/* Should we fallback to FDMI-2 / FDMI-1 ? */
2295 		switch (cmd) {
2296 		case SLI_MGMT_RHBA:
2297 			if (vport->fdmi_hba_mask == LPFC_FDMI2_HBA_ATTR) {
2298 				/* Fallback to FDMI-1 for HBA attributes */
2299 				vport->fdmi_hba_mask = LPFC_FDMI1_HBA_ATTR;
2300 
2301 				/* If HBA attributes are FDMI1, so should
2302 				 * port attributes be for consistency.
2303 				 */
2304 				vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
2305 				/* Start over */
2306 				lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
2307 			}
2308 			return;
2309 
2310 		case SLI_MGMT_RPRT:
2311 			if (vport->port_type != LPFC_PHYSICAL_PORT) {
2312 				ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2313 				if (!ndlp)
2314 					return;
2315 			}
2316 			if (vport->fdmi_port_mask == LPFC_FDMI2_PORT_ATTR) {
2317 				/* Fallback to FDMI-1 */
2318 				vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
2319 				/* Start over */
2320 				lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
2321 				return;
2322 			}
2323 			if (vport->fdmi_port_mask == LPFC_FDMI2_SMART_ATTR) {
2324 				vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
2325 				/* Retry the same command */
2326 				lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
2327 			}
2328 			return;
2329 
2330 		case SLI_MGMT_RPA:
2331 			/* No retry on Vendor, RPA only done on physical port */
2332 			if (phba->link_flag & LS_CT_VEN_RPA) {
2333 				phba->link_flag &= ~LS_CT_VEN_RPA;
2334 				if (phba->cmf_active_mode == LPFC_CFG_OFF)
2335 					return;
2336 				lpfc_printf_log(phba, KERN_WARNING,
2337 						LOG_DISCOVERY | LOG_ELS,
2338 						"6460 VEN FDMI RPA RJT\n");
2339 				return;
2340 			}
2341 			if (vport->fdmi_port_mask == LPFC_FDMI2_PORT_ATTR) {
2342 				/* Fallback to FDMI-1 */
2343 				vport->fdmi_hba_mask = LPFC_FDMI1_HBA_ATTR;
2344 				vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
2345 				/* Start over */
2346 				lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
2347 				return;
2348 			}
2349 			if (vport->fdmi_port_mask == LPFC_FDMI2_SMART_ATTR) {
2350 				vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
2351 				/* Retry the same command */
2352 				lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
2353 			}
2354 			return;
2355 		}
2356 	}
2357 
2358 	/*
2359 	 * On success, need to cycle thru FDMI registration for discovery
2360 	 * DHBA -> DPRT -> RHBA -> RPA  (physical port)
2361 	 * DPRT -> RPRT (vports)
2362 	 */
2363 	switch (cmd) {
2364 	case SLI_MGMT_RHBA:
2365 		/* Check for any RPRTs deferred till after RHBA completes */
2366 		lpfc_fdmi_rprt_defer(phba, vport->fdmi_port_mask);
2367 
2368 		lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA, 0);
2369 		break;
2370 
2371 	case SLI_MGMT_DHBA:
2372 		lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT, 0);
2373 		break;
2374 
2375 	case SLI_MGMT_DPRT:
2376 		if (vport->port_type == LPFC_PHYSICAL_PORT) {
2377 			lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RHBA, 0);
2378 		} else {
2379 			ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2380 			if (!ndlp)
2381 				return;
2382 
2383 			/* Only issue a RPRT for the vport if the RHBA
2384 			 * for the physical port completes successfully.
2385 			 * We may have to defer the RPRT accordingly.
2386 			 */
2387 			if (phba->hba_flag & HBA_RHBA_CMPL) {
2388 				lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT, 0);
2389 			} else {
2390 				lpfc_printf_vlog(vport, KERN_INFO,
2391 						 LOG_DISCOVERY,
2392 						 "6078 RPRT deferred\n");
2393 				vport->ct_flags |= FC_CT_RPRT_DEFER;
2394 			}
2395 		}
2396 		break;
2397 	case SLI_MGMT_RPA:
2398 		if (vport->port_type == LPFC_PHYSICAL_PORT &&
2399 		    phba->sli4_hba.pc_sli4_params.mi_ver) {
2400 			/* mi is only for the phyical port, no vports */
2401 			if (phba->link_flag & LS_CT_VEN_RPA) {
2402 				lpfc_printf_vlog(vport, KERN_INFO,
2403 						 LOG_DISCOVERY | LOG_ELS |
2404 						 LOG_CGN_MGMT,
2405 						 "6449 VEN RPA FDMI Success\n");
2406 				phba->link_flag &= ~LS_CT_VEN_RPA;
2407 				break;
2408 			}
2409 
2410 			lpfc_printf_log(phba, KERN_INFO,
2411 					LOG_DISCOVERY | LOG_CGN_MGMT,
2412 					"6210 Issue Vendor MI FDMI %x\n",
2413 					phba->sli4_hba.pc_sli4_params.mi_ver);
2414 
2415 			/* CGN is only for the physical port, no vports */
2416 			if (lpfc_fdmi_cmd(vport, ndlp, cmd,
2417 					  LPFC_FDMI_VENDOR_ATTR_mi) == 0)
2418 				phba->link_flag |= LS_CT_VEN_RPA;
2419 			lpfc_printf_log(phba, KERN_INFO,
2420 					LOG_DISCOVERY | LOG_ELS,
2421 					"6458 Send MI FDMI:%x Flag x%x\n",
2422 					phba->sli4_hba.pc_sli4_params.mi_ver,
2423 					phba->link_flag);
2424 		} else {
2425 			lpfc_printf_log(phba, KERN_INFO,
2426 					LOG_DISCOVERY | LOG_ELS,
2427 					"6459 No FDMI VEN MI support - "
2428 					"RPA Success\n");
2429 		}
2430 		break;
2431 	}
2432 	return;
2433 }
2434 
2435 
2436 /**
2437  * lpfc_fdmi_change_check - Check for changed FDMI parameters
2438  * @vport: pointer to a host virtual N_Port data structure.
2439  *
2440  * Check how many mapped NPorts we are connected to
2441  * Check if our hostname changed
2442  * Called from hbeat timeout routine to check if any FDMI parameters
2443  * changed. If so, re-register those Attributes.
2444  */
2445 void
lpfc_fdmi_change_check(struct lpfc_vport * vport)2446 lpfc_fdmi_change_check(struct lpfc_vport *vport)
2447 {
2448 	struct lpfc_hba *phba = vport->phba;
2449 	struct lpfc_nodelist *ndlp;
2450 	uint16_t cnt;
2451 
2452 	if (!lpfc_is_link_up(phba))
2453 		return;
2454 
2455 	/* Must be connected to a Fabric */
2456 	if (!(vport->fc_flag & FC_FABRIC))
2457 		return;
2458 
2459 	ndlp = lpfc_findnode_did(vport, FDMI_DID);
2460 	if (!ndlp)
2461 		return;
2462 
2463 	/* Check if system hostname changed */
2464 	if (strcmp(phba->os_host_name, init_utsname()->nodename)) {
2465 		memset(phba->os_host_name, 0, sizeof(phba->os_host_name));
2466 		scnprintf(phba->os_host_name, sizeof(phba->os_host_name), "%s",
2467 			  init_utsname()->nodename);
2468 		lpfc_ns_cmd(vport, SLI_CTNS_RSNN_NN, 0, 0);
2469 
2470 		/* Since this effects multiple HBA and PORT attributes, we need
2471 		 * de-register and go thru the whole FDMI registration cycle.
2472 		 * DHBA -> DPRT -> RHBA -> RPA  (physical port)
2473 		 * DPRT -> RPRT (vports)
2474 		 */
2475 		if (vport->port_type == LPFC_PHYSICAL_PORT) {
2476 			/* For extra Vendor RPA */
2477 			phba->link_flag &= ~LS_CT_VEN_RPA;
2478 			lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
2479 		} else {
2480 			ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2481 			if (!ndlp)
2482 				return;
2483 			lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT, 0);
2484 		}
2485 
2486 		/* Since this code path registers all the port attributes
2487 		 * we can just return without further checking.
2488 		 */
2489 		return;
2490 	}
2491 
2492 	if (!(vport->fdmi_port_mask & LPFC_FDMI_PORT_ATTR_num_disc))
2493 		return;
2494 
2495 	/* Check if the number of mapped NPorts changed */
2496 	cnt = lpfc_find_map_node(vport);
2497 	if (cnt == vport->fdmi_num_disc)
2498 		return;
2499 
2500 	if (vport->port_type == LPFC_PHYSICAL_PORT) {
2501 		lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA,
2502 			      LPFC_FDMI_PORT_ATTR_num_disc);
2503 	} else {
2504 		ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2505 		if (!ndlp)
2506 			return;
2507 		lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT,
2508 			      LPFC_FDMI_PORT_ATTR_num_disc);
2509 	}
2510 }
2511 
2512 static inline int
lpfc_fdmi_set_attr_u32(void * attr,uint16_t attrtype,uint32_t attrval)2513 lpfc_fdmi_set_attr_u32(void *attr, uint16_t attrtype, uint32_t attrval)
2514 {
2515 	struct lpfc_fdmi_attr_u32 *ae = attr;
2516 	int size = sizeof(*ae);
2517 
2518 	ae->type = cpu_to_be16(attrtype);
2519 	ae->len = cpu_to_be16(size);
2520 	ae->value_u32 = cpu_to_be32(attrval);
2521 
2522 	return size;
2523 }
2524 
2525 static inline int
lpfc_fdmi_set_attr_wwn(void * attr,uint16_t attrtype,struct lpfc_name * wwn)2526 lpfc_fdmi_set_attr_wwn(void *attr, uint16_t attrtype, struct lpfc_name *wwn)
2527 {
2528 	struct lpfc_fdmi_attr_wwn *ae = attr;
2529 	int size = sizeof(*ae);
2530 
2531 	ae->type = cpu_to_be16(attrtype);
2532 	ae->len = cpu_to_be16(size);
2533 	/* WWN's assumed to be bytestreams - Big Endian presentation */
2534 	memcpy(ae->name, wwn,
2535 	       min_t(size_t, sizeof(struct lpfc_name), sizeof(__be64)));
2536 
2537 	return size;
2538 }
2539 
2540 static inline int
lpfc_fdmi_set_attr_fullwwn(void * attr,uint16_t attrtype,struct lpfc_name * wwnn,struct lpfc_name * wwpn)2541 lpfc_fdmi_set_attr_fullwwn(void *attr, uint16_t attrtype,
2542 			   struct lpfc_name *wwnn, struct lpfc_name *wwpn)
2543 {
2544 	struct lpfc_fdmi_attr_fullwwn *ae = attr;
2545 	u8 *nname = ae->nname;
2546 	u8 *pname = ae->pname;
2547 	int size = sizeof(*ae);
2548 
2549 	ae->type = cpu_to_be16(attrtype);
2550 	ae->len = cpu_to_be16(size);
2551 	/* WWN's assumed to be bytestreams - Big Endian presentation */
2552 	memcpy(nname, wwnn,
2553 	       min_t(size_t, sizeof(struct lpfc_name), sizeof(__be64)));
2554 	memcpy(pname, wwpn,
2555 	       min_t(size_t, sizeof(struct lpfc_name), sizeof(__be64)));
2556 
2557 	return size;
2558 }
2559 
2560 static inline int
lpfc_fdmi_set_attr_string(void * attr,uint16_t attrtype,char * attrstring)2561 lpfc_fdmi_set_attr_string(void *attr, uint16_t attrtype, char *attrstring)
2562 {
2563 	struct lpfc_fdmi_attr_string *ae = attr;
2564 	int len, size;
2565 
2566 	/*
2567 	 * We are trusting the caller that if a fdmi string field
2568 	 * is capped at 64 bytes, the caller passes in a string of
2569 	 * 64 bytes or less.
2570 	 */
2571 
2572 	strncpy(ae->value_string, attrstring, sizeof(ae->value_string));
2573 	len = strnlen(ae->value_string, sizeof(ae->value_string));
2574 	/* round string length to a 32bit boundary. Ensure there's a NULL */
2575 	len += (len & 3) ? (4 - (len & 3)) : 4;
2576 	/* size is Type/Len (4 bytes) plus string length */
2577 	size = FOURBYTES + len;
2578 
2579 	ae->type = cpu_to_be16(attrtype);
2580 	ae->len = cpu_to_be16(size);
2581 
2582 	return size;
2583 }
2584 
2585 /* Bitfields for FC4 Types that can be reported */
2586 #define ATTR_FC4_CT	0x00000001
2587 #define ATTR_FC4_FCP	0x00000002
2588 #define ATTR_FC4_NVME	0x00000004
2589 
2590 static inline int
lpfc_fdmi_set_attr_fc4types(void * attr,uint16_t attrtype,uint32_t typemask)2591 lpfc_fdmi_set_attr_fc4types(void *attr, uint16_t attrtype, uint32_t typemask)
2592 {
2593 	struct lpfc_fdmi_attr_fc4types *ae = attr;
2594 	int size = sizeof(*ae);
2595 
2596 	ae->type = cpu_to_be16(attrtype);
2597 	ae->len = cpu_to_be16(size);
2598 
2599 	if (typemask & ATTR_FC4_FCP)
2600 		ae->value_types[2] = 0x01; /* Type 0x8 - FCP */
2601 
2602 	if (typemask & ATTR_FC4_CT)
2603 		ae->value_types[7] = 0x01; /* Type 0x20 - CT */
2604 
2605 	if (typemask & ATTR_FC4_NVME)
2606 		ae->value_types[6] = 0x01; /* Type 0x28 - NVME */
2607 
2608 	return size;
2609 }
2610 
2611 /* Routines for all individual HBA attributes */
2612 static int
lpfc_fdmi_hba_attr_wwnn(struct lpfc_vport * vport,void * attr)2613 lpfc_fdmi_hba_attr_wwnn(struct lpfc_vport *vport, void *attr)
2614 {
2615 	return lpfc_fdmi_set_attr_wwn(attr, RHBA_NODENAME,
2616 			&vport->fc_sparam.nodeName);
2617 }
2618 
2619 static int
lpfc_fdmi_hba_attr_manufacturer(struct lpfc_vport * vport,void * attr)2620 lpfc_fdmi_hba_attr_manufacturer(struct lpfc_vport *vport, void *attr)
2621 {
2622 	/* This string MUST be consistent with other FC platforms
2623 	 * supported by Broadcom.
2624 	 */
2625 	return lpfc_fdmi_set_attr_string(attr, RHBA_MANUFACTURER,
2626 			"Emulex Corporation");
2627 }
2628 
2629 static int
lpfc_fdmi_hba_attr_sn(struct lpfc_vport * vport,void * attr)2630 lpfc_fdmi_hba_attr_sn(struct lpfc_vport *vport, void *attr)
2631 {
2632 	struct lpfc_hba *phba = vport->phba;
2633 
2634 	return lpfc_fdmi_set_attr_string(attr, RHBA_SERIAL_NUMBER,
2635 			phba->SerialNumber);
2636 }
2637 
2638 static int
lpfc_fdmi_hba_attr_model(struct lpfc_vport * vport,void * attr)2639 lpfc_fdmi_hba_attr_model(struct lpfc_vport *vport, void *attr)
2640 {
2641 	struct lpfc_hba *phba = vport->phba;
2642 
2643 	return lpfc_fdmi_set_attr_string(attr, RHBA_MODEL,
2644 			phba->ModelName);
2645 }
2646 
2647 static int
lpfc_fdmi_hba_attr_description(struct lpfc_vport * vport,void * attr)2648 lpfc_fdmi_hba_attr_description(struct lpfc_vport *vport, void *attr)
2649 {
2650 	struct lpfc_hba *phba = vport->phba;
2651 
2652 	return lpfc_fdmi_set_attr_string(attr, RHBA_MODEL_DESCRIPTION,
2653 			phba->ModelDesc);
2654 }
2655 
2656 static int
lpfc_fdmi_hba_attr_hdw_ver(struct lpfc_vport * vport,void * attr)2657 lpfc_fdmi_hba_attr_hdw_ver(struct lpfc_vport *vport, void *attr)
2658 {
2659 	struct lpfc_hba *phba = vport->phba;
2660 	lpfc_vpd_t *vp = &phba->vpd;
2661 	char buf[16] = { 0 };
2662 
2663 	snprintf(buf, sizeof(buf), "%08x", vp->rev.biuRev);
2664 
2665 	return lpfc_fdmi_set_attr_string(attr, RHBA_HARDWARE_VERSION, buf);
2666 }
2667 
2668 static int
lpfc_fdmi_hba_attr_drvr_ver(struct lpfc_vport * vport,void * attr)2669 lpfc_fdmi_hba_attr_drvr_ver(struct lpfc_vport *vport, void *attr)
2670 {
2671 	return lpfc_fdmi_set_attr_string(attr, RHBA_DRIVER_VERSION,
2672 			lpfc_release_version);
2673 }
2674 
2675 static int
lpfc_fdmi_hba_attr_rom_ver(struct lpfc_vport * vport,void * attr)2676 lpfc_fdmi_hba_attr_rom_ver(struct lpfc_vport *vport, void *attr)
2677 {
2678 	struct lpfc_hba *phba = vport->phba;
2679 	char buf[64] = { 0 };
2680 
2681 	if (phba->sli_rev == LPFC_SLI_REV4) {
2682 		lpfc_decode_firmware_rev(phba, buf, 1);
2683 
2684 		return lpfc_fdmi_set_attr_string(attr, RHBA_OPTION_ROM_VERSION,
2685 				buf);
2686 	}
2687 
2688 	return lpfc_fdmi_set_attr_string(attr, RHBA_OPTION_ROM_VERSION,
2689 			phba->OptionROMVersion);
2690 }
2691 
2692 static int
lpfc_fdmi_hba_attr_fmw_ver(struct lpfc_vport * vport,void * attr)2693 lpfc_fdmi_hba_attr_fmw_ver(struct lpfc_vport *vport, void *attr)
2694 {
2695 	struct lpfc_hba *phba = vport->phba;
2696 	char buf[64] = { 0 };
2697 
2698 	lpfc_decode_firmware_rev(phba, buf, 1);
2699 
2700 	return lpfc_fdmi_set_attr_string(attr, RHBA_FIRMWARE_VERSION, buf);
2701 }
2702 
2703 static int
lpfc_fdmi_hba_attr_os_ver(struct lpfc_vport * vport,void * attr)2704 lpfc_fdmi_hba_attr_os_ver(struct lpfc_vport *vport, void *attr)
2705 {
2706 	char buf[256] = { 0 };
2707 
2708 	snprintf(buf, sizeof(buf), "%s %s %s",
2709 		 init_utsname()->sysname,
2710 		 init_utsname()->release,
2711 		 init_utsname()->version);
2712 
2713 	return lpfc_fdmi_set_attr_string(attr, RHBA_OS_NAME_VERSION, buf);
2714 }
2715 
2716 static int
lpfc_fdmi_hba_attr_ct_len(struct lpfc_vport * vport,void * attr)2717 lpfc_fdmi_hba_attr_ct_len(struct lpfc_vport *vport, void *attr)
2718 {
2719 	return lpfc_fdmi_set_attr_u32(attr, RHBA_MAX_CT_PAYLOAD_LEN,
2720 			LPFC_MAX_CT_SIZE);
2721 }
2722 
2723 static int
lpfc_fdmi_hba_attr_symbolic_name(struct lpfc_vport * vport,void * attr)2724 lpfc_fdmi_hba_attr_symbolic_name(struct lpfc_vport *vport, void *attr)
2725 {
2726 	char buf[256] = { 0 };
2727 
2728 	lpfc_vport_symbolic_node_name(vport, buf, sizeof(buf));
2729 
2730 	return lpfc_fdmi_set_attr_string(attr, RHBA_SYM_NODENAME, buf);
2731 }
2732 
2733 static int
lpfc_fdmi_hba_attr_vendor_info(struct lpfc_vport * vport,void * attr)2734 lpfc_fdmi_hba_attr_vendor_info(struct lpfc_vport *vport, void *attr)
2735 {
2736 	return lpfc_fdmi_set_attr_u32(attr, RHBA_VENDOR_INFO, 0);
2737 }
2738 
2739 static int
lpfc_fdmi_hba_attr_num_ports(struct lpfc_vport * vport,void * attr)2740 lpfc_fdmi_hba_attr_num_ports(struct lpfc_vport *vport, void *attr)
2741 {
2742 	/* Each driver instance corresponds to a single port */
2743 	return lpfc_fdmi_set_attr_u32(attr, RHBA_NUM_PORTS, 1);
2744 }
2745 
2746 static int
lpfc_fdmi_hba_attr_fabric_wwnn(struct lpfc_vport * vport,void * attr)2747 lpfc_fdmi_hba_attr_fabric_wwnn(struct lpfc_vport *vport, void *attr)
2748 {
2749 	return lpfc_fdmi_set_attr_wwn(attr, RHBA_FABRIC_WWNN,
2750 			&vport->fabric_nodename);
2751 }
2752 
2753 static int
lpfc_fdmi_hba_attr_bios_ver(struct lpfc_vport * vport,void * attr)2754 lpfc_fdmi_hba_attr_bios_ver(struct lpfc_vport *vport, void *attr)
2755 {
2756 	struct lpfc_hba *phba = vport->phba;
2757 
2758 	return lpfc_fdmi_set_attr_string(attr, RHBA_BIOS_VERSION,
2759 			phba->BIOSVersion);
2760 }
2761 
2762 static int
lpfc_fdmi_hba_attr_bios_state(struct lpfc_vport * vport,void * attr)2763 lpfc_fdmi_hba_attr_bios_state(struct lpfc_vport *vport, void *attr)
2764 {
2765 	/* Driver doesn't have access to this information */
2766 	return lpfc_fdmi_set_attr_u32(attr, RHBA_BIOS_STATE, 0);
2767 }
2768 
2769 static int
lpfc_fdmi_hba_attr_vendor_id(struct lpfc_vport * vport,void * attr)2770 lpfc_fdmi_hba_attr_vendor_id(struct lpfc_vport *vport, void *attr)
2771 {
2772 	return lpfc_fdmi_set_attr_string(attr, RHBA_VENDOR_ID, "EMULEX");
2773 }
2774 
2775 /*
2776  * Routines for all individual PORT attributes
2777  */
2778 
2779 static int
lpfc_fdmi_port_attr_fc4type(struct lpfc_vport * vport,void * attr)2780 lpfc_fdmi_port_attr_fc4type(struct lpfc_vport *vport, void *attr)
2781 {
2782 	struct lpfc_hba   *phba = vport->phba;
2783 	u32 fc4types;
2784 
2785 	fc4types = (ATTR_FC4_CT | ATTR_FC4_FCP);
2786 
2787 	/* Check to see if Firmware supports NVME and on physical port */
2788 	if ((phba->sli_rev == LPFC_SLI_REV4) && (vport == phba->pport) &&
2789 	    phba->sli4_hba.pc_sli4_params.nvme)
2790 		fc4types |= ATTR_FC4_NVME;
2791 
2792 	return lpfc_fdmi_set_attr_fc4types(attr, RPRT_SUPPORTED_FC4_TYPES,
2793 			fc4types);
2794 }
2795 
2796 static int
lpfc_fdmi_port_attr_support_speed(struct lpfc_vport * vport,void * attr)2797 lpfc_fdmi_port_attr_support_speed(struct lpfc_vport *vport, void *attr)
2798 {
2799 	struct lpfc_hba *phba = vport->phba;
2800 	u32 speeds = 0;
2801 	u32 tcfg;
2802 	u8 i, cnt;
2803 
2804 	if (!(phba->hba_flag & HBA_FCOE_MODE)) {
2805 		cnt = 0;
2806 		if (phba->sli_rev == LPFC_SLI_REV4) {
2807 			tcfg = phba->sli4_hba.conf_trunk;
2808 			for (i = 0; i < 4; i++, tcfg >>= 1)
2809 				if (tcfg & 1)
2810 					cnt++;
2811 		}
2812 
2813 		if (cnt > 2) { /* 4 lane trunk group */
2814 			if (phba->lmt & LMT_64Gb)
2815 				speeds |= HBA_PORTSPEED_256GFC;
2816 			if (phba->lmt & LMT_32Gb)
2817 				speeds |= HBA_PORTSPEED_128GFC;
2818 			if (phba->lmt & LMT_16Gb)
2819 				speeds |= HBA_PORTSPEED_64GFC;
2820 		} else if (cnt) { /* 2 lane trunk group */
2821 			if (phba->lmt & LMT_128Gb)
2822 				speeds |= HBA_PORTSPEED_256GFC;
2823 			if (phba->lmt & LMT_64Gb)
2824 				speeds |= HBA_PORTSPEED_128GFC;
2825 			if (phba->lmt & LMT_32Gb)
2826 				speeds |= HBA_PORTSPEED_64GFC;
2827 			if (phba->lmt & LMT_16Gb)
2828 				speeds |= HBA_PORTSPEED_32GFC;
2829 		} else {
2830 			if (phba->lmt & LMT_256Gb)
2831 				speeds |= HBA_PORTSPEED_256GFC;
2832 			if (phba->lmt & LMT_128Gb)
2833 				speeds |= HBA_PORTSPEED_128GFC;
2834 			if (phba->lmt & LMT_64Gb)
2835 				speeds |= HBA_PORTSPEED_64GFC;
2836 			if (phba->lmt & LMT_32Gb)
2837 				speeds |= HBA_PORTSPEED_32GFC;
2838 			if (phba->lmt & LMT_16Gb)
2839 				speeds |= HBA_PORTSPEED_16GFC;
2840 			if (phba->lmt & LMT_10Gb)
2841 				speeds |= HBA_PORTSPEED_10GFC;
2842 			if (phba->lmt & LMT_8Gb)
2843 				speeds |= HBA_PORTSPEED_8GFC;
2844 			if (phba->lmt & LMT_4Gb)
2845 				speeds |= HBA_PORTSPEED_4GFC;
2846 			if (phba->lmt & LMT_2Gb)
2847 				speeds |= HBA_PORTSPEED_2GFC;
2848 			if (phba->lmt & LMT_1Gb)
2849 				speeds |= HBA_PORTSPEED_1GFC;
2850 		}
2851 	} else {
2852 		/* FCoE links support only one speed */
2853 		switch (phba->fc_linkspeed) {
2854 		case LPFC_ASYNC_LINK_SPEED_10GBPS:
2855 			speeds = HBA_PORTSPEED_10GE;
2856 			break;
2857 		case LPFC_ASYNC_LINK_SPEED_25GBPS:
2858 			speeds = HBA_PORTSPEED_25GE;
2859 			break;
2860 		case LPFC_ASYNC_LINK_SPEED_40GBPS:
2861 			speeds = HBA_PORTSPEED_40GE;
2862 			break;
2863 		case LPFC_ASYNC_LINK_SPEED_100GBPS:
2864 			speeds = HBA_PORTSPEED_100GE;
2865 			break;
2866 		}
2867 	}
2868 
2869 	return lpfc_fdmi_set_attr_u32(attr, RPRT_SUPPORTED_SPEED, speeds);
2870 }
2871 
2872 static int
lpfc_fdmi_port_attr_speed(struct lpfc_vport * vport,void * attr)2873 lpfc_fdmi_port_attr_speed(struct lpfc_vport *vport, void *attr)
2874 {
2875 	struct lpfc_hba   *phba = vport->phba;
2876 	u32 speeds = 0;
2877 
2878 	if (!(phba->hba_flag & HBA_FCOE_MODE)) {
2879 		switch (phba->fc_linkspeed) {
2880 		case LPFC_LINK_SPEED_1GHZ:
2881 			speeds = HBA_PORTSPEED_1GFC;
2882 			break;
2883 		case LPFC_LINK_SPEED_2GHZ:
2884 			speeds = HBA_PORTSPEED_2GFC;
2885 			break;
2886 		case LPFC_LINK_SPEED_4GHZ:
2887 			speeds = HBA_PORTSPEED_4GFC;
2888 			break;
2889 		case LPFC_LINK_SPEED_8GHZ:
2890 			speeds = HBA_PORTSPEED_8GFC;
2891 			break;
2892 		case LPFC_LINK_SPEED_10GHZ:
2893 			speeds = HBA_PORTSPEED_10GFC;
2894 			break;
2895 		case LPFC_LINK_SPEED_16GHZ:
2896 			speeds = HBA_PORTSPEED_16GFC;
2897 			break;
2898 		case LPFC_LINK_SPEED_32GHZ:
2899 			speeds = HBA_PORTSPEED_32GFC;
2900 			break;
2901 		case LPFC_LINK_SPEED_64GHZ:
2902 			speeds = HBA_PORTSPEED_64GFC;
2903 			break;
2904 		case LPFC_LINK_SPEED_128GHZ:
2905 			speeds = HBA_PORTSPEED_128GFC;
2906 			break;
2907 		case LPFC_LINK_SPEED_256GHZ:
2908 			speeds = HBA_PORTSPEED_256GFC;
2909 			break;
2910 		default:
2911 			speeds = HBA_PORTSPEED_UNKNOWN;
2912 			break;
2913 		}
2914 	} else {
2915 		switch (phba->fc_linkspeed) {
2916 		case LPFC_ASYNC_LINK_SPEED_10GBPS:
2917 			speeds = HBA_PORTSPEED_10GE;
2918 			break;
2919 		case LPFC_ASYNC_LINK_SPEED_25GBPS:
2920 			speeds = HBA_PORTSPEED_25GE;
2921 			break;
2922 		case LPFC_ASYNC_LINK_SPEED_40GBPS:
2923 			speeds = HBA_PORTSPEED_40GE;
2924 			break;
2925 		case LPFC_ASYNC_LINK_SPEED_100GBPS:
2926 			speeds = HBA_PORTSPEED_100GE;
2927 			break;
2928 		default:
2929 			speeds = HBA_PORTSPEED_UNKNOWN;
2930 			break;
2931 		}
2932 	}
2933 
2934 	return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_SPEED, speeds);
2935 }
2936 
2937 static int
lpfc_fdmi_port_attr_max_frame(struct lpfc_vport * vport,void * attr)2938 lpfc_fdmi_port_attr_max_frame(struct lpfc_vport *vport, void *attr)
2939 {
2940 	struct serv_parm *hsp = (struct serv_parm *)&vport->fc_sparam;
2941 
2942 	return lpfc_fdmi_set_attr_u32(attr, RPRT_MAX_FRAME_SIZE,
2943 			(((uint32_t)hsp->cmn.bbRcvSizeMsb & 0x0F) << 8) |
2944 			  (uint32_t)hsp->cmn.bbRcvSizeLsb);
2945 }
2946 
2947 static int
lpfc_fdmi_port_attr_os_devname(struct lpfc_vport * vport,void * attr)2948 lpfc_fdmi_port_attr_os_devname(struct lpfc_vport *vport, void *attr)
2949 {
2950 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2951 	char buf[64] = { 0 };
2952 
2953 	snprintf(buf, sizeof(buf), "/sys/class/scsi_host/host%d",
2954 		 shost->host_no);
2955 
2956 	return lpfc_fdmi_set_attr_string(attr, RPRT_OS_DEVICE_NAME, buf);
2957 }
2958 
2959 static int
lpfc_fdmi_port_attr_host_name(struct lpfc_vport * vport,void * attr)2960 lpfc_fdmi_port_attr_host_name(struct lpfc_vport *vport, void *attr)
2961 {
2962 	char buf[64] = { 0 };
2963 
2964 	scnprintf(buf, sizeof(buf), "%s", vport->phba->os_host_name);
2965 
2966 	return lpfc_fdmi_set_attr_string(attr, RPRT_HOST_NAME, buf);
2967 }
2968 
2969 static int
lpfc_fdmi_port_attr_wwnn(struct lpfc_vport * vport,void * attr)2970 lpfc_fdmi_port_attr_wwnn(struct lpfc_vport *vport, void *attr)
2971 {
2972 	return lpfc_fdmi_set_attr_wwn(attr, RPRT_NODENAME,
2973 			&vport->fc_sparam.nodeName);
2974 }
2975 
2976 static int
lpfc_fdmi_port_attr_wwpn(struct lpfc_vport * vport,void * attr)2977 lpfc_fdmi_port_attr_wwpn(struct lpfc_vport *vport, void *attr)
2978 {
2979 	return lpfc_fdmi_set_attr_wwn(attr, RPRT_PORTNAME,
2980 			&vport->fc_sparam.portName);
2981 }
2982 
2983 static int
lpfc_fdmi_port_attr_symbolic_name(struct lpfc_vport * vport,void * attr)2984 lpfc_fdmi_port_attr_symbolic_name(struct lpfc_vport *vport, void *attr)
2985 {
2986 	char buf[256] = { 0 };
2987 
2988 	lpfc_vport_symbolic_port_name(vport, buf, sizeof(buf));
2989 
2990 	return lpfc_fdmi_set_attr_string(attr, RPRT_SYM_PORTNAME, buf);
2991 }
2992 
2993 static int
lpfc_fdmi_port_attr_port_type(struct lpfc_vport * vport,void * attr)2994 lpfc_fdmi_port_attr_port_type(struct lpfc_vport *vport, void *attr)
2995 {
2996 	struct lpfc_hba *phba = vport->phba;
2997 
2998 	return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_TYPE,
2999 			(phba->fc_topology == LPFC_TOPOLOGY_LOOP) ?
3000 				LPFC_FDMI_PORTTYPE_NLPORT :
3001 				LPFC_FDMI_PORTTYPE_NPORT);
3002 }
3003 
3004 static int
lpfc_fdmi_port_attr_class(struct lpfc_vport * vport,void * attr)3005 lpfc_fdmi_port_attr_class(struct lpfc_vport *vport, void *attr)
3006 {
3007 	return lpfc_fdmi_set_attr_u32(attr, RPRT_SUPPORTED_CLASS,
3008 			FC_COS_CLASS2 | FC_COS_CLASS3);
3009 }
3010 
3011 static int
lpfc_fdmi_port_attr_fabric_wwpn(struct lpfc_vport * vport,void * attr)3012 lpfc_fdmi_port_attr_fabric_wwpn(struct lpfc_vport *vport, void *attr)
3013 {
3014 	return lpfc_fdmi_set_attr_wwn(attr, RPRT_FABRICNAME,
3015 			&vport->fabric_portname);
3016 }
3017 
3018 static int
lpfc_fdmi_port_attr_active_fc4type(struct lpfc_vport * vport,void * attr)3019 lpfc_fdmi_port_attr_active_fc4type(struct lpfc_vport *vport, void *attr)
3020 {
3021 	struct lpfc_hba *phba = vport->phba;
3022 	u32 fc4types;
3023 
3024 	fc4types = (ATTR_FC4_CT | ATTR_FC4_FCP);
3025 
3026 	/* Check to see if NVME is configured or not */
3027 	if (vport == phba->pport &&
3028 	    phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
3029 		fc4types |= ATTR_FC4_NVME;
3030 
3031 	return lpfc_fdmi_set_attr_fc4types(attr, RPRT_ACTIVE_FC4_TYPES,
3032 			fc4types);
3033 }
3034 
3035 static int
lpfc_fdmi_port_attr_port_state(struct lpfc_vport * vport,void * attr)3036 lpfc_fdmi_port_attr_port_state(struct lpfc_vport *vport, void *attr)
3037 {
3038 	return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_STATE,
3039 			LPFC_FDMI_PORTSTATE_ONLINE);
3040 }
3041 
3042 static int
lpfc_fdmi_port_attr_num_disc(struct lpfc_vport * vport,void * attr)3043 lpfc_fdmi_port_attr_num_disc(struct lpfc_vport *vport, void *attr)
3044 {
3045 	vport->fdmi_num_disc = lpfc_find_map_node(vport);
3046 
3047 	return lpfc_fdmi_set_attr_u32(attr, RPRT_DISC_PORT,
3048 			vport->fdmi_num_disc);
3049 }
3050 
3051 static int
lpfc_fdmi_port_attr_nportid(struct lpfc_vport * vport,void * attr)3052 lpfc_fdmi_port_attr_nportid(struct lpfc_vport *vport, void *attr)
3053 {
3054 	return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_ID, vport->fc_myDID);
3055 }
3056 
3057 static int
lpfc_fdmi_smart_attr_service(struct lpfc_vport * vport,void * attr)3058 lpfc_fdmi_smart_attr_service(struct lpfc_vport *vport, void *attr)
3059 {
3060 	return lpfc_fdmi_set_attr_string(attr, RPRT_SMART_SERVICE,
3061 			"Smart SAN Initiator");
3062 }
3063 
3064 static int
lpfc_fdmi_smart_attr_guid(struct lpfc_vport * vport,void * attr)3065 lpfc_fdmi_smart_attr_guid(struct lpfc_vport *vport, void *attr)
3066 {
3067 	return lpfc_fdmi_set_attr_fullwwn(attr, RPRT_SMART_GUID,
3068 			&vport->fc_sparam.nodeName,
3069 			&vport->fc_sparam.portName);
3070 }
3071 
3072 static int
lpfc_fdmi_smart_attr_version(struct lpfc_vport * vport,void * attr)3073 lpfc_fdmi_smart_attr_version(struct lpfc_vport *vport, void *attr)
3074 {
3075 	return lpfc_fdmi_set_attr_string(attr, RPRT_SMART_VERSION,
3076 			"Smart SAN Version 2.0");
3077 }
3078 
3079 static int
lpfc_fdmi_smart_attr_model(struct lpfc_vport * vport,void * attr)3080 lpfc_fdmi_smart_attr_model(struct lpfc_vport *vport, void *attr)
3081 {
3082 	struct lpfc_hba *phba = vport->phba;
3083 
3084 	return lpfc_fdmi_set_attr_string(attr, RPRT_SMART_MODEL,
3085 			phba->ModelName);
3086 }
3087 
3088 static int
lpfc_fdmi_smart_attr_port_info(struct lpfc_vport * vport,void * attr)3089 lpfc_fdmi_smart_attr_port_info(struct lpfc_vport *vport, void *attr)
3090 {
3091 	/* SRIOV (type 3) is not supported */
3092 
3093 	return lpfc_fdmi_set_attr_u32(attr, RPRT_SMART_PORT_INFO,
3094 			(vport->vpi) ?  2 /* NPIV */ : 1 /* Physical */);
3095 }
3096 
3097 static int
lpfc_fdmi_smart_attr_qos(struct lpfc_vport * vport,void * attr)3098 lpfc_fdmi_smart_attr_qos(struct lpfc_vport *vport, void *attr)
3099 {
3100 	return lpfc_fdmi_set_attr_u32(attr, RPRT_SMART_QOS, 0);
3101 }
3102 
3103 static int
lpfc_fdmi_smart_attr_security(struct lpfc_vport * vport,void * attr)3104 lpfc_fdmi_smart_attr_security(struct lpfc_vport *vport, void *attr)
3105 {
3106 	return lpfc_fdmi_set_attr_u32(attr, RPRT_SMART_SECURITY, 1);
3107 }
3108 
3109 static int
lpfc_fdmi_vendor_attr_mi(struct lpfc_vport * vport,void * attr)3110 lpfc_fdmi_vendor_attr_mi(struct lpfc_vport *vport, void *attr)
3111 {
3112 	struct lpfc_hba *phba = vport->phba;
3113 	char buf[32] = { 0 };
3114 
3115 	sprintf(buf, "ELXE2EM:%04d", phba->sli4_hba.pc_sli4_params.mi_ver);
3116 
3117 	return lpfc_fdmi_set_attr_string(attr, RPRT_VENDOR_MI, buf);
3118 }
3119 
3120 /* RHBA attribute jump table */
3121 static int (*lpfc_fdmi_hba_action[])
3122 	(struct lpfc_vport *vport, void *attrbuf) = {
3123 	/* Action routine                 Mask bit     Attribute type */
3124 	lpfc_fdmi_hba_attr_wwnn,	  /* bit0     RHBA_NODENAME           */
3125 	lpfc_fdmi_hba_attr_manufacturer,  /* bit1     RHBA_MANUFACTURER       */
3126 	lpfc_fdmi_hba_attr_sn,		  /* bit2     RHBA_SERIAL_NUMBER      */
3127 	lpfc_fdmi_hba_attr_model,	  /* bit3     RHBA_MODEL              */
3128 	lpfc_fdmi_hba_attr_description,	  /* bit4     RHBA_MODEL_DESCRIPTION  */
3129 	lpfc_fdmi_hba_attr_hdw_ver,	  /* bit5     RHBA_HARDWARE_VERSION   */
3130 	lpfc_fdmi_hba_attr_drvr_ver,	  /* bit6     RHBA_DRIVER_VERSION     */
3131 	lpfc_fdmi_hba_attr_rom_ver,	  /* bit7     RHBA_OPTION_ROM_VERSION */
3132 	lpfc_fdmi_hba_attr_fmw_ver,	  /* bit8     RHBA_FIRMWARE_VERSION   */
3133 	lpfc_fdmi_hba_attr_os_ver,	  /* bit9     RHBA_OS_NAME_VERSION    */
3134 	lpfc_fdmi_hba_attr_ct_len,	  /* bit10    RHBA_MAX_CT_PAYLOAD_LEN */
3135 	lpfc_fdmi_hba_attr_symbolic_name, /* bit11    RHBA_SYM_NODENAME       */
3136 	lpfc_fdmi_hba_attr_vendor_info,	  /* bit12    RHBA_VENDOR_INFO        */
3137 	lpfc_fdmi_hba_attr_num_ports,	  /* bit13    RHBA_NUM_PORTS          */
3138 	lpfc_fdmi_hba_attr_fabric_wwnn,	  /* bit14    RHBA_FABRIC_WWNN        */
3139 	lpfc_fdmi_hba_attr_bios_ver,	  /* bit15    RHBA_BIOS_VERSION       */
3140 	lpfc_fdmi_hba_attr_bios_state,	  /* bit16    RHBA_BIOS_STATE         */
3141 	lpfc_fdmi_hba_attr_vendor_id,	  /* bit17    RHBA_VENDOR_ID          */
3142 };
3143 
3144 /* RPA / RPRT attribute jump table */
3145 static int (*lpfc_fdmi_port_action[])
3146 	(struct lpfc_vport *vport, void *attrbuf) = {
3147 	/* Action routine                   Mask bit   Attribute type */
3148 	lpfc_fdmi_port_attr_fc4type,        /* bit0   RPRT_SUPPORT_FC4_TYPES  */
3149 	lpfc_fdmi_port_attr_support_speed,  /* bit1   RPRT_SUPPORTED_SPEED    */
3150 	lpfc_fdmi_port_attr_speed,          /* bit2   RPRT_PORT_SPEED         */
3151 	lpfc_fdmi_port_attr_max_frame,      /* bit3   RPRT_MAX_FRAME_SIZE     */
3152 	lpfc_fdmi_port_attr_os_devname,     /* bit4   RPRT_OS_DEVICE_NAME     */
3153 	lpfc_fdmi_port_attr_host_name,      /* bit5   RPRT_HOST_NAME          */
3154 	lpfc_fdmi_port_attr_wwnn,           /* bit6   RPRT_NODENAME           */
3155 	lpfc_fdmi_port_attr_wwpn,           /* bit7   RPRT_PORTNAME           */
3156 	lpfc_fdmi_port_attr_symbolic_name,  /* bit8   RPRT_SYM_PORTNAME       */
3157 	lpfc_fdmi_port_attr_port_type,      /* bit9   RPRT_PORT_TYPE          */
3158 	lpfc_fdmi_port_attr_class,          /* bit10  RPRT_SUPPORTED_CLASS    */
3159 	lpfc_fdmi_port_attr_fabric_wwpn,    /* bit11  RPRT_FABRICNAME         */
3160 	lpfc_fdmi_port_attr_active_fc4type, /* bit12  RPRT_ACTIVE_FC4_TYPES   */
3161 	lpfc_fdmi_port_attr_port_state,     /* bit13  RPRT_PORT_STATE         */
3162 	lpfc_fdmi_port_attr_num_disc,       /* bit14  RPRT_DISC_PORT          */
3163 	lpfc_fdmi_port_attr_nportid,        /* bit15  RPRT_PORT_ID            */
3164 	lpfc_fdmi_smart_attr_service,       /* bit16  RPRT_SMART_SERVICE      */
3165 	lpfc_fdmi_smart_attr_guid,          /* bit17  RPRT_SMART_GUID         */
3166 	lpfc_fdmi_smart_attr_version,       /* bit18  RPRT_SMART_VERSION      */
3167 	lpfc_fdmi_smart_attr_model,         /* bit19  RPRT_SMART_MODEL        */
3168 	lpfc_fdmi_smart_attr_port_info,     /* bit20  RPRT_SMART_PORT_INFO    */
3169 	lpfc_fdmi_smart_attr_qos,           /* bit21  RPRT_SMART_QOS          */
3170 	lpfc_fdmi_smart_attr_security,      /* bit22  RPRT_SMART_SECURITY     */
3171 	lpfc_fdmi_vendor_attr_mi,           /* bit23  RPRT_VENDOR_MI          */
3172 };
3173 
3174 /**
3175  * lpfc_fdmi_cmd - Build and send a FDMI cmd to the specified NPort
3176  * @vport: pointer to a host virtual N_Port data structure.
3177  * @ndlp: ndlp to send FDMI cmd to (if NULL use FDMI_DID)
3178  * @cmdcode: FDMI command to send
3179  * @new_mask: Mask of HBA or PORT Attributes to send
3180  *
3181  * Builds and sends a FDMI command using the CT subsystem.
3182  */
3183 int
lpfc_fdmi_cmd(struct lpfc_vport * vport,struct lpfc_nodelist * ndlp,int cmdcode,uint32_t new_mask)3184 lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
3185 	      int cmdcode, uint32_t new_mask)
3186 {
3187 	struct lpfc_hba *phba = vport->phba;
3188 	struct lpfc_dmabuf *rq, *rsp;
3189 	struct lpfc_sli_ct_request *CtReq;
3190 	struct ulp_bde64_le *bde;
3191 	uint32_t bit_pos;
3192 	uint32_t size, addsz;
3193 	uint32_t rsp_size;
3194 	uint32_t mask;
3195 	struct lpfc_fdmi_reg_hba *rh;
3196 	struct lpfc_fdmi_port_entry *pe;
3197 	struct lpfc_fdmi_reg_portattr *pab = NULL, *base = NULL;
3198 	struct lpfc_fdmi_attr_block *ab = NULL;
3199 	int  (*func)(struct lpfc_vport *vport, void *attrbuf);
3200 	void (*cmpl)(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3201 		     struct lpfc_iocbq *rspiocb);
3202 
3203 	if (!ndlp)
3204 		return 0;
3205 
3206 	cmpl = lpfc_cmpl_ct_disc_fdmi; /* called from discovery */
3207 
3208 	/* fill in BDEs for command */
3209 	/* Allocate buffer for command payload */
3210 	rq = kmalloc(sizeof(*rq), GFP_KERNEL);
3211 	if (!rq)
3212 		goto fdmi_cmd_exit;
3213 
3214 	rq->virt = lpfc_mbuf_alloc(phba, 0, &rq->phys);
3215 	if (!rq->virt)
3216 		goto fdmi_cmd_free_rq;
3217 
3218 	/* Allocate buffer for Buffer ptr list */
3219 	rsp = kmalloc(sizeof(*rsp), GFP_KERNEL);
3220 	if (!rsp)
3221 		goto fdmi_cmd_free_rqvirt;
3222 
3223 	rsp->virt = lpfc_mbuf_alloc(phba, 0, &rsp->phys);
3224 	if (!rsp->virt)
3225 		goto fdmi_cmd_free_rsp;
3226 
3227 	INIT_LIST_HEAD(&rq->list);
3228 	INIT_LIST_HEAD(&rsp->list);
3229 
3230 	/* mbuf buffers are 1K in length - aka LPFC_BPL_SIZE */
3231 	memset(rq->virt, 0, LPFC_BPL_SIZE);
3232 	rsp_size = LPFC_BPL_SIZE;
3233 
3234 	/* FDMI request */
3235 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3236 			 "0218 FDMI Request x%x mask x%x Data: x%x x%x x%x\n",
3237 			 cmdcode, new_mask, vport->fdmi_port_mask,
3238 			 vport->fc_flag, vport->port_state);
3239 
3240 	CtReq = (struct lpfc_sli_ct_request *)rq->virt;
3241 
3242 	/* First populate the CT_IU preamble */
3243 	CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
3244 	CtReq->RevisionId.bits.InId = 0;
3245 
3246 	CtReq->FsType = SLI_CT_MANAGEMENT_SERVICE;
3247 	CtReq->FsSubType = SLI_CT_FDMI_Subtypes;
3248 
3249 	CtReq->CommandResponse.bits.CmdRsp = cpu_to_be16(cmdcode);
3250 
3251 	size = 0;
3252 
3253 	/* Next fill in the specific FDMI cmd information */
3254 	switch (cmdcode) {
3255 	case SLI_MGMT_RHAT:
3256 	case SLI_MGMT_RHBA:
3257 		rh = (struct lpfc_fdmi_reg_hba *)&CtReq->un;
3258 		/* HBA Identifier */
3259 		memcpy(&rh->hi.PortName, &phba->pport->fc_sparam.portName,
3260 		       sizeof(struct lpfc_name));
3261 		size += sizeof(struct lpfc_fdmi_hba_ident);
3262 
3263 		if (cmdcode == SLI_MGMT_RHBA) {
3264 			/* Registered Port List */
3265 			/* One entry (port) per adapter */
3266 			rh->rpl.EntryCnt = cpu_to_be32(1);
3267 			memcpy(&rh->rpl.pe.PortName,
3268 			       &phba->pport->fc_sparam.portName,
3269 			       sizeof(struct lpfc_name));
3270 			size += sizeof(struct lpfc_fdmi_reg_port_list);
3271 		}
3272 
3273 		ab = (struct lpfc_fdmi_attr_block *)((uint8_t *)rh + size);
3274 		ab->EntryCnt = 0;
3275 		size += FOURBYTES;	/* add length of EntryCnt field */
3276 
3277 		bit_pos = 0;
3278 		if (new_mask)
3279 			mask = new_mask;
3280 		else
3281 			mask = vport->fdmi_hba_mask;
3282 
3283 		/* Mask will dictate what attributes to build in the request */
3284 		while (mask) {
3285 			if (mask & 0x1) {
3286 				func = lpfc_fdmi_hba_action[bit_pos];
3287 				addsz = func(vport, ((uint8_t *)rh + size));
3288 				if (addsz) {
3289 					ab->EntryCnt++;
3290 					size += addsz;
3291 				}
3292 				/* check if another attribute fits */
3293 				if ((size + FDMI_MAX_ATTRLEN) >
3294 				    (LPFC_BPL_SIZE - LPFC_CT_PREAMBLE))
3295 					goto hba_out;
3296 			}
3297 			mask = mask >> 1;
3298 			bit_pos++;
3299 		}
3300 hba_out:
3301 		ab->EntryCnt = cpu_to_be32(ab->EntryCnt);
3302 		/* Total size */
3303 		size += GID_REQUEST_SZ - 4;
3304 		break;
3305 
3306 	case SLI_MGMT_RPRT:
3307 		if (vport->port_type != LPFC_PHYSICAL_PORT) {
3308 			ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
3309 			if (!ndlp)
3310 				return 0;
3311 		}
3312 		fallthrough;
3313 	case SLI_MGMT_RPA:
3314 		/* Store base ptr right after preamble */
3315 		base = (struct lpfc_fdmi_reg_portattr *)&CtReq->un;
3316 
3317 		if (cmdcode == SLI_MGMT_RPRT) {
3318 			rh = (struct lpfc_fdmi_reg_hba *)base;
3319 			/* HBA Identifier */
3320 			memcpy(&rh->hi.PortName,
3321 			       &phba->pport->fc_sparam.portName,
3322 			       sizeof(struct lpfc_name));
3323 			pab = (struct lpfc_fdmi_reg_portattr *)
3324 				((uint8_t *)base + sizeof(struct lpfc_name));
3325 			size += sizeof(struct lpfc_name);
3326 		} else {
3327 			pab = base;
3328 		}
3329 
3330 		memcpy((uint8_t *)&pab->PortName,
3331 		       (uint8_t *)&vport->fc_sparam.portName,
3332 		       sizeof(struct lpfc_name));
3333 		pab->ab.EntryCnt = 0;
3334 		/* add length of name and EntryCnt field */
3335 		size += sizeof(struct lpfc_name) + FOURBYTES;
3336 
3337 		bit_pos = 0;
3338 		if (new_mask)
3339 			mask = new_mask;
3340 		else
3341 			mask = vport->fdmi_port_mask;
3342 
3343 		/* Mask will dictate what attributes to build in the request */
3344 		while (mask) {
3345 			if (mask & 0x1) {
3346 				func = lpfc_fdmi_port_action[bit_pos];
3347 				addsz = func(vport, ((uint8_t *)base + size));
3348 				if (addsz) {
3349 					pab->ab.EntryCnt++;
3350 					size += addsz;
3351 				}
3352 				/* check if another attribute fits */
3353 				if ((size + FDMI_MAX_ATTRLEN) >
3354 				    (LPFC_BPL_SIZE - LPFC_CT_PREAMBLE))
3355 					goto port_out;
3356 			}
3357 			mask = mask >> 1;
3358 			bit_pos++;
3359 		}
3360 port_out:
3361 		pab->ab.EntryCnt = cpu_to_be32(pab->ab.EntryCnt);
3362 		size += GID_REQUEST_SZ - 4;
3363 		break;
3364 
3365 	case SLI_MGMT_GHAT:
3366 	case SLI_MGMT_GRPL:
3367 		rsp_size = FC_MAX_NS_RSP;
3368 		fallthrough;
3369 	case SLI_MGMT_DHBA:
3370 	case SLI_MGMT_DHAT:
3371 		pe = (struct lpfc_fdmi_port_entry *)&CtReq->un;
3372 		memcpy((uint8_t *)&pe->PortName,
3373 		       (uint8_t *)&vport->fc_sparam.portName,
3374 		       sizeof(struct lpfc_name));
3375 		size = GID_REQUEST_SZ - 4 + sizeof(struct lpfc_name);
3376 		break;
3377 
3378 	case SLI_MGMT_GPAT:
3379 	case SLI_MGMT_GPAS:
3380 		rsp_size = FC_MAX_NS_RSP;
3381 		fallthrough;
3382 	case SLI_MGMT_DPRT:
3383 		if (vport->port_type != LPFC_PHYSICAL_PORT) {
3384 			ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
3385 			if (!ndlp)
3386 				return 0;
3387 		}
3388 		fallthrough;
3389 	case SLI_MGMT_DPA:
3390 		pe = (struct lpfc_fdmi_port_entry *)&CtReq->un;
3391 		memcpy((uint8_t *)&pe->PortName,
3392 		       (uint8_t *)&vport->fc_sparam.portName,
3393 		       sizeof(struct lpfc_name));
3394 		size = GID_REQUEST_SZ - 4 + sizeof(struct lpfc_name);
3395 		break;
3396 	case SLI_MGMT_GRHL:
3397 		size = GID_REQUEST_SZ - 4;
3398 		break;
3399 	default:
3400 		lpfc_printf_vlog(vport, KERN_WARNING, LOG_DISCOVERY,
3401 				 "0298 FDMI cmdcode x%x not supported\n",
3402 				 cmdcode);
3403 		goto fdmi_cmd_free_rspvirt;
3404 	}
3405 	CtReq->CommandResponse.bits.Size = cpu_to_be16(rsp_size);
3406 
3407 	bde = (struct ulp_bde64_le *)rsp->virt;
3408 	bde->addr_high = cpu_to_le32(putPaddrHigh(rq->phys));
3409 	bde->addr_low = cpu_to_le32(putPaddrLow(rq->phys));
3410 	bde->type_size = cpu_to_le32(ULP_BDE64_TYPE_BDE_64 <<
3411 				     ULP_BDE64_TYPE_SHIFT);
3412 	bde->type_size |= cpu_to_le32(size);
3413 
3414 	/*
3415 	 * The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
3416 	 * to hold ndlp reference for the corresponding callback function.
3417 	 */
3418 	if (!lpfc_ct_cmd(vport, rq, rsp, ndlp, cmpl, rsp_size, 0))
3419 		return 0;
3420 
3421 fdmi_cmd_free_rspvirt:
3422 	lpfc_mbuf_free(phba, rsp->virt, rsp->phys);
3423 fdmi_cmd_free_rsp:
3424 	kfree(rsp);
3425 fdmi_cmd_free_rqvirt:
3426 	lpfc_mbuf_free(phba, rq->virt, rq->phys);
3427 fdmi_cmd_free_rq:
3428 	kfree(rq);
3429 fdmi_cmd_exit:
3430 	/* Issue FDMI request failed */
3431 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3432 			 "0244 Issue FDMI request failed Data: x%x\n",
3433 			 cmdcode);
3434 	return 1;
3435 }
3436 
3437 /**
3438  * lpfc_delayed_disc_tmo - Timeout handler for delayed discovery timer.
3439  * @t: Context object of the timer.
3440  *
3441  * This function set the WORKER_DELAYED_DISC_TMO flag and wake up
3442  * the worker thread.
3443  **/
3444 void
lpfc_delayed_disc_tmo(struct timer_list * t)3445 lpfc_delayed_disc_tmo(struct timer_list *t)
3446 {
3447 	struct lpfc_vport *vport = from_timer(vport, t, delayed_disc_tmo);
3448 	struct lpfc_hba   *phba = vport->phba;
3449 	uint32_t tmo_posted;
3450 	unsigned long iflag;
3451 
3452 	spin_lock_irqsave(&vport->work_port_lock, iflag);
3453 	tmo_posted = vport->work_port_events & WORKER_DELAYED_DISC_TMO;
3454 	if (!tmo_posted)
3455 		vport->work_port_events |= WORKER_DELAYED_DISC_TMO;
3456 	spin_unlock_irqrestore(&vport->work_port_lock, iflag);
3457 
3458 	if (!tmo_posted)
3459 		lpfc_worker_wake_up(phba);
3460 	return;
3461 }
3462 
3463 /**
3464  * lpfc_delayed_disc_timeout_handler - Function called by worker thread to
3465  *      handle delayed discovery.
3466  * @vport: pointer to a host virtual N_Port data structure.
3467  *
3468  * This function start nport discovery of the vport.
3469  **/
3470 void
lpfc_delayed_disc_timeout_handler(struct lpfc_vport * vport)3471 lpfc_delayed_disc_timeout_handler(struct lpfc_vport *vport)
3472 {
3473 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3474 
3475 	spin_lock_irq(shost->host_lock);
3476 	if (!(vport->fc_flag & FC_DISC_DELAYED)) {
3477 		spin_unlock_irq(shost->host_lock);
3478 		return;
3479 	}
3480 	vport->fc_flag &= ~FC_DISC_DELAYED;
3481 	spin_unlock_irq(shost->host_lock);
3482 
3483 	lpfc_do_scr_ns_plogi(vport->phba, vport);
3484 }
3485 
3486 void
lpfc_decode_firmware_rev(struct lpfc_hba * phba,char * fwrevision,int flag)3487 lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag)
3488 {
3489 	struct lpfc_sli *psli = &phba->sli;
3490 	lpfc_vpd_t *vp = &phba->vpd;
3491 	uint32_t b1, b2, b3, b4, i, rev;
3492 	char c;
3493 	uint32_t *ptr, str[4];
3494 	uint8_t *fwname;
3495 
3496 	if (phba->sli_rev == LPFC_SLI_REV4)
3497 		snprintf(fwrevision, FW_REV_STR_SIZE, "%s", vp->rev.opFwName);
3498 	else if (vp->rev.rBit) {
3499 		if (psli->sli_flag & LPFC_SLI_ACTIVE)
3500 			rev = vp->rev.sli2FwRev;
3501 		else
3502 			rev = vp->rev.sli1FwRev;
3503 
3504 		b1 = (rev & 0x0000f000) >> 12;
3505 		b2 = (rev & 0x00000f00) >> 8;
3506 		b3 = (rev & 0x000000c0) >> 6;
3507 		b4 = (rev & 0x00000030) >> 4;
3508 
3509 		switch (b4) {
3510 		case 0:
3511 			c = 'N';
3512 			break;
3513 		case 1:
3514 			c = 'A';
3515 			break;
3516 		case 2:
3517 			c = 'B';
3518 			break;
3519 		case 3:
3520 			c = 'X';
3521 			break;
3522 		default:
3523 			c = 0;
3524 			break;
3525 		}
3526 		b4 = (rev & 0x0000000f);
3527 
3528 		if (psli->sli_flag & LPFC_SLI_ACTIVE)
3529 			fwname = vp->rev.sli2FwName;
3530 		else
3531 			fwname = vp->rev.sli1FwName;
3532 
3533 		for (i = 0; i < 16; i++)
3534 			if (fwname[i] == 0x20)
3535 				fwname[i] = 0;
3536 
3537 		ptr = (uint32_t*)fwname;
3538 
3539 		for (i = 0; i < 3; i++)
3540 			str[i] = be32_to_cpu(*ptr++);
3541 
3542 		if (c == 0) {
3543 			if (flag)
3544 				sprintf(fwrevision, "%d.%d%d (%s)",
3545 					b1, b2, b3, (char *)str);
3546 			else
3547 				sprintf(fwrevision, "%d.%d%d", b1,
3548 					b2, b3);
3549 		} else {
3550 			if (flag)
3551 				sprintf(fwrevision, "%d.%d%d%c%d (%s)",
3552 					b1, b2, b3, c,
3553 					b4, (char *)str);
3554 			else
3555 				sprintf(fwrevision, "%d.%d%d%c%d",
3556 					b1, b2, b3, c, b4);
3557 		}
3558 	} else {
3559 		rev = vp->rev.smFwRev;
3560 
3561 		b1 = (rev & 0xff000000) >> 24;
3562 		b2 = (rev & 0x00f00000) >> 20;
3563 		b3 = (rev & 0x000f0000) >> 16;
3564 		c  = (rev & 0x0000ff00) >> 8;
3565 		b4 = (rev & 0x000000ff);
3566 
3567 		sprintf(fwrevision, "%d.%d%d%c%d", b1, b2, b3, c, b4);
3568 	}
3569 	return;
3570 }
3571 
3572 static void
lpfc_cmpl_ct_cmd_vmid(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)3573 lpfc_cmpl_ct_cmd_vmid(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3574 		      struct lpfc_iocbq *rspiocb)
3575 {
3576 	struct lpfc_vport *vport = cmdiocb->vport;
3577 	struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf;
3578 	struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf;
3579 	struct lpfc_sli_ct_request *ctcmd = inp->virt;
3580 	struct lpfc_sli_ct_request *ctrsp = outp->virt;
3581 	__be16 rsp = ctrsp->CommandResponse.bits.CmdRsp;
3582 	struct app_id_object *app;
3583 	struct lpfc_nodelist *ndlp = cmdiocb->ndlp;
3584 	u32 cmd, hash, bucket;
3585 	struct lpfc_vmid *vmp, *cur;
3586 	u8 *data = outp->virt;
3587 	int i;
3588 
3589 	cmd = be16_to_cpu(ctcmd->CommandResponse.bits.CmdRsp);
3590 	if (cmd == SLI_CTAS_DALLAPP_ID)
3591 		lpfc_ct_free_iocb(phba, cmdiocb);
3592 
3593 	if (lpfc_els_chk_latt(vport) || get_job_ulpstatus(phba, rspiocb)) {
3594 		if (cmd != SLI_CTAS_DALLAPP_ID)
3595 			goto free_res;
3596 	}
3597 	/* Check for a CT LS_RJT response */
3598 	if (be16_to_cpu(rsp) == SLI_CT_RESPONSE_FS_RJT) {
3599 		if (cmd != SLI_CTAS_DALLAPP_ID)
3600 			lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3601 					 "3306 VMID FS_RJT Data: x%x x%x x%x\n",
3602 					 cmd, ctrsp->ReasonCode,
3603 					 ctrsp->Explanation);
3604 		if ((cmd != SLI_CTAS_DALLAPP_ID) ||
3605 		    (ctrsp->ReasonCode != SLI_CT_UNABLE_TO_PERFORM_REQ) ||
3606 		    (ctrsp->Explanation != SLI_CT_APP_ID_NOT_AVAILABLE)) {
3607 			/* If DALLAPP_ID failed retry later */
3608 			if (cmd == SLI_CTAS_DALLAPP_ID)
3609 				vport->load_flag |= FC_DEREGISTER_ALL_APP_ID;
3610 			goto free_res;
3611 		}
3612 	}
3613 
3614 	switch (cmd) {
3615 	case SLI_CTAS_RAPP_IDENT:
3616 		app = (struct app_id_object *)(RAPP_IDENT_OFFSET + data);
3617 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3618 				 "6712 RAPP_IDENT app id %d  port id x%x id "
3619 				 "len %d\n", be32_to_cpu(app->app_id),
3620 				 be32_to_cpu(app->port_id),
3621 				 app->obj.entity_id_len);
3622 
3623 		if (app->obj.entity_id_len == 0 || app->port_id == 0)
3624 			goto free_res;
3625 
3626 		hash = lpfc_vmid_hash_fn(app->obj.entity_id,
3627 					 app->obj.entity_id_len);
3628 		vmp = lpfc_get_vmid_from_hashtable(vport, hash,
3629 						  app->obj.entity_id);
3630 		if (vmp) {
3631 			write_lock(&vport->vmid_lock);
3632 			vmp->un.app_id = be32_to_cpu(app->app_id);
3633 			vmp->flag |= LPFC_VMID_REGISTERED;
3634 			vmp->flag &= ~LPFC_VMID_REQ_REGISTER;
3635 			write_unlock(&vport->vmid_lock);
3636 			/* Set IN USE flag */
3637 			vport->vmid_flag |= LPFC_VMID_IN_USE;
3638 		} else {
3639 			lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3640 					 "6901 No entry found %s hash %d\n",
3641 					 app->obj.entity_id, hash);
3642 		}
3643 		break;
3644 	case SLI_CTAS_DAPP_IDENT:
3645 		app = (struct app_id_object *)(DAPP_IDENT_OFFSET + data);
3646 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3647 				 "6713 DAPP_IDENT app id %d  port id x%x\n",
3648 				 be32_to_cpu(app->app_id),
3649 				 be32_to_cpu(app->port_id));
3650 		break;
3651 	case SLI_CTAS_DALLAPP_ID:
3652 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3653 				 "8856 Deregistered all app ids\n");
3654 		read_lock(&vport->vmid_lock);
3655 		for (i = 0; i < phba->cfg_max_vmid; i++) {
3656 			vmp = &vport->vmid[i];
3657 			if (vmp->flag != LPFC_VMID_SLOT_FREE)
3658 				memset(vmp, 0, sizeof(struct lpfc_vmid));
3659 		}
3660 		read_unlock(&vport->vmid_lock);
3661 		/* for all elements in the hash table */
3662 		if (!hash_empty(vport->hash_table))
3663 			hash_for_each(vport->hash_table, bucket, cur, hnode)
3664 				hash_del(&cur->hnode);
3665 		vport->load_flag |= FC_ALLOW_VMID;
3666 		break;
3667 	default:
3668 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3669 				 "8857 Invalid command code\n");
3670 	}
3671 free_res:
3672 	lpfc_ct_free_iocb(phba, cmdiocb);
3673 	lpfc_nlp_put(ndlp);
3674 }
3675 
3676 /**
3677  * lpfc_vmid_cmd - Build and send a FDMI cmd to the specified NPort
3678  * @vport: pointer to a host virtual N_Port data structure.
3679  * @cmdcode: application server command code to send
3680  * @vmid: pointer to vmid info structure
3681  *
3682  * Builds and sends a FDMI command using the CT subsystem.
3683  */
3684 int
lpfc_vmid_cmd(struct lpfc_vport * vport,int cmdcode,struct lpfc_vmid * vmid)3685 lpfc_vmid_cmd(struct lpfc_vport *vport,
3686 	      int cmdcode, struct lpfc_vmid *vmid)
3687 {
3688 	struct lpfc_hba *phba = vport->phba;
3689 	struct lpfc_dmabuf *mp, *bmp;
3690 	struct lpfc_sli_ct_request *ctreq;
3691 	struct ulp_bde64 *bpl;
3692 	u32 size;
3693 	u32 rsp_size;
3694 	u8 *data;
3695 	struct lpfc_vmid_rapp_ident_list *rap;
3696 	struct lpfc_vmid_dapp_ident_list *dap;
3697 	u8 retry = 0;
3698 	struct lpfc_nodelist *ndlp;
3699 
3700 	void (*cmpl)(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3701 		     struct lpfc_iocbq *rspiocb);
3702 
3703 	ndlp = lpfc_findnode_did(vport, FDMI_DID);
3704 	if (!ndlp || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE)
3705 		return 0;
3706 
3707 	cmpl = lpfc_cmpl_ct_cmd_vmid;
3708 
3709 	/* fill in BDEs for command */
3710 	/* Allocate buffer for command payload */
3711 	mp = kmalloc(sizeof(*mp), GFP_KERNEL);
3712 	if (!mp)
3713 		goto vmid_free_mp_exit;
3714 
3715 	mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
3716 	if (!mp->virt)
3717 		goto vmid_free_mp_virt_exit;
3718 
3719 	/* Allocate buffer for Buffer ptr list */
3720 	bmp = kmalloc(sizeof(*bmp), GFP_KERNEL);
3721 	if (!bmp)
3722 		goto vmid_free_bmp_exit;
3723 
3724 	bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
3725 	if (!bmp->virt)
3726 		goto vmid_free_bmp_virt_exit;
3727 
3728 	INIT_LIST_HEAD(&mp->list);
3729 	INIT_LIST_HEAD(&bmp->list);
3730 
3731 	lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3732 			 "3275 VMID Request Data: x%x x%x x%x\n",
3733 			 vport->fc_flag, vport->port_state, cmdcode);
3734 	ctreq = (struct lpfc_sli_ct_request *)mp->virt;
3735 	data = mp->virt;
3736 	/* First populate the CT_IU preamble */
3737 	memset(data, 0, LPFC_BPL_SIZE);
3738 	ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
3739 	ctreq->RevisionId.bits.InId = 0;
3740 
3741 	ctreq->FsType = SLI_CT_MANAGEMENT_SERVICE;
3742 	ctreq->FsSubType = SLI_CT_APP_SEV_Subtypes;
3743 
3744 	ctreq->CommandResponse.bits.CmdRsp = cpu_to_be16(cmdcode);
3745 	rsp_size = LPFC_BPL_SIZE;
3746 	size = 0;
3747 
3748 	switch (cmdcode) {
3749 	case SLI_CTAS_RAPP_IDENT:
3750 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3751 				 "1329 RAPP_IDENT for %s\n", vmid->host_vmid);
3752 		ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3753 		rap = (struct lpfc_vmid_rapp_ident_list *)
3754 			(DAPP_IDENT_OFFSET + data);
3755 		rap->no_of_objects = cpu_to_be32(1);
3756 		rap->obj[0].entity_id_len = vmid->vmid_len;
3757 		memcpy(rap->obj[0].entity_id, vmid->host_vmid, vmid->vmid_len);
3758 		size = RAPP_IDENT_OFFSET +
3759 		       struct_size(rap, obj, be32_to_cpu(rap->no_of_objects));
3760 		retry = 1;
3761 		break;
3762 
3763 	case SLI_CTAS_GALLAPPIA_ID:
3764 		ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3765 		size = GALLAPPIA_ID_SIZE;
3766 		break;
3767 
3768 	case SLI_CTAS_DAPP_IDENT:
3769 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3770 				 "1469 DAPP_IDENT for %s\n", vmid->host_vmid);
3771 		ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3772 		dap = (struct lpfc_vmid_dapp_ident_list *)
3773 			(DAPP_IDENT_OFFSET + data);
3774 		dap->no_of_objects = cpu_to_be32(1);
3775 		dap->obj[0].entity_id_len = vmid->vmid_len;
3776 		memcpy(dap->obj[0].entity_id, vmid->host_vmid, vmid->vmid_len);
3777 		size = DAPP_IDENT_OFFSET +
3778 		       struct_size(dap, obj, be32_to_cpu(dap->no_of_objects));
3779 		write_lock(&vport->vmid_lock);
3780 		vmid->flag &= ~LPFC_VMID_REGISTERED;
3781 		write_unlock(&vport->vmid_lock);
3782 		retry = 1;
3783 		break;
3784 
3785 	case SLI_CTAS_DALLAPP_ID:
3786 		ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3787 		size = DALLAPP_ID_SIZE;
3788 		break;
3789 
3790 	default:
3791 		lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3792 				 "7062 VMID cmdcode x%x not supported\n",
3793 				 cmdcode);
3794 		goto vmid_free_all_mem;
3795 	}
3796 
3797 	ctreq->CommandResponse.bits.Size = cpu_to_be16(rsp_size);
3798 
3799 	bpl = (struct ulp_bde64 *)bmp->virt;
3800 	bpl->addrHigh = putPaddrHigh(mp->phys);
3801 	bpl->addrLow = putPaddrLow(mp->phys);
3802 	bpl->tus.f.bdeFlags = 0;
3803 	bpl->tus.f.bdeSize = size;
3804 
3805 	/* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
3806 	 * to hold ndlp reference for the corresponding callback function.
3807 	 */
3808 	if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry))
3809 		return 0;
3810 
3811  vmid_free_all_mem:
3812 	lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
3813  vmid_free_bmp_virt_exit:
3814 	kfree(bmp);
3815  vmid_free_bmp_exit:
3816 	lpfc_mbuf_free(phba, mp->virt, mp->phys);
3817  vmid_free_mp_virt_exit:
3818 	kfree(mp);
3819  vmid_free_mp_exit:
3820 
3821 	/* Issue CT request failed */
3822 	lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3823 			 "3276 VMID CT request failed Data: x%x\n", cmdcode);
3824 	return -EIO;
3825 }
3826