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