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