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