1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2017-2024 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%lx\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_vlog_msg(vport, KERN_WARNING, 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 (test_bit(FC_UNLOADING, &vport->load_flag))
302 return;
303
304 ndlp = lpfc_findnode_did(vport, did);
305 if (!ndlp) {
306 lpfc_vlog_msg(vport, KERN_WARNING, 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_vlog_msg(vport, KERN_WARNING, 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%lx 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%lx x%x x%x x%lx 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 (test_bit(NLP_NPR_2B_DISC, &ndlp->nlp_flag) &&
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%lx 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%lx x%x x%px\n",
760 Did, vport->fc_flag,
761 vport->fc_rscn_id_cnt, ndlp);
762 }
763 } else {
764 if (!test_bit(FC_RSCN_MODE, &vport->fc_flag) ||
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%lx 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%lx 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%lx 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 if (ndlp->nlp_DID == Did)
836 clear_bit(NLP_NVMET_RECOV, &ndlp->nlp_flag);
837 else
838 set_bit(NLP_NVMET_RECOV, &ndlp->nlp_flag);
839 }
840 }
841 }
842
843 static int
lpfc_ns_rsp(struct lpfc_vport * vport,struct lpfc_dmabuf * mp,uint8_t fc4_type,uint32_t Size)844 lpfc_ns_rsp(struct lpfc_vport *vport, struct lpfc_dmabuf *mp, uint8_t fc4_type,
845 uint32_t Size)
846 {
847 struct lpfc_sli_ct_request *Response =
848 (struct lpfc_sli_ct_request *) mp->virt;
849 struct lpfc_dmabuf *mlast, *next_mp;
850 uint32_t *ctptr = (uint32_t *) & Response->un.gid.PortType;
851 uint32_t Did, CTentry;
852 int Cnt;
853 struct list_head head;
854 struct lpfc_nodelist *ndlp = NULL;
855
856 lpfc_set_disctmo(vport);
857 vport->num_disc_nodes = 0;
858 vport->fc_ns_retry = 0;
859
860
861 list_add_tail(&head, &mp->list);
862 list_for_each_entry_safe(mp, next_mp, &head, list) {
863 mlast = mp;
864
865 Cnt = Size > FCELSSIZE ? FCELSSIZE : Size;
866
867 Size -= Cnt;
868
869 if (!ctptr) {
870 ctptr = (uint32_t *) mlast->virt;
871 } else
872 Cnt -= 16; /* subtract length of CT header */
873
874 /* Loop through entire NameServer list of DIDs */
875 while (Cnt >= sizeof(uint32_t)) {
876 /* Get next DID from NameServer List */
877 CTentry = *ctptr++;
878 Did = ((be32_to_cpu(CTentry)) & Mask_DID);
879 lpfc_ns_rsp_audit_did(vport, Did, fc4_type);
880 if (CTentry & (cpu_to_be32(SLI_CT_LAST_ENTRY)))
881 goto nsout1;
882
883 Cnt -= sizeof(uint32_t);
884 }
885 ctptr = NULL;
886
887 }
888
889 /* All GID_FT entries processed. If the driver is running in
890 * in target mode, put impacted nodes into recovery and drop
891 * the RPI to flush outstanding IO.
892 */
893 if (vport->phba->nvmet_support) {
894 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
895 if (!test_bit(NLP_NVMET_RECOV, &ndlp->nlp_flag))
896 continue;
897 lpfc_disc_state_machine(vport, ndlp, NULL,
898 NLP_EVT_DEVICE_RECOVERY);
899 clear_bit(NLP_NVMET_RECOV, &ndlp->nlp_flag);
900 }
901 }
902
903 nsout1:
904 list_del(&head);
905 return 0;
906 }
907
908 static void
lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)909 lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
910 struct lpfc_iocbq *rspiocb)
911 {
912 struct lpfc_vport *vport = cmdiocb->vport;
913 struct lpfc_dmabuf *outp;
914 struct lpfc_dmabuf *inp;
915 struct lpfc_sli_ct_request *CTrsp;
916 struct lpfc_sli_ct_request *CTreq;
917 struct lpfc_nodelist *ndlp;
918 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
919 u32 ulp_word4 = get_job_word4(phba, rspiocb);
920 int rc, type;
921
922 /* First save ndlp, before we overwrite it */
923 ndlp = cmdiocb->ndlp;
924
925 /* we pass cmdiocb to state machine which needs rspiocb as well */
926 cmdiocb->rsp_iocb = rspiocb;
927 inp = cmdiocb->cmd_dmabuf;
928 outp = cmdiocb->rsp_dmabuf;
929
930 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
931 "GID_FT cmpl: status:x%x/x%x rtry:%d",
932 ulp_status, ulp_word4, vport->fc_ns_retry);
933
934 /* Ignore response if link flipped after this request was made */
935 if (cmdiocb->event_tag != phba->fc_eventTag) {
936 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
937 "9043 Event tag mismatch. Ignoring NS rsp\n");
938 goto out;
939 }
940
941 /* Skip processing response on pport if unloading */
942 if (vport == phba->pport && test_bit(FC_UNLOADING, &vport->load_flag)) {
943 if (test_bit(FC_RSCN_MODE, &vport->fc_flag))
944 lpfc_els_flush_rscn(vport);
945 goto out;
946 }
947
948 if (lpfc_els_chk_latt(vport)) {
949 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
950 "0216 Link event during NS query\n");
951 if (test_bit(FC_RSCN_MODE, &vport->fc_flag))
952 lpfc_els_flush_rscn(vport);
953 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
954 goto out;
955 }
956 if (lpfc_error_lost_link(vport, ulp_status, ulp_word4)) {
957 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
958 "0226 NS query failed due to link event: "
959 "ulp_status x%x ulp_word4 x%x fc_flag x%lx "
960 "port_state x%x gidft_inp x%x\n",
961 ulp_status, ulp_word4, vport->fc_flag,
962 vport->port_state, vport->gidft_inp);
963 if (test_bit(FC_RSCN_MODE, &vport->fc_flag))
964 lpfc_els_flush_rscn(vport);
965 if (vport->gidft_inp)
966 vport->gidft_inp--;
967 goto out;
968 }
969
970 if (test_and_clear_bit(FC_RSCN_DEFERRED, &vport->fc_flag)) {
971 /* This is a GID_FT completing so the gidft_inp counter was
972 * incremented before the GID_FT was issued to the wire.
973 */
974 if (vport->gidft_inp)
975 vport->gidft_inp--;
976
977 /*
978 * Skip processing the NS response
979 * Re-issue the NS cmd
980 */
981 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
982 "0151 Process Deferred RSCN Data: x%lx x%x\n",
983 vport->fc_flag, vport->fc_rscn_id_cnt);
984 lpfc_els_handle_rscn(vport);
985
986 goto out;
987 }
988
989 if (ulp_status) {
990 /* Check for retry */
991 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) {
992 if (ulp_status != IOSTAT_LOCAL_REJECT ||
993 (ulp_word4 & IOERR_PARAM_MASK) !=
994 IOERR_NO_RESOURCES)
995 vport->fc_ns_retry++;
996
997 type = lpfc_get_gidft_type(vport, cmdiocb);
998 if (type == 0)
999 goto out;
1000
1001 /* CT command is being retried */
1002 rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT,
1003 vport->fc_ns_retry, type);
1004 if (rc == 0)
1005 goto out;
1006 else { /* Unable to send NS cmd */
1007 if (vport->gidft_inp)
1008 vport->gidft_inp--;
1009 }
1010 }
1011 if (test_bit(FC_RSCN_MODE, &vport->fc_flag))
1012 lpfc_els_flush_rscn(vport);
1013 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1014 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1015 "0257 GID_FT Query error: 0x%x 0x%x\n",
1016 ulp_status, vport->fc_ns_retry);
1017 } else {
1018 /* Good status, continue checking */
1019 CTreq = (struct lpfc_sli_ct_request *) inp->virt;
1020 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1021 if (CTrsp->CommandResponse.bits.CmdRsp ==
1022 cpu_to_be16(SLI_CT_RESPONSE_FS_ACC)) {
1023 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1024 "0208 NameServer Rsp Data: x%lx x%x "
1025 "x%x x%x sz x%x\n",
1026 vport->fc_flag,
1027 CTreq->un.gid.Fc4Type,
1028 vport->num_disc_nodes,
1029 vport->gidft_inp,
1030 get_job_data_placed(phba, rspiocb));
1031
1032 lpfc_ns_rsp(vport,
1033 outp,
1034 CTreq->un.gid.Fc4Type,
1035 get_job_data_placed(phba, rspiocb));
1036 } else if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1037 SLI_CT_RESPONSE_FS_RJT) {
1038 /* NameServer Rsp Error */
1039 if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ)
1040 && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) {
1041 lpfc_printf_vlog(vport, KERN_INFO,
1042 LOG_DISCOVERY,
1043 "0269 No NameServer Entries "
1044 "Data: x%x x%x x%x x%lx\n",
1045 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1046 (uint32_t) CTrsp->ReasonCode,
1047 (uint32_t) CTrsp->Explanation,
1048 vport->fc_flag);
1049
1050 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1051 "GID_FT no entry cmd:x%x rsn:x%x exp:x%x",
1052 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1053 (uint32_t) CTrsp->ReasonCode,
1054 (uint32_t) CTrsp->Explanation);
1055 } else {
1056 lpfc_printf_vlog(vport, KERN_INFO,
1057 LOG_DISCOVERY,
1058 "0240 NameServer Rsp Error "
1059 "Data: x%x x%x x%x x%lx\n",
1060 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1061 (uint32_t) CTrsp->ReasonCode,
1062 (uint32_t) CTrsp->Explanation,
1063 vport->fc_flag);
1064
1065 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1066 "GID_FT rsp err1 cmd:x%x rsn:x%x exp:x%x",
1067 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1068 (uint32_t) CTrsp->ReasonCode,
1069 (uint32_t) CTrsp->Explanation);
1070 }
1071
1072
1073 } else {
1074 /* NameServer Rsp Error */
1075 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1076 "0241 NameServer Rsp Error "
1077 "Data: x%x x%x x%x x%lx\n",
1078 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1079 (uint32_t) CTrsp->ReasonCode,
1080 (uint32_t) CTrsp->Explanation,
1081 vport->fc_flag);
1082
1083 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1084 "GID_FT rsp err2 cmd:x%x rsn:x%x exp:x%x",
1085 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1086 (uint32_t) CTrsp->ReasonCode,
1087 (uint32_t) CTrsp->Explanation);
1088 }
1089 if (vport->gidft_inp)
1090 vport->gidft_inp--;
1091 }
1092
1093 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1094 "4216 GID_FT cmpl inp %d disc %d\n",
1095 vport->gidft_inp, vport->num_disc_nodes);
1096
1097 /* Link up / RSCN discovery */
1098 if ((vport->num_disc_nodes == 0) &&
1099 (vport->gidft_inp == 0)) {
1100 /*
1101 * The driver has cycled through all Nports in the RSCN payload.
1102 * Complete the handling by cleaning up and marking the
1103 * current driver state.
1104 */
1105 if (vport->port_state >= LPFC_DISC_AUTH) {
1106 if (test_bit(FC_RSCN_MODE, &vport->fc_flag)) {
1107 lpfc_els_flush_rscn(vport);
1108 /* RSCN still */
1109 set_bit(FC_RSCN_MODE, &vport->fc_flag);
1110 } else {
1111 lpfc_els_flush_rscn(vport);
1112 }
1113 }
1114
1115 lpfc_disc_start(vport);
1116 }
1117 out:
1118 lpfc_ct_free_iocb(phba, cmdiocb);
1119 lpfc_nlp_put(ndlp);
1120 return;
1121 }
1122
1123 static void
lpfc_cmpl_ct_cmd_gid_pt(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1124 lpfc_cmpl_ct_cmd_gid_pt(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1125 struct lpfc_iocbq *rspiocb)
1126 {
1127 struct lpfc_vport *vport = cmdiocb->vport;
1128 struct lpfc_dmabuf *outp;
1129 struct lpfc_dmabuf *inp;
1130 struct lpfc_sli_ct_request *CTrsp;
1131 struct lpfc_sli_ct_request *CTreq;
1132 struct lpfc_nodelist *ndlp;
1133 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1134 u32 ulp_word4 = get_job_word4(phba, rspiocb);
1135 int rc;
1136
1137 /* First save ndlp, before we overwrite it */
1138 ndlp = cmdiocb->ndlp;
1139
1140 /* we pass cmdiocb to state machine which needs rspiocb as well */
1141 cmdiocb->rsp_iocb = rspiocb;
1142 inp = cmdiocb->cmd_dmabuf;
1143 outp = cmdiocb->rsp_dmabuf;
1144
1145 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1146 "GID_PT cmpl: status:x%x/x%x rtry:%d",
1147 ulp_status, ulp_word4,
1148 vport->fc_ns_retry);
1149
1150 /* Ignore response if link flipped after this request was made */
1151 if (cmdiocb->event_tag != phba->fc_eventTag) {
1152 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1153 "9044 Event tag mismatch. Ignoring NS rsp\n");
1154 goto out;
1155 }
1156
1157 /* Skip processing response on pport if unloading */
1158 if (vport == phba->pport && test_bit(FC_UNLOADING, &vport->load_flag)) {
1159 if (test_bit(FC_RSCN_MODE, &vport->fc_flag))
1160 lpfc_els_flush_rscn(vport);
1161 goto out;
1162 }
1163
1164 if (lpfc_els_chk_latt(vport)) {
1165 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1166 "4108 Link event during NS query\n");
1167 if (test_bit(FC_RSCN_MODE, &vport->fc_flag))
1168 lpfc_els_flush_rscn(vport);
1169 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1170 goto out;
1171 }
1172 if (lpfc_error_lost_link(vport, ulp_status, ulp_word4)) {
1173 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1174 "4166 NS query failed due to link event: "
1175 "ulp_status x%x ulp_word4 x%x fc_flag x%lx "
1176 "port_state x%x gidft_inp x%x\n",
1177 ulp_status, ulp_word4, vport->fc_flag,
1178 vport->port_state, vport->gidft_inp);
1179 if (test_bit(FC_RSCN_MODE, &vport->fc_flag))
1180 lpfc_els_flush_rscn(vport);
1181 if (vport->gidft_inp)
1182 vport->gidft_inp--;
1183 goto out;
1184 }
1185
1186 if (test_and_clear_bit(FC_RSCN_DEFERRED, &vport->fc_flag)) {
1187 /* This is a GID_PT completing so the gidft_inp counter was
1188 * incremented before the GID_PT was issued to the wire.
1189 */
1190 if (vport->gidft_inp)
1191 vport->gidft_inp--;
1192
1193 /*
1194 * Skip processing the NS response
1195 * Re-issue the NS cmd
1196 */
1197 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1198 "4167 Process Deferred RSCN Data: x%lx x%x\n",
1199 vport->fc_flag, vport->fc_rscn_id_cnt);
1200 lpfc_els_handle_rscn(vport);
1201
1202 goto out;
1203 }
1204
1205 if (ulp_status) {
1206 /* Check for retry */
1207 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) {
1208 if (ulp_status != IOSTAT_LOCAL_REJECT ||
1209 (ulp_word4 & IOERR_PARAM_MASK) !=
1210 IOERR_NO_RESOURCES)
1211 vport->fc_ns_retry++;
1212
1213 /* CT command is being retried */
1214 rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_PT,
1215 vport->fc_ns_retry, GID_PT_N_PORT);
1216 if (rc == 0)
1217 goto out;
1218 else { /* Unable to send NS cmd */
1219 if (vport->gidft_inp)
1220 vport->gidft_inp--;
1221 }
1222 }
1223 if (test_bit(FC_RSCN_MODE, &vport->fc_flag))
1224 lpfc_els_flush_rscn(vport);
1225 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1226 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1227 "4103 GID_FT Query error: 0x%x 0x%x\n",
1228 ulp_status, vport->fc_ns_retry);
1229 } else {
1230 /* Good status, continue checking */
1231 CTreq = (struct lpfc_sli_ct_request *)inp->virt;
1232 CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1233 if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1234 SLI_CT_RESPONSE_FS_ACC) {
1235 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1236 "4105 NameServer Rsp Data: x%lx x%x "
1237 "x%x x%x sz x%x\n",
1238 vport->fc_flag,
1239 CTreq->un.gid.Fc4Type,
1240 vport->num_disc_nodes,
1241 vport->gidft_inp,
1242 get_job_data_placed(phba, rspiocb));
1243
1244 lpfc_ns_rsp(vport,
1245 outp,
1246 CTreq->un.gid.Fc4Type,
1247 get_job_data_placed(phba, rspiocb));
1248 } else if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1249 SLI_CT_RESPONSE_FS_RJT) {
1250 /* NameServer Rsp Error */
1251 if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ)
1252 && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) {
1253 lpfc_printf_vlog(
1254 vport, KERN_INFO, LOG_DISCOVERY,
1255 "4106 No NameServer Entries "
1256 "Data: x%x x%x x%x x%lx\n",
1257 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1258 (uint32_t)CTrsp->ReasonCode,
1259 (uint32_t)CTrsp->Explanation,
1260 vport->fc_flag);
1261
1262 lpfc_debugfs_disc_trc(
1263 vport, LPFC_DISC_TRC_CT,
1264 "GID_PT no entry cmd:x%x rsn:x%x exp:x%x",
1265 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1266 (uint32_t)CTrsp->ReasonCode,
1267 (uint32_t)CTrsp->Explanation);
1268 } else {
1269 lpfc_printf_vlog(
1270 vport, KERN_INFO, LOG_DISCOVERY,
1271 "4107 NameServer Rsp Error "
1272 "Data: x%x x%x x%x x%lx\n",
1273 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1274 (uint32_t)CTrsp->ReasonCode,
1275 (uint32_t)CTrsp->Explanation,
1276 vport->fc_flag);
1277
1278 lpfc_debugfs_disc_trc(
1279 vport, LPFC_DISC_TRC_CT,
1280 "GID_PT rsp err1 cmd:x%x rsn:x%x exp:x%x",
1281 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1282 (uint32_t)CTrsp->ReasonCode,
1283 (uint32_t)CTrsp->Explanation);
1284 }
1285 } else {
1286 /* NameServer Rsp Error */
1287 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1288 "4109 NameServer Rsp Error "
1289 "Data: x%x x%x x%x x%lx\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 err2 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 if (vport->gidft_inp)
1303 vport->gidft_inp--;
1304 }
1305
1306 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1307 "6450 GID_PT cmpl inp %d disc %d\n",
1308 vport->gidft_inp, vport->num_disc_nodes);
1309
1310 /* Link up / RSCN discovery */
1311 if ((vport->num_disc_nodes == 0) &&
1312 (vport->gidft_inp == 0)) {
1313 /*
1314 * The driver has cycled through all Nports in the RSCN payload.
1315 * Complete the handling by cleaning up and marking the
1316 * current driver state.
1317 */
1318 if (vport->port_state >= LPFC_DISC_AUTH) {
1319 if (test_bit(FC_RSCN_MODE, &vport->fc_flag)) {
1320 lpfc_els_flush_rscn(vport);
1321 /* RSCN still */
1322 set_bit(FC_RSCN_MODE, &vport->fc_flag);
1323 } else {
1324 lpfc_els_flush_rscn(vport);
1325 }
1326 }
1327
1328 lpfc_disc_start(vport);
1329 }
1330 out:
1331 lpfc_ct_free_iocb(phba, cmdiocb);
1332 lpfc_nlp_put(ndlp);
1333 }
1334
1335 static void
lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1336 lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1337 struct lpfc_iocbq *rspiocb)
1338 {
1339 struct lpfc_vport *vport = cmdiocb->vport;
1340 struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf;
1341 struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf;
1342 struct lpfc_sli_ct_request *CTrsp;
1343 int did, rc, retry;
1344 uint8_t fbits;
1345 struct lpfc_nodelist *ndlp = NULL, *free_ndlp = NULL;
1346 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1347 u32 ulp_word4 = get_job_word4(phba, rspiocb);
1348
1349 did = ((struct lpfc_sli_ct_request *) inp->virt)->un.gff.PortId;
1350 did = be32_to_cpu(did);
1351
1352 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1353 "GFF_ID cmpl: status:x%x/x%x did:x%x",
1354 ulp_status, ulp_word4, did);
1355
1356 /* Ignore response if link flipped after this request was made */
1357 if (cmdiocb->event_tag != phba->fc_eventTag) {
1358 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1359 "9045 Event tag mismatch. Ignoring NS rsp\n");
1360 goto iocb_free;
1361 }
1362
1363 if (ulp_status == IOSTAT_SUCCESS) {
1364 /* Good status, continue checking */
1365 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1366 fbits = CTrsp->un.gff_acc.fbits[FCP_TYPE_FEATURE_OFFSET];
1367
1368 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1369 "6431 Process GFF_ID rsp for %08x "
1370 "fbits %02x %s %s\n",
1371 did, fbits,
1372 (fbits & FC4_FEATURE_INIT) ? "Initiator" : " ",
1373 (fbits & FC4_FEATURE_TARGET) ? "Target" : " ");
1374
1375 if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1376 SLI_CT_RESPONSE_FS_ACC) {
1377 if ((fbits & FC4_FEATURE_INIT) &&
1378 !(fbits & FC4_FEATURE_TARGET)) {
1379 lpfc_printf_vlog(vport, KERN_INFO,
1380 LOG_DISCOVERY,
1381 "0270 Skip x%x GFF "
1382 "NameServer Rsp Data: (init) "
1383 "x%x x%x\n", did, fbits,
1384 vport->fc_rscn_id_cnt);
1385 goto out;
1386 }
1387 }
1388 }
1389 else {
1390 /* Check for retry */
1391 if (cmdiocb->retry < LPFC_MAX_NS_RETRY) {
1392 retry = 1;
1393 if (ulp_status == IOSTAT_LOCAL_REJECT) {
1394 switch ((ulp_word4 &
1395 IOERR_PARAM_MASK)) {
1396
1397 case IOERR_NO_RESOURCES:
1398 /* We don't increment the retry
1399 * count for this case.
1400 */
1401 break;
1402 case IOERR_LINK_DOWN:
1403 case IOERR_SLI_ABORTED:
1404 case IOERR_SLI_DOWN:
1405 retry = 0;
1406 break;
1407 default:
1408 cmdiocb->retry++;
1409 }
1410 }
1411 else
1412 cmdiocb->retry++;
1413
1414 if (retry) {
1415 /* CT command is being retried */
1416 rc = lpfc_ns_cmd(vport, SLI_CTNS_GFF_ID,
1417 cmdiocb->retry, did);
1418 if (rc == 0) {
1419 /* success */
1420 free_ndlp = cmdiocb->ndlp;
1421 lpfc_ct_free_iocb(phba, cmdiocb);
1422 lpfc_nlp_put(free_ndlp);
1423 return;
1424 }
1425 }
1426 }
1427 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1428 "0267 NameServer GFF Rsp "
1429 "x%x Error (%d %d) Data: x%lx x%x\n",
1430 did, ulp_status, ulp_word4,
1431 vport->fc_flag, vport->fc_rscn_id_cnt);
1432 }
1433
1434 /* This is a target port, unregistered port, or the GFF_ID failed */
1435 ndlp = lpfc_setup_disc_node(vport, did);
1436 if (ndlp) {
1437 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1438 "0242 Process x%x GFF "
1439 "NameServer Rsp Data: x%lx x%lx x%x\n",
1440 did, ndlp->nlp_flag, vport->fc_flag,
1441 vport->fc_rscn_id_cnt);
1442 } else {
1443 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1444 "0243 Skip x%x GFF "
1445 "NameServer Rsp Data: x%lx x%x\n", did,
1446 vport->fc_flag, vport->fc_rscn_id_cnt);
1447 }
1448 out:
1449 /* Link up / RSCN discovery */
1450 if (vport->num_disc_nodes)
1451 vport->num_disc_nodes--;
1452
1453 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1454 "6451 GFF_ID cmpl inp %d disc %d\n",
1455 vport->gidft_inp, vport->num_disc_nodes);
1456
1457 if (vport->num_disc_nodes == 0) {
1458 /*
1459 * The driver has cycled through all Nports in the RSCN payload.
1460 * Complete the handling by cleaning up and marking the
1461 * current driver state.
1462 */
1463 if (vport->port_state >= LPFC_DISC_AUTH) {
1464 if (test_bit(FC_RSCN_MODE, &vport->fc_flag)) {
1465 lpfc_els_flush_rscn(vport);
1466 /* RSCN still */
1467 set_bit(FC_RSCN_MODE, &vport->fc_flag);
1468 } else {
1469 lpfc_els_flush_rscn(vport);
1470 }
1471 }
1472 lpfc_disc_start(vport);
1473 }
1474
1475 iocb_free:
1476 free_ndlp = cmdiocb->ndlp;
1477 lpfc_ct_free_iocb(phba, cmdiocb);
1478 lpfc_nlp_put(free_ndlp);
1479 return;
1480 }
1481
1482 static void
lpfc_cmpl_ct_cmd_gft_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1483 lpfc_cmpl_ct_cmd_gft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1484 struct lpfc_iocbq *rspiocb)
1485 {
1486 struct lpfc_vport *vport = cmdiocb->vport;
1487 struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf;
1488 struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf;
1489 struct lpfc_sli_ct_request *CTrsp;
1490 int did;
1491 struct lpfc_nodelist *ndlp = NULL;
1492 struct lpfc_nodelist *ns_ndlp = cmdiocb->ndlp;
1493 uint32_t fc4_data_0, fc4_data_1;
1494 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1495 u32 ulp_word4 = get_job_word4(phba, rspiocb);
1496
1497 did = ((struct lpfc_sli_ct_request *)inp->virt)->un.gft.PortId;
1498 did = be32_to_cpu(did);
1499
1500 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1501 "GFT_ID cmpl: status:x%x/x%x did:x%x",
1502 ulp_status, ulp_word4, did);
1503
1504 /* Ignore response if link flipped after this request was made */
1505 if ((uint32_t)cmdiocb->event_tag != phba->fc_eventTag) {
1506 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1507 "9046 Event tag mismatch. Ignoring NS rsp\n");
1508 goto out;
1509 }
1510
1511 if (ulp_status == IOSTAT_SUCCESS) {
1512 /* Good status, continue checking */
1513 CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1514 fc4_data_0 = be32_to_cpu(CTrsp->un.gft_acc.fc4_types[0]);
1515 fc4_data_1 = be32_to_cpu(CTrsp->un.gft_acc.fc4_types[1]);
1516
1517 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1518 "6432 Process GFT_ID rsp for %08x "
1519 "Data %08x %08x %s %s\n",
1520 did, fc4_data_0, fc4_data_1,
1521 (fc4_data_0 & LPFC_FC4_TYPE_BITMASK) ?
1522 "FCP" : " ",
1523 (fc4_data_1 & LPFC_FC4_TYPE_BITMASK) ?
1524 "NVME" : " ");
1525
1526 /* Lookup the NPort_ID queried in the GFT_ID and find the
1527 * driver's local node. It's an error if the driver
1528 * doesn't have one.
1529 */
1530 ndlp = lpfc_findnode_did(vport, did);
1531 if (ndlp) {
1532 /* The bitmask value for FCP and NVME FCP types is
1533 * the same because they are 32 bits distant from
1534 * each other in word0 and word0.
1535 */
1536 if (fc4_data_0 & LPFC_FC4_TYPE_BITMASK)
1537 ndlp->nlp_fc4_type |= NLP_FC4_FCP;
1538 if (fc4_data_1 & LPFC_FC4_TYPE_BITMASK)
1539 ndlp->nlp_fc4_type |= NLP_FC4_NVME;
1540 lpfc_printf_vlog(vport, KERN_INFO,
1541 LOG_DISCOVERY | LOG_NODE,
1542 "3064 Setting ndlp x%px, DID x%06x "
1543 "with FC4 x%08x, Data: x%08x x%08x "
1544 "%d\n",
1545 ndlp, did, ndlp->nlp_fc4_type,
1546 FC_TYPE_FCP, FC_TYPE_NVME,
1547 ndlp->nlp_state);
1548
1549 if (ndlp->nlp_state == NLP_STE_REG_LOGIN_ISSUE &&
1550 ndlp->nlp_fc4_type) {
1551 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1552 lpfc_nlp_set_state(vport, ndlp,
1553 NLP_STE_PRLI_ISSUE);
1554 lpfc_issue_els_prli(vport, ndlp, 0);
1555 } else if (!ndlp->nlp_fc4_type) {
1556 /* If fc4 type is still unknown, then LOGO */
1557 lpfc_printf_vlog(vport, KERN_INFO,
1558 LOG_DISCOVERY | LOG_NODE,
1559 "6443 Sending LOGO ndlp x%px, "
1560 "DID x%06x with fc4_type: "
1561 "x%08x, state: %d\n",
1562 ndlp, did, ndlp->nlp_fc4_type,
1563 ndlp->nlp_state);
1564 lpfc_issue_els_logo(vport, ndlp, 0);
1565 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1566 lpfc_nlp_set_state(vport, ndlp,
1567 NLP_STE_NPR_NODE);
1568 }
1569 }
1570 } else
1571 lpfc_vlog_msg(vport, KERN_WARNING, LOG_DISCOVERY,
1572 "3065 GFT_ID status x%08x\n", ulp_status);
1573
1574 out:
1575 lpfc_ct_free_iocb(phba, cmdiocb);
1576 lpfc_nlp_put(ns_ndlp);
1577 }
1578
1579 static void
lpfc_cmpl_ct(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1580 lpfc_cmpl_ct(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1581 struct lpfc_iocbq *rspiocb)
1582 {
1583 struct lpfc_vport *vport = cmdiocb->vport;
1584 struct lpfc_dmabuf *inp;
1585 struct lpfc_dmabuf *outp;
1586 struct lpfc_sli_ct_request *CTrsp;
1587 struct lpfc_nodelist *ndlp;
1588 int cmdcode, rc;
1589 uint8_t retry;
1590 uint32_t latt;
1591 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1592 u32 ulp_word4 = get_job_word4(phba, rspiocb);
1593
1594 /* First save ndlp, before we overwrite it */
1595 ndlp = cmdiocb->ndlp;
1596
1597 /* we pass cmdiocb to state machine which needs rspiocb as well */
1598 cmdiocb->rsp_iocb = rspiocb;
1599
1600 inp = cmdiocb->cmd_dmabuf;
1601 outp = cmdiocb->rsp_dmabuf;
1602
1603 cmdcode = be16_to_cpu(((struct lpfc_sli_ct_request *) inp->virt)->
1604 CommandResponse.bits.CmdRsp);
1605 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1606
1607 latt = lpfc_els_chk_latt(vport);
1608
1609 /* RFT request completes status <ulp_status> CmdRsp <CmdRsp> */
1610 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1611 "0209 CT Request completes, latt %d, "
1612 "ulp_status x%x CmdRsp x%x, Context x%x, Tag x%x\n",
1613 latt, ulp_status,
1614 be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp),
1615 get_job_ulpcontext(phba, cmdiocb), cmdiocb->iotag);
1616
1617 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1618 "CT cmd cmpl: status:x%x/x%x cmd:x%x",
1619 ulp_status, ulp_word4, cmdcode);
1620
1621 if (ulp_status) {
1622 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1623 "0268 NS cmd x%x Error (x%x x%x)\n",
1624 cmdcode, ulp_status, ulp_word4);
1625
1626 if (ulp_status == IOSTAT_LOCAL_REJECT &&
1627 (((ulp_word4 & IOERR_PARAM_MASK) ==
1628 IOERR_SLI_DOWN) ||
1629 ((ulp_word4 & IOERR_PARAM_MASK) ==
1630 IOERR_SLI_ABORTED)))
1631 goto out;
1632
1633 retry = cmdiocb->retry;
1634 if (retry >= LPFC_MAX_NS_RETRY)
1635 goto out;
1636
1637 retry++;
1638 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1639 "0250 Retrying NS cmd %x\n", cmdcode);
1640 rc = lpfc_ns_cmd(vport, cmdcode, retry, 0);
1641 if (rc == 0)
1642 goto out;
1643 }
1644
1645 out:
1646 /* If the caller wanted a synchronous DA_ID completion, signal the
1647 * wait obj and clear flag to reset the vport.
1648 */
1649 if (test_bit(NLP_WAIT_FOR_DA_ID, &ndlp->save_flags)) {
1650 if (ndlp->da_id_waitq)
1651 wake_up(ndlp->da_id_waitq);
1652 }
1653
1654 clear_bit(NLP_WAIT_FOR_DA_ID, &ndlp->save_flags);
1655
1656 lpfc_ct_free_iocb(phba, cmdiocb);
1657 lpfc_nlp_put(ndlp);
1658 return;
1659 }
1660
1661 static void
lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1662 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1663 struct lpfc_iocbq *rspiocb)
1664 {
1665 struct lpfc_vport *vport = cmdiocb->vport;
1666 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1667
1668 if (ulp_status == IOSTAT_SUCCESS) {
1669 struct lpfc_dmabuf *outp;
1670 struct lpfc_sli_ct_request *CTrsp;
1671
1672 outp = cmdiocb->rsp_dmabuf;
1673 CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1674 if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1675 SLI_CT_RESPONSE_FS_ACC)
1676 vport->ct_flags |= FC_CT_RFT_ID;
1677 }
1678 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1679 return;
1680 }
1681
1682 static void
lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1683 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1684 struct lpfc_iocbq *rspiocb)
1685 {
1686 struct lpfc_vport *vport = cmdiocb->vport;
1687 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1688
1689 if (ulp_status == IOSTAT_SUCCESS) {
1690 struct lpfc_dmabuf *outp;
1691 struct lpfc_sli_ct_request *CTrsp;
1692
1693 outp = cmdiocb->rsp_dmabuf;
1694 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1695 if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1696 SLI_CT_RESPONSE_FS_ACC)
1697 vport->ct_flags |= FC_CT_RNN_ID;
1698 }
1699 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1700 return;
1701 }
1702
1703 static void
lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1704 lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1705 struct lpfc_iocbq *rspiocb)
1706 {
1707 struct lpfc_vport *vport = cmdiocb->vport;
1708 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1709
1710 if (ulp_status == IOSTAT_SUCCESS) {
1711 struct lpfc_dmabuf *outp;
1712 struct lpfc_sli_ct_request *CTrsp;
1713
1714 outp = cmdiocb->rsp_dmabuf;
1715 CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1716 if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1717 SLI_CT_RESPONSE_FS_ACC)
1718 vport->ct_flags |= FC_CT_RSPN_ID;
1719 }
1720 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1721 return;
1722 }
1723
1724 static void
lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1725 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1726 struct lpfc_iocbq *rspiocb)
1727 {
1728 struct lpfc_vport *vport = cmdiocb->vport;
1729 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1730
1731 if (ulp_status == IOSTAT_SUCCESS) {
1732 struct lpfc_dmabuf *outp;
1733 struct lpfc_sli_ct_request *CTrsp;
1734
1735 outp = cmdiocb->rsp_dmabuf;
1736 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1737 if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1738 SLI_CT_RESPONSE_FS_ACC)
1739 vport->ct_flags |= FC_CT_RSNN_NN;
1740 }
1741 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1742 return;
1743 }
1744
1745 static void
lpfc_cmpl_ct_cmd_da_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1746 lpfc_cmpl_ct_cmd_da_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1747 struct lpfc_iocbq *rspiocb)
1748 {
1749 struct lpfc_vport *vport = cmdiocb->vport;
1750
1751 /* even if it fails we will act as though it succeeded. */
1752 vport->ct_flags = 0;
1753 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1754 return;
1755 }
1756
1757 static void
lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)1758 lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1759 struct lpfc_iocbq *rspiocb)
1760 {
1761 struct lpfc_vport *vport = cmdiocb->vport;
1762 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
1763
1764 if (ulp_status == IOSTAT_SUCCESS) {
1765 struct lpfc_dmabuf *outp;
1766 struct lpfc_sli_ct_request *CTrsp;
1767
1768 outp = cmdiocb->rsp_dmabuf;
1769 CTrsp = (struct lpfc_sli_ct_request *)outp->virt;
1770 if (be16_to_cpu(CTrsp->CommandResponse.bits.CmdRsp) ==
1771 SLI_CT_RESPONSE_FS_ACC)
1772 vport->ct_flags |= FC_CT_RFF_ID;
1773 }
1774 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1775 return;
1776 }
1777
1778 /*
1779 * Although the symbolic port name is thought to be an integer
1780 * as of January 18, 2016, leave it as a string until more of
1781 * the record state becomes defined.
1782 */
1783 int
lpfc_vport_symbolic_port_name(struct lpfc_vport * vport,char * symbol,size_t size)1784 lpfc_vport_symbolic_port_name(struct lpfc_vport *vport, char *symbol,
1785 size_t size)
1786 {
1787 int n;
1788
1789 /*
1790 * Use the lpfc board number as the Symbolic Port
1791 * Name object. NPIV is not in play so this integer
1792 * value is sufficient and unique per FC-ID.
1793 */
1794 n = scnprintf(symbol, size, "%d", vport->phba->brd_no);
1795 return n;
1796 }
1797
1798
1799 int
lpfc_vport_symbolic_node_name(struct lpfc_vport * vport,char * symbol,size_t size)1800 lpfc_vport_symbolic_node_name(struct lpfc_vport *vport, char *symbol,
1801 size_t size)
1802 {
1803 char fwrev[FW_REV_STR_SIZE] = {0};
1804 char tmp[MAXHOSTNAMELEN] = {0};
1805
1806 memset(symbol, 0, size);
1807
1808 scnprintf(tmp, sizeof(tmp), "Emulex %s", vport->phba->ModelName);
1809 if (strlcat(symbol, tmp, size) >= size)
1810 goto buffer_done;
1811
1812 lpfc_decode_firmware_rev(vport->phba, fwrev, 0);
1813 scnprintf(tmp, sizeof(tmp), " FV%s", fwrev);
1814 if (strlcat(symbol, tmp, size) >= size)
1815 goto buffer_done;
1816
1817 scnprintf(tmp, sizeof(tmp), " DV%s", lpfc_release_version);
1818 if (strlcat(symbol, tmp, size) >= size)
1819 goto buffer_done;
1820
1821 scnprintf(tmp, sizeof(tmp), " HN:%s", vport->phba->os_host_name);
1822 if (strlcat(symbol, tmp, size) >= size)
1823 goto buffer_done;
1824
1825 /* Note :- OS name is "Linux" */
1826 scnprintf(tmp, sizeof(tmp), " OS:%s", init_utsname()->sysname);
1827 strlcat(symbol, tmp, size);
1828
1829 buffer_done:
1830 return strnlen(symbol, size);
1831
1832 }
1833
1834 static uint32_t
lpfc_find_map_node(struct lpfc_vport * vport)1835 lpfc_find_map_node(struct lpfc_vport *vport)
1836 {
1837 struct lpfc_nodelist *ndlp, *next_ndlp;
1838 unsigned long iflags;
1839 uint32_t cnt = 0;
1840
1841 spin_lock_irqsave(&vport->fc_nodes_list_lock, iflags);
1842 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
1843 if (ndlp->nlp_type & NLP_FABRIC)
1844 continue;
1845 if ((ndlp->nlp_state == NLP_STE_MAPPED_NODE) ||
1846 (ndlp->nlp_state == NLP_STE_UNMAPPED_NODE))
1847 cnt++;
1848 }
1849 spin_unlock_irqrestore(&vport->fc_nodes_list_lock, iflags);
1850 return cnt;
1851 }
1852
1853 /*
1854 * This routine will return the FC4 Type associated with the CT
1855 * GID_FT command.
1856 */
1857 int
lpfc_get_gidft_type(struct lpfc_vport * vport,struct lpfc_iocbq * cmdiocb)1858 lpfc_get_gidft_type(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb)
1859 {
1860 struct lpfc_sli_ct_request *CtReq;
1861 struct lpfc_dmabuf *mp;
1862 uint32_t type;
1863
1864 mp = cmdiocb->cmd_dmabuf;
1865 if (mp == NULL)
1866 return 0;
1867 CtReq = (struct lpfc_sli_ct_request *)mp->virt;
1868 type = (uint32_t)CtReq->un.gid.Fc4Type;
1869 if ((type != SLI_CTPT_FCP) && (type != SLI_CTPT_NVME))
1870 return 0;
1871 return type;
1872 }
1873
1874 /*
1875 * lpfc_ns_cmd
1876 * Description:
1877 * Issue Cmd to NameServer
1878 * SLI_CTNS_GID_FT
1879 * LI_CTNS_RFT_ID
1880 */
1881 int
lpfc_ns_cmd(struct lpfc_vport * vport,int cmdcode,uint8_t retry,uint32_t context)1882 lpfc_ns_cmd(struct lpfc_vport *vport, int cmdcode,
1883 uint8_t retry, uint32_t context)
1884 {
1885 struct lpfc_nodelist * ndlp;
1886 struct lpfc_hba *phba = vport->phba;
1887 struct lpfc_dmabuf *mp, *bmp;
1888 struct lpfc_sli_ct_request *CtReq;
1889 struct ulp_bde64 *bpl;
1890 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
1891 struct lpfc_iocbq *) = NULL;
1892 uint32_t *ptr;
1893 uint32_t rsp_size = 1024;
1894 size_t size;
1895 int rc = 0;
1896
1897 ndlp = lpfc_findnode_did(vport, NameServer_DID);
1898 if (!ndlp || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) {
1899 rc=1;
1900 goto ns_cmd_exit;
1901 }
1902
1903 /* fill in BDEs for command */
1904 /* Allocate buffer for command payload */
1905 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1906 if (!mp) {
1907 rc=2;
1908 goto ns_cmd_exit;
1909 }
1910
1911 INIT_LIST_HEAD(&mp->list);
1912 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
1913 if (!mp->virt) {
1914 rc=3;
1915 goto ns_cmd_free_mp;
1916 }
1917
1918 /* Allocate buffer for Buffer ptr list */
1919 bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1920 if (!bmp) {
1921 rc=4;
1922 goto ns_cmd_free_mpvirt;
1923 }
1924
1925 INIT_LIST_HEAD(&bmp->list);
1926 bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys));
1927 if (!bmp->virt) {
1928 rc=5;
1929 goto ns_cmd_free_bmp;
1930 }
1931
1932 /* NameServer Req */
1933 lpfc_printf_vlog(vport, KERN_INFO ,LOG_DISCOVERY,
1934 "0236 NameServer Req Data: x%x x%lx x%x x%x\n",
1935 cmdcode, vport->fc_flag, vport->fc_rscn_id_cnt,
1936 context);
1937
1938 bpl = (struct ulp_bde64 *) bmp->virt;
1939 memset(bpl, 0, sizeof(struct ulp_bde64));
1940 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
1941 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
1942 bpl->tus.f.bdeFlags = 0;
1943 if (cmdcode == SLI_CTNS_GID_FT)
1944 bpl->tus.f.bdeSize = GID_REQUEST_SZ;
1945 else if (cmdcode == SLI_CTNS_GID_PT)
1946 bpl->tus.f.bdeSize = GID_REQUEST_SZ;
1947 else if (cmdcode == SLI_CTNS_GFF_ID)
1948 bpl->tus.f.bdeSize = GFF_REQUEST_SZ;
1949 else if (cmdcode == SLI_CTNS_GFT_ID)
1950 bpl->tus.f.bdeSize = GFT_REQUEST_SZ;
1951 else if (cmdcode == SLI_CTNS_RFT_ID)
1952 bpl->tus.f.bdeSize = RFT_REQUEST_SZ;
1953 else if (cmdcode == SLI_CTNS_RNN_ID)
1954 bpl->tus.f.bdeSize = RNN_REQUEST_SZ;
1955 else if (cmdcode == SLI_CTNS_RSPN_ID)
1956 bpl->tus.f.bdeSize = RSPN_REQUEST_SZ;
1957 else if (cmdcode == SLI_CTNS_RSNN_NN)
1958 bpl->tus.f.bdeSize = RSNN_REQUEST_SZ;
1959 else if (cmdcode == SLI_CTNS_DA_ID)
1960 bpl->tus.f.bdeSize = DA_ID_REQUEST_SZ;
1961 else if (cmdcode == SLI_CTNS_RFF_ID)
1962 bpl->tus.f.bdeSize = RFF_REQUEST_SZ;
1963 else
1964 bpl->tus.f.bdeSize = 0;
1965 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1966
1967 CtReq = (struct lpfc_sli_ct_request *) mp->virt;
1968 memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request));
1969 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
1970 CtReq->RevisionId.bits.InId = 0;
1971 CtReq->FsType = SLI_CT_DIRECTORY_SERVICE;
1972 CtReq->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER;
1973 CtReq->CommandResponse.bits.Size = 0;
1974 switch (cmdcode) {
1975 case SLI_CTNS_GID_FT:
1976 CtReq->CommandResponse.bits.CmdRsp =
1977 cpu_to_be16(SLI_CTNS_GID_FT);
1978 CtReq->un.gid.Fc4Type = context;
1979
1980 if (vport->port_state < LPFC_NS_QRY)
1981 vport->port_state = LPFC_NS_QRY;
1982 lpfc_set_disctmo(vport);
1983 cmpl = lpfc_cmpl_ct_cmd_gid_ft;
1984 rsp_size = FC_MAX_NS_RSP;
1985 break;
1986
1987 case SLI_CTNS_GID_PT:
1988 CtReq->CommandResponse.bits.CmdRsp =
1989 cpu_to_be16(SLI_CTNS_GID_PT);
1990 CtReq->un.gid.PortType = context;
1991
1992 if (vport->port_state < LPFC_NS_QRY)
1993 vport->port_state = LPFC_NS_QRY;
1994 lpfc_set_disctmo(vport);
1995 cmpl = lpfc_cmpl_ct_cmd_gid_pt;
1996 rsp_size = FC_MAX_NS_RSP;
1997 break;
1998
1999 case SLI_CTNS_GFF_ID:
2000 CtReq->CommandResponse.bits.CmdRsp =
2001 cpu_to_be16(SLI_CTNS_GFF_ID);
2002 CtReq->un.gff.PortId = cpu_to_be32(context);
2003 cmpl = lpfc_cmpl_ct_cmd_gff_id;
2004 break;
2005
2006 case SLI_CTNS_GFT_ID:
2007 CtReq->CommandResponse.bits.CmdRsp =
2008 cpu_to_be16(SLI_CTNS_GFT_ID);
2009 CtReq->un.gft.PortId = cpu_to_be32(context);
2010 cmpl = lpfc_cmpl_ct_cmd_gft_id;
2011 break;
2012
2013 case SLI_CTNS_RFT_ID:
2014 vport->ct_flags &= ~FC_CT_RFT_ID;
2015 CtReq->CommandResponse.bits.CmdRsp =
2016 cpu_to_be16(SLI_CTNS_RFT_ID);
2017 CtReq->un.rft.port_id = cpu_to_be32(vport->fc_myDID);
2018
2019 /* Register Application Services type if vmid enabled. */
2020 if (phba->cfg_vmid_app_header)
2021 CtReq->un.rft.app_serv_reg =
2022 cpu_to_be32(RFT_APP_SERV_REG);
2023
2024 /* Register FC4 FCP type if enabled. */
2025 if (vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH ||
2026 vport->cfg_enable_fc4_type == LPFC_ENABLE_FCP)
2027 CtReq->un.rft.fcp_reg = cpu_to_be32(RFT_FCP_REG);
2028
2029 /* Register NVME type if enabled. */
2030 if (vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH ||
2031 vport->cfg_enable_fc4_type == LPFC_ENABLE_NVME)
2032 CtReq->un.rft.nvme_reg = cpu_to_be32(RFT_NVME_REG);
2033
2034 ptr = (uint32_t *)CtReq;
2035 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2036 "6433 Issue RFT (%s %s %s): %08x %08x %08x "
2037 "%08x %08x %08x %08x %08x\n",
2038 CtReq->un.rft.fcp_reg ? "FCP" : " ",
2039 CtReq->un.rft.nvme_reg ? "NVME" : " ",
2040 CtReq->un.rft.app_serv_reg ? "APPS" : " ",
2041 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3),
2042 *(ptr + 4), *(ptr + 5),
2043 *(ptr + 6), *(ptr + 7));
2044 cmpl = lpfc_cmpl_ct_cmd_rft_id;
2045 break;
2046
2047 case SLI_CTNS_RNN_ID:
2048 vport->ct_flags &= ~FC_CT_RNN_ID;
2049 CtReq->CommandResponse.bits.CmdRsp =
2050 cpu_to_be16(SLI_CTNS_RNN_ID);
2051 CtReq->un.rnn.PortId = cpu_to_be32(vport->fc_myDID);
2052 memcpy(CtReq->un.rnn.wwnn, &vport->fc_nodename,
2053 sizeof(struct lpfc_name));
2054 cmpl = lpfc_cmpl_ct_cmd_rnn_id;
2055 break;
2056
2057 case SLI_CTNS_RSPN_ID:
2058 vport->ct_flags &= ~FC_CT_RSPN_ID;
2059 CtReq->CommandResponse.bits.CmdRsp =
2060 cpu_to_be16(SLI_CTNS_RSPN_ID);
2061 CtReq->un.rspn.PortId = cpu_to_be32(vport->fc_myDID);
2062 size = sizeof(CtReq->un.rspn.symbname);
2063 CtReq->un.rspn.len =
2064 lpfc_vport_symbolic_port_name(vport,
2065 CtReq->un.rspn.symbname, size);
2066 cmpl = lpfc_cmpl_ct_cmd_rspn_id;
2067 break;
2068 case SLI_CTNS_RSNN_NN:
2069 vport->ct_flags &= ~FC_CT_RSNN_NN;
2070 CtReq->CommandResponse.bits.CmdRsp =
2071 cpu_to_be16(SLI_CTNS_RSNN_NN);
2072 memcpy(CtReq->un.rsnn.wwnn, &vport->fc_nodename,
2073 sizeof(struct lpfc_name));
2074 size = sizeof(CtReq->un.rsnn.symbname);
2075 CtReq->un.rsnn.len =
2076 lpfc_vport_symbolic_node_name(vport,
2077 CtReq->un.rsnn.symbname, size);
2078 cmpl = lpfc_cmpl_ct_cmd_rsnn_nn;
2079 break;
2080 case SLI_CTNS_DA_ID:
2081 /* Implement DA_ID Nameserver request */
2082 CtReq->CommandResponse.bits.CmdRsp =
2083 cpu_to_be16(SLI_CTNS_DA_ID);
2084 CtReq->un.da_id.port_id = cpu_to_be32(vport->fc_myDID);
2085 cmpl = lpfc_cmpl_ct_cmd_da_id;
2086 break;
2087 case SLI_CTNS_RFF_ID:
2088 vport->ct_flags &= ~FC_CT_RFF_ID;
2089 CtReq->CommandResponse.bits.CmdRsp =
2090 cpu_to_be16(SLI_CTNS_RFF_ID);
2091 CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID);
2092 CtReq->un.rff.fbits = FC4_FEATURE_INIT;
2093
2094 /* The driver always supports FC_TYPE_FCP. However, the
2095 * caller can specify NVME (type x28) as well. But only
2096 * these that FC4 type is supported.
2097 */
2098 if (((vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) ||
2099 (vport->cfg_enable_fc4_type == LPFC_ENABLE_NVME)) &&
2100 (context == FC_TYPE_NVME)) {
2101 if ((vport == phba->pport) && phba->nvmet_support) {
2102 CtReq->un.rff.fbits = (FC4_FEATURE_TARGET |
2103 FC4_FEATURE_NVME_DISC);
2104 lpfc_nvmet_update_targetport(phba);
2105 } else {
2106 lpfc_nvme_update_localport(vport);
2107 }
2108 CtReq->un.rff.type_code = context;
2109
2110 } else if (((vport->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) ||
2111 (vport->cfg_enable_fc4_type == LPFC_ENABLE_FCP)) &&
2112 (context == FC_TYPE_FCP))
2113 CtReq->un.rff.type_code = context;
2114
2115 else
2116 goto ns_cmd_free_bmpvirt;
2117
2118 ptr = (uint32_t *)CtReq;
2119 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2120 "6434 Issue RFF (%s): %08x %08x %08x %08x "
2121 "%08x %08x %08x %08x\n",
2122 (context == FC_TYPE_NVME) ? "NVME" : "FCP",
2123 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3),
2124 *(ptr + 4), *(ptr + 5),
2125 *(ptr + 6), *(ptr + 7));
2126 cmpl = lpfc_cmpl_ct_cmd_rff_id;
2127 break;
2128 }
2129 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
2130 * to hold ndlp reference for the corresponding callback function.
2131 */
2132 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry)) {
2133 /* On success, The cmpl function will free the buffers */
2134 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
2135 "Issue CT cmd: cmd:x%x did:x%x",
2136 cmdcode, ndlp->nlp_DID, 0);
2137 return 0;
2138 }
2139 rc=6;
2140
2141 ns_cmd_free_bmpvirt:
2142 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
2143 ns_cmd_free_bmp:
2144 kfree(bmp);
2145 ns_cmd_free_mpvirt:
2146 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2147 ns_cmd_free_mp:
2148 kfree(mp);
2149 ns_cmd_exit:
2150 lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
2151 "0266 Issue NameServer Req x%x err %d Data: x%lx "
2152 "x%x\n",
2153 cmdcode, rc, vport->fc_flag, vport->fc_rscn_id_cnt);
2154 return 1;
2155 }
2156
2157 /**
2158 * lpfc_fdmi_rprt_defer - Check for any deferred FDMI RPRT commands
2159 * @phba: Pointer to HBA context object.
2160 * @mask: Initial port attributes mask
2161 *
2162 * This function checks to see if any vports have deferred their FDMI RPRT.
2163 * A vports RPRT may be deferred if it is issued before the primary ports
2164 * RHBA completes.
2165 */
2166 static void
lpfc_fdmi_rprt_defer(struct lpfc_hba * phba,uint32_t mask)2167 lpfc_fdmi_rprt_defer(struct lpfc_hba *phba, uint32_t mask)
2168 {
2169 struct lpfc_vport **vports;
2170 struct lpfc_vport *vport;
2171 struct lpfc_nodelist *ndlp;
2172 int i;
2173
2174 set_bit(HBA_RHBA_CMPL, &phba->hba_flag);
2175 vports = lpfc_create_vport_work_array(phba);
2176 if (vports) {
2177 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2178 vport = vports[i];
2179 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2180 if (!ndlp)
2181 continue;
2182 if (vport->ct_flags & FC_CT_RPRT_DEFER) {
2183 vport->ct_flags &= ~FC_CT_RPRT_DEFER;
2184 vport->fdmi_port_mask = mask;
2185 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT, 0);
2186 }
2187 }
2188 }
2189 lpfc_destroy_vport_work_array(phba, vports);
2190 }
2191
2192 /**
2193 * lpfc_cmpl_ct_disc_fdmi - Handle a discovery FDMI completion
2194 * @phba: Pointer to HBA context object.
2195 * @cmdiocb: Pointer to the command IOCBQ.
2196 * @rspiocb: Pointer to the response IOCBQ.
2197 *
2198 * This function to handle the completion of a driver initiated FDMI
2199 * CT command issued during discovery.
2200 */
2201 static void
lpfc_cmpl_ct_disc_fdmi(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)2202 lpfc_cmpl_ct_disc_fdmi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2203 struct lpfc_iocbq *rspiocb)
2204 {
2205 struct lpfc_vport *vport = cmdiocb->vport;
2206 struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf;
2207 struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf;
2208 struct lpfc_sli_ct_request *CTcmd = inp->virt;
2209 struct lpfc_sli_ct_request *CTrsp = outp->virt;
2210 __be16 fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp;
2211 __be16 fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp;
2212 struct lpfc_nodelist *ndlp, *free_ndlp = NULL;
2213 uint32_t latt, cmd, err;
2214 u32 ulp_status = get_job_ulpstatus(phba, rspiocb);
2215 u32 ulp_word4 = get_job_word4(phba, rspiocb);
2216
2217 latt = lpfc_els_chk_latt(vport);
2218 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
2219 "FDMI cmpl: status:x%x/x%x latt:%d",
2220 ulp_status, ulp_word4, latt);
2221
2222 if (latt || ulp_status) {
2223 lpfc_printf_vlog(vport, KERN_WARNING, LOG_DISCOVERY,
2224 "0229 FDMI cmd %04x failed, latt = %d "
2225 "ulp_status: (x%x/x%x), sli_flag x%x\n",
2226 be16_to_cpu(fdmi_cmd), latt, ulp_status,
2227 ulp_word4, phba->sli.sli_flag);
2228
2229 /* Look for a retryable error */
2230 if (ulp_status == IOSTAT_LOCAL_REJECT) {
2231 switch ((ulp_word4 & IOERR_PARAM_MASK)) {
2232 case IOERR_SLI_ABORTED:
2233 case IOERR_SLI_DOWN:
2234 /* Driver aborted this IO. No retry as error
2235 * is likely Offline->Online or some adapter
2236 * error. Recovery will try again, but if port
2237 * is not active there's no point to continue
2238 * issuing follow up FDMI commands.
2239 */
2240 if (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)) {
2241 free_ndlp = cmdiocb->ndlp;
2242 lpfc_ct_free_iocb(phba, cmdiocb);
2243 lpfc_nlp_put(free_ndlp);
2244 return;
2245 }
2246 break;
2247 case IOERR_ABORT_IN_PROGRESS:
2248 case IOERR_SEQUENCE_TIMEOUT:
2249 case IOERR_ILLEGAL_FRAME:
2250 case IOERR_NO_RESOURCES:
2251 case IOERR_ILLEGAL_COMMAND:
2252 cmdiocb->retry++;
2253 if (cmdiocb->retry >= LPFC_FDMI_MAX_RETRY)
2254 break;
2255
2256 /* Retry the same FDMI command */
2257 err = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING,
2258 cmdiocb, 0);
2259 if (err == IOCB_ERROR)
2260 break;
2261 return;
2262 default:
2263 break;
2264 }
2265 }
2266 }
2267
2268 free_ndlp = cmdiocb->ndlp;
2269 lpfc_ct_free_iocb(phba, cmdiocb);
2270 lpfc_nlp_put(free_ndlp);
2271
2272 ndlp = lpfc_findnode_did(vport, FDMI_DID);
2273 if (!ndlp)
2274 return;
2275
2276 /* Check for a CT LS_RJT response */
2277 cmd = be16_to_cpu(fdmi_cmd);
2278 if (be16_to_cpu(fdmi_rsp) == SLI_CT_RESPONSE_FS_RJT) {
2279 /* Log FDMI reject */
2280 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY | LOG_ELS,
2281 "0220 FDMI cmd FS_RJT Data: x%x", cmd);
2282
2283 /* Should we fallback to FDMI-2 / FDMI-1 ? */
2284 switch (cmd) {
2285 case SLI_MGMT_RHBA:
2286 if (vport->fdmi_hba_mask == LPFC_FDMI2_HBA_ATTR) {
2287 /* Fallback to FDMI-1 for HBA attributes */
2288 vport->fdmi_hba_mask = LPFC_FDMI1_HBA_ATTR;
2289
2290 /* If HBA attributes are FDMI1, so should
2291 * port attributes be for consistency.
2292 */
2293 vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
2294 /* Start over */
2295 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
2296 }
2297 return;
2298
2299 case SLI_MGMT_RPRT:
2300 if (vport->port_type != LPFC_PHYSICAL_PORT) {
2301 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2302 if (!ndlp)
2303 return;
2304 }
2305 if (vport->fdmi_port_mask == LPFC_FDMI2_PORT_ATTR) {
2306 /* Fallback to FDMI-1 */
2307 vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
2308 /* Start over */
2309 lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
2310 return;
2311 }
2312 if (vport->fdmi_port_mask == LPFC_FDMI2_SMART_ATTR) {
2313 vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
2314 /* Retry the same command */
2315 lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
2316 }
2317 return;
2318
2319 case SLI_MGMT_RPA:
2320 /* No retry on Vendor, RPA only done on physical port */
2321 if (phba->link_flag & LS_CT_VEN_RPA) {
2322 phba->link_flag &= ~LS_CT_VEN_RPA;
2323 if (phba->cmf_active_mode == LPFC_CFG_OFF)
2324 return;
2325 lpfc_printf_log(phba, KERN_WARNING,
2326 LOG_DISCOVERY | LOG_ELS,
2327 "6460 VEN FDMI RPA RJT\n");
2328 return;
2329 }
2330 if (vport->fdmi_port_mask == LPFC_FDMI2_PORT_ATTR) {
2331 /* Fallback to FDMI-1 */
2332 vport->fdmi_hba_mask = LPFC_FDMI1_HBA_ATTR;
2333 vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
2334 /* Start over */
2335 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
2336 return;
2337 }
2338 if (vport->fdmi_port_mask == LPFC_FDMI2_SMART_ATTR) {
2339 vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
2340 /* Retry the same command */
2341 lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
2342 }
2343 return;
2344 }
2345 }
2346
2347 /*
2348 * On success, need to cycle thru FDMI registration for discovery
2349 * DHBA -> DPRT -> RHBA -> RPA (physical port)
2350 * DPRT -> RPRT (vports)
2351 */
2352 switch (cmd) {
2353 case SLI_MGMT_RHBA:
2354 /* Check for any RPRTs deferred till after RHBA completes */
2355 lpfc_fdmi_rprt_defer(phba, vport->fdmi_port_mask);
2356
2357 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA, 0);
2358 break;
2359
2360 case SLI_MGMT_DHBA:
2361 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT, 0);
2362 break;
2363
2364 case SLI_MGMT_DPRT:
2365 if (vport->port_type == LPFC_PHYSICAL_PORT) {
2366 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RHBA, 0);
2367 } else {
2368 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2369 if (!ndlp)
2370 return;
2371
2372 /* Only issue a RPRT for the vport if the RHBA
2373 * for the physical port completes successfully.
2374 * We may have to defer the RPRT accordingly.
2375 */
2376 if (test_bit(HBA_RHBA_CMPL, &phba->hba_flag)) {
2377 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT, 0);
2378 } else {
2379 lpfc_printf_vlog(vport, KERN_INFO,
2380 LOG_DISCOVERY,
2381 "6078 RPRT deferred\n");
2382 vport->ct_flags |= FC_CT_RPRT_DEFER;
2383 }
2384 }
2385 break;
2386 case SLI_MGMT_RPA:
2387 if (vport->port_type == LPFC_PHYSICAL_PORT &&
2388 phba->sli4_hba.pc_sli4_params.mi_ver) {
2389 /* mi is only for the phyical port, no vports */
2390 if (phba->link_flag & LS_CT_VEN_RPA) {
2391 lpfc_printf_vlog(vport, KERN_INFO,
2392 LOG_DISCOVERY | LOG_ELS |
2393 LOG_CGN_MGMT,
2394 "6449 VEN RPA FDMI Success\n");
2395 phba->link_flag &= ~LS_CT_VEN_RPA;
2396 break;
2397 }
2398
2399 lpfc_printf_log(phba, KERN_INFO,
2400 LOG_DISCOVERY | LOG_CGN_MGMT,
2401 "6210 Issue Vendor MI FDMI %x\n",
2402 phba->sli4_hba.pc_sli4_params.mi_ver);
2403
2404 /* CGN is only for the physical port, no vports */
2405 if (lpfc_fdmi_cmd(vport, ndlp, cmd,
2406 LPFC_FDMI_VENDOR_ATTR_mi) == 0)
2407 phba->link_flag |= LS_CT_VEN_RPA;
2408 lpfc_printf_log(phba, KERN_INFO,
2409 LOG_DISCOVERY | LOG_ELS,
2410 "6458 Send MI FDMI:%x Flag x%x\n",
2411 phba->sli4_hba.pc_sli4_params.mi_ver,
2412 phba->link_flag);
2413 } else {
2414 lpfc_printf_log(phba, KERN_INFO,
2415 LOG_DISCOVERY | LOG_ELS,
2416 "6459 No FDMI VEN MI support - "
2417 "RPA Success\n");
2418 }
2419 break;
2420 }
2421 return;
2422 }
2423
2424
2425 /**
2426 * lpfc_fdmi_change_check - Check for changed FDMI parameters
2427 * @vport: pointer to a host virtual N_Port data structure.
2428 *
2429 * Check how many mapped NPorts we are connected to
2430 * Check if our hostname changed
2431 * Called from hbeat timeout routine to check if any FDMI parameters
2432 * changed. If so, re-register those Attributes.
2433 */
2434 void
lpfc_fdmi_change_check(struct lpfc_vport * vport)2435 lpfc_fdmi_change_check(struct lpfc_vport *vport)
2436 {
2437 struct lpfc_hba *phba = vport->phba;
2438 struct lpfc_nodelist *ndlp;
2439 uint16_t cnt;
2440
2441 if (!lpfc_is_link_up(phba))
2442 return;
2443
2444 /* Must be connected to a Fabric */
2445 if (!test_bit(FC_FABRIC, &vport->fc_flag))
2446 return;
2447
2448 ndlp = lpfc_findnode_did(vport, FDMI_DID);
2449 if (!ndlp)
2450 return;
2451
2452 /* Check if system hostname changed */
2453 if (strcmp(phba->os_host_name, init_utsname()->nodename)) {
2454 memset(phba->os_host_name, 0, sizeof(phba->os_host_name));
2455 scnprintf(phba->os_host_name, sizeof(phba->os_host_name), "%s",
2456 init_utsname()->nodename);
2457 lpfc_ns_cmd(vport, SLI_CTNS_RSNN_NN, 0, 0);
2458
2459 /* Since this effects multiple HBA and PORT attributes, we need
2460 * de-register and go thru the whole FDMI registration cycle.
2461 * DHBA -> DPRT -> RHBA -> RPA (physical port)
2462 * DPRT -> RPRT (vports)
2463 */
2464 if (vport->port_type == LPFC_PHYSICAL_PORT) {
2465 /* For extra Vendor RPA */
2466 phba->link_flag &= ~LS_CT_VEN_RPA;
2467 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
2468 } else {
2469 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2470 if (!ndlp)
2471 return;
2472 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT, 0);
2473 }
2474
2475 /* Since this code path registers all the port attributes
2476 * we can just return without further checking.
2477 */
2478 return;
2479 }
2480
2481 if (!(vport->fdmi_port_mask & LPFC_FDMI_PORT_ATTR_num_disc))
2482 return;
2483
2484 /* Check if the number of mapped NPorts changed */
2485 cnt = lpfc_find_map_node(vport);
2486 if (cnt == vport->fdmi_num_disc)
2487 return;
2488
2489 if (vport->port_type == LPFC_PHYSICAL_PORT) {
2490 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA,
2491 LPFC_FDMI_PORT_ATTR_num_disc);
2492 } else {
2493 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
2494 if (!ndlp)
2495 return;
2496 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT,
2497 LPFC_FDMI_PORT_ATTR_num_disc);
2498 }
2499 }
2500
2501 static inline int
lpfc_fdmi_set_attr_u32(void * attr,uint16_t attrtype,uint32_t attrval)2502 lpfc_fdmi_set_attr_u32(void *attr, uint16_t attrtype, uint32_t attrval)
2503 {
2504 struct lpfc_fdmi_attr_u32 *ae = attr;
2505 int size = sizeof(*ae);
2506
2507 ae->type = cpu_to_be16(attrtype);
2508 ae->len = cpu_to_be16(size);
2509 ae->value_u32 = cpu_to_be32(attrval);
2510
2511 return size;
2512 }
2513
2514 static inline int
lpfc_fdmi_set_attr_wwn(void * attr,uint16_t attrtype,struct lpfc_name * wwn)2515 lpfc_fdmi_set_attr_wwn(void *attr, uint16_t attrtype, struct lpfc_name *wwn)
2516 {
2517 struct lpfc_fdmi_attr_wwn *ae = attr;
2518 int size = sizeof(*ae);
2519
2520 ae->type = cpu_to_be16(attrtype);
2521 ae->len = cpu_to_be16(size);
2522 /* WWN's assumed to be bytestreams - Big Endian presentation */
2523 memcpy(ae->name, wwn,
2524 min_t(size_t, sizeof(struct lpfc_name), sizeof(__be64)));
2525
2526 return size;
2527 }
2528
2529 static inline int
lpfc_fdmi_set_attr_fullwwn(void * attr,uint16_t attrtype,struct lpfc_name * wwnn,struct lpfc_name * wwpn)2530 lpfc_fdmi_set_attr_fullwwn(void *attr, uint16_t attrtype,
2531 struct lpfc_name *wwnn, struct lpfc_name *wwpn)
2532 {
2533 struct lpfc_fdmi_attr_fullwwn *ae = attr;
2534 u8 *nname = ae->nname;
2535 u8 *pname = ae->pname;
2536 int size = sizeof(*ae);
2537
2538 ae->type = cpu_to_be16(attrtype);
2539 ae->len = cpu_to_be16(size);
2540 /* WWN's assumed to be bytestreams - Big Endian presentation */
2541 memcpy(nname, wwnn,
2542 min_t(size_t, sizeof(struct lpfc_name), sizeof(__be64)));
2543 memcpy(pname, wwpn,
2544 min_t(size_t, sizeof(struct lpfc_name), sizeof(__be64)));
2545
2546 return size;
2547 }
2548
2549 static inline int
lpfc_fdmi_set_attr_string(void * attr,uint16_t attrtype,char * attrstring)2550 lpfc_fdmi_set_attr_string(void *attr, uint16_t attrtype, char *attrstring)
2551 {
2552 struct lpfc_fdmi_attr_string *ae = attr;
2553 int len, size;
2554
2555 /*
2556 * We are trusting the caller that if a fdmi string field
2557 * is capped at 64 bytes, the caller passes in a string of
2558 * 64 bytes or less.
2559 */
2560
2561 strscpy(ae->value_string, attrstring, sizeof(ae->value_string));
2562 len = strnlen(ae->value_string, sizeof(ae->value_string));
2563 /* round string length to a 32bit boundary */
2564 len += (len & 3) ? (4 - (len & 3)) : 4;
2565 /* size is Type/Len (4 bytes) plus string length */
2566 size = FOURBYTES + len;
2567
2568 ae->type = cpu_to_be16(attrtype);
2569 ae->len = cpu_to_be16(size);
2570
2571 return size;
2572 }
2573
2574 /* Bitfields for FC4 Types that can be reported */
2575 #define ATTR_FC4_CT 0x00000001
2576 #define ATTR_FC4_FCP 0x00000002
2577 #define ATTR_FC4_NVME 0x00000004
2578
2579 static inline int
lpfc_fdmi_set_attr_fc4types(void * attr,uint16_t attrtype,uint32_t typemask)2580 lpfc_fdmi_set_attr_fc4types(void *attr, uint16_t attrtype, uint32_t typemask)
2581 {
2582 struct lpfc_fdmi_attr_fc4types *ae = attr;
2583 int size = sizeof(*ae);
2584
2585 ae->type = cpu_to_be16(attrtype);
2586 ae->len = cpu_to_be16(size);
2587
2588 if (typemask & ATTR_FC4_FCP)
2589 ae->value_types[2] = 0x01; /* Type 0x8 - FCP */
2590
2591 if (typemask & ATTR_FC4_CT)
2592 ae->value_types[7] = 0x01; /* Type 0x20 - CT */
2593
2594 if (typemask & ATTR_FC4_NVME)
2595 ae->value_types[6] = 0x01; /* Type 0x28 - NVME */
2596
2597 return size;
2598 }
2599
2600 /* Routines for all individual HBA attributes */
2601 static int
lpfc_fdmi_hba_attr_wwnn(struct lpfc_vport * vport,void * attr)2602 lpfc_fdmi_hba_attr_wwnn(struct lpfc_vport *vport, void *attr)
2603 {
2604 return lpfc_fdmi_set_attr_wwn(attr, RHBA_NODENAME,
2605 &vport->fc_sparam.nodeName);
2606 }
2607
2608 static int
lpfc_fdmi_hba_attr_manufacturer(struct lpfc_vport * vport,void * attr)2609 lpfc_fdmi_hba_attr_manufacturer(struct lpfc_vport *vport, void *attr)
2610 {
2611 /* This string MUST be consistent with other FC platforms
2612 * supported by Broadcom.
2613 */
2614 return lpfc_fdmi_set_attr_string(attr, RHBA_MANUFACTURER,
2615 "Emulex Corporation");
2616 }
2617
2618 static int
lpfc_fdmi_hba_attr_sn(struct lpfc_vport * vport,void * attr)2619 lpfc_fdmi_hba_attr_sn(struct lpfc_vport *vport, void *attr)
2620 {
2621 struct lpfc_hba *phba = vport->phba;
2622
2623 return lpfc_fdmi_set_attr_string(attr, RHBA_SERIAL_NUMBER,
2624 phba->SerialNumber);
2625 }
2626
2627 static int
lpfc_fdmi_hba_attr_model(struct lpfc_vport * vport,void * attr)2628 lpfc_fdmi_hba_attr_model(struct lpfc_vport *vport, void *attr)
2629 {
2630 struct lpfc_hba *phba = vport->phba;
2631
2632 return lpfc_fdmi_set_attr_string(attr, RHBA_MODEL,
2633 phba->ModelName);
2634 }
2635
2636 static int
lpfc_fdmi_hba_attr_description(struct lpfc_vport * vport,void * attr)2637 lpfc_fdmi_hba_attr_description(struct lpfc_vport *vport, void *attr)
2638 {
2639 struct lpfc_hba *phba = vport->phba;
2640
2641 return lpfc_fdmi_set_attr_string(attr, RHBA_MODEL_DESCRIPTION,
2642 phba->ModelDesc);
2643 }
2644
2645 static int
lpfc_fdmi_hba_attr_hdw_ver(struct lpfc_vport * vport,void * attr)2646 lpfc_fdmi_hba_attr_hdw_ver(struct lpfc_vport *vport, void *attr)
2647 {
2648 struct lpfc_hba *phba = vport->phba;
2649 lpfc_vpd_t *vp = &phba->vpd;
2650 char buf[16] = { 0 };
2651
2652 snprintf(buf, sizeof(buf), "%08x", vp->rev.biuRev);
2653
2654 return lpfc_fdmi_set_attr_string(attr, RHBA_HARDWARE_VERSION, buf);
2655 }
2656
2657 static int
lpfc_fdmi_hba_attr_drvr_ver(struct lpfc_vport * vport,void * attr)2658 lpfc_fdmi_hba_attr_drvr_ver(struct lpfc_vport *vport, void *attr)
2659 {
2660 return lpfc_fdmi_set_attr_string(attr, RHBA_DRIVER_VERSION,
2661 lpfc_release_version);
2662 }
2663
2664 static int
lpfc_fdmi_hba_attr_rom_ver(struct lpfc_vport * vport,void * attr)2665 lpfc_fdmi_hba_attr_rom_ver(struct lpfc_vport *vport, void *attr)
2666 {
2667 struct lpfc_hba *phba = vport->phba;
2668 char buf[64] = { 0 };
2669
2670 if (phba->sli_rev == LPFC_SLI_REV4) {
2671 lpfc_decode_firmware_rev(phba, buf, 1);
2672
2673 return lpfc_fdmi_set_attr_string(attr, RHBA_OPTION_ROM_VERSION,
2674 buf);
2675 }
2676
2677 return lpfc_fdmi_set_attr_string(attr, RHBA_OPTION_ROM_VERSION,
2678 phba->OptionROMVersion);
2679 }
2680
2681 static int
lpfc_fdmi_hba_attr_fmw_ver(struct lpfc_vport * vport,void * attr)2682 lpfc_fdmi_hba_attr_fmw_ver(struct lpfc_vport *vport, void *attr)
2683 {
2684 struct lpfc_hba *phba = vport->phba;
2685 char buf[64] = { 0 };
2686
2687 lpfc_decode_firmware_rev(phba, buf, 1);
2688
2689 return lpfc_fdmi_set_attr_string(attr, RHBA_FIRMWARE_VERSION, buf);
2690 }
2691
2692 static int
lpfc_fdmi_hba_attr_os_ver(struct lpfc_vport * vport,void * attr)2693 lpfc_fdmi_hba_attr_os_ver(struct lpfc_vport *vport, void *attr)
2694 {
2695 char buf[256] = { 0 };
2696
2697 snprintf(buf, sizeof(buf), "%s %s %s",
2698 init_utsname()->sysname,
2699 init_utsname()->release,
2700 init_utsname()->version);
2701
2702 return lpfc_fdmi_set_attr_string(attr, RHBA_OS_NAME_VERSION, buf);
2703 }
2704
2705 static int
lpfc_fdmi_hba_attr_ct_len(struct lpfc_vport * vport,void * attr)2706 lpfc_fdmi_hba_attr_ct_len(struct lpfc_vport *vport, void *attr)
2707 {
2708 return lpfc_fdmi_set_attr_u32(attr, RHBA_MAX_CT_PAYLOAD_LEN,
2709 LPFC_MAX_CT_SIZE);
2710 }
2711
2712 static int
lpfc_fdmi_hba_attr_symbolic_name(struct lpfc_vport * vport,void * attr)2713 lpfc_fdmi_hba_attr_symbolic_name(struct lpfc_vport *vport, void *attr)
2714 {
2715 char buf[256] = { 0 };
2716
2717 lpfc_vport_symbolic_node_name(vport, buf, sizeof(buf));
2718
2719 return lpfc_fdmi_set_attr_string(attr, RHBA_SYM_NODENAME, buf);
2720 }
2721
2722 static int
lpfc_fdmi_hba_attr_vendor_info(struct lpfc_vport * vport,void * attr)2723 lpfc_fdmi_hba_attr_vendor_info(struct lpfc_vport *vport, void *attr)
2724 {
2725 return lpfc_fdmi_set_attr_u32(attr, RHBA_VENDOR_INFO, 0);
2726 }
2727
2728 static int
lpfc_fdmi_hba_attr_num_ports(struct lpfc_vport * vport,void * attr)2729 lpfc_fdmi_hba_attr_num_ports(struct lpfc_vport *vport, void *attr)
2730 {
2731 /* Each driver instance corresponds to a single port */
2732 return lpfc_fdmi_set_attr_u32(attr, RHBA_NUM_PORTS, 1);
2733 }
2734
2735 static int
lpfc_fdmi_hba_attr_fabric_wwnn(struct lpfc_vport * vport,void * attr)2736 lpfc_fdmi_hba_attr_fabric_wwnn(struct lpfc_vport *vport, void *attr)
2737 {
2738 return lpfc_fdmi_set_attr_wwn(attr, RHBA_FABRIC_WWNN,
2739 &vport->fabric_nodename);
2740 }
2741
2742 static int
lpfc_fdmi_hba_attr_bios_ver(struct lpfc_vport * vport,void * attr)2743 lpfc_fdmi_hba_attr_bios_ver(struct lpfc_vport *vport, void *attr)
2744 {
2745 struct lpfc_hba *phba = vport->phba;
2746
2747 return lpfc_fdmi_set_attr_string(attr, RHBA_BIOS_VERSION,
2748 phba->BIOSVersion);
2749 }
2750
2751 static int
lpfc_fdmi_hba_attr_bios_state(struct lpfc_vport * vport,void * attr)2752 lpfc_fdmi_hba_attr_bios_state(struct lpfc_vport *vport, void *attr)
2753 {
2754 /* Driver doesn't have access to this information */
2755 return lpfc_fdmi_set_attr_u32(attr, RHBA_BIOS_STATE, 0);
2756 }
2757
2758 static int
lpfc_fdmi_hba_attr_vendor_id(struct lpfc_vport * vport,void * attr)2759 lpfc_fdmi_hba_attr_vendor_id(struct lpfc_vport *vport, void *attr)
2760 {
2761 return lpfc_fdmi_set_attr_string(attr, RHBA_VENDOR_ID, "EMULEX");
2762 }
2763
2764 /*
2765 * Routines for all individual PORT attributes
2766 */
2767
2768 static int
lpfc_fdmi_port_attr_fc4type(struct lpfc_vport * vport,void * attr)2769 lpfc_fdmi_port_attr_fc4type(struct lpfc_vport *vport, void *attr)
2770 {
2771 struct lpfc_hba *phba = vport->phba;
2772 u32 fc4types;
2773
2774 fc4types = (ATTR_FC4_CT | ATTR_FC4_FCP);
2775
2776 /* Check to see if Firmware supports NVME and on physical port */
2777 if ((phba->sli_rev == LPFC_SLI_REV4) && (vport == phba->pport) &&
2778 phba->sli4_hba.pc_sli4_params.nvme)
2779 fc4types |= ATTR_FC4_NVME;
2780
2781 return lpfc_fdmi_set_attr_fc4types(attr, RPRT_SUPPORTED_FC4_TYPES,
2782 fc4types);
2783 }
2784
2785 static int
lpfc_fdmi_port_attr_support_speed(struct lpfc_vport * vport,void * attr)2786 lpfc_fdmi_port_attr_support_speed(struct lpfc_vport *vport, void *attr)
2787 {
2788 struct lpfc_hba *phba = vport->phba;
2789 u32 speeds = 0;
2790 u32 tcfg;
2791 u8 i, cnt;
2792
2793 if (!test_bit(HBA_FCOE_MODE, &phba->hba_flag)) {
2794 cnt = 0;
2795 if (phba->sli_rev == LPFC_SLI_REV4) {
2796 tcfg = phba->sli4_hba.conf_trunk;
2797 for (i = 0; i < 4; i++, tcfg >>= 1)
2798 if (tcfg & 1)
2799 cnt++;
2800 }
2801
2802 if (cnt > 2) { /* 4 lane trunk group */
2803 if (phba->lmt & LMT_64Gb)
2804 speeds |= HBA_PORTSPEED_256GFC;
2805 if (phba->lmt & LMT_32Gb)
2806 speeds |= HBA_PORTSPEED_128GFC;
2807 if (phba->lmt & LMT_16Gb)
2808 speeds |= HBA_PORTSPEED_64GFC;
2809 } else if (cnt) { /* 2 lane trunk group */
2810 if (phba->lmt & LMT_128Gb)
2811 speeds |= HBA_PORTSPEED_256GFC;
2812 if (phba->lmt & LMT_64Gb)
2813 speeds |= HBA_PORTSPEED_128GFC;
2814 if (phba->lmt & LMT_32Gb)
2815 speeds |= HBA_PORTSPEED_64GFC;
2816 if (phba->lmt & LMT_16Gb)
2817 speeds |= HBA_PORTSPEED_32GFC;
2818 } else {
2819 if (phba->lmt & LMT_256Gb)
2820 speeds |= HBA_PORTSPEED_256GFC;
2821 if (phba->lmt & LMT_128Gb)
2822 speeds |= HBA_PORTSPEED_128GFC;
2823 if (phba->lmt & LMT_64Gb)
2824 speeds |= HBA_PORTSPEED_64GFC;
2825 if (phba->lmt & LMT_32Gb)
2826 speeds |= HBA_PORTSPEED_32GFC;
2827 if (phba->lmt & LMT_16Gb)
2828 speeds |= HBA_PORTSPEED_16GFC;
2829 if (phba->lmt & LMT_10Gb)
2830 speeds |= HBA_PORTSPEED_10GFC;
2831 if (phba->lmt & LMT_8Gb)
2832 speeds |= HBA_PORTSPEED_8GFC;
2833 if (phba->lmt & LMT_4Gb)
2834 speeds |= HBA_PORTSPEED_4GFC;
2835 if (phba->lmt & LMT_2Gb)
2836 speeds |= HBA_PORTSPEED_2GFC;
2837 if (phba->lmt & LMT_1Gb)
2838 speeds |= HBA_PORTSPEED_1GFC;
2839 }
2840 } else {
2841 /* FCoE links support only one speed */
2842 switch (phba->fc_linkspeed) {
2843 case LPFC_ASYNC_LINK_SPEED_10GBPS:
2844 speeds = HBA_PORTSPEED_10GE;
2845 break;
2846 case LPFC_ASYNC_LINK_SPEED_25GBPS:
2847 speeds = HBA_PORTSPEED_25GE;
2848 break;
2849 case LPFC_ASYNC_LINK_SPEED_40GBPS:
2850 speeds = HBA_PORTSPEED_40GE;
2851 break;
2852 case LPFC_ASYNC_LINK_SPEED_100GBPS:
2853 speeds = HBA_PORTSPEED_100GE;
2854 break;
2855 }
2856 }
2857
2858 return lpfc_fdmi_set_attr_u32(attr, RPRT_SUPPORTED_SPEED, speeds);
2859 }
2860
2861 static int
lpfc_fdmi_port_attr_speed(struct lpfc_vport * vport,void * attr)2862 lpfc_fdmi_port_attr_speed(struct lpfc_vport *vport, void *attr)
2863 {
2864 struct lpfc_hba *phba = vport->phba;
2865 u32 speeds = 0;
2866
2867 if (!test_bit(HBA_FCOE_MODE, &phba->hba_flag)) {
2868 switch (phba->fc_linkspeed) {
2869 case LPFC_LINK_SPEED_1GHZ:
2870 speeds = HBA_PORTSPEED_1GFC;
2871 break;
2872 case LPFC_LINK_SPEED_2GHZ:
2873 speeds = HBA_PORTSPEED_2GFC;
2874 break;
2875 case LPFC_LINK_SPEED_4GHZ:
2876 speeds = HBA_PORTSPEED_4GFC;
2877 break;
2878 case LPFC_LINK_SPEED_8GHZ:
2879 speeds = HBA_PORTSPEED_8GFC;
2880 break;
2881 case LPFC_LINK_SPEED_10GHZ:
2882 speeds = HBA_PORTSPEED_10GFC;
2883 break;
2884 case LPFC_LINK_SPEED_16GHZ:
2885 speeds = HBA_PORTSPEED_16GFC;
2886 break;
2887 case LPFC_LINK_SPEED_32GHZ:
2888 speeds = HBA_PORTSPEED_32GFC;
2889 break;
2890 case LPFC_LINK_SPEED_64GHZ:
2891 speeds = HBA_PORTSPEED_64GFC;
2892 break;
2893 case LPFC_LINK_SPEED_128GHZ:
2894 speeds = HBA_PORTSPEED_128GFC;
2895 break;
2896 case LPFC_LINK_SPEED_256GHZ:
2897 speeds = HBA_PORTSPEED_256GFC;
2898 break;
2899 default:
2900 speeds = HBA_PORTSPEED_UNKNOWN;
2901 break;
2902 }
2903 } else {
2904 switch (phba->fc_linkspeed) {
2905 case LPFC_ASYNC_LINK_SPEED_10GBPS:
2906 speeds = HBA_PORTSPEED_10GE;
2907 break;
2908 case LPFC_ASYNC_LINK_SPEED_25GBPS:
2909 speeds = HBA_PORTSPEED_25GE;
2910 break;
2911 case LPFC_ASYNC_LINK_SPEED_40GBPS:
2912 speeds = HBA_PORTSPEED_40GE;
2913 break;
2914 case LPFC_ASYNC_LINK_SPEED_100GBPS:
2915 speeds = HBA_PORTSPEED_100GE;
2916 break;
2917 default:
2918 speeds = HBA_PORTSPEED_UNKNOWN;
2919 break;
2920 }
2921 }
2922
2923 return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_SPEED, speeds);
2924 }
2925
2926 static int
lpfc_fdmi_port_attr_max_frame(struct lpfc_vport * vport,void * attr)2927 lpfc_fdmi_port_attr_max_frame(struct lpfc_vport *vport, void *attr)
2928 {
2929 struct serv_parm *hsp = (struct serv_parm *)&vport->fc_sparam;
2930
2931 return lpfc_fdmi_set_attr_u32(attr, RPRT_MAX_FRAME_SIZE,
2932 (((uint32_t)hsp->cmn.bbRcvSizeMsb & 0x0F) << 8) |
2933 (uint32_t)hsp->cmn.bbRcvSizeLsb);
2934 }
2935
2936 static int
lpfc_fdmi_port_attr_os_devname(struct lpfc_vport * vport,void * attr)2937 lpfc_fdmi_port_attr_os_devname(struct lpfc_vport *vport, void *attr)
2938 {
2939 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2940 char buf[64] = { 0 };
2941
2942 snprintf(buf, sizeof(buf), "/sys/class/scsi_host/host%d",
2943 shost->host_no);
2944
2945 return lpfc_fdmi_set_attr_string(attr, RPRT_OS_DEVICE_NAME, buf);
2946 }
2947
2948 static int
lpfc_fdmi_port_attr_host_name(struct lpfc_vport * vport,void * attr)2949 lpfc_fdmi_port_attr_host_name(struct lpfc_vport *vport, void *attr)
2950 {
2951 char buf[64] = { 0 };
2952
2953 scnprintf(buf, sizeof(buf), "%s", vport->phba->os_host_name);
2954
2955 return lpfc_fdmi_set_attr_string(attr, RPRT_HOST_NAME, buf);
2956 }
2957
2958 static int
lpfc_fdmi_port_attr_wwnn(struct lpfc_vport * vport,void * attr)2959 lpfc_fdmi_port_attr_wwnn(struct lpfc_vport *vport, void *attr)
2960 {
2961 return lpfc_fdmi_set_attr_wwn(attr, RPRT_NODENAME,
2962 &vport->fc_sparam.nodeName);
2963 }
2964
2965 static int
lpfc_fdmi_port_attr_wwpn(struct lpfc_vport * vport,void * attr)2966 lpfc_fdmi_port_attr_wwpn(struct lpfc_vport *vport, void *attr)
2967 {
2968 return lpfc_fdmi_set_attr_wwn(attr, RPRT_PORTNAME,
2969 &vport->fc_sparam.portName);
2970 }
2971
2972 static int
lpfc_fdmi_port_attr_symbolic_name(struct lpfc_vport * vport,void * attr)2973 lpfc_fdmi_port_attr_symbolic_name(struct lpfc_vport *vport, void *attr)
2974 {
2975 char buf[256] = { 0 };
2976
2977 lpfc_vport_symbolic_port_name(vport, buf, sizeof(buf));
2978
2979 return lpfc_fdmi_set_attr_string(attr, RPRT_SYM_PORTNAME, buf);
2980 }
2981
2982 static int
lpfc_fdmi_port_attr_port_type(struct lpfc_vport * vport,void * attr)2983 lpfc_fdmi_port_attr_port_type(struct lpfc_vport *vport, void *attr)
2984 {
2985 struct lpfc_hba *phba = vport->phba;
2986
2987 return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_TYPE,
2988 (phba->fc_topology == LPFC_TOPOLOGY_LOOP) ?
2989 LPFC_FDMI_PORTTYPE_NLPORT :
2990 LPFC_FDMI_PORTTYPE_NPORT);
2991 }
2992
2993 static int
lpfc_fdmi_port_attr_class(struct lpfc_vport * vport,void * attr)2994 lpfc_fdmi_port_attr_class(struct lpfc_vport *vport, void *attr)
2995 {
2996 return lpfc_fdmi_set_attr_u32(attr, RPRT_SUPPORTED_CLASS,
2997 FC_COS_CLASS2 | FC_COS_CLASS3);
2998 }
2999
3000 static int
lpfc_fdmi_port_attr_fabric_wwpn(struct lpfc_vport * vport,void * attr)3001 lpfc_fdmi_port_attr_fabric_wwpn(struct lpfc_vport *vport, void *attr)
3002 {
3003 return lpfc_fdmi_set_attr_wwn(attr, RPRT_FABRICNAME,
3004 &vport->fabric_portname);
3005 }
3006
3007 static int
lpfc_fdmi_port_attr_active_fc4type(struct lpfc_vport * vport,void * attr)3008 lpfc_fdmi_port_attr_active_fc4type(struct lpfc_vport *vport, void *attr)
3009 {
3010 struct lpfc_hba *phba = vport->phba;
3011 u32 fc4types;
3012
3013 fc4types = (ATTR_FC4_CT | ATTR_FC4_FCP);
3014
3015 /* Check to see if NVME is configured or not */
3016 if (vport == phba->pport &&
3017 phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
3018 fc4types |= ATTR_FC4_NVME;
3019
3020 return lpfc_fdmi_set_attr_fc4types(attr, RPRT_ACTIVE_FC4_TYPES,
3021 fc4types);
3022 }
3023
3024 static int
lpfc_fdmi_port_attr_port_state(struct lpfc_vport * vport,void * attr)3025 lpfc_fdmi_port_attr_port_state(struct lpfc_vport *vport, void *attr)
3026 {
3027 return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_STATE,
3028 LPFC_FDMI_PORTSTATE_ONLINE);
3029 }
3030
3031 static int
lpfc_fdmi_port_attr_num_disc(struct lpfc_vport * vport,void * attr)3032 lpfc_fdmi_port_attr_num_disc(struct lpfc_vport *vport, void *attr)
3033 {
3034 vport->fdmi_num_disc = lpfc_find_map_node(vport);
3035
3036 return lpfc_fdmi_set_attr_u32(attr, RPRT_DISC_PORT,
3037 vport->fdmi_num_disc);
3038 }
3039
3040 static int
lpfc_fdmi_port_attr_nportid(struct lpfc_vport * vport,void * attr)3041 lpfc_fdmi_port_attr_nportid(struct lpfc_vport *vport, void *attr)
3042 {
3043 return lpfc_fdmi_set_attr_u32(attr, RPRT_PORT_ID, vport->fc_myDID);
3044 }
3045
3046 static int
lpfc_fdmi_smart_attr_service(struct lpfc_vport * vport,void * attr)3047 lpfc_fdmi_smart_attr_service(struct lpfc_vport *vport, void *attr)
3048 {
3049 return lpfc_fdmi_set_attr_string(attr, RPRT_SMART_SERVICE,
3050 "Smart SAN Initiator");
3051 }
3052
3053 static int
lpfc_fdmi_smart_attr_guid(struct lpfc_vport * vport,void * attr)3054 lpfc_fdmi_smart_attr_guid(struct lpfc_vport *vport, void *attr)
3055 {
3056 return lpfc_fdmi_set_attr_fullwwn(attr, RPRT_SMART_GUID,
3057 &vport->fc_sparam.nodeName,
3058 &vport->fc_sparam.portName);
3059 }
3060
3061 static int
lpfc_fdmi_smart_attr_version(struct lpfc_vport * vport,void * attr)3062 lpfc_fdmi_smart_attr_version(struct lpfc_vport *vport, void *attr)
3063 {
3064 return lpfc_fdmi_set_attr_string(attr, RPRT_SMART_VERSION,
3065 "Smart SAN Version 2.0");
3066 }
3067
3068 static int
lpfc_fdmi_smart_attr_model(struct lpfc_vport * vport,void * attr)3069 lpfc_fdmi_smart_attr_model(struct lpfc_vport *vport, void *attr)
3070 {
3071 struct lpfc_hba *phba = vport->phba;
3072
3073 return lpfc_fdmi_set_attr_string(attr, RPRT_SMART_MODEL,
3074 phba->ModelName);
3075 }
3076
3077 static int
lpfc_fdmi_smart_attr_port_info(struct lpfc_vport * vport,void * attr)3078 lpfc_fdmi_smart_attr_port_info(struct lpfc_vport *vport, void *attr)
3079 {
3080 /* SRIOV (type 3) is not supported */
3081
3082 return lpfc_fdmi_set_attr_u32(attr, RPRT_SMART_PORT_INFO,
3083 (vport->vpi) ? 2 /* NPIV */ : 1 /* Physical */);
3084 }
3085
3086 static int
lpfc_fdmi_smart_attr_qos(struct lpfc_vport * vport,void * attr)3087 lpfc_fdmi_smart_attr_qos(struct lpfc_vport *vport, void *attr)
3088 {
3089 return lpfc_fdmi_set_attr_u32(attr, RPRT_SMART_QOS, 0);
3090 }
3091
3092 static int
lpfc_fdmi_smart_attr_security(struct lpfc_vport * vport,void * attr)3093 lpfc_fdmi_smart_attr_security(struct lpfc_vport *vport, void *attr)
3094 {
3095 return lpfc_fdmi_set_attr_u32(attr, RPRT_SMART_SECURITY, 1);
3096 }
3097
3098 static int
lpfc_fdmi_vendor_attr_mi(struct lpfc_vport * vport,void * attr)3099 lpfc_fdmi_vendor_attr_mi(struct lpfc_vport *vport, void *attr)
3100 {
3101 struct lpfc_hba *phba = vport->phba;
3102 char buf[32] = { 0 };
3103
3104 sprintf(buf, "ELXE2EM:%04d", phba->sli4_hba.pc_sli4_params.mi_ver);
3105
3106 return lpfc_fdmi_set_attr_string(attr, RPRT_VENDOR_MI, buf);
3107 }
3108
3109 /* RHBA attribute jump table */
3110 static int (*lpfc_fdmi_hba_action[])
3111 (struct lpfc_vport *vport, void *attrbuf) = {
3112 /* Action routine Mask bit Attribute type */
3113 lpfc_fdmi_hba_attr_wwnn, /* bit0 RHBA_NODENAME */
3114 lpfc_fdmi_hba_attr_manufacturer, /* bit1 RHBA_MANUFACTURER */
3115 lpfc_fdmi_hba_attr_sn, /* bit2 RHBA_SERIAL_NUMBER */
3116 lpfc_fdmi_hba_attr_model, /* bit3 RHBA_MODEL */
3117 lpfc_fdmi_hba_attr_description, /* bit4 RHBA_MODEL_DESCRIPTION */
3118 lpfc_fdmi_hba_attr_hdw_ver, /* bit5 RHBA_HARDWARE_VERSION */
3119 lpfc_fdmi_hba_attr_drvr_ver, /* bit6 RHBA_DRIVER_VERSION */
3120 lpfc_fdmi_hba_attr_rom_ver, /* bit7 RHBA_OPTION_ROM_VERSION */
3121 lpfc_fdmi_hba_attr_fmw_ver, /* bit8 RHBA_FIRMWARE_VERSION */
3122 lpfc_fdmi_hba_attr_os_ver, /* bit9 RHBA_OS_NAME_VERSION */
3123 lpfc_fdmi_hba_attr_ct_len, /* bit10 RHBA_MAX_CT_PAYLOAD_LEN */
3124 lpfc_fdmi_hba_attr_symbolic_name, /* bit11 RHBA_SYM_NODENAME */
3125 lpfc_fdmi_hba_attr_vendor_info, /* bit12 RHBA_VENDOR_INFO */
3126 lpfc_fdmi_hba_attr_num_ports, /* bit13 RHBA_NUM_PORTS */
3127 lpfc_fdmi_hba_attr_fabric_wwnn, /* bit14 RHBA_FABRIC_WWNN */
3128 lpfc_fdmi_hba_attr_bios_ver, /* bit15 RHBA_BIOS_VERSION */
3129 lpfc_fdmi_hba_attr_bios_state, /* bit16 RHBA_BIOS_STATE */
3130 lpfc_fdmi_hba_attr_vendor_id, /* bit17 RHBA_VENDOR_ID */
3131 };
3132
3133 /* RPA / RPRT attribute jump table */
3134 static int (*lpfc_fdmi_port_action[])
3135 (struct lpfc_vport *vport, void *attrbuf) = {
3136 /* Action routine Mask bit Attribute type */
3137 lpfc_fdmi_port_attr_fc4type, /* bit0 RPRT_SUPPORT_FC4_TYPES */
3138 lpfc_fdmi_port_attr_support_speed, /* bit1 RPRT_SUPPORTED_SPEED */
3139 lpfc_fdmi_port_attr_speed, /* bit2 RPRT_PORT_SPEED */
3140 lpfc_fdmi_port_attr_max_frame, /* bit3 RPRT_MAX_FRAME_SIZE */
3141 lpfc_fdmi_port_attr_os_devname, /* bit4 RPRT_OS_DEVICE_NAME */
3142 lpfc_fdmi_port_attr_host_name, /* bit5 RPRT_HOST_NAME */
3143 lpfc_fdmi_port_attr_wwnn, /* bit6 RPRT_NODENAME */
3144 lpfc_fdmi_port_attr_wwpn, /* bit7 RPRT_PORTNAME */
3145 lpfc_fdmi_port_attr_symbolic_name, /* bit8 RPRT_SYM_PORTNAME */
3146 lpfc_fdmi_port_attr_port_type, /* bit9 RPRT_PORT_TYPE */
3147 lpfc_fdmi_port_attr_class, /* bit10 RPRT_SUPPORTED_CLASS */
3148 lpfc_fdmi_port_attr_fabric_wwpn, /* bit11 RPRT_FABRICNAME */
3149 lpfc_fdmi_port_attr_active_fc4type, /* bit12 RPRT_ACTIVE_FC4_TYPES */
3150 lpfc_fdmi_port_attr_port_state, /* bit13 RPRT_PORT_STATE */
3151 lpfc_fdmi_port_attr_num_disc, /* bit14 RPRT_DISC_PORT */
3152 lpfc_fdmi_port_attr_nportid, /* bit15 RPRT_PORT_ID */
3153 lpfc_fdmi_smart_attr_service, /* bit16 RPRT_SMART_SERVICE */
3154 lpfc_fdmi_smart_attr_guid, /* bit17 RPRT_SMART_GUID */
3155 lpfc_fdmi_smart_attr_version, /* bit18 RPRT_SMART_VERSION */
3156 lpfc_fdmi_smart_attr_model, /* bit19 RPRT_SMART_MODEL */
3157 lpfc_fdmi_smart_attr_port_info, /* bit20 RPRT_SMART_PORT_INFO */
3158 lpfc_fdmi_smart_attr_qos, /* bit21 RPRT_SMART_QOS */
3159 lpfc_fdmi_smart_attr_security, /* bit22 RPRT_SMART_SECURITY */
3160 lpfc_fdmi_vendor_attr_mi, /* bit23 RPRT_VENDOR_MI */
3161 };
3162
3163 /**
3164 * lpfc_fdmi_cmd - Build and send a FDMI cmd to the specified NPort
3165 * @vport: pointer to a host virtual N_Port data structure.
3166 * @ndlp: ndlp to send FDMI cmd to (if NULL use FDMI_DID)
3167 * @cmdcode: FDMI command to send
3168 * @new_mask: Mask of HBA or PORT Attributes to send
3169 *
3170 * Builds and sends a FDMI command using the CT subsystem.
3171 */
3172 int
lpfc_fdmi_cmd(struct lpfc_vport * vport,struct lpfc_nodelist * ndlp,int cmdcode,uint32_t new_mask)3173 lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
3174 int cmdcode, uint32_t new_mask)
3175 {
3176 struct lpfc_hba *phba = vport->phba;
3177 struct lpfc_dmabuf *rq, *rsp;
3178 struct lpfc_sli_ct_request *CtReq;
3179 struct ulp_bde64_le *bde;
3180 uint32_t bit_pos;
3181 uint32_t size, addsz;
3182 uint32_t rsp_size;
3183 uint32_t mask;
3184 struct lpfc_fdmi_reg_hba *rh;
3185 struct lpfc_fdmi_port_entry *pe;
3186 struct lpfc_fdmi_reg_portattr *pab = NULL, *base = NULL;
3187 struct lpfc_fdmi_attr_block *ab = NULL;
3188 int (*func)(struct lpfc_vport *vport, void *attrbuf);
3189 void (*cmpl)(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3190 struct lpfc_iocbq *rspiocb);
3191
3192 if (!ndlp)
3193 return 0;
3194
3195 cmpl = lpfc_cmpl_ct_disc_fdmi; /* called from discovery */
3196
3197 /* fill in BDEs for command */
3198 /* Allocate buffer for command payload */
3199 rq = kmalloc(sizeof(*rq), GFP_KERNEL);
3200 if (!rq)
3201 goto fdmi_cmd_exit;
3202
3203 rq->virt = lpfc_mbuf_alloc(phba, 0, &rq->phys);
3204 if (!rq->virt)
3205 goto fdmi_cmd_free_rq;
3206
3207 /* Allocate buffer for Buffer ptr list */
3208 rsp = kmalloc(sizeof(*rsp), GFP_KERNEL);
3209 if (!rsp)
3210 goto fdmi_cmd_free_rqvirt;
3211
3212 rsp->virt = lpfc_mbuf_alloc(phba, 0, &rsp->phys);
3213 if (!rsp->virt)
3214 goto fdmi_cmd_free_rsp;
3215
3216 INIT_LIST_HEAD(&rq->list);
3217 INIT_LIST_HEAD(&rsp->list);
3218
3219 /* mbuf buffers are 1K in length - aka LPFC_BPL_SIZE */
3220 memset(rq->virt, 0, LPFC_BPL_SIZE);
3221 rsp_size = LPFC_BPL_SIZE;
3222
3223 /* FDMI request */
3224 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3225 "0218 FDMI Request x%x mask x%x Data: x%x x%lx x%x\n",
3226 cmdcode, new_mask, vport->fdmi_port_mask,
3227 vport->fc_flag, vport->port_state);
3228
3229 CtReq = (struct lpfc_sli_ct_request *)rq->virt;
3230
3231 /* First populate the CT_IU preamble */
3232 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
3233 CtReq->RevisionId.bits.InId = 0;
3234
3235 CtReq->FsType = SLI_CT_MANAGEMENT_SERVICE;
3236 CtReq->FsSubType = SLI_CT_FDMI_Subtypes;
3237
3238 CtReq->CommandResponse.bits.CmdRsp = cpu_to_be16(cmdcode);
3239
3240 size = 0;
3241
3242 /* Next fill in the specific FDMI cmd information */
3243 switch (cmdcode) {
3244 case SLI_MGMT_RHAT:
3245 case SLI_MGMT_RHBA:
3246 rh = (struct lpfc_fdmi_reg_hba *)&CtReq->un;
3247 /* HBA Identifier */
3248 memcpy(&rh->hi.PortName, &phba->pport->fc_sparam.portName,
3249 sizeof(struct lpfc_name));
3250 size += sizeof(struct lpfc_fdmi_hba_ident);
3251
3252 if (cmdcode == SLI_MGMT_RHBA) {
3253 /* Registered Port List */
3254 /* One entry (port) per adapter */
3255 rh->rpl.EntryCnt = cpu_to_be32(1);
3256 memcpy(&rh->rpl.pe.PortName,
3257 &phba->pport->fc_sparam.portName,
3258 sizeof(struct lpfc_name));
3259 size += sizeof(struct lpfc_fdmi_reg_port_list);
3260 }
3261
3262 ab = (struct lpfc_fdmi_attr_block *)((uint8_t *)rh + size);
3263 ab->EntryCnt = 0;
3264 size += FOURBYTES; /* add length of EntryCnt field */
3265
3266 bit_pos = 0;
3267 if (new_mask)
3268 mask = new_mask;
3269 else
3270 mask = vport->fdmi_hba_mask;
3271
3272 /* Mask will dictate what attributes to build in the request */
3273 while (mask) {
3274 if (mask & 0x1) {
3275 func = lpfc_fdmi_hba_action[bit_pos];
3276 addsz = func(vport, ((uint8_t *)rh + size));
3277 if (addsz) {
3278 ab->EntryCnt++;
3279 size += addsz;
3280 }
3281 /* check if another attribute fits */
3282 if ((size + FDMI_MAX_ATTRLEN) >
3283 (LPFC_BPL_SIZE - LPFC_CT_PREAMBLE))
3284 goto hba_out;
3285 }
3286 mask = mask >> 1;
3287 bit_pos++;
3288 }
3289 hba_out:
3290 ab->EntryCnt = cpu_to_be32(ab->EntryCnt);
3291 /* Total size */
3292 size += GID_REQUEST_SZ - 4;
3293 break;
3294
3295 case SLI_MGMT_RPRT:
3296 if (vport->port_type != LPFC_PHYSICAL_PORT) {
3297 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
3298 if (!ndlp)
3299 return 0;
3300 }
3301 fallthrough;
3302 case SLI_MGMT_RPA:
3303 /* Store base ptr right after preamble */
3304 base = (struct lpfc_fdmi_reg_portattr *)&CtReq->un;
3305
3306 if (cmdcode == SLI_MGMT_RPRT) {
3307 rh = (struct lpfc_fdmi_reg_hba *)base;
3308 /* HBA Identifier */
3309 memcpy(&rh->hi.PortName,
3310 &phba->pport->fc_sparam.portName,
3311 sizeof(struct lpfc_name));
3312 pab = (struct lpfc_fdmi_reg_portattr *)
3313 ((uint8_t *)base + sizeof(struct lpfc_name));
3314 size += sizeof(struct lpfc_name);
3315 } else {
3316 pab = base;
3317 }
3318
3319 memcpy((uint8_t *)&pab->PortName,
3320 (uint8_t *)&vport->fc_sparam.portName,
3321 sizeof(struct lpfc_name));
3322 pab->ab.EntryCnt = 0;
3323 /* add length of name and EntryCnt field */
3324 size += sizeof(struct lpfc_name) + FOURBYTES;
3325
3326 bit_pos = 0;
3327 if (new_mask)
3328 mask = new_mask;
3329 else
3330 mask = vport->fdmi_port_mask;
3331
3332 /* Mask will dictate what attributes to build in the request */
3333 while (mask) {
3334 if (mask & 0x1) {
3335 func = lpfc_fdmi_port_action[bit_pos];
3336 addsz = func(vport, ((uint8_t *)base + size));
3337 if (addsz) {
3338 pab->ab.EntryCnt++;
3339 size += addsz;
3340 }
3341 /* check if another attribute fits */
3342 if ((size + FDMI_MAX_ATTRLEN) >
3343 (LPFC_BPL_SIZE - LPFC_CT_PREAMBLE))
3344 goto port_out;
3345 }
3346 mask = mask >> 1;
3347 bit_pos++;
3348 }
3349 port_out:
3350 pab->ab.EntryCnt = cpu_to_be32(pab->ab.EntryCnt);
3351 size += GID_REQUEST_SZ - 4;
3352 break;
3353
3354 case SLI_MGMT_GHAT:
3355 case SLI_MGMT_GRPL:
3356 rsp_size = FC_MAX_NS_RSP;
3357 fallthrough;
3358 case SLI_MGMT_DHBA:
3359 case SLI_MGMT_DHAT:
3360 pe = (struct lpfc_fdmi_port_entry *)&CtReq->un;
3361 memcpy((uint8_t *)&pe->PortName,
3362 (uint8_t *)&vport->fc_sparam.portName,
3363 sizeof(struct lpfc_name));
3364 size = GID_REQUEST_SZ - 4 + sizeof(struct lpfc_name);
3365 break;
3366
3367 case SLI_MGMT_GPAT:
3368 case SLI_MGMT_GPAS:
3369 rsp_size = FC_MAX_NS_RSP;
3370 fallthrough;
3371 case SLI_MGMT_DPRT:
3372 if (vport->port_type != LPFC_PHYSICAL_PORT) {
3373 ndlp = lpfc_findnode_did(phba->pport, FDMI_DID);
3374 if (!ndlp)
3375 return 0;
3376 }
3377 fallthrough;
3378 case SLI_MGMT_DPA:
3379 pe = (struct lpfc_fdmi_port_entry *)&CtReq->un;
3380 memcpy((uint8_t *)&pe->PortName,
3381 (uint8_t *)&vport->fc_sparam.portName,
3382 sizeof(struct lpfc_name));
3383 size = GID_REQUEST_SZ - 4 + sizeof(struct lpfc_name);
3384 break;
3385 case SLI_MGMT_GRHL:
3386 size = GID_REQUEST_SZ - 4;
3387 break;
3388 default:
3389 lpfc_printf_vlog(vport, KERN_WARNING, LOG_DISCOVERY,
3390 "0298 FDMI cmdcode x%x not supported\n",
3391 cmdcode);
3392 goto fdmi_cmd_free_rspvirt;
3393 }
3394 CtReq->CommandResponse.bits.Size = cpu_to_be16(rsp_size);
3395
3396 bde = (struct ulp_bde64_le *)rsp->virt;
3397 bde->addr_high = cpu_to_le32(putPaddrHigh(rq->phys));
3398 bde->addr_low = cpu_to_le32(putPaddrLow(rq->phys));
3399 bde->type_size = cpu_to_le32(ULP_BDE64_TYPE_BDE_64 <<
3400 ULP_BDE64_TYPE_SHIFT);
3401 bde->type_size |= cpu_to_le32(size);
3402
3403 /*
3404 * The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
3405 * to hold ndlp reference for the corresponding callback function.
3406 */
3407 if (!lpfc_ct_cmd(vport, rq, rsp, ndlp, cmpl, rsp_size, 0))
3408 return 0;
3409
3410 fdmi_cmd_free_rspvirt:
3411 lpfc_mbuf_free(phba, rsp->virt, rsp->phys);
3412 fdmi_cmd_free_rsp:
3413 kfree(rsp);
3414 fdmi_cmd_free_rqvirt:
3415 lpfc_mbuf_free(phba, rq->virt, rq->phys);
3416 fdmi_cmd_free_rq:
3417 kfree(rq);
3418 fdmi_cmd_exit:
3419 /* Issue FDMI request failed */
3420 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3421 "0244 Issue FDMI request failed Data: x%x\n",
3422 cmdcode);
3423 return 1;
3424 }
3425
3426 /**
3427 * lpfc_delayed_disc_tmo - Timeout handler for delayed discovery timer.
3428 * @t: Context object of the timer.
3429 *
3430 * This function set the WORKER_DELAYED_DISC_TMO flag and wake up
3431 * the worker thread.
3432 **/
3433 void
lpfc_delayed_disc_tmo(struct timer_list * t)3434 lpfc_delayed_disc_tmo(struct timer_list *t)
3435 {
3436 struct lpfc_vport *vport = from_timer(vport, t, delayed_disc_tmo);
3437 struct lpfc_hba *phba = vport->phba;
3438 uint32_t tmo_posted;
3439 unsigned long iflag;
3440
3441 spin_lock_irqsave(&vport->work_port_lock, iflag);
3442 tmo_posted = vport->work_port_events & WORKER_DELAYED_DISC_TMO;
3443 if (!tmo_posted)
3444 vport->work_port_events |= WORKER_DELAYED_DISC_TMO;
3445 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
3446
3447 if (!tmo_posted)
3448 lpfc_worker_wake_up(phba);
3449 return;
3450 }
3451
3452 /**
3453 * lpfc_delayed_disc_timeout_handler - Function called by worker thread to
3454 * handle delayed discovery.
3455 * @vport: pointer to a host virtual N_Port data structure.
3456 *
3457 * This function start nport discovery of the vport.
3458 **/
3459 void
lpfc_delayed_disc_timeout_handler(struct lpfc_vport * vport)3460 lpfc_delayed_disc_timeout_handler(struct lpfc_vport *vport)
3461 {
3462 if (!test_and_clear_bit(FC_DISC_DELAYED, &vport->fc_flag))
3463 return;
3464
3465 lpfc_do_scr_ns_plogi(vport->phba, vport);
3466 }
3467
3468 void
lpfc_decode_firmware_rev(struct lpfc_hba * phba,char * fwrevision,int flag)3469 lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag)
3470 {
3471 struct lpfc_sli *psli = &phba->sli;
3472 lpfc_vpd_t *vp = &phba->vpd;
3473 uint32_t b1, b2, b3, b4, i, rev;
3474 char c;
3475 uint32_t *ptr, str[4];
3476 uint8_t *fwname;
3477
3478 if (phba->sli_rev == LPFC_SLI_REV4)
3479 snprintf(fwrevision, FW_REV_STR_SIZE, "%s", vp->rev.opFwName);
3480 else if (vp->rev.rBit) {
3481 if (psli->sli_flag & LPFC_SLI_ACTIVE)
3482 rev = vp->rev.sli2FwRev;
3483 else
3484 rev = vp->rev.sli1FwRev;
3485
3486 b1 = (rev & 0x0000f000) >> 12;
3487 b2 = (rev & 0x00000f00) >> 8;
3488 b3 = (rev & 0x000000c0) >> 6;
3489 b4 = (rev & 0x00000030) >> 4;
3490
3491 switch (b4) {
3492 case 0:
3493 c = 'N';
3494 break;
3495 case 1:
3496 c = 'A';
3497 break;
3498 case 2:
3499 c = 'B';
3500 break;
3501 case 3:
3502 c = 'X';
3503 break;
3504 default:
3505 c = 0;
3506 break;
3507 }
3508 b4 = (rev & 0x0000000f);
3509
3510 if (psli->sli_flag & LPFC_SLI_ACTIVE)
3511 fwname = vp->rev.sli2FwName;
3512 else
3513 fwname = vp->rev.sli1FwName;
3514
3515 for (i = 0; i < 16; i++)
3516 if (fwname[i] == 0x20)
3517 fwname[i] = 0;
3518
3519 ptr = (uint32_t*)fwname;
3520
3521 for (i = 0; i < 3; i++)
3522 str[i] = be32_to_cpu(*ptr++);
3523
3524 if (c == 0) {
3525 if (flag)
3526 sprintf(fwrevision, "%d.%d%d (%s)",
3527 b1, b2, b3, (char *)str);
3528 else
3529 sprintf(fwrevision, "%d.%d%d", b1,
3530 b2, b3);
3531 } else {
3532 if (flag)
3533 sprintf(fwrevision, "%d.%d%d%c%d (%s)",
3534 b1, b2, b3, c,
3535 b4, (char *)str);
3536 else
3537 sprintf(fwrevision, "%d.%d%d%c%d",
3538 b1, b2, b3, c, b4);
3539 }
3540 } else {
3541 rev = vp->rev.smFwRev;
3542
3543 b1 = (rev & 0xff000000) >> 24;
3544 b2 = (rev & 0x00f00000) >> 20;
3545 b3 = (rev & 0x000f0000) >> 16;
3546 c = (rev & 0x0000ff00) >> 8;
3547 b4 = (rev & 0x000000ff);
3548
3549 sprintf(fwrevision, "%d.%d%d%c%d", b1, b2, b3, c, b4);
3550 }
3551 return;
3552 }
3553
3554 static void
lpfc_cmpl_ct_cmd_vmid(struct lpfc_hba * phba,struct lpfc_iocbq * cmdiocb,struct lpfc_iocbq * rspiocb)3555 lpfc_cmpl_ct_cmd_vmid(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3556 struct lpfc_iocbq *rspiocb)
3557 {
3558 struct lpfc_vport *vport = cmdiocb->vport;
3559 struct lpfc_dmabuf *inp = cmdiocb->cmd_dmabuf;
3560 struct lpfc_dmabuf *outp = cmdiocb->rsp_dmabuf;
3561 struct lpfc_sli_ct_request *ctcmd = inp->virt;
3562 struct lpfc_sli_ct_request *ctrsp = outp->virt;
3563 __be16 rsp = ctrsp->CommandResponse.bits.CmdRsp;
3564 struct app_id_object *app;
3565 struct lpfc_nodelist *ndlp = cmdiocb->ndlp;
3566 u32 cmd, hash, bucket;
3567 struct lpfc_vmid *vmp, *cur;
3568 u8 *data = outp->virt;
3569 int i;
3570
3571 cmd = be16_to_cpu(ctcmd->CommandResponse.bits.CmdRsp);
3572 if (cmd == SLI_CTAS_DALLAPP_ID)
3573 lpfc_ct_free_iocb(phba, cmdiocb);
3574
3575 if (lpfc_els_chk_latt(vport) || get_job_ulpstatus(phba, rspiocb)) {
3576 if (cmd != SLI_CTAS_DALLAPP_ID)
3577 goto free_res;
3578 }
3579 /* Check for a CT LS_RJT response */
3580 if (be16_to_cpu(rsp) == SLI_CT_RESPONSE_FS_RJT) {
3581 if (cmd != SLI_CTAS_DALLAPP_ID)
3582 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3583 "3306 VMID FS_RJT Data: x%x x%x x%x\n",
3584 cmd, ctrsp->ReasonCode,
3585 ctrsp->Explanation);
3586 if ((cmd != SLI_CTAS_DALLAPP_ID) ||
3587 (ctrsp->ReasonCode != SLI_CT_UNABLE_TO_PERFORM_REQ) ||
3588 (ctrsp->Explanation != SLI_CT_APP_ID_NOT_AVAILABLE)) {
3589 /* If DALLAPP_ID failed retry later */
3590 if (cmd == SLI_CTAS_DALLAPP_ID)
3591 set_bit(FC_DEREGISTER_ALL_APP_ID,
3592 &vport->load_flag);
3593 goto free_res;
3594 }
3595 }
3596
3597 switch (cmd) {
3598 case SLI_CTAS_RAPP_IDENT:
3599 app = (struct app_id_object *)(RAPP_IDENT_OFFSET + data);
3600 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3601 "6712 RAPP_IDENT app id %d port id x%x id "
3602 "len %d\n", be32_to_cpu(app->app_id),
3603 be32_to_cpu(app->port_id),
3604 app->obj.entity_id_len);
3605
3606 if (app->obj.entity_id_len == 0 || app->port_id == 0)
3607 goto free_res;
3608
3609 hash = lpfc_vmid_hash_fn(app->obj.entity_id,
3610 app->obj.entity_id_len);
3611 vmp = lpfc_get_vmid_from_hashtable(vport, hash,
3612 app->obj.entity_id);
3613 if (vmp) {
3614 write_lock(&vport->vmid_lock);
3615 vmp->un.app_id = be32_to_cpu(app->app_id);
3616 vmp->flag |= LPFC_VMID_REGISTERED;
3617 vmp->flag &= ~LPFC_VMID_REQ_REGISTER;
3618 write_unlock(&vport->vmid_lock);
3619 /* Set IN USE flag */
3620 vport->vmid_flag |= LPFC_VMID_IN_USE;
3621 } else {
3622 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3623 "6901 No entry found %s hash %d\n",
3624 app->obj.entity_id, hash);
3625 }
3626 break;
3627 case SLI_CTAS_DAPP_IDENT:
3628 app = (struct app_id_object *)(DAPP_IDENT_OFFSET + data);
3629 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3630 "6713 DAPP_IDENT app id %d port id x%x\n",
3631 be32_to_cpu(app->app_id),
3632 be32_to_cpu(app->port_id));
3633 break;
3634 case SLI_CTAS_DALLAPP_ID:
3635 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3636 "8856 Deregistered all app ids\n");
3637 read_lock(&vport->vmid_lock);
3638 for (i = 0; i < phba->cfg_max_vmid; i++) {
3639 vmp = &vport->vmid[i];
3640 if (vmp->flag != LPFC_VMID_SLOT_FREE)
3641 memset(vmp, 0, sizeof(struct lpfc_vmid));
3642 }
3643 read_unlock(&vport->vmid_lock);
3644 /* for all elements in the hash table */
3645 if (!hash_empty(vport->hash_table))
3646 hash_for_each(vport->hash_table, bucket, cur, hnode)
3647 hash_del(&cur->hnode);
3648 set_bit(FC_ALLOW_VMID, &vport->load_flag);
3649 break;
3650 default:
3651 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3652 "8857 Invalid command code\n");
3653 }
3654 free_res:
3655 lpfc_ct_free_iocb(phba, cmdiocb);
3656 lpfc_nlp_put(ndlp);
3657 }
3658
3659 /**
3660 * lpfc_vmid_cmd - Build and send a FDMI cmd to the specified NPort
3661 * @vport: pointer to a host virtual N_Port data structure.
3662 * @cmdcode: application server command code to send
3663 * @vmid: pointer to vmid info structure
3664 *
3665 * Builds and sends a FDMI command using the CT subsystem.
3666 */
3667 int
lpfc_vmid_cmd(struct lpfc_vport * vport,int cmdcode,struct lpfc_vmid * vmid)3668 lpfc_vmid_cmd(struct lpfc_vport *vport,
3669 int cmdcode, struct lpfc_vmid *vmid)
3670 {
3671 struct lpfc_hba *phba = vport->phba;
3672 struct lpfc_dmabuf *mp, *bmp;
3673 struct lpfc_sli_ct_request *ctreq;
3674 struct ulp_bde64 *bpl;
3675 u32 size;
3676 u32 rsp_size;
3677 u8 *data;
3678 struct lpfc_vmid_rapp_ident_list *rap;
3679 struct lpfc_vmid_dapp_ident_list *dap;
3680 u8 retry = 0;
3681 struct lpfc_nodelist *ndlp;
3682
3683 void (*cmpl)(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
3684 struct lpfc_iocbq *rspiocb);
3685
3686 ndlp = lpfc_findnode_did(vport, FDMI_DID);
3687 if (!ndlp || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE)
3688 return 0;
3689
3690 cmpl = lpfc_cmpl_ct_cmd_vmid;
3691
3692 /* fill in BDEs for command */
3693 /* Allocate buffer for command payload */
3694 mp = kmalloc(sizeof(*mp), GFP_KERNEL);
3695 if (!mp)
3696 goto vmid_free_mp_exit;
3697
3698 mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
3699 if (!mp->virt)
3700 goto vmid_free_mp_virt_exit;
3701
3702 /* Allocate buffer for Buffer ptr list */
3703 bmp = kmalloc(sizeof(*bmp), GFP_KERNEL);
3704 if (!bmp)
3705 goto vmid_free_bmp_exit;
3706
3707 bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
3708 if (!bmp->virt)
3709 goto vmid_free_bmp_virt_exit;
3710
3711 INIT_LIST_HEAD(&mp->list);
3712 INIT_LIST_HEAD(&bmp->list);
3713
3714 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3715 "3275 VMID Request Data: x%lx x%x x%x\n",
3716 vport->fc_flag, vport->port_state, cmdcode);
3717 ctreq = (struct lpfc_sli_ct_request *)mp->virt;
3718 data = mp->virt;
3719 /* First populate the CT_IU preamble */
3720 memset(data, 0, LPFC_BPL_SIZE);
3721 ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
3722 ctreq->RevisionId.bits.InId = 0;
3723
3724 ctreq->FsType = SLI_CT_MANAGEMENT_SERVICE;
3725 ctreq->FsSubType = SLI_CT_APP_SEV_Subtypes;
3726
3727 ctreq->CommandResponse.bits.CmdRsp = cpu_to_be16(cmdcode);
3728 rsp_size = LPFC_BPL_SIZE;
3729 size = 0;
3730
3731 switch (cmdcode) {
3732 case SLI_CTAS_RAPP_IDENT:
3733 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3734 "1329 RAPP_IDENT for %s\n", vmid->host_vmid);
3735 ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3736 rap = (struct lpfc_vmid_rapp_ident_list *)
3737 (DAPP_IDENT_OFFSET + data);
3738 rap->no_of_objects = cpu_to_be32(1);
3739 rap->obj[0].entity_id_len = vmid->vmid_len;
3740 memcpy(rap->obj[0].entity_id, vmid->host_vmid, vmid->vmid_len);
3741 size = RAPP_IDENT_OFFSET +
3742 struct_size(rap, obj, be32_to_cpu(rap->no_of_objects));
3743 retry = 1;
3744 break;
3745
3746 case SLI_CTAS_GALLAPPIA_ID:
3747 ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3748 size = GALLAPPIA_ID_SIZE;
3749 break;
3750
3751 case SLI_CTAS_DAPP_IDENT:
3752 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3753 "1469 DAPP_IDENT for %s\n", vmid->host_vmid);
3754 ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3755 dap = (struct lpfc_vmid_dapp_ident_list *)
3756 (DAPP_IDENT_OFFSET + data);
3757 dap->no_of_objects = cpu_to_be32(1);
3758 dap->obj[0].entity_id_len = vmid->vmid_len;
3759 memcpy(dap->obj[0].entity_id, vmid->host_vmid, vmid->vmid_len);
3760 size = DAPP_IDENT_OFFSET +
3761 struct_size(dap, obj, be32_to_cpu(dap->no_of_objects));
3762 write_lock(&vport->vmid_lock);
3763 vmid->flag &= ~LPFC_VMID_REGISTERED;
3764 write_unlock(&vport->vmid_lock);
3765 retry = 1;
3766 break;
3767
3768 case SLI_CTAS_DALLAPP_ID:
3769 ctreq->un.PortID = cpu_to_be32(vport->fc_myDID);
3770 size = DALLAPP_ID_SIZE;
3771 break;
3772
3773 default:
3774 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3775 "7062 VMID cmdcode x%x not supported\n",
3776 cmdcode);
3777 goto vmid_free_all_mem;
3778 }
3779
3780 ctreq->CommandResponse.bits.Size = cpu_to_be16(rsp_size);
3781
3782 bpl = (struct ulp_bde64 *)bmp->virt;
3783 bpl->addrHigh = putPaddrHigh(mp->phys);
3784 bpl->addrLow = putPaddrLow(mp->phys);
3785 bpl->tus.f.bdeFlags = 0;
3786 bpl->tus.f.bdeSize = size;
3787
3788 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
3789 * to hold ndlp reference for the corresponding callback function.
3790 */
3791 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry))
3792 return 0;
3793
3794 vmid_free_all_mem:
3795 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
3796 vmid_free_bmp_virt_exit:
3797 kfree(bmp);
3798 vmid_free_bmp_exit:
3799 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3800 vmid_free_mp_virt_exit:
3801 kfree(mp);
3802 vmid_free_mp_exit:
3803
3804 /* Issue CT request failed */
3805 lpfc_printf_vlog(vport, KERN_DEBUG, LOG_DISCOVERY,
3806 "3276 VMID CT request failed Data: x%x\n", cmdcode);
3807 return -EIO;
3808 }
3809