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