1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2016 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
8 * This program is free software; you can redistribute it and/or *
9 * modify it under the terms of version 2 of the GNU General *
10 * Public License as published by the Free Software Foundation. *
11 * This program is distributed in the hope that it will be useful. *
12 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
13 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
14 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
15 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
16 * TO BE LEGALLY INVALID. See the GNU General Public License for *
17 * more details, a copy of which can be found in the file COPYING *
18 * included with this package. *
19 *******************************************************************/
22 * Fibre Channel SCSI LAN Device Driver CT support: FC Generic Services FC-GS
25 #include <linux/blkdev.h>
26 #include <linux/pci.h>
27 #include <linux/interrupt.h>
28 #include <linux/slab.h>
29 #include <linux/utsname.h>
31 #include <scsi/scsi.h>
32 #include <scsi/scsi_device.h>
33 #include <scsi/scsi_host.h>
34 #include <scsi/scsi_transport_fc.h>
35 #include <scsi/fc/fc_fs.h>
40 #include "lpfc_sli4.h"
42 #include "lpfc_disc.h"
43 #include "lpfc_scsi.h"
45 #include "lpfc_logmsg.h"
46 #include "lpfc_crtn.h"
47 #include "lpfc_version.h"
48 #include "lpfc_vport.h"
49 #include "lpfc_debugfs.h"
51 /* FDMI Port Speed definitions - FC-GS-7 */
52 #define HBA_PORTSPEED_1GFC 0x00000001 /* 1G FC */
53 #define HBA_PORTSPEED_2GFC 0x00000002 /* 2G FC */
54 #define HBA_PORTSPEED_4GFC 0x00000008 /* 4G FC */
55 #define HBA_PORTSPEED_10GFC 0x00000004 /* 10G FC */
56 #define HBA_PORTSPEED_8GFC 0x00000010 /* 8G FC */
57 #define HBA_PORTSPEED_16GFC 0x00000020 /* 16G FC */
58 #define HBA_PORTSPEED_32GFC 0x00000040 /* 32G FC */
59 #define HBA_PORTSPEED_20GFC 0x00000080 /* 20G FC */
60 #define HBA_PORTSPEED_40GFC 0x00000100 /* 40G FC */
61 #define HBA_PORTSPEED_128GFC 0x00000200 /* 128G FC */
62 #define HBA_PORTSPEED_64GFC 0x00000400 /* 64G FC */
63 #define HBA_PORTSPEED_256GFC 0x00000800 /* 256G FC */
64 #define HBA_PORTSPEED_UNKNOWN 0x00008000 /* Unknown */
65 #define HBA_PORTSPEED_10GE 0x00010000 /* 10G E */
66 #define HBA_PORTSPEED_40GE 0x00020000 /* 40G E */
67 #define HBA_PORTSPEED_100GE 0x00040000 /* 100G E */
68 #define HBA_PORTSPEED_25GE 0x00080000 /* 25G E */
69 #define HBA_PORTSPEED_50GE 0x00100000 /* 50G E */
70 #define HBA_PORTSPEED_400GE 0x00200000 /* 400G E */
75 static char *lpfc_release_version = LPFC_DRIVER_VERSION;
78 lpfc_ct_ignore_hbq_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
79 struct lpfc_dmabuf *mp, uint32_t size)
82 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
83 "0146 Ignoring unsolicited CT No HBQ "
85 piocbq->iocb.ulpStatus);
87 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
88 "0145 Ignoring unsolicted CT HBQ Size:%d "
90 size, piocbq->iocb.ulpStatus);
94 lpfc_ct_unsol_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
95 struct lpfc_dmabuf *mp, uint32_t size)
97 lpfc_ct_ignore_hbq_buffer(phba, piocbq, mp, size);
101 lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
102 struct lpfc_iocbq *piocbq)
104 struct lpfc_dmabuf *mp = NULL;
105 IOCB_t *icmd = &piocbq->iocb;
107 struct lpfc_iocbq *iocbq;
110 struct list_head head;
111 struct lpfc_dmabuf *bdeBuf;
113 if (lpfc_bsg_ct_unsol_event(phba, pring, piocbq) == 0)
116 if (unlikely(icmd->ulpStatus == IOSTAT_NEED_BUFFER)) {
117 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
118 } else if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
119 ((icmd->un.ulpWord[4] & IOERR_PARAM_MASK) ==
120 IOERR_RCV_BUFFER_WAITING)) {
121 /* Not enough posted buffers; Try posting more buffers */
122 phba->fc_stat.NoRcvBuf++;
123 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
124 lpfc_post_buffer(phba, pring, 2);
128 /* If there are no BDEs associated with this IOCB,
129 * there is nothing to do.
131 if (icmd->ulpBdeCount == 0)
134 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
135 INIT_LIST_HEAD(&head);
136 list_add_tail(&head, &piocbq->list);
137 list_for_each_entry(iocbq, &head, list) {
139 if (icmd->ulpBdeCount == 0)
141 bdeBuf = iocbq->context2;
142 iocbq->context2 = NULL;
143 size = icmd->un.cont64[0].tus.f.bdeSize;
144 lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf, size);
145 lpfc_in_buf_free(phba, bdeBuf);
146 if (icmd->ulpBdeCount == 2) {
147 bdeBuf = iocbq->context3;
148 iocbq->context3 = NULL;
149 size = icmd->unsli3.rcvsli3.bde2.tus.f.bdeSize;
150 lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf,
152 lpfc_in_buf_free(phba, bdeBuf);
157 INIT_LIST_HEAD(&head);
158 list_add_tail(&head, &piocbq->list);
159 list_for_each_entry(iocbq, &head, list) {
161 if (icmd->ulpBdeCount == 0)
162 lpfc_ct_unsol_buffer(phba, iocbq, NULL, 0);
163 for (i = 0; i < icmd->ulpBdeCount; i++) {
164 paddr = getPaddr(icmd->un.cont64[i].addrHigh,
165 icmd->un.cont64[i].addrLow);
166 mp = lpfc_sli_ringpostbuf_get(phba, pring,
168 size = icmd->un.cont64[i].tus.f.bdeSize;
169 lpfc_ct_unsol_buffer(phba, iocbq, mp, size);
170 lpfc_in_buf_free(phba, mp);
172 lpfc_post_buffer(phba, pring, i);
179 * lpfc_ct_handle_unsol_abort - ct upper level protocol abort handler
180 * @phba: Pointer to HBA context object.
181 * @dmabuf: pointer to a dmabuf that describes the FC sequence
183 * This function serves as the upper level protocol abort handler for CT
186 * Return 1 if abort has been handled, 0 otherwise.
189 lpfc_ct_handle_unsol_abort(struct lpfc_hba *phba, struct hbq_dmabuf *dmabuf)
193 /* CT upper level goes through BSG */
194 handled = lpfc_bsg_ct_unsol_abort(phba, dmabuf);
200 lpfc_free_ct_rsp(struct lpfc_hba *phba, struct lpfc_dmabuf *mlist)
202 struct lpfc_dmabuf *mlast, *next_mlast;
204 list_for_each_entry_safe(mlast, next_mlast, &mlist->list, list) {
205 lpfc_mbuf_free(phba, mlast->virt, mlast->phys);
206 list_del(&mlast->list);
209 lpfc_mbuf_free(phba, mlist->virt, mlist->phys);
214 static struct lpfc_dmabuf *
215 lpfc_alloc_ct_rsp(struct lpfc_hba *phba, int cmdcode, struct ulp_bde64 *bpl,
216 uint32_t size, int *entries)
218 struct lpfc_dmabuf *mlist = NULL;
219 struct lpfc_dmabuf *mp;
222 /* We get chunks of FCELSSIZE */
223 cnt = size > FCELSSIZE ? FCELSSIZE: size;
226 /* Allocate buffer for rsp payload */
227 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
230 lpfc_free_ct_rsp(phba, mlist);
234 INIT_LIST_HEAD(&mp->list);
236 if (cmdcode == be16_to_cpu(SLI_CTNS_GID_FT) ||
237 cmdcode == be16_to_cpu(SLI_CTNS_GFF_ID))
238 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
240 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys));
245 lpfc_free_ct_rsp(phba, mlist);
249 /* Queue it to a linked list */
253 list_add_tail(&mp->list, &mlist->list);
255 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
256 /* build buffer ptr list for IOCB */
257 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
258 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
259 bpl->tus.f.bdeSize = (uint16_t) cnt;
260 bpl->tus.w = le32_to_cpu(bpl->tus.w);
272 lpfc_ct_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *ctiocb)
274 struct lpfc_dmabuf *buf_ptr;
276 if (ctiocb->context_un.ndlp) {
277 lpfc_nlp_put(ctiocb->context_un.ndlp);
278 ctiocb->context_un.ndlp = NULL;
280 if (ctiocb->context1) {
281 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context1;
282 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
284 ctiocb->context1 = NULL;
286 if (ctiocb->context2) {
287 lpfc_free_ct_rsp(phba, (struct lpfc_dmabuf *) ctiocb->context2);
288 ctiocb->context2 = NULL;
291 if (ctiocb->context3) {
292 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context3;
293 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
295 ctiocb->context3 = NULL;
297 lpfc_sli_release_iocbq(phba, ctiocb);
302 * lpfc_gen_req - Build and issue a GEN_REQUEST command to the SLI Layer
303 * @vport: pointer to a host virtual N_Port data structure.
304 * @bmp: Pointer to BPL for SLI command
305 * @inp: Pointer to data buffer for response data.
306 * @outp: Pointer to data buffer that hold the CT command.
307 * @cmpl: completion routine to call when command completes
308 * @ndlp: Destination NPort nodelist entry
310 * This function as the final part for issuing a CT command.
313 lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp,
314 struct lpfc_dmabuf *inp, struct lpfc_dmabuf *outp,
315 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
316 struct lpfc_iocbq *),
317 struct lpfc_nodelist *ndlp, uint32_t usr_flg, uint32_t num_entry,
318 uint32_t tmo, uint8_t retry)
320 struct lpfc_hba *phba = vport->phba;
322 struct lpfc_iocbq *geniocb;
325 /* Allocate buffer for command iocb */
326 geniocb = lpfc_sli_get_iocbq(phba);
331 icmd = &geniocb->iocb;
332 icmd->un.genreq64.bdl.ulpIoTag32 = 0;
333 icmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
334 icmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys);
335 icmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
336 icmd->un.genreq64.bdl.bdeSize = (num_entry * sizeof(struct ulp_bde64));
339 geniocb->context3 = NULL;
341 geniocb->context3 = (uint8_t *) bmp;
343 /* Save for completion so we can release these resources */
344 geniocb->context1 = (uint8_t *) inp;
345 geniocb->context2 = (uint8_t *) outp;
346 geniocb->context_un.ndlp = lpfc_nlp_get(ndlp);
348 /* Fill in payload, bp points to frame payload */
349 icmd->ulpCommand = CMD_GEN_REQUEST64_CR;
351 /* Fill in rest of iocb */
352 icmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
353 icmd->un.genreq64.w5.hcsw.Dfctl = 0;
354 icmd->un.genreq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
355 icmd->un.genreq64.w5.hcsw.Type = FC_TYPE_CT;
358 /* FC spec states we need 3 * ratov for CT requests */
359 tmo = (3 * phba->fc_ratov);
361 icmd->ulpTimeout = tmo;
362 icmd->ulpBdeCount = 1;
364 icmd->ulpClass = CLASS3;
365 icmd->ulpContext = ndlp->nlp_rpi;
366 if (phba->sli_rev == LPFC_SLI_REV4)
367 icmd->ulpContext = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
369 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
370 /* For GEN_REQUEST64_CR, use the RPI */
375 /* Issue GEN REQ IOCB for NPORT <did> */
376 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
377 "0119 Issue GEN REQ IOCB to NPORT x%x "
379 ndlp->nlp_DID, icmd->ulpIoTag,
381 geniocb->iocb_cmpl = cmpl;
382 geniocb->drvrTimeout = icmd->ulpTimeout + LPFC_DRVR_TIMEOUT;
383 geniocb->vport = vport;
384 geniocb->retry = retry;
385 rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, geniocb, 0);
387 if (rc == IOCB_ERROR) {
388 lpfc_sli_release_iocbq(phba, geniocb);
396 * lpfc_ct_cmd - Build and issue a CT command
397 * @vport: pointer to a host virtual N_Port data structure.
398 * @inmp: Pointer to data buffer for response data.
399 * @bmp: Pointer to BPL for SLI command
400 * @ndlp: Destination NPort nodelist entry
401 * @cmpl: completion routine to call when command completes
403 * This function is called for issuing a CT command.
406 lpfc_ct_cmd(struct lpfc_vport *vport, struct lpfc_dmabuf *inmp,
407 struct lpfc_dmabuf *bmp, struct lpfc_nodelist *ndlp,
408 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
409 struct lpfc_iocbq *),
410 uint32_t rsp_size, uint8_t retry)
412 struct lpfc_hba *phba = vport->phba;
413 struct ulp_bde64 *bpl = (struct ulp_bde64 *) bmp->virt;
414 struct lpfc_dmabuf *outmp;
416 int cmdcode = ((struct lpfc_sli_ct_request *) inmp->virt)->
417 CommandResponse.bits.CmdRsp;
419 bpl++; /* Skip past ct request */
421 /* Put buffer(s) for ct rsp in bpl */
422 outmp = lpfc_alloc_ct_rsp(phba, cmdcode, bpl, rsp_size, &cnt);
426 * Form the CT IOCB. The total number of BDEs in this IOCB
427 * is the single command plus response count from
431 status = lpfc_gen_req(vport, bmp, inmp, outmp, cmpl, ndlp, 0,
434 lpfc_free_ct_rsp(phba, outmp);
441 lpfc_find_vport_by_did(struct lpfc_hba *phba, uint32_t did) {
442 struct lpfc_vport *vport_curr;
445 spin_lock_irqsave(&phba->hbalock, flags);
446 list_for_each_entry(vport_curr, &phba->port_list, listentry) {
447 if ((vport_curr->fc_myDID) && (vport_curr->fc_myDID == did)) {
448 spin_unlock_irqrestore(&phba->hbalock, flags);
452 spin_unlock_irqrestore(&phba->hbalock, flags);
457 lpfc_ns_rsp(struct lpfc_vport *vport, struct lpfc_dmabuf *mp, uint32_t Size)
459 struct lpfc_hba *phba = vport->phba;
460 struct lpfc_sli_ct_request *Response =
461 (struct lpfc_sli_ct_request *) mp->virt;
462 struct lpfc_nodelist *ndlp = NULL;
463 struct lpfc_dmabuf *mlast, *next_mp;
464 uint32_t *ctptr = (uint32_t *) & Response->un.gid.PortType;
465 uint32_t Did, CTentry;
467 struct list_head head;
469 lpfc_set_disctmo(vport);
470 vport->num_disc_nodes = 0;
471 vport->fc_ns_retry = 0;
474 list_add_tail(&head, &mp->list);
475 list_for_each_entry_safe(mp, next_mp, &head, list) {
478 Cnt = Size > FCELSSIZE ? FCELSSIZE : Size;
483 ctptr = (uint32_t *) mlast->virt;
485 Cnt -= 16; /* subtract length of CT header */
487 /* Loop through entire NameServer list of DIDs */
488 while (Cnt >= sizeof(uint32_t)) {
489 /* Get next DID from NameServer List */
491 Did = ((be32_to_cpu(CTentry)) & Mask_DID);
496 * Check for rscn processing or not
497 * To conserve rpi's, filter out addresses for other
498 * vports on the same physical HBAs.
500 if ((Did != vport->fc_myDID) &&
501 ((lpfc_find_vport_by_did(phba, Did) == NULL) ||
502 vport->cfg_peer_port_login)) {
503 if ((vport->port_type != LPFC_NPIV_PORT) ||
504 (!(vport->ct_flags & FC_CT_RFF_ID)) ||
505 (!vport->cfg_restrict_login)) {
506 ndlp = lpfc_setup_disc_node(vport, Did);
507 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
508 lpfc_debugfs_disc_trc(vport,
511 "did:x%x flg:x%x x%x",
515 lpfc_printf_vlog(vport,
520 "Data: x%x x%x x%x\n",
523 vport->fc_rscn_id_cnt);
525 lpfc_debugfs_disc_trc(vport,
528 "did:x%x flg:x%x cnt:%d",
530 vport->fc_rscn_id_cnt);
532 lpfc_printf_vlog(vport,
536 "NameServer Rsp Data: "
539 vport->fc_rscn_id_cnt);
543 if (!(vport->fc_flag & FC_RSCN_MODE) ||
544 (lpfc_rscn_payload_check(vport, Did))) {
545 lpfc_debugfs_disc_trc(vport,
548 "did:x%x flg:x%x cnt:%d",
550 vport->fc_rscn_id_cnt);
552 /* This NPortID was previously
553 * a FCP target, * Don't even
554 * bother to send GFF_ID.
556 ndlp = lpfc_findnode_did(vport,
559 NLP_CHK_NODE_ACT(ndlp)
564 else if (lpfc_ns_cmd(vport,
567 vport->num_disc_nodes++;
573 lpfc_debugfs_disc_trc(vport,
576 "did:x%x flg:x%x cnt:%d",
578 vport->fc_rscn_id_cnt);
580 lpfc_printf_vlog(vport,
584 "NameServer Rsp Data: "
587 vport->fc_rscn_id_cnt);
591 if (CTentry & (cpu_to_be32(SLI_CT_LAST_ENTRY)))
593 Cnt -= sizeof(uint32_t);
605 lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
606 struct lpfc_iocbq *rspiocb)
608 struct lpfc_vport *vport = cmdiocb->vport;
609 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
611 struct lpfc_dmabuf *outp;
612 struct lpfc_sli_ct_request *CTrsp;
613 struct lpfc_nodelist *ndlp;
616 /* First save ndlp, before we overwrite it */
617 ndlp = cmdiocb->context_un.ndlp;
619 /* we pass cmdiocb to state machine which needs rspiocb as well */
620 cmdiocb->context_un.rsp_iocb = rspiocb;
622 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
623 irsp = &rspiocb->iocb;
625 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
626 "GID_FT cmpl: status:x%x/x%x rtry:%d",
627 irsp->ulpStatus, irsp->un.ulpWord[4], vport->fc_ns_retry);
629 /* Don't bother processing response if vport is being torn down. */
630 if (vport->load_flag & FC_UNLOADING) {
631 if (vport->fc_flag & FC_RSCN_MODE)
632 lpfc_els_flush_rscn(vport);
636 if (lpfc_els_chk_latt(vport)) {
637 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
638 "0216 Link event during NS query\n");
639 if (vport->fc_flag & FC_RSCN_MODE)
640 lpfc_els_flush_rscn(vport);
641 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
644 if (lpfc_error_lost_link(irsp)) {
645 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
646 "0226 NS query failed due to link event\n");
647 if (vport->fc_flag & FC_RSCN_MODE)
648 lpfc_els_flush_rscn(vport);
651 if (irsp->ulpStatus) {
652 /* Check for retry */
653 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) {
654 if (irsp->ulpStatus != IOSTAT_LOCAL_REJECT ||
655 (irsp->un.ulpWord[4] & IOERR_PARAM_MASK) !=
657 vport->fc_ns_retry++;
659 /* CT command is being retried */
660 rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT,
661 vport->fc_ns_retry, 0);
665 if (vport->fc_flag & FC_RSCN_MODE)
666 lpfc_els_flush_rscn(vport);
667 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
668 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
669 "0257 GID_FT Query error: 0x%x 0x%x\n",
670 irsp->ulpStatus, vport->fc_ns_retry);
672 /* Good status, continue checking */
673 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
674 if (CTrsp->CommandResponse.bits.CmdRsp ==
675 cpu_to_be16(SLI_CT_RESPONSE_FS_ACC)) {
676 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
677 "0208 NameServer Rsp Data: x%x\n",
679 lpfc_ns_rsp(vport, outp,
680 (uint32_t) (irsp->un.genreq64.bdl.bdeSize));
681 } else if (CTrsp->CommandResponse.bits.CmdRsp ==
682 be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) {
683 /* NameServer Rsp Error */
684 if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ)
685 && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) {
686 lpfc_printf_vlog(vport, KERN_INFO,
688 "0269 No NameServer Entries "
689 "Data: x%x x%x x%x x%x\n",
690 CTrsp->CommandResponse.bits.CmdRsp,
691 (uint32_t) CTrsp->ReasonCode,
692 (uint32_t) CTrsp->Explanation,
695 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
696 "GID_FT no entry cmd:x%x rsn:x%x exp:x%x",
697 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp,
698 (uint32_t) CTrsp->ReasonCode,
699 (uint32_t) CTrsp->Explanation);
701 lpfc_printf_vlog(vport, KERN_INFO,
703 "0240 NameServer Rsp Error "
704 "Data: x%x x%x x%x x%x\n",
705 CTrsp->CommandResponse.bits.CmdRsp,
706 (uint32_t) CTrsp->ReasonCode,
707 (uint32_t) CTrsp->Explanation,
710 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
711 "GID_FT rsp err1 cmd:x%x rsn:x%x exp:x%x",
712 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp,
713 (uint32_t) CTrsp->ReasonCode,
714 (uint32_t) CTrsp->Explanation);
719 /* NameServer Rsp Error */
720 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
721 "0241 NameServer Rsp Error "
722 "Data: x%x x%x x%x x%x\n",
723 CTrsp->CommandResponse.bits.CmdRsp,
724 (uint32_t) CTrsp->ReasonCode,
725 (uint32_t) CTrsp->Explanation,
728 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
729 "GID_FT rsp err2 cmd:x%x rsn:x%x exp:x%x",
730 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp,
731 (uint32_t) CTrsp->ReasonCode,
732 (uint32_t) CTrsp->Explanation);
735 /* Link up / RSCN discovery */
736 if (vport->num_disc_nodes == 0) {
738 * The driver has cycled through all Nports in the RSCN payload.
739 * Complete the handling by cleaning up and marking the
740 * current driver state.
742 if (vport->port_state >= LPFC_DISC_AUTH) {
743 if (vport->fc_flag & FC_RSCN_MODE) {
744 lpfc_els_flush_rscn(vport);
745 spin_lock_irq(shost->host_lock);
746 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */
747 spin_unlock_irq(shost->host_lock);
750 lpfc_els_flush_rscn(vport);
753 lpfc_disc_start(vport);
756 cmdiocb->context_un.ndlp = ndlp; /* Now restore ndlp for free */
757 lpfc_ct_free_iocb(phba, cmdiocb);
762 lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
763 struct lpfc_iocbq *rspiocb)
765 struct lpfc_vport *vport = cmdiocb->vport;
766 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
767 IOCB_t *irsp = &rspiocb->iocb;
768 struct lpfc_dmabuf *inp = (struct lpfc_dmabuf *) cmdiocb->context1;
769 struct lpfc_dmabuf *outp = (struct lpfc_dmabuf *) cmdiocb->context2;
770 struct lpfc_sli_ct_request *CTrsp;
773 struct lpfc_nodelist *ndlp;
775 did = ((struct lpfc_sli_ct_request *) inp->virt)->un.gff.PortId;
776 did = be32_to_cpu(did);
778 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
779 "GFF_ID cmpl: status:x%x/x%x did:x%x",
780 irsp->ulpStatus, irsp->un.ulpWord[4], did);
782 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
783 /* Good status, continue checking */
784 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
785 fbits = CTrsp->un.gff_acc.fbits[FCP_TYPE_FEATURE_OFFSET];
787 if (CTrsp->CommandResponse.bits.CmdRsp ==
788 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) {
789 if ((fbits & FC4_FEATURE_INIT) &&
790 !(fbits & FC4_FEATURE_TARGET)) {
791 lpfc_printf_vlog(vport, KERN_INFO,
794 "NameServer Rsp Data: (init) "
795 "x%x x%x\n", did, fbits,
796 vport->fc_rscn_id_cnt);
802 /* Check for retry */
803 if (cmdiocb->retry < LPFC_MAX_NS_RETRY) {
805 if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
806 switch ((irsp->un.ulpWord[4] &
809 case IOERR_NO_RESOURCES:
810 /* We don't increment the retry
811 * count for this case.
814 case IOERR_LINK_DOWN:
815 case IOERR_SLI_ABORTED:
827 /* CT command is being retried */
828 rc = lpfc_ns_cmd(vport, SLI_CTNS_GFF_ID,
829 cmdiocb->retry, did);
832 lpfc_ct_free_iocb(phba, cmdiocb);
837 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
838 "0267 NameServer GFF Rsp "
839 "x%x Error (%d %d) Data: x%x x%x\n",
840 did, irsp->ulpStatus, irsp->un.ulpWord[4],
841 vport->fc_flag, vport->fc_rscn_id_cnt);
844 /* This is a target port, unregistered port, or the GFF_ID failed */
845 ndlp = lpfc_setup_disc_node(vport, did);
846 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
847 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
848 "0242 Process x%x GFF "
849 "NameServer Rsp Data: x%x x%x x%x\n",
850 did, ndlp->nlp_flag, vport->fc_flag,
851 vport->fc_rscn_id_cnt);
853 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
855 "NameServer Rsp Data: x%x x%x\n", did,
856 vport->fc_flag, vport->fc_rscn_id_cnt);
859 /* Link up / RSCN discovery */
860 if (vport->num_disc_nodes)
861 vport->num_disc_nodes--;
862 if (vport->num_disc_nodes == 0) {
864 * The driver has cycled through all Nports in the RSCN payload.
865 * Complete the handling by cleaning up and marking the
866 * current driver state.
868 if (vport->port_state >= LPFC_DISC_AUTH) {
869 if (vport->fc_flag & FC_RSCN_MODE) {
870 lpfc_els_flush_rscn(vport);
871 spin_lock_irq(shost->host_lock);
872 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */
873 spin_unlock_irq(shost->host_lock);
876 lpfc_els_flush_rscn(vport);
878 lpfc_disc_start(vport);
880 lpfc_ct_free_iocb(phba, cmdiocb);
886 lpfc_cmpl_ct(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
887 struct lpfc_iocbq *rspiocb)
889 struct lpfc_vport *vport = cmdiocb->vport;
890 struct lpfc_dmabuf *inp;
891 struct lpfc_dmabuf *outp;
893 struct lpfc_sli_ct_request *CTrsp;
894 struct lpfc_nodelist *ndlp;
899 /* First save ndlp, before we overwrite it */
900 ndlp = cmdiocb->context_un.ndlp;
902 /* we pass cmdiocb to state machine which needs rspiocb as well */
903 cmdiocb->context_un.rsp_iocb = rspiocb;
905 inp = (struct lpfc_dmabuf *) cmdiocb->context1;
906 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
907 irsp = &rspiocb->iocb;
909 cmdcode = be16_to_cpu(((struct lpfc_sli_ct_request *) inp->virt)->
910 CommandResponse.bits.CmdRsp);
911 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
913 latt = lpfc_els_chk_latt(vport);
915 /* RFT request completes status <ulpStatus> CmdRsp <CmdRsp> */
916 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
917 "0209 CT Request completes, latt %d, "
918 "ulpStatus x%x CmdRsp x%x, Context x%x, Tag x%x\n",
919 latt, irsp->ulpStatus,
920 CTrsp->CommandResponse.bits.CmdRsp,
921 cmdiocb->iocb.ulpContext, cmdiocb->iocb.ulpIoTag);
923 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
924 "CT cmd cmpl: status:x%x/x%x cmd:x%x",
925 irsp->ulpStatus, irsp->un.ulpWord[4], cmdcode);
927 if (irsp->ulpStatus) {
928 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
929 "0268 NS cmd x%x Error (x%x x%x)\n",
930 cmdcode, irsp->ulpStatus, irsp->un.ulpWord[4]);
932 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
933 (((irsp->un.ulpWord[4] & IOERR_PARAM_MASK) ==
935 ((irsp->un.ulpWord[4] & IOERR_PARAM_MASK) ==
939 retry = cmdiocb->retry;
940 if (retry >= LPFC_MAX_NS_RETRY)
944 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
945 "0250 Retrying NS cmd %x\n", cmdcode);
946 rc = lpfc_ns_cmd(vport, cmdcode, retry, 0);
952 cmdiocb->context_un.ndlp = ndlp; /* Now restore ndlp for free */
953 lpfc_ct_free_iocb(phba, cmdiocb);
958 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
959 struct lpfc_iocbq *rspiocb)
961 IOCB_t *irsp = &rspiocb->iocb;
962 struct lpfc_vport *vport = cmdiocb->vport;
964 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
965 struct lpfc_dmabuf *outp;
966 struct lpfc_sli_ct_request *CTrsp;
968 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
969 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
970 if (CTrsp->CommandResponse.bits.CmdRsp ==
971 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
972 vport->ct_flags |= FC_CT_RFT_ID;
974 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
979 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
980 struct lpfc_iocbq *rspiocb)
982 IOCB_t *irsp = &rspiocb->iocb;
983 struct lpfc_vport *vport = cmdiocb->vport;
985 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
986 struct lpfc_dmabuf *outp;
987 struct lpfc_sli_ct_request *CTrsp;
989 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
990 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
991 if (CTrsp->CommandResponse.bits.CmdRsp ==
992 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
993 vport->ct_flags |= FC_CT_RNN_ID;
995 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1000 lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1001 struct lpfc_iocbq *rspiocb)
1003 IOCB_t *irsp = &rspiocb->iocb;
1004 struct lpfc_vport *vport = cmdiocb->vport;
1006 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
1007 struct lpfc_dmabuf *outp;
1008 struct lpfc_sli_ct_request *CTrsp;
1010 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
1011 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1012 if (CTrsp->CommandResponse.bits.CmdRsp ==
1013 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
1014 vport->ct_flags |= FC_CT_RSPN_ID;
1016 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1021 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1022 struct lpfc_iocbq *rspiocb)
1024 IOCB_t *irsp = &rspiocb->iocb;
1025 struct lpfc_vport *vport = cmdiocb->vport;
1027 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
1028 struct lpfc_dmabuf *outp;
1029 struct lpfc_sli_ct_request *CTrsp;
1031 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
1032 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1033 if (CTrsp->CommandResponse.bits.CmdRsp ==
1034 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
1035 vport->ct_flags |= FC_CT_RSNN_NN;
1037 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1042 lpfc_cmpl_ct_cmd_da_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1043 struct lpfc_iocbq *rspiocb)
1045 struct lpfc_vport *vport = cmdiocb->vport;
1047 /* even if it fails we will act as though it succeeded. */
1048 vport->ct_flags = 0;
1049 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1054 lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1055 struct lpfc_iocbq *rspiocb)
1057 IOCB_t *irsp = &rspiocb->iocb;
1058 struct lpfc_vport *vport = cmdiocb->vport;
1060 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
1061 struct lpfc_dmabuf *outp;
1062 struct lpfc_sli_ct_request *CTrsp;
1064 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
1065 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1066 if (CTrsp->CommandResponse.bits.CmdRsp ==
1067 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
1068 vport->ct_flags |= FC_CT_RFF_ID;
1070 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1075 lpfc_vport_symbolic_port_name(struct lpfc_vport *vport, char *symbol,
1079 uint8_t *wwn = vport->phba->wwpn;
1081 n = snprintf(symbol, size,
1082 "Emulex PPN-%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1083 wwn[0], wwn[1], wwn[2], wwn[3],
1084 wwn[4], wwn[5], wwn[6], wwn[7]);
1086 if (vport->port_type == LPFC_PHYSICAL_PORT)
1090 n += snprintf(symbol + n, size - n, " VPort-%d", vport->vpi);
1093 strlen(vport->fc_vport->symbolic_name))
1094 n += snprintf(symbol + n, size - n, " VName-%s",
1095 vport->fc_vport->symbolic_name);
1100 lpfc_vport_symbolic_node_name(struct lpfc_vport *vport, char *symbol,
1103 char fwrev[FW_REV_STR_SIZE];
1106 lpfc_decode_firmware_rev(vport->phba, fwrev, 0);
1108 n = snprintf(symbol, size, "Emulex %s", vport->phba->ModelName);
1112 n += snprintf(symbol + n, size - n, " FV%s", fwrev);
1116 n += snprintf(symbol + n, size - n, " DV%s", lpfc_release_version);
1120 n += snprintf(symbol + n, size - n, " HN:%s", init_utsname()->nodename);
1122 /* Note :- OS name is "Linux" */
1125 n += snprintf(symbol + n, size - n, " OS:%s", init_utsname()->sysname);
1131 lpfc_find_map_node(struct lpfc_vport *vport)
1133 struct lpfc_nodelist *ndlp, *next_ndlp;
1134 struct Scsi_Host *shost;
1137 shost = lpfc_shost_from_vport(vport);
1138 spin_lock_irq(shost->host_lock);
1139 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
1140 if (ndlp->nlp_type & NLP_FABRIC)
1142 if ((ndlp->nlp_state == NLP_STE_MAPPED_NODE) ||
1143 (ndlp->nlp_state == NLP_STE_UNMAPPED_NODE))
1146 spin_unlock_irq(shost->host_lock);
1153 * Issue Cmd to NameServer
1158 lpfc_ns_cmd(struct lpfc_vport *vport, int cmdcode,
1159 uint8_t retry, uint32_t context)
1161 struct lpfc_nodelist * ndlp;
1162 struct lpfc_hba *phba = vport->phba;
1163 struct lpfc_dmabuf *mp, *bmp;
1164 struct lpfc_sli_ct_request *CtReq;
1165 struct ulp_bde64 *bpl;
1166 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
1167 struct lpfc_iocbq *) = NULL;
1168 uint32_t rsp_size = 1024;
1172 ndlp = lpfc_findnode_did(vport, NameServer_DID);
1173 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)
1174 || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) {
1179 /* fill in BDEs for command */
1180 /* Allocate buffer for command payload */
1181 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1187 INIT_LIST_HEAD(&mp->list);
1188 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
1191 goto ns_cmd_free_mp;
1194 /* Allocate buffer for Buffer ptr list */
1195 bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1198 goto ns_cmd_free_mpvirt;
1201 INIT_LIST_HEAD(&bmp->list);
1202 bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys));
1205 goto ns_cmd_free_bmp;
1208 /* NameServer Req */
1209 lpfc_printf_vlog(vport, KERN_INFO ,LOG_DISCOVERY,
1210 "0236 NameServer Req Data: x%x x%x x%x\n",
1211 cmdcode, vport->fc_flag, vport->fc_rscn_id_cnt);
1213 bpl = (struct ulp_bde64 *) bmp->virt;
1214 memset(bpl, 0, sizeof(struct ulp_bde64));
1215 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
1216 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
1217 bpl->tus.f.bdeFlags = 0;
1218 if (cmdcode == SLI_CTNS_GID_FT)
1219 bpl->tus.f.bdeSize = GID_REQUEST_SZ;
1220 else if (cmdcode == SLI_CTNS_GFF_ID)
1221 bpl->tus.f.bdeSize = GFF_REQUEST_SZ;
1222 else if (cmdcode == SLI_CTNS_RFT_ID)
1223 bpl->tus.f.bdeSize = RFT_REQUEST_SZ;
1224 else if (cmdcode == SLI_CTNS_RNN_ID)
1225 bpl->tus.f.bdeSize = RNN_REQUEST_SZ;
1226 else if (cmdcode == SLI_CTNS_RSPN_ID)
1227 bpl->tus.f.bdeSize = RSPN_REQUEST_SZ;
1228 else if (cmdcode == SLI_CTNS_RSNN_NN)
1229 bpl->tus.f.bdeSize = RSNN_REQUEST_SZ;
1230 else if (cmdcode == SLI_CTNS_DA_ID)
1231 bpl->tus.f.bdeSize = DA_ID_REQUEST_SZ;
1232 else if (cmdcode == SLI_CTNS_RFF_ID)
1233 bpl->tus.f.bdeSize = RFF_REQUEST_SZ;
1235 bpl->tus.f.bdeSize = 0;
1236 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1238 CtReq = (struct lpfc_sli_ct_request *) mp->virt;
1239 memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request));
1240 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
1241 CtReq->RevisionId.bits.InId = 0;
1242 CtReq->FsType = SLI_CT_DIRECTORY_SERVICE;
1243 CtReq->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER;
1244 CtReq->CommandResponse.bits.Size = 0;
1246 case SLI_CTNS_GID_FT:
1247 CtReq->CommandResponse.bits.CmdRsp =
1248 cpu_to_be16(SLI_CTNS_GID_FT);
1249 CtReq->un.gid.Fc4Type = SLI_CTPT_FCP;
1250 if (vport->port_state < LPFC_NS_QRY)
1251 vport->port_state = LPFC_NS_QRY;
1252 lpfc_set_disctmo(vport);
1253 cmpl = lpfc_cmpl_ct_cmd_gid_ft;
1254 rsp_size = FC_MAX_NS_RSP;
1257 case SLI_CTNS_GFF_ID:
1258 CtReq->CommandResponse.bits.CmdRsp =
1259 cpu_to_be16(SLI_CTNS_GFF_ID);
1260 CtReq->un.gff.PortId = cpu_to_be32(context);
1261 cmpl = lpfc_cmpl_ct_cmd_gff_id;
1264 case SLI_CTNS_RFT_ID:
1265 vport->ct_flags &= ~FC_CT_RFT_ID;
1266 CtReq->CommandResponse.bits.CmdRsp =
1267 cpu_to_be16(SLI_CTNS_RFT_ID);
1268 CtReq->un.rft.PortId = cpu_to_be32(vport->fc_myDID);
1269 CtReq->un.rft.fcpReg = 1;
1270 cmpl = lpfc_cmpl_ct_cmd_rft_id;
1273 case SLI_CTNS_RNN_ID:
1274 vport->ct_flags &= ~FC_CT_RNN_ID;
1275 CtReq->CommandResponse.bits.CmdRsp =
1276 cpu_to_be16(SLI_CTNS_RNN_ID);
1277 CtReq->un.rnn.PortId = cpu_to_be32(vport->fc_myDID);
1278 memcpy(CtReq->un.rnn.wwnn, &vport->fc_nodename,
1279 sizeof(struct lpfc_name));
1280 cmpl = lpfc_cmpl_ct_cmd_rnn_id;
1283 case SLI_CTNS_RSPN_ID:
1284 vport->ct_flags &= ~FC_CT_RSPN_ID;
1285 CtReq->CommandResponse.bits.CmdRsp =
1286 cpu_to_be16(SLI_CTNS_RSPN_ID);
1287 CtReq->un.rspn.PortId = cpu_to_be32(vport->fc_myDID);
1288 size = sizeof(CtReq->un.rspn.symbname);
1289 CtReq->un.rspn.len =
1290 lpfc_vport_symbolic_port_name(vport,
1291 CtReq->un.rspn.symbname, size);
1292 cmpl = lpfc_cmpl_ct_cmd_rspn_id;
1294 case SLI_CTNS_RSNN_NN:
1295 vport->ct_flags &= ~FC_CT_RSNN_NN;
1296 CtReq->CommandResponse.bits.CmdRsp =
1297 cpu_to_be16(SLI_CTNS_RSNN_NN);
1298 memcpy(CtReq->un.rsnn.wwnn, &vport->fc_nodename,
1299 sizeof(struct lpfc_name));
1300 size = sizeof(CtReq->un.rsnn.symbname);
1301 CtReq->un.rsnn.len =
1302 lpfc_vport_symbolic_node_name(vport,
1303 CtReq->un.rsnn.symbname, size);
1304 cmpl = lpfc_cmpl_ct_cmd_rsnn_nn;
1306 case SLI_CTNS_DA_ID:
1307 /* Implement DA_ID Nameserver request */
1308 CtReq->CommandResponse.bits.CmdRsp =
1309 cpu_to_be16(SLI_CTNS_DA_ID);
1310 CtReq->un.da_id.port_id = cpu_to_be32(vport->fc_myDID);
1311 cmpl = lpfc_cmpl_ct_cmd_da_id;
1313 case SLI_CTNS_RFF_ID:
1314 vport->ct_flags &= ~FC_CT_RFF_ID;
1315 CtReq->CommandResponse.bits.CmdRsp =
1316 cpu_to_be16(SLI_CTNS_RFF_ID);
1317 CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID);
1318 CtReq->un.rff.fbits = FC4_FEATURE_INIT;
1319 CtReq->un.rff.type_code = FC_TYPE_FCP;
1320 cmpl = lpfc_cmpl_ct_cmd_rff_id;
1323 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
1324 * to hold ndlp reference for the corresponding callback function.
1326 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry)) {
1327 /* On success, The cmpl function will free the buffers */
1328 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1329 "Issue CT cmd: cmd:x%x did:x%x",
1330 cmdcode, ndlp->nlp_DID, 0);
1335 /* Decrement ndlp reference count to release ndlp reference held
1336 * for the failed command's callback function.
1340 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1344 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1348 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
1349 "0266 Issue NameServer Req x%x err %d Data: x%x x%x\n",
1350 cmdcode, rc, vport->fc_flag, vport->fc_rscn_id_cnt);
1355 * lpfc_cmpl_ct_disc_fdmi - Handle a discovery FDMI completion
1356 * @phba: Pointer to HBA context object.
1357 * @cmdiocb: Pointer to the command IOCBQ.
1358 * @rspiocb: Pointer to the response IOCBQ.
1360 * This function to handle the completion of a driver initiated FDMI
1361 * CT command issued during discovery.
1364 lpfc_cmpl_ct_disc_fdmi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1365 struct lpfc_iocbq *rspiocb)
1367 struct lpfc_vport *vport = cmdiocb->vport;
1368 struct lpfc_dmabuf *inp = cmdiocb->context1;
1369 struct lpfc_dmabuf *outp = cmdiocb->context2;
1370 struct lpfc_sli_ct_request *CTcmd = inp->virt;
1371 struct lpfc_sli_ct_request *CTrsp = outp->virt;
1372 uint16_t fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp;
1373 uint16_t fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp;
1374 IOCB_t *irsp = &rspiocb->iocb;
1375 struct lpfc_nodelist *ndlp;
1376 uint32_t latt, cmd, err;
1378 latt = lpfc_els_chk_latt(vport);
1379 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1380 "FDMI cmpl: status:x%x/x%x latt:%d",
1381 irsp->ulpStatus, irsp->un.ulpWord[4], latt);
1383 if (latt || irsp->ulpStatus) {
1385 /* Look for a retryable error */
1386 if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
1387 switch ((irsp->un.ulpWord[4] & IOERR_PARAM_MASK)) {
1388 case IOERR_SLI_ABORTED:
1389 case IOERR_ABORT_IN_PROGRESS:
1390 case IOERR_SEQUENCE_TIMEOUT:
1391 case IOERR_ILLEGAL_FRAME:
1392 case IOERR_NO_RESOURCES:
1393 case IOERR_ILLEGAL_COMMAND:
1395 if (cmdiocb->retry >= LPFC_FDMI_MAX_RETRY)
1398 /* Retry the same FDMI command */
1399 err = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING,
1401 if (err == IOCB_ERROR)
1409 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1410 "0229 FDMI cmd %04x failed, latt = %d "
1411 "ulpStatus: x%x, rid x%x\n",
1412 be16_to_cpu(fdmi_cmd), latt, irsp->ulpStatus,
1413 irsp->un.ulpWord[4]);
1415 lpfc_ct_free_iocb(phba, cmdiocb);
1417 ndlp = lpfc_findnode_did(vport, FDMI_DID);
1418 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
1421 /* Check for a CT LS_RJT response */
1422 cmd = be16_to_cpu(fdmi_cmd);
1423 if (fdmi_rsp == cpu_to_be16(SLI_CT_RESPONSE_FS_RJT)) {
1424 /* FDMI rsp failed */
1425 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1426 "0220 FDMI cmd failed FS_RJT Data: x%x", cmd);
1428 /* Should we fallback to FDMI-2 / FDMI-1 ? */
1431 if (vport->fdmi_hba_mask == LPFC_FDMI2_HBA_ATTR) {
1432 /* Fallback to FDMI-1 */
1433 vport->fdmi_hba_mask = LPFC_FDMI1_HBA_ATTR;
1434 vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
1436 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
1441 if (vport->fdmi_port_mask == LPFC_FDMI2_PORT_ATTR) {
1442 /* Fallback to FDMI-1 */
1443 vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
1445 lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
1447 if (vport->fdmi_port_mask == LPFC_FDMI2_SMART_ATTR) {
1448 vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
1449 /* Retry the same command */
1450 lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
1455 if (vport->fdmi_port_mask == LPFC_FDMI2_PORT_ATTR) {
1456 /* Fallback to FDMI-1 */
1457 vport->fdmi_hba_mask = LPFC_FDMI1_HBA_ATTR;
1458 vport->fdmi_port_mask = LPFC_FDMI1_PORT_ATTR;
1460 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA, 0);
1462 if (vport->fdmi_port_mask == LPFC_FDMI2_SMART_ATTR) {
1463 vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
1464 /* Retry the same command */
1465 lpfc_fdmi_cmd(vport, ndlp, cmd, 0);
1472 * On success, need to cycle thru FDMI registration for discovery
1473 * DHBA -> DPRT -> RHBA -> RPA (physical port)
1474 * DPRT -> RPRT (vports)
1478 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA, 0);
1482 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT, 0);
1486 if (vport->port_type == LPFC_PHYSICAL_PORT)
1487 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RHBA, 0);
1489 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT, 0);
1497 * lpfc_fdmi_num_disc_check - Check how many mapped NPorts we are connected to
1498 * @vport: pointer to a host virtual N_Port data structure.
1500 * Called from hbeat timeout routine to check if the number of discovered
1501 * ports has changed. If so, re-register thar port Attribute.
1504 lpfc_fdmi_num_disc_check(struct lpfc_vport *vport)
1506 struct lpfc_hba *phba = vport->phba;
1507 struct lpfc_nodelist *ndlp;
1510 if (!lpfc_is_link_up(phba))
1513 /* Must be connected to a Fabric */
1514 if (!(vport->fc_flag & FC_FABRIC))
1517 if (!(vport->fdmi_port_mask & LPFC_FDMI_PORT_ATTR_num_disc))
1520 cnt = lpfc_find_map_node(vport);
1521 if (cnt == vport->fdmi_num_disc)
1524 ndlp = lpfc_findnode_did(vport, FDMI_DID);
1525 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
1528 if (vport->port_type == LPFC_PHYSICAL_PORT) {
1529 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA,
1530 LPFC_FDMI_PORT_ATTR_num_disc);
1532 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPRT,
1533 LPFC_FDMI_PORT_ATTR_num_disc);
1537 /* Routines for all individual HBA attributes */
1539 lpfc_fdmi_hba_attr_wwnn(struct lpfc_vport *vport, struct lpfc_fdmi_attr_def *ad)
1541 struct lpfc_fdmi_attr_entry *ae;
1544 ae = &ad->AttrValue;
1545 memset(ae, 0, sizeof(*ae));
1547 memcpy(&ae->un.AttrWWN, &vport->fc_sparam.nodeName,
1548 sizeof(struct lpfc_name));
1549 size = FOURBYTES + sizeof(struct lpfc_name);
1550 ad->AttrLen = cpu_to_be16(size);
1551 ad->AttrType = cpu_to_be16(RHBA_NODENAME);
1555 lpfc_fdmi_hba_attr_manufacturer(struct lpfc_vport *vport,
1556 struct lpfc_fdmi_attr_def *ad)
1558 struct lpfc_fdmi_attr_entry *ae;
1561 ae = &ad->AttrValue;
1562 memset(ae, 0, sizeof(*ae));
1564 /* This string MUST be consistent with other FC platforms
1565 * supported by Broadcom.
1567 strncpy(ae->un.AttrString,
1568 "Emulex Corporation",
1569 sizeof(ae->un.AttrString));
1570 len = strnlen(ae->un.AttrString,
1571 sizeof(ae->un.AttrString));
1572 len += (len & 3) ? (4 - (len & 3)) : 4;
1573 size = FOURBYTES + len;
1574 ad->AttrLen = cpu_to_be16(size);
1575 ad->AttrType = cpu_to_be16(RHBA_MANUFACTURER);
1580 lpfc_fdmi_hba_attr_sn(struct lpfc_vport *vport, struct lpfc_fdmi_attr_def *ad)
1582 struct lpfc_hba *phba = vport->phba;
1583 struct lpfc_fdmi_attr_entry *ae;
1586 ae = &ad->AttrValue;
1587 memset(ae, 0, sizeof(*ae));
1589 strncpy(ae->un.AttrString, phba->SerialNumber,
1590 sizeof(ae->un.AttrString));
1591 len = strnlen(ae->un.AttrString,
1592 sizeof(ae->un.AttrString));
1593 len += (len & 3) ? (4 - (len & 3)) : 4;
1594 size = FOURBYTES + len;
1595 ad->AttrLen = cpu_to_be16(size);
1596 ad->AttrType = cpu_to_be16(RHBA_SERIAL_NUMBER);
1601 lpfc_fdmi_hba_attr_model(struct lpfc_vport *vport,
1602 struct lpfc_fdmi_attr_def *ad)
1604 struct lpfc_hba *phba = vport->phba;
1605 struct lpfc_fdmi_attr_entry *ae;
1608 ae = &ad->AttrValue;
1609 memset(ae, 0, sizeof(*ae));
1611 strncpy(ae->un.AttrString, phba->ModelName,
1612 sizeof(ae->un.AttrString));
1613 len = strnlen(ae->un.AttrString, sizeof(ae->un.AttrString));
1614 len += (len & 3) ? (4 - (len & 3)) : 4;
1615 size = FOURBYTES + len;
1616 ad->AttrLen = cpu_to_be16(size);
1617 ad->AttrType = cpu_to_be16(RHBA_MODEL);
1622 lpfc_fdmi_hba_attr_description(struct lpfc_vport *vport,
1623 struct lpfc_fdmi_attr_def *ad)
1625 struct lpfc_hba *phba = vport->phba;
1626 struct lpfc_fdmi_attr_entry *ae;
1629 ae = &ad->AttrValue;
1630 memset(ae, 0, sizeof(*ae));
1632 strncpy(ae->un.AttrString, phba->ModelDesc,
1633 sizeof(ae->un.AttrString));
1634 len = strnlen(ae->un.AttrString,
1635 sizeof(ae->un.AttrString));
1636 len += (len & 3) ? (4 - (len & 3)) : 4;
1637 size = FOURBYTES + len;
1638 ad->AttrLen = cpu_to_be16(size);
1639 ad->AttrType = cpu_to_be16(RHBA_MODEL_DESCRIPTION);
1644 lpfc_fdmi_hba_attr_hdw_ver(struct lpfc_vport *vport,
1645 struct lpfc_fdmi_attr_def *ad)
1647 struct lpfc_hba *phba = vport->phba;
1648 lpfc_vpd_t *vp = &phba->vpd;
1649 struct lpfc_fdmi_attr_entry *ae;
1650 uint32_t i, j, incr, size;
1652 ae = &ad->AttrValue;
1653 memset(ae, 0, sizeof(*ae));
1655 /* Convert JEDEC ID to ascii for hardware version */
1656 incr = vp->rev.biuRev;
1657 for (i = 0; i < 8; i++) {
1660 ae->un.AttrString[7 - i] =
1661 (char)((uint8_t) 0x30 +
1664 ae->un.AttrString[7 - i] =
1665 (char)((uint8_t) 0x61 +
1666 (uint8_t) (j - 10));
1669 size = FOURBYTES + 8;
1670 ad->AttrLen = cpu_to_be16(size);
1671 ad->AttrType = cpu_to_be16(RHBA_HARDWARE_VERSION);
1676 lpfc_fdmi_hba_attr_drvr_ver(struct lpfc_vport *vport,
1677 struct lpfc_fdmi_attr_def *ad)
1679 struct lpfc_fdmi_attr_entry *ae;
1682 ae = &ad->AttrValue;
1683 memset(ae, 0, sizeof(*ae));
1685 strncpy(ae->un.AttrString, lpfc_release_version,
1686 sizeof(ae->un.AttrString));
1687 len = strnlen(ae->un.AttrString,
1688 sizeof(ae->un.AttrString));
1689 len += (len & 3) ? (4 - (len & 3)) : 4;
1690 size = FOURBYTES + len;
1691 ad->AttrLen = cpu_to_be16(size);
1692 ad->AttrType = cpu_to_be16(RHBA_DRIVER_VERSION);
1697 lpfc_fdmi_hba_attr_rom_ver(struct lpfc_vport *vport,
1698 struct lpfc_fdmi_attr_def *ad)
1700 struct lpfc_hba *phba = vport->phba;
1701 struct lpfc_fdmi_attr_entry *ae;
1704 ae = &ad->AttrValue;
1705 memset(ae, 0, sizeof(*ae));
1707 if (phba->sli_rev == LPFC_SLI_REV4)
1708 lpfc_decode_firmware_rev(phba, ae->un.AttrString, 1);
1710 strncpy(ae->un.AttrString, phba->OptionROMVersion,
1711 sizeof(ae->un.AttrString));
1712 len = strnlen(ae->un.AttrString,
1713 sizeof(ae->un.AttrString));
1714 len += (len & 3) ? (4 - (len & 3)) : 4;
1715 size = FOURBYTES + len;
1716 ad->AttrLen = cpu_to_be16(size);
1717 ad->AttrType = cpu_to_be16(RHBA_OPTION_ROM_VERSION);
1722 lpfc_fdmi_hba_attr_fmw_ver(struct lpfc_vport *vport,
1723 struct lpfc_fdmi_attr_def *ad)
1725 struct lpfc_hba *phba = vport->phba;
1726 struct lpfc_fdmi_attr_entry *ae;
1729 ae = &ad->AttrValue;
1730 memset(ae, 0, sizeof(*ae));
1732 lpfc_decode_firmware_rev(phba, ae->un.AttrString, 1);
1733 len = strnlen(ae->un.AttrString,
1734 sizeof(ae->un.AttrString));
1735 len += (len & 3) ? (4 - (len & 3)) : 4;
1736 size = FOURBYTES + len;
1737 ad->AttrLen = cpu_to_be16(size);
1738 ad->AttrType = cpu_to_be16(RHBA_FIRMWARE_VERSION);
1743 lpfc_fdmi_hba_attr_os_ver(struct lpfc_vport *vport,
1744 struct lpfc_fdmi_attr_def *ad)
1746 struct lpfc_fdmi_attr_entry *ae;
1749 ae = &ad->AttrValue;
1750 memset(ae, 0, sizeof(*ae));
1752 snprintf(ae->un.AttrString, sizeof(ae->un.AttrString), "%s %s %s",
1753 init_utsname()->sysname,
1754 init_utsname()->release,
1755 init_utsname()->version);
1757 len = strnlen(ae->un.AttrString, sizeof(ae->un.AttrString));
1758 len += (len & 3) ? (4 - (len & 3)) : 4;
1759 size = FOURBYTES + len;
1760 ad->AttrLen = cpu_to_be16(size);
1761 ad->AttrType = cpu_to_be16(RHBA_OS_NAME_VERSION);
1766 lpfc_fdmi_hba_attr_ct_len(struct lpfc_vport *vport,
1767 struct lpfc_fdmi_attr_def *ad)
1769 struct lpfc_fdmi_attr_entry *ae;
1772 ae = &ad->AttrValue;
1774 ae->un.AttrInt = cpu_to_be32(LPFC_MAX_CT_SIZE);
1775 size = FOURBYTES + sizeof(uint32_t);
1776 ad->AttrLen = cpu_to_be16(size);
1777 ad->AttrType = cpu_to_be16(RHBA_MAX_CT_PAYLOAD_LEN);
1782 lpfc_fdmi_hba_attr_symbolic_name(struct lpfc_vport *vport,
1783 struct lpfc_fdmi_attr_def *ad)
1785 struct lpfc_fdmi_attr_entry *ae;
1788 ae = &ad->AttrValue;
1789 memset(ae, 0, sizeof(*ae));
1791 len = lpfc_vport_symbolic_node_name(vport,
1792 ae->un.AttrString, 256);
1793 len += (len & 3) ? (4 - (len & 3)) : 4;
1794 size = FOURBYTES + len;
1795 ad->AttrLen = cpu_to_be16(size);
1796 ad->AttrType = cpu_to_be16(RHBA_SYM_NODENAME);
1801 lpfc_fdmi_hba_attr_vendor_info(struct lpfc_vport *vport,
1802 struct lpfc_fdmi_attr_def *ad)
1804 struct lpfc_fdmi_attr_entry *ae;
1807 ae = &ad->AttrValue;
1809 /* Nothing is defined for this currently */
1810 ae->un.AttrInt = cpu_to_be32(0);
1811 size = FOURBYTES + sizeof(uint32_t);
1812 ad->AttrLen = cpu_to_be16(size);
1813 ad->AttrType = cpu_to_be16(RHBA_VENDOR_INFO);
1818 lpfc_fdmi_hba_attr_num_ports(struct lpfc_vport *vport,
1819 struct lpfc_fdmi_attr_def *ad)
1821 struct lpfc_fdmi_attr_entry *ae;
1824 ae = &ad->AttrValue;
1826 /* Each driver instance corresponds to a single port */
1827 ae->un.AttrInt = cpu_to_be32(1);
1828 size = FOURBYTES + sizeof(uint32_t);
1829 ad->AttrLen = cpu_to_be16(size);
1830 ad->AttrType = cpu_to_be16(RHBA_NUM_PORTS);
1835 lpfc_fdmi_hba_attr_fabric_wwnn(struct lpfc_vport *vport,
1836 struct lpfc_fdmi_attr_def *ad)
1838 struct lpfc_fdmi_attr_entry *ae;
1841 ae = &ad->AttrValue;
1842 memset(ae, 0, sizeof(*ae));
1844 memcpy(&ae->un.AttrWWN, &vport->fabric_nodename,
1845 sizeof(struct lpfc_name));
1846 size = FOURBYTES + sizeof(struct lpfc_name);
1847 ad->AttrLen = cpu_to_be16(size);
1848 ad->AttrType = cpu_to_be16(RHBA_FABRIC_WWNN);
1853 lpfc_fdmi_hba_attr_bios_ver(struct lpfc_vport *vport,
1854 struct lpfc_fdmi_attr_def *ad)
1856 struct lpfc_hba *phba = vport->phba;
1857 struct lpfc_fdmi_attr_entry *ae;
1860 ae = &ad->AttrValue;
1861 memset(ae, 0, sizeof(*ae));
1863 lpfc_decode_firmware_rev(phba, ae->un.AttrString, 1);
1864 len = strnlen(ae->un.AttrString,
1865 sizeof(ae->un.AttrString));
1866 len += (len & 3) ? (4 - (len & 3)) : 4;
1867 size = FOURBYTES + len;
1868 ad->AttrLen = cpu_to_be16(size);
1869 ad->AttrType = cpu_to_be16(RHBA_BIOS_VERSION);
1874 lpfc_fdmi_hba_attr_bios_state(struct lpfc_vport *vport,
1875 struct lpfc_fdmi_attr_def *ad)
1877 struct lpfc_fdmi_attr_entry *ae;
1880 ae = &ad->AttrValue;
1882 /* Driver doesn't have access to this information */
1883 ae->un.AttrInt = cpu_to_be32(0);
1884 size = FOURBYTES + sizeof(uint32_t);
1885 ad->AttrLen = cpu_to_be16(size);
1886 ad->AttrType = cpu_to_be16(RHBA_BIOS_STATE);
1891 lpfc_fdmi_hba_attr_vendor_id(struct lpfc_vport *vport,
1892 struct lpfc_fdmi_attr_def *ad)
1894 struct lpfc_fdmi_attr_entry *ae;
1897 ae = &ad->AttrValue;
1898 memset(ae, 0, sizeof(*ae));
1900 strncpy(ae->un.AttrString, "EMULEX",
1901 sizeof(ae->un.AttrString));
1902 len = strnlen(ae->un.AttrString,
1903 sizeof(ae->un.AttrString));
1904 len += (len & 3) ? (4 - (len & 3)) : 4;
1905 size = FOURBYTES + len;
1906 ad->AttrLen = cpu_to_be16(size);
1907 ad->AttrType = cpu_to_be16(RHBA_VENDOR_ID);
1911 /* Routines for all individual PORT attributes */
1913 lpfc_fdmi_port_attr_fc4type(struct lpfc_vport *vport,
1914 struct lpfc_fdmi_attr_def *ad)
1916 struct lpfc_fdmi_attr_entry *ae;
1919 ae = &ad->AttrValue;
1920 memset(ae, 0, sizeof(*ae));
1922 ae->un.AttrTypes[3] = 0x02; /* Type 1 - ELS */
1923 ae->un.AttrTypes[2] = 0x01; /* Type 8 - FCP */
1924 ae->un.AttrTypes[7] = 0x01; /* Type 32 - CT */
1925 size = FOURBYTES + 32;
1926 ad->AttrLen = cpu_to_be16(size);
1927 ad->AttrType = cpu_to_be16(RPRT_SUPPORTED_FC4_TYPES);
1932 lpfc_fdmi_port_attr_support_speed(struct lpfc_vport *vport,
1933 struct lpfc_fdmi_attr_def *ad)
1935 struct lpfc_hba *phba = vport->phba;
1936 struct lpfc_fdmi_attr_entry *ae;
1939 ae = &ad->AttrValue;
1942 if (!(phba->hba_flag & HBA_FCOE_MODE)) {
1943 if (phba->lmt & LMT_32Gb)
1944 ae->un.AttrInt |= HBA_PORTSPEED_32GFC;
1945 if (phba->lmt & LMT_16Gb)
1946 ae->un.AttrInt |= HBA_PORTSPEED_16GFC;
1947 if (phba->lmt & LMT_10Gb)
1948 ae->un.AttrInt |= HBA_PORTSPEED_10GFC;
1949 if (phba->lmt & LMT_8Gb)
1950 ae->un.AttrInt |= HBA_PORTSPEED_8GFC;
1951 if (phba->lmt & LMT_4Gb)
1952 ae->un.AttrInt |= HBA_PORTSPEED_4GFC;
1953 if (phba->lmt & LMT_2Gb)
1954 ae->un.AttrInt |= HBA_PORTSPEED_2GFC;
1955 if (phba->lmt & LMT_1Gb)
1956 ae->un.AttrInt |= HBA_PORTSPEED_1GFC;
1958 /* FCoE links support only one speed */
1959 switch (phba->fc_linkspeed) {
1960 case LPFC_ASYNC_LINK_SPEED_10GBPS:
1961 ae->un.AttrInt = HBA_PORTSPEED_10GE;
1963 case LPFC_ASYNC_LINK_SPEED_25GBPS:
1964 ae->un.AttrInt = HBA_PORTSPEED_25GE;
1966 case LPFC_ASYNC_LINK_SPEED_40GBPS:
1967 ae->un.AttrInt = HBA_PORTSPEED_40GE;
1969 case LPFC_ASYNC_LINK_SPEED_100GBPS:
1970 ae->un.AttrInt = HBA_PORTSPEED_100GE;
1974 ae->un.AttrInt = cpu_to_be32(ae->un.AttrInt);
1975 size = FOURBYTES + sizeof(uint32_t);
1976 ad->AttrLen = cpu_to_be16(size);
1977 ad->AttrType = cpu_to_be16(RPRT_SUPPORTED_SPEED);
1982 lpfc_fdmi_port_attr_speed(struct lpfc_vport *vport,
1983 struct lpfc_fdmi_attr_def *ad)
1985 struct lpfc_hba *phba = vport->phba;
1986 struct lpfc_fdmi_attr_entry *ae;
1989 ae = &ad->AttrValue;
1991 if (!(phba->hba_flag & HBA_FCOE_MODE)) {
1992 switch (phba->fc_linkspeed) {
1993 case LPFC_LINK_SPEED_1GHZ:
1994 ae->un.AttrInt = HBA_PORTSPEED_1GFC;
1996 case LPFC_LINK_SPEED_2GHZ:
1997 ae->un.AttrInt = HBA_PORTSPEED_2GFC;
1999 case LPFC_LINK_SPEED_4GHZ:
2000 ae->un.AttrInt = HBA_PORTSPEED_4GFC;
2002 case LPFC_LINK_SPEED_8GHZ:
2003 ae->un.AttrInt = HBA_PORTSPEED_8GFC;
2005 case LPFC_LINK_SPEED_10GHZ:
2006 ae->un.AttrInt = HBA_PORTSPEED_10GFC;
2008 case LPFC_LINK_SPEED_16GHZ:
2009 ae->un.AttrInt = HBA_PORTSPEED_16GFC;
2011 case LPFC_LINK_SPEED_32GHZ:
2012 ae->un.AttrInt = HBA_PORTSPEED_32GFC;
2015 ae->un.AttrInt = HBA_PORTSPEED_UNKNOWN;
2019 switch (phba->fc_linkspeed) {
2020 case LPFC_ASYNC_LINK_SPEED_10GBPS:
2021 ae->un.AttrInt = HBA_PORTSPEED_10GE;
2023 case LPFC_ASYNC_LINK_SPEED_25GBPS:
2024 ae->un.AttrInt = HBA_PORTSPEED_25GE;
2026 case LPFC_ASYNC_LINK_SPEED_40GBPS:
2027 ae->un.AttrInt = HBA_PORTSPEED_40GE;
2029 case LPFC_ASYNC_LINK_SPEED_100GBPS:
2030 ae->un.AttrInt = HBA_PORTSPEED_100GE;
2033 ae->un.AttrInt = HBA_PORTSPEED_UNKNOWN;
2038 ae->un.AttrInt = cpu_to_be32(ae->un.AttrInt);
2039 size = FOURBYTES + sizeof(uint32_t);
2040 ad->AttrLen = cpu_to_be16(size);
2041 ad->AttrType = cpu_to_be16(RPRT_PORT_SPEED);
2046 lpfc_fdmi_port_attr_max_frame(struct lpfc_vport *vport,
2047 struct lpfc_fdmi_attr_def *ad)
2049 struct serv_parm *hsp;
2050 struct lpfc_fdmi_attr_entry *ae;
2053 ae = &ad->AttrValue;
2055 hsp = (struct serv_parm *)&vport->fc_sparam;
2056 ae->un.AttrInt = (((uint32_t) hsp->cmn.bbRcvSizeMsb) << 8) |
2057 (uint32_t) hsp->cmn.bbRcvSizeLsb;
2058 ae->un.AttrInt = cpu_to_be32(ae->un.AttrInt);
2059 size = FOURBYTES + sizeof(uint32_t);
2060 ad->AttrLen = cpu_to_be16(size);
2061 ad->AttrType = cpu_to_be16(RPRT_MAX_FRAME_SIZE);
2066 lpfc_fdmi_port_attr_os_devname(struct lpfc_vport *vport,
2067 struct lpfc_fdmi_attr_def *ad)
2069 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2070 struct lpfc_fdmi_attr_entry *ae;
2073 ae = &ad->AttrValue;
2074 memset(ae, 0, sizeof(*ae));
2076 snprintf(ae->un.AttrString, sizeof(ae->un.AttrString),
2077 "/sys/class/scsi_host/host%d", shost->host_no);
2078 len = strnlen((char *)ae->un.AttrString,
2079 sizeof(ae->un.AttrString));
2080 len += (len & 3) ? (4 - (len & 3)) : 4;
2081 size = FOURBYTES + len;
2082 ad->AttrLen = cpu_to_be16(size);
2083 ad->AttrType = cpu_to_be16(RPRT_OS_DEVICE_NAME);
2088 lpfc_fdmi_port_attr_host_name(struct lpfc_vport *vport,
2089 struct lpfc_fdmi_attr_def *ad)
2091 struct lpfc_fdmi_attr_entry *ae;
2094 ae = &ad->AttrValue;
2095 memset(ae, 0, sizeof(*ae));
2097 snprintf(ae->un.AttrString, sizeof(ae->un.AttrString), "%s",
2098 init_utsname()->nodename);
2100 len = strnlen(ae->un.AttrString, sizeof(ae->un.AttrString));
2101 len += (len & 3) ? (4 - (len & 3)) : 4;
2102 size = FOURBYTES + len;
2103 ad->AttrLen = cpu_to_be16(size);
2104 ad->AttrType = cpu_to_be16(RPRT_HOST_NAME);
2109 lpfc_fdmi_port_attr_wwnn(struct lpfc_vport *vport,
2110 struct lpfc_fdmi_attr_def *ad)
2112 struct lpfc_fdmi_attr_entry *ae;
2115 ae = &ad->AttrValue;
2116 memset(ae, 0, sizeof(*ae));
2118 memcpy(&ae->un.AttrWWN, &vport->fc_sparam.nodeName,
2119 sizeof(struct lpfc_name));
2120 size = FOURBYTES + sizeof(struct lpfc_name);
2121 ad->AttrLen = cpu_to_be16(size);
2122 ad->AttrType = cpu_to_be16(RPRT_NODENAME);
2127 lpfc_fdmi_port_attr_wwpn(struct lpfc_vport *vport,
2128 struct lpfc_fdmi_attr_def *ad)
2130 struct lpfc_fdmi_attr_entry *ae;
2133 ae = &ad->AttrValue;
2134 memset(ae, 0, sizeof(*ae));
2136 memcpy(&ae->un.AttrWWN, &vport->fc_sparam.portName,
2137 sizeof(struct lpfc_name));
2138 size = FOURBYTES + sizeof(struct lpfc_name);
2139 ad->AttrLen = cpu_to_be16(size);
2140 ad->AttrType = cpu_to_be16(RPRT_PORTNAME);
2145 lpfc_fdmi_port_attr_symbolic_name(struct lpfc_vport *vport,
2146 struct lpfc_fdmi_attr_def *ad)
2148 struct lpfc_fdmi_attr_entry *ae;
2151 ae = &ad->AttrValue;
2152 memset(ae, 0, sizeof(*ae));
2154 len = lpfc_vport_symbolic_port_name(vport, ae->un.AttrString, 256);
2155 len += (len & 3) ? (4 - (len & 3)) : 4;
2156 size = FOURBYTES + len;
2157 ad->AttrLen = cpu_to_be16(size);
2158 ad->AttrType = cpu_to_be16(RPRT_SYM_PORTNAME);
2163 lpfc_fdmi_port_attr_port_type(struct lpfc_vport *vport,
2164 struct lpfc_fdmi_attr_def *ad)
2166 struct lpfc_hba *phba = vport->phba;
2167 struct lpfc_fdmi_attr_entry *ae;
2170 ae = &ad->AttrValue;
2171 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP)
2172 ae->un.AttrInt = cpu_to_be32(LPFC_FDMI_PORTTYPE_NLPORT);
2174 ae->un.AttrInt = cpu_to_be32(LPFC_FDMI_PORTTYPE_NPORT);
2175 size = FOURBYTES + sizeof(uint32_t);
2176 ad->AttrLen = cpu_to_be16(size);
2177 ad->AttrType = cpu_to_be16(RPRT_PORT_TYPE);
2182 lpfc_fdmi_port_attr_class(struct lpfc_vport *vport,
2183 struct lpfc_fdmi_attr_def *ad)
2185 struct lpfc_fdmi_attr_entry *ae;
2188 ae = &ad->AttrValue;
2189 ae->un.AttrInt = cpu_to_be32(FC_COS_CLASS2 | FC_COS_CLASS3);
2190 size = FOURBYTES + sizeof(uint32_t);
2191 ad->AttrLen = cpu_to_be16(size);
2192 ad->AttrType = cpu_to_be16(RPRT_SUPPORTED_CLASS);
2197 lpfc_fdmi_port_attr_fabric_wwpn(struct lpfc_vport *vport,
2198 struct lpfc_fdmi_attr_def *ad)
2200 struct lpfc_fdmi_attr_entry *ae;
2203 ae = &ad->AttrValue;
2204 memset(ae, 0, sizeof(*ae));
2206 memcpy(&ae->un.AttrWWN, &vport->fabric_portname,
2207 sizeof(struct lpfc_name));
2208 size = FOURBYTES + sizeof(struct lpfc_name);
2209 ad->AttrLen = cpu_to_be16(size);
2210 ad->AttrType = cpu_to_be16(RPRT_FABRICNAME);
2215 lpfc_fdmi_port_attr_active_fc4type(struct lpfc_vport *vport,
2216 struct lpfc_fdmi_attr_def *ad)
2218 struct lpfc_fdmi_attr_entry *ae;
2221 ae = &ad->AttrValue;
2222 memset(ae, 0, sizeof(*ae));
2224 ae->un.AttrTypes[3] = 0x02; /* Type 1 - ELS */
2225 ae->un.AttrTypes[2] = 0x01; /* Type 8 - FCP */
2226 ae->un.AttrTypes[7] = 0x01; /* Type 32 - CT */
2227 size = FOURBYTES + 32;
2228 ad->AttrLen = cpu_to_be16(size);
2229 ad->AttrType = cpu_to_be16(RPRT_ACTIVE_FC4_TYPES);
2234 lpfc_fdmi_port_attr_port_state(struct lpfc_vport *vport,
2235 struct lpfc_fdmi_attr_def *ad)
2237 struct lpfc_fdmi_attr_entry *ae;
2240 ae = &ad->AttrValue;
2241 /* Link Up - operational */
2242 ae->un.AttrInt = cpu_to_be32(LPFC_FDMI_PORTSTATE_ONLINE);
2243 size = FOURBYTES + sizeof(uint32_t);
2244 ad->AttrLen = cpu_to_be16(size);
2245 ad->AttrType = cpu_to_be16(RPRT_PORT_STATE);
2250 lpfc_fdmi_port_attr_num_disc(struct lpfc_vport *vport,
2251 struct lpfc_fdmi_attr_def *ad)
2253 struct lpfc_fdmi_attr_entry *ae;
2256 ae = &ad->AttrValue;
2257 vport->fdmi_num_disc = lpfc_find_map_node(vport);
2258 ae->un.AttrInt = cpu_to_be32(vport->fdmi_num_disc);
2259 size = FOURBYTES + sizeof(uint32_t);
2260 ad->AttrLen = cpu_to_be16(size);
2261 ad->AttrType = cpu_to_be16(RPRT_DISC_PORT);
2266 lpfc_fdmi_port_attr_nportid(struct lpfc_vport *vport,
2267 struct lpfc_fdmi_attr_def *ad)
2269 struct lpfc_fdmi_attr_entry *ae;
2272 ae = &ad->AttrValue;
2273 ae->un.AttrInt = cpu_to_be32(vport->fc_myDID);
2274 size = FOURBYTES + sizeof(uint32_t);
2275 ad->AttrLen = cpu_to_be16(size);
2276 ad->AttrType = cpu_to_be16(RPRT_PORT_ID);
2281 lpfc_fdmi_smart_attr_service(struct lpfc_vport *vport,
2282 struct lpfc_fdmi_attr_def *ad)
2284 struct lpfc_fdmi_attr_entry *ae;
2287 ae = &ad->AttrValue;
2288 memset(ae, 0, sizeof(*ae));
2290 strncpy(ae->un.AttrString, "Smart SAN Initiator",
2291 sizeof(ae->un.AttrString));
2292 len = strnlen(ae->un.AttrString,
2293 sizeof(ae->un.AttrString));
2294 len += (len & 3) ? (4 - (len & 3)) : 4;
2295 size = FOURBYTES + len;
2296 ad->AttrLen = cpu_to_be16(size);
2297 ad->AttrType = cpu_to_be16(RPRT_SMART_SERVICE);
2302 lpfc_fdmi_smart_attr_guid(struct lpfc_vport *vport,
2303 struct lpfc_fdmi_attr_def *ad)
2305 struct lpfc_fdmi_attr_entry *ae;
2308 ae = &ad->AttrValue;
2309 memset(ae, 0, sizeof(*ae));
2311 memcpy(&ae->un.AttrString, &vport->fc_sparam.nodeName,
2312 sizeof(struct lpfc_name));
2313 memcpy((((uint8_t *)&ae->un.AttrString) +
2314 sizeof(struct lpfc_name)),
2315 &vport->fc_sparam.portName, sizeof(struct lpfc_name));
2316 size = FOURBYTES + (2 * sizeof(struct lpfc_name));
2317 ad->AttrLen = cpu_to_be16(size);
2318 ad->AttrType = cpu_to_be16(RPRT_SMART_GUID);
2323 lpfc_fdmi_smart_attr_version(struct lpfc_vport *vport,
2324 struct lpfc_fdmi_attr_def *ad)
2326 struct lpfc_fdmi_attr_entry *ae;
2329 ae = &ad->AttrValue;
2330 memset(ae, 0, sizeof(*ae));
2332 strncpy(ae->un.AttrString, "Smart SAN Version 2.0",
2333 sizeof(ae->un.AttrString));
2334 len = strnlen(ae->un.AttrString,
2335 sizeof(ae->un.AttrString));
2336 len += (len & 3) ? (4 - (len & 3)) : 4;
2337 size = FOURBYTES + len;
2338 ad->AttrLen = cpu_to_be16(size);
2339 ad->AttrType = cpu_to_be16(RPRT_SMART_VERSION);
2344 lpfc_fdmi_smart_attr_model(struct lpfc_vport *vport,
2345 struct lpfc_fdmi_attr_def *ad)
2347 struct lpfc_hba *phba = vport->phba;
2348 struct lpfc_fdmi_attr_entry *ae;
2351 ae = &ad->AttrValue;
2352 memset(ae, 0, sizeof(*ae));
2354 strncpy(ae->un.AttrString, phba->ModelName,
2355 sizeof(ae->un.AttrString));
2356 len = strnlen(ae->un.AttrString, sizeof(ae->un.AttrString));
2357 len += (len & 3) ? (4 - (len & 3)) : 4;
2358 size = FOURBYTES + len;
2359 ad->AttrLen = cpu_to_be16(size);
2360 ad->AttrType = cpu_to_be16(RPRT_SMART_MODEL);
2365 lpfc_fdmi_smart_attr_port_info(struct lpfc_vport *vport,
2366 struct lpfc_fdmi_attr_def *ad)
2368 struct lpfc_fdmi_attr_entry *ae;
2371 ae = &ad->AttrValue;
2373 /* SRIOV (type 3) is not supported */
2375 ae->un.AttrInt = cpu_to_be32(2); /* NPIV */
2377 ae->un.AttrInt = cpu_to_be32(1); /* Physical */
2378 size = FOURBYTES + sizeof(uint32_t);
2379 ad->AttrLen = cpu_to_be16(size);
2380 ad->AttrType = cpu_to_be16(RPRT_SMART_PORT_INFO);
2385 lpfc_fdmi_smart_attr_qos(struct lpfc_vport *vport,
2386 struct lpfc_fdmi_attr_def *ad)
2388 struct lpfc_fdmi_attr_entry *ae;
2391 ae = &ad->AttrValue;
2392 ae->un.AttrInt = cpu_to_be32(0);
2393 size = FOURBYTES + sizeof(uint32_t);
2394 ad->AttrLen = cpu_to_be16(size);
2395 ad->AttrType = cpu_to_be16(RPRT_SMART_QOS);
2400 lpfc_fdmi_smart_attr_security(struct lpfc_vport *vport,
2401 struct lpfc_fdmi_attr_def *ad)
2403 struct lpfc_fdmi_attr_entry *ae;
2406 ae = &ad->AttrValue;
2407 ae->un.AttrInt = cpu_to_be32(1);
2408 size = FOURBYTES + sizeof(uint32_t);
2409 ad->AttrLen = cpu_to_be16(size);
2410 ad->AttrType = cpu_to_be16(RPRT_SMART_SECURITY);
2414 /* RHBA attribute jump table */
2415 int (*lpfc_fdmi_hba_action[])
2416 (struct lpfc_vport *vport, struct lpfc_fdmi_attr_def *ad) = {
2417 /* Action routine Mask bit Attribute type */
2418 lpfc_fdmi_hba_attr_wwnn, /* bit0 RHBA_NODENAME */
2419 lpfc_fdmi_hba_attr_manufacturer, /* bit1 RHBA_MANUFACTURER */
2420 lpfc_fdmi_hba_attr_sn, /* bit2 RHBA_SERIAL_NUMBER */
2421 lpfc_fdmi_hba_attr_model, /* bit3 RHBA_MODEL */
2422 lpfc_fdmi_hba_attr_description, /* bit4 RHBA_MODEL_DESCRIPTION */
2423 lpfc_fdmi_hba_attr_hdw_ver, /* bit5 RHBA_HARDWARE_VERSION */
2424 lpfc_fdmi_hba_attr_drvr_ver, /* bit6 RHBA_DRIVER_VERSION */
2425 lpfc_fdmi_hba_attr_rom_ver, /* bit7 RHBA_OPTION_ROM_VERSION */
2426 lpfc_fdmi_hba_attr_fmw_ver, /* bit8 RHBA_FIRMWARE_VERSION */
2427 lpfc_fdmi_hba_attr_os_ver, /* bit9 RHBA_OS_NAME_VERSION */
2428 lpfc_fdmi_hba_attr_ct_len, /* bit10 RHBA_MAX_CT_PAYLOAD_LEN */
2429 lpfc_fdmi_hba_attr_symbolic_name, /* bit11 RHBA_SYM_NODENAME */
2430 lpfc_fdmi_hba_attr_vendor_info, /* bit12 RHBA_VENDOR_INFO */
2431 lpfc_fdmi_hba_attr_num_ports, /* bit13 RHBA_NUM_PORTS */
2432 lpfc_fdmi_hba_attr_fabric_wwnn, /* bit14 RHBA_FABRIC_WWNN */
2433 lpfc_fdmi_hba_attr_bios_ver, /* bit15 RHBA_BIOS_VERSION */
2434 lpfc_fdmi_hba_attr_bios_state, /* bit16 RHBA_BIOS_STATE */
2435 lpfc_fdmi_hba_attr_vendor_id, /* bit17 RHBA_VENDOR_ID */
2438 /* RPA / RPRT attribute jump table */
2439 int (*lpfc_fdmi_port_action[])
2440 (struct lpfc_vport *vport, struct lpfc_fdmi_attr_def *ad) = {
2441 /* Action routine Mask bit Attribute type */
2442 lpfc_fdmi_port_attr_fc4type, /* bit0 RPRT_SUPPORT_FC4_TYPES */
2443 lpfc_fdmi_port_attr_support_speed, /* bit1 RPRT_SUPPORTED_SPEED */
2444 lpfc_fdmi_port_attr_speed, /* bit2 RPRT_PORT_SPEED */
2445 lpfc_fdmi_port_attr_max_frame, /* bit3 RPRT_MAX_FRAME_SIZE */
2446 lpfc_fdmi_port_attr_os_devname, /* bit4 RPRT_OS_DEVICE_NAME */
2447 lpfc_fdmi_port_attr_host_name, /* bit5 RPRT_HOST_NAME */
2448 lpfc_fdmi_port_attr_wwnn, /* bit6 RPRT_NODENAME */
2449 lpfc_fdmi_port_attr_wwpn, /* bit7 RPRT_PORTNAME */
2450 lpfc_fdmi_port_attr_symbolic_name, /* bit8 RPRT_SYM_PORTNAME */
2451 lpfc_fdmi_port_attr_port_type, /* bit9 RPRT_PORT_TYPE */
2452 lpfc_fdmi_port_attr_class, /* bit10 RPRT_SUPPORTED_CLASS */
2453 lpfc_fdmi_port_attr_fabric_wwpn, /* bit11 RPRT_FABRICNAME */
2454 lpfc_fdmi_port_attr_active_fc4type, /* bit12 RPRT_ACTIVE_FC4_TYPES */
2455 lpfc_fdmi_port_attr_port_state, /* bit13 RPRT_PORT_STATE */
2456 lpfc_fdmi_port_attr_num_disc, /* bit14 RPRT_DISC_PORT */
2457 lpfc_fdmi_port_attr_nportid, /* bit15 RPRT_PORT_ID */
2458 lpfc_fdmi_smart_attr_service, /* bit16 RPRT_SMART_SERVICE */
2459 lpfc_fdmi_smart_attr_guid, /* bit17 RPRT_SMART_GUID */
2460 lpfc_fdmi_smart_attr_version, /* bit18 RPRT_SMART_VERSION */
2461 lpfc_fdmi_smart_attr_model, /* bit19 RPRT_SMART_MODEL */
2462 lpfc_fdmi_smart_attr_port_info, /* bit20 RPRT_SMART_PORT_INFO */
2463 lpfc_fdmi_smart_attr_qos, /* bit21 RPRT_SMART_QOS */
2464 lpfc_fdmi_smart_attr_security, /* bit22 RPRT_SMART_SECURITY */
2468 * lpfc_fdmi_cmd - Build and send a FDMI cmd to the specified NPort
2469 * @vport: pointer to a host virtual N_Port data structure.
2470 * @ndlp: ndlp to send FDMI cmd to (if NULL use FDMI_DID)
2471 * cmdcode: FDMI command to send
2472 * mask: Mask of HBA or PORT Attributes to send
2474 * Builds and sends a FDMI command using the CT subsystem.
2477 lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2478 int cmdcode, uint32_t new_mask)
2480 struct lpfc_hba *phba = vport->phba;
2481 struct lpfc_dmabuf *mp, *bmp;
2482 struct lpfc_sli_ct_request *CtReq;
2483 struct ulp_bde64 *bpl;
2488 struct lpfc_fdmi_reg_hba *rh;
2489 struct lpfc_fdmi_port_entry *pe;
2490 struct lpfc_fdmi_reg_portattr *pab = NULL;
2491 struct lpfc_fdmi_attr_block *ab = NULL;
2492 int (*func)(struct lpfc_vport *vport, struct lpfc_fdmi_attr_def *ad);
2493 void (*cmpl)(struct lpfc_hba *, struct lpfc_iocbq *,
2494 struct lpfc_iocbq *);
2496 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
2499 cmpl = lpfc_cmpl_ct_disc_fdmi; /* called from discovery */
2501 /* fill in BDEs for command */
2502 /* Allocate buffer for command payload */
2503 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
2507 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys));
2509 goto fdmi_cmd_free_mp;
2511 /* Allocate buffer for Buffer ptr list */
2512 bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
2514 goto fdmi_cmd_free_mpvirt;
2516 bmp->virt = lpfc_mbuf_alloc(phba, 0, &(bmp->phys));
2518 goto fdmi_cmd_free_bmp;
2520 INIT_LIST_HEAD(&mp->list);
2521 INIT_LIST_HEAD(&bmp->list);
2524 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2525 "0218 FDMI Request Data: x%x x%x x%x\n",
2526 vport->fc_flag, vport->port_state, cmdcode);
2527 CtReq = (struct lpfc_sli_ct_request *)mp->virt;
2529 /* First populate the CT_IU preamble */
2530 memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request));
2531 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
2532 CtReq->RevisionId.bits.InId = 0;
2534 CtReq->FsType = SLI_CT_MANAGEMENT_SERVICE;
2535 CtReq->FsSubType = SLI_CT_FDMI_Subtypes;
2537 CtReq->CommandResponse.bits.CmdRsp = cpu_to_be16(cmdcode);
2538 rsp_size = LPFC_BPL_SIZE;
2541 /* Next fill in the specific FDMI cmd information */
2545 rh = (struct lpfc_fdmi_reg_hba *)&CtReq->un.PortID;
2546 /* HBA Identifier */
2547 memcpy(&rh->hi.PortName, &phba->pport->fc_sparam.portName,
2548 sizeof(struct lpfc_name));
2550 if (cmdcode == SLI_MGMT_RHBA) {
2551 /* Registered Port List */
2552 /* One entry (port) per adapter */
2553 rh->rpl.EntryCnt = cpu_to_be32(1);
2554 memcpy(&rh->rpl.pe.PortName,
2555 &phba->pport->fc_sparam.portName,
2556 sizeof(struct lpfc_name));
2558 /* point to the HBA attribute block */
2559 size = 2 * sizeof(struct lpfc_name) +
2562 size = sizeof(struct lpfc_name);
2564 ab = (struct lpfc_fdmi_attr_block *)((uint8_t *)rh + size);
2571 mask = vport->fdmi_hba_mask;
2573 /* Mask will dictate what attributes to build in the request */
2576 func = lpfc_fdmi_hba_action[bit_pos];
2578 (struct lpfc_fdmi_attr_def *)
2579 ((uint8_t *)rh + size));
2582 (LPFC_BPL_SIZE - LPFC_CT_PREAMBLE))
2589 ab->EntryCnt = cpu_to_be32(ab->EntryCnt);
2591 size = GID_REQUEST_SZ - 4 + size;
2596 pab = (struct lpfc_fdmi_reg_portattr *)&CtReq->un.PortID;
2597 if (cmdcode == SLI_MGMT_RPRT) {
2598 rh = (struct lpfc_fdmi_reg_hba *)pab;
2599 /* HBA Identifier */
2600 memcpy(&rh->hi.PortName,
2601 &phba->pport->fc_sparam.portName,
2602 sizeof(struct lpfc_name));
2603 pab = (struct lpfc_fdmi_reg_portattr *)
2604 ((uint8_t *)pab + sizeof(struct lpfc_name));
2607 memcpy((uint8_t *)&pab->PortName,
2608 (uint8_t *)&vport->fc_sparam.portName,
2609 sizeof(struct lpfc_name));
2610 size += sizeof(struct lpfc_name) + FOURBYTES;
2611 pab->ab.EntryCnt = 0;
2616 mask = vport->fdmi_port_mask;
2618 /* Mask will dictate what attributes to build in the request */
2621 func = lpfc_fdmi_port_action[bit_pos];
2623 (struct lpfc_fdmi_attr_def *)
2624 ((uint8_t *)pab + size));
2627 (LPFC_BPL_SIZE - LPFC_CT_PREAMBLE))
2634 pab->ab.EntryCnt = cpu_to_be32(pab->ab.EntryCnt);
2636 if (cmdcode == SLI_MGMT_RPRT)
2637 size += sizeof(struct lpfc_name);
2638 size = GID_REQUEST_SZ - 4 + size;
2643 rsp_size = FC_MAX_NS_RSP;
2646 pe = (struct lpfc_fdmi_port_entry *)&CtReq->un.PortID;
2647 memcpy((uint8_t *)&pe->PortName,
2648 (uint8_t *)&vport->fc_sparam.portName,
2649 sizeof(struct lpfc_name));
2650 size = GID_REQUEST_SZ - 4 + sizeof(struct lpfc_name);
2655 rsp_size = FC_MAX_NS_RSP;
2658 pe = (struct lpfc_fdmi_port_entry *)&CtReq->un.PortID;
2659 memcpy((uint8_t *)&pe->PortName,
2660 (uint8_t *)&vport->fc_sparam.portName,
2661 sizeof(struct lpfc_name));
2662 size = GID_REQUEST_SZ - 4 + sizeof(struct lpfc_name);
2665 size = GID_REQUEST_SZ - 4;
2668 lpfc_printf_vlog(vport, KERN_WARNING, LOG_DISCOVERY,
2669 "0298 FDMI cmdcode x%x not supported\n",
2671 goto fdmi_cmd_free_bmpvirt;
2673 CtReq->CommandResponse.bits.Size = cpu_to_be16(rsp_size);
2675 bpl = (struct ulp_bde64 *)bmp->virt;
2676 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys));
2677 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys));
2678 bpl->tus.f.bdeFlags = 0;
2679 bpl->tus.f.bdeSize = size;
2682 * The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
2683 * to hold ndlp reference for the corresponding callback function.
2685 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, 0))
2689 * Decrement ndlp reference count to release ndlp reference held
2690 * for the failed command's callback function.
2694 fdmi_cmd_free_bmpvirt:
2695 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
2698 fdmi_cmd_free_mpvirt:
2699 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2703 /* Issue FDMI request failed */
2704 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2705 "0244 Issue FDMI request failed Data: x%x\n",
2711 * lpfc_delayed_disc_tmo - Timeout handler for delayed discovery timer.
2712 * @ptr - Context object of the timer.
2714 * This function set the WORKER_DELAYED_DISC_TMO flag and wake up
2715 * the worker thread.
2718 lpfc_delayed_disc_tmo(unsigned long ptr)
2720 struct lpfc_vport *vport = (struct lpfc_vport *)ptr;
2721 struct lpfc_hba *phba = vport->phba;
2722 uint32_t tmo_posted;
2723 unsigned long iflag;
2725 spin_lock_irqsave(&vport->work_port_lock, iflag);
2726 tmo_posted = vport->work_port_events & WORKER_DELAYED_DISC_TMO;
2728 vport->work_port_events |= WORKER_DELAYED_DISC_TMO;
2729 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
2732 lpfc_worker_wake_up(phba);
2737 * lpfc_delayed_disc_timeout_handler - Function called by worker thread to
2738 * handle delayed discovery.
2739 * @vport: pointer to a host virtual N_Port data structure.
2741 * This function start nport discovery of the vport.
2744 lpfc_delayed_disc_timeout_handler(struct lpfc_vport *vport)
2746 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2748 spin_lock_irq(shost->host_lock);
2749 if (!(vport->fc_flag & FC_DISC_DELAYED)) {
2750 spin_unlock_irq(shost->host_lock);
2753 vport->fc_flag &= ~FC_DISC_DELAYED;
2754 spin_unlock_irq(shost->host_lock);
2756 lpfc_do_scr_ns_plogi(vport->phba, vport);
2760 lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag)
2762 struct lpfc_sli *psli = &phba->sli;
2763 lpfc_vpd_t *vp = &phba->vpd;
2764 uint32_t b1, b2, b3, b4, i, rev;
2766 uint32_t *ptr, str[4];
2769 if (phba->sli_rev == LPFC_SLI_REV4)
2770 snprintf(fwrevision, FW_REV_STR_SIZE, "%s", vp->rev.opFwName);
2771 else if (vp->rev.rBit) {
2772 if (psli->sli_flag & LPFC_SLI_ACTIVE)
2773 rev = vp->rev.sli2FwRev;
2775 rev = vp->rev.sli1FwRev;
2777 b1 = (rev & 0x0000f000) >> 12;
2778 b2 = (rev & 0x00000f00) >> 8;
2779 b3 = (rev & 0x000000c0) >> 6;
2780 b4 = (rev & 0x00000030) >> 4;
2799 b4 = (rev & 0x0000000f);
2801 if (psli->sli_flag & LPFC_SLI_ACTIVE)
2802 fwname = vp->rev.sli2FwName;
2804 fwname = vp->rev.sli1FwName;
2806 for (i = 0; i < 16; i++)
2807 if (fwname[i] == 0x20)
2810 ptr = (uint32_t*)fwname;
2812 for (i = 0; i < 3; i++)
2813 str[i] = be32_to_cpu(*ptr++);
2817 sprintf(fwrevision, "%d.%d%d (%s)",
2818 b1, b2, b3, (char *)str);
2820 sprintf(fwrevision, "%d.%d%d", b1,
2824 sprintf(fwrevision, "%d.%d%d%c%d (%s)",
2828 sprintf(fwrevision, "%d.%d%d%c%d",
2832 rev = vp->rev.smFwRev;
2834 b1 = (rev & 0xff000000) >> 24;
2835 b2 = (rev & 0x00f00000) >> 20;
2836 b3 = (rev & 0x000f0000) >> 16;
2837 c = (rev & 0x0000ff00) >> 8;
2838 b4 = (rev & 0x000000ff);
2840 sprintf(fwrevision, "%d.%d%d%c%d", b1, b2, b3, c, b4);