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