1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2008 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/utsname.h>
30 #include <scsi/scsi.h>
31 #include <scsi/scsi_device.h>
32 #include <scsi/scsi_host.h>
33 #include <scsi/scsi_transport_fc.h>
37 #include "lpfc_disc.h"
38 #include "lpfc_scsi.h"
40 #include "lpfc_logmsg.h"
41 #include "lpfc_crtn.h"
42 #include "lpfc_version.h"
43 #include "lpfc_vport.h"
44 #include "lpfc_debugfs.h"
46 #define HBA_PORTSPEED_UNKNOWN 0 /* Unknown - transceiver
47 * incapable of reporting */
48 #define HBA_PORTSPEED_1GBIT 1 /* 1 GBit/sec */
49 #define HBA_PORTSPEED_2GBIT 2 /* 2 GBit/sec */
50 #define HBA_PORTSPEED_4GBIT 8 /* 4 GBit/sec */
51 #define HBA_PORTSPEED_8GBIT 16 /* 8 GBit/sec */
52 #define HBA_PORTSPEED_10GBIT 4 /* 10 GBit/sec */
53 #define HBA_PORTSPEED_NOT_NEGOTIATED 5 /* Speed not established */
58 static char *lpfc_release_version = LPFC_DRIVER_VERSION;
61 lpfc_ct_ignore_hbq_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
62 struct lpfc_dmabuf *mp, uint32_t size)
65 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
66 "0146 Ignoring unsolicted CT No HBQ "
68 piocbq->iocb.ulpStatus);
70 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
71 "0145 Ignoring unsolicted CT HBQ Size:%d "
73 size, piocbq->iocb.ulpStatus);
77 lpfc_ct_unsol_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
78 struct lpfc_dmabuf *mp, uint32_t size)
80 lpfc_ct_ignore_hbq_buffer(phba, piocbq, mp, size);
84 lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
85 struct lpfc_iocbq *piocbq)
88 struct lpfc_dmabuf *mp = NULL;
89 IOCB_t *icmd = &piocbq->iocb;
91 struct lpfc_iocbq *iocbq;
94 struct list_head head;
95 struct lpfc_dmabuf *bdeBuf;
97 if (unlikely(icmd->ulpStatus == IOSTAT_NEED_BUFFER)) {
98 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
99 } else if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
100 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) {
101 /* Not enough posted buffers; Try posting more buffers */
102 phba->fc_stat.NoRcvBuf++;
103 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
104 lpfc_post_buffer(phba, pring, 2, 1);
108 /* If there are no BDEs associated with this IOCB,
109 * there is nothing to do.
111 if (icmd->ulpBdeCount == 0)
114 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
115 INIT_LIST_HEAD(&head);
116 list_add_tail(&head, &piocbq->list);
117 list_for_each_entry(iocbq, &head, list) {
119 if (icmd->ulpBdeCount == 0)
121 bdeBuf = iocbq->context2;
122 iocbq->context2 = NULL;
123 size = icmd->un.cont64[0].tus.f.bdeSize;
124 lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf, size);
125 lpfc_in_buf_free(phba, bdeBuf);
126 if (icmd->ulpBdeCount == 2) {
127 bdeBuf = iocbq->context3;
128 iocbq->context3 = NULL;
129 size = icmd->unsli3.rcvsli3.bde2.tus.f.bdeSize;
130 lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf,
132 lpfc_in_buf_free(phba, bdeBuf);
137 struct lpfc_iocbq *next;
139 list_for_each_entry_safe(iocbq, next, &piocbq->list, list) {
141 if (icmd->ulpBdeCount == 0)
142 lpfc_ct_unsol_buffer(phba, piocbq, NULL, 0);
143 for (i = 0; i < icmd->ulpBdeCount; i++) {
144 paddr = getPaddr(icmd->un.cont64[i].addrHigh,
145 icmd->un.cont64[i].addrLow);
146 mp = lpfc_sli_ringpostbuf_get(phba, pring,
148 size = icmd->un.cont64[i].tus.f.bdeSize;
149 lpfc_ct_unsol_buffer(phba, piocbq, mp, size);
150 lpfc_in_buf_free(phba, mp);
152 list_del(&iocbq->list);
153 lpfc_sli_release_iocbq(phba, iocbq);
154 lpfc_post_buffer(phba, pring, i, 1);
160 lpfc_free_ct_rsp(struct lpfc_hba *phba, struct lpfc_dmabuf *mlist)
162 struct lpfc_dmabuf *mlast, *next_mlast;
164 list_for_each_entry_safe(mlast, next_mlast, &mlist->list, list) {
165 lpfc_mbuf_free(phba, mlast->virt, mlast->phys);
166 list_del(&mlast->list);
169 lpfc_mbuf_free(phba, mlist->virt, mlist->phys);
174 static struct lpfc_dmabuf *
175 lpfc_alloc_ct_rsp(struct lpfc_hba *phba, int cmdcode, struct ulp_bde64 *bpl,
176 uint32_t size, int *entries)
178 struct lpfc_dmabuf *mlist = NULL;
179 struct lpfc_dmabuf *mp;
182 /* We get chunks of FCELSSIZE */
183 cnt = size > FCELSSIZE ? FCELSSIZE: size;
186 /* Allocate buffer for rsp payload */
187 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
190 lpfc_free_ct_rsp(phba, mlist);
194 INIT_LIST_HEAD(&mp->list);
196 if (cmdcode == be16_to_cpu(SLI_CTNS_GID_FT) ||
197 cmdcode == be16_to_cpu(SLI_CTNS_GFF_ID))
198 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
200 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys));
205 lpfc_free_ct_rsp(phba, mlist);
209 /* Queue it to a linked list */
213 list_add_tail(&mp->list, &mlist->list);
215 bpl->tus.f.bdeFlags = BUFF_USE_RCV;
216 /* build buffer ptr list for IOCB */
217 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
218 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
219 bpl->tus.f.bdeSize = (uint16_t) cnt;
220 bpl->tus.w = le32_to_cpu(bpl->tus.w);
232 lpfc_ct_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *ctiocb)
234 struct lpfc_dmabuf *buf_ptr;
236 if (ctiocb->context_un.ndlp) {
237 lpfc_nlp_put(ctiocb->context_un.ndlp);
238 ctiocb->context_un.ndlp = NULL;
240 if (ctiocb->context1) {
241 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context1;
242 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
244 ctiocb->context1 = NULL;
246 if (ctiocb->context2) {
247 lpfc_free_ct_rsp(phba, (struct lpfc_dmabuf *) ctiocb->context2);
248 ctiocb->context2 = NULL;
251 if (ctiocb->context3) {
252 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context3;
253 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
255 ctiocb->context1 = NULL;
257 lpfc_sli_release_iocbq(phba, ctiocb);
262 lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp,
263 struct lpfc_dmabuf *inp, struct lpfc_dmabuf *outp,
264 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
265 struct lpfc_iocbq *),
266 struct lpfc_nodelist *ndlp, uint32_t usr_flg, uint32_t num_entry,
267 uint32_t tmo, uint8_t retry)
269 struct lpfc_hba *phba = vport->phba;
270 struct lpfc_sli *psli = &phba->sli;
271 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
273 struct lpfc_iocbq *geniocb;
276 /* Allocate buffer for command iocb */
277 geniocb = lpfc_sli_get_iocbq(phba);
282 icmd = &geniocb->iocb;
283 icmd->un.genreq64.bdl.ulpIoTag32 = 0;
284 icmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
285 icmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys);
286 icmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BDL;
287 icmd->un.genreq64.bdl.bdeSize = (num_entry * sizeof (struct ulp_bde64));
290 geniocb->context3 = NULL;
292 geniocb->context3 = (uint8_t *) bmp;
294 /* Save for completion so we can release these resources */
295 geniocb->context1 = (uint8_t *) inp;
296 geniocb->context2 = (uint8_t *) outp;
297 geniocb->context_un.ndlp = lpfc_nlp_get(ndlp);
299 /* Fill in payload, bp points to frame payload */
300 icmd->ulpCommand = CMD_GEN_REQUEST64_CR;
302 /* Fill in rest of iocb */
303 icmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
304 icmd->un.genreq64.w5.hcsw.Dfctl = 0;
305 icmd->un.genreq64.w5.hcsw.Rctl = FC_UNSOL_CTL;
306 icmd->un.genreq64.w5.hcsw.Type = FC_COMMON_TRANSPORT_ULP;
309 /* FC spec states we need 3 * ratov for CT requests */
310 tmo = (3 * phba->fc_ratov);
312 icmd->ulpTimeout = tmo;
313 icmd->ulpBdeCount = 1;
315 icmd->ulpClass = CLASS3;
316 icmd->ulpContext = ndlp->nlp_rpi;
318 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
319 /* For GEN_REQUEST64_CR, use the RPI */
324 /* Issue GEN REQ IOCB for NPORT <did> */
325 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
326 "0119 Issue GEN REQ IOCB to NPORT x%x "
328 ndlp->nlp_DID, icmd->ulpIoTag,
330 geniocb->iocb_cmpl = cmpl;
331 geniocb->drvrTimeout = icmd->ulpTimeout + LPFC_DRVR_TIMEOUT;
332 geniocb->vport = vport;
333 geniocb->retry = retry;
334 rc = lpfc_sli_issue_iocb(phba, pring, geniocb, 0);
336 if (rc == IOCB_ERROR) {
337 lpfc_sli_release_iocbq(phba, geniocb);
345 lpfc_ct_cmd(struct lpfc_vport *vport, struct lpfc_dmabuf *inmp,
346 struct lpfc_dmabuf *bmp, struct lpfc_nodelist *ndlp,
347 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
348 struct lpfc_iocbq *),
349 uint32_t rsp_size, uint8_t retry)
351 struct lpfc_hba *phba = vport->phba;
352 struct ulp_bde64 *bpl = (struct ulp_bde64 *) bmp->virt;
353 struct lpfc_dmabuf *outmp;
355 int cmdcode = ((struct lpfc_sli_ct_request *) inmp->virt)->
356 CommandResponse.bits.CmdRsp;
358 bpl++; /* Skip past ct request */
360 /* Put buffer(s) for ct rsp in bpl */
361 outmp = lpfc_alloc_ct_rsp(phba, cmdcode, bpl, rsp_size, &cnt);
365 status = lpfc_gen_req(vport, bmp, inmp, outmp, cmpl, ndlp, 0,
368 lpfc_free_ct_rsp(phba, outmp);
375 lpfc_find_vport_by_did(struct lpfc_hba *phba, uint32_t did) {
376 struct lpfc_vport *vport_curr;
379 spin_lock_irqsave(&phba->hbalock, flags);
380 list_for_each_entry(vport_curr, &phba->port_list, listentry) {
381 if ((vport_curr->fc_myDID) && (vport_curr->fc_myDID == did)) {
382 spin_unlock_irqrestore(&phba->hbalock, flags);
386 spin_unlock_irqrestore(&phba->hbalock, flags);
391 lpfc_ns_rsp(struct lpfc_vport *vport, struct lpfc_dmabuf *mp, uint32_t Size)
393 struct lpfc_hba *phba = vport->phba;
394 struct lpfc_sli_ct_request *Response =
395 (struct lpfc_sli_ct_request *) mp->virt;
396 struct lpfc_nodelist *ndlp = NULL;
397 struct lpfc_dmabuf *mlast, *next_mp;
398 uint32_t *ctptr = (uint32_t *) & Response->un.gid.PortType;
399 uint32_t Did, CTentry;
401 struct list_head head;
403 lpfc_set_disctmo(vport);
404 vport->num_disc_nodes = 0;
405 vport->fc_ns_retry = 0;
408 list_add_tail(&head, &mp->list);
409 list_for_each_entry_safe(mp, next_mp, &head, list) {
412 Cnt = Size > FCELSSIZE ? FCELSSIZE : Size;
417 ctptr = (uint32_t *) mlast->virt;
419 Cnt -= 16; /* subtract length of CT header */
421 /* Loop through entire NameServer list of DIDs */
422 while (Cnt >= sizeof (uint32_t)) {
423 /* Get next DID from NameServer List */
425 Did = ((be32_to_cpu(CTentry)) & Mask_DID);
430 * Check for rscn processing or not
431 * To conserve rpi's, filter out addresses for other
432 * vports on the same physical HBAs.
434 if ((Did != vport->fc_myDID) &&
435 ((lpfc_find_vport_by_did(phba, Did) == NULL) ||
436 vport->cfg_peer_port_login)) {
437 if ((vport->port_type != LPFC_NPIV_PORT) ||
438 (!(vport->ct_flags & FC_CT_RFF_ID)) ||
439 (!vport->cfg_restrict_login)) {
440 ndlp = lpfc_setup_disc_node(vport, Did);
442 lpfc_debugfs_disc_trc(vport,
445 "did:x%x flg:x%x x%x",
449 lpfc_printf_vlog(vport,
454 "Data: x%x x%x x%x\n",
457 vport->fc_rscn_id_cnt);
459 lpfc_debugfs_disc_trc(vport,
462 "did:x%x flg:x%x cnt:%d",
464 vport->fc_rscn_id_cnt);
466 lpfc_printf_vlog(vport,
470 "NameServer Rsp Data: "
473 vport->fc_rscn_id_cnt);
477 if (!(vport->fc_flag & FC_RSCN_MODE) ||
478 (lpfc_rscn_payload_check(vport, Did))) {
479 lpfc_debugfs_disc_trc(vport,
482 "did:x%x flg:x%x cnt:%d",
484 vport->fc_rscn_id_cnt);
486 /* This NPortID was previously
487 * a FCP target, * Don't even
488 * bother to send GFF_ID.
490 ndlp = lpfc_findnode_did(vport,
493 NLP_CHK_NODE_ACT(ndlp)
498 else if (lpfc_ns_cmd(vport,
501 vport->num_disc_nodes++;
504 lpfc_debugfs_disc_trc(vport,
507 "did:x%x flg:x%x cnt:%d",
509 vport->fc_rscn_id_cnt);
511 lpfc_printf_vlog(vport,
515 "NameServer Rsp Data: "
518 vport->fc_rscn_id_cnt);
522 if (CTentry & (be32_to_cpu(SLI_CT_LAST_ENTRY)))
524 Cnt -= sizeof (uint32_t);
536 lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
537 struct lpfc_iocbq *rspiocb)
539 struct lpfc_vport *vport = cmdiocb->vport;
540 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
542 struct lpfc_dmabuf *bmp;
543 struct lpfc_dmabuf *outp;
544 struct lpfc_sli_ct_request *CTrsp;
545 struct lpfc_nodelist *ndlp;
548 /* First save ndlp, before we overwrite it */
549 ndlp = cmdiocb->context_un.ndlp;
551 /* we pass cmdiocb to state machine which needs rspiocb as well */
552 cmdiocb->context_un.rsp_iocb = rspiocb;
554 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
555 bmp = (struct lpfc_dmabuf *) cmdiocb->context3;
556 irsp = &rspiocb->iocb;
558 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
559 "GID_FT cmpl: status:x%x/x%x rtry:%d",
560 irsp->ulpStatus, irsp->un.ulpWord[4], vport->fc_ns_retry);
562 /* Don't bother processing response if vport is being torn down. */
563 if (vport->load_flag & FC_UNLOADING)
566 if (lpfc_els_chk_latt(vport) || lpfc_error_lost_link(irsp)) {
567 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
568 "0216 Link event during NS query\n");
569 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
573 if (irsp->ulpStatus) {
574 /* Check for retry */
575 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) {
577 if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
578 switch (irsp->un.ulpWord[4]) {
579 case IOERR_NO_RESOURCES:
580 /* We don't increment the retry
581 * count for this case.
584 case IOERR_LINK_DOWN:
585 case IOERR_SLI_ABORTED:
590 vport->fc_ns_retry++;
594 vport->fc_ns_retry++;
597 /* CT command is being retried */
598 rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT,
599 vport->fc_ns_retry, 0);
606 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
607 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
608 "0257 GID_FT Query error: 0x%x 0x%x\n",
609 irsp->ulpStatus, vport->fc_ns_retry);
611 /* Good status, continue checking */
612 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
613 if (CTrsp->CommandResponse.bits.CmdRsp ==
614 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) {
615 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
616 "0208 NameServer Rsp Data: x%x\n",
618 lpfc_ns_rsp(vport, outp,
619 (uint32_t) (irsp->un.genreq64.bdl.bdeSize));
620 } else if (CTrsp->CommandResponse.bits.CmdRsp ==
621 be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) {
622 /* NameServer Rsp Error */
623 if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ)
624 && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) {
625 lpfc_printf_vlog(vport, KERN_INFO,
627 "0269 No NameServer Entries "
628 "Data: x%x x%x x%x x%x\n",
629 CTrsp->CommandResponse.bits.CmdRsp,
630 (uint32_t) CTrsp->ReasonCode,
631 (uint32_t) CTrsp->Explanation,
634 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
635 "GID_FT no entry cmd:x%x rsn:x%x exp:x%x",
636 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp,
637 (uint32_t) CTrsp->ReasonCode,
638 (uint32_t) CTrsp->Explanation);
640 lpfc_printf_vlog(vport, KERN_INFO,
642 "0240 NameServer Rsp Error "
643 "Data: x%x x%x x%x x%x\n",
644 CTrsp->CommandResponse.bits.CmdRsp,
645 (uint32_t) CTrsp->ReasonCode,
646 (uint32_t) CTrsp->Explanation,
649 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
650 "GID_FT rsp err1 cmd:x%x rsn:x%x exp:x%x",
651 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp,
652 (uint32_t) CTrsp->ReasonCode,
653 (uint32_t) CTrsp->Explanation);
658 /* NameServer Rsp Error */
659 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
660 "0241 NameServer Rsp Error "
661 "Data: x%x x%x x%x x%x\n",
662 CTrsp->CommandResponse.bits.CmdRsp,
663 (uint32_t) CTrsp->ReasonCode,
664 (uint32_t) CTrsp->Explanation,
667 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
668 "GID_FT rsp err2 cmd:x%x rsn:x%x exp:x%x",
669 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp,
670 (uint32_t) CTrsp->ReasonCode,
671 (uint32_t) CTrsp->Explanation);
674 /* Link up / RSCN discovery */
675 if (vport->num_disc_nodes == 0) {
677 * The driver has cycled through all Nports in the RSCN payload.
678 * Complete the handling by cleaning up and marking the
679 * current driver state.
681 if (vport->port_state >= LPFC_DISC_AUTH) {
682 if (vport->fc_flag & FC_RSCN_MODE) {
683 lpfc_els_flush_rscn(vport);
684 spin_lock_irq(shost->host_lock);
685 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */
686 spin_unlock_irq(shost->host_lock);
689 lpfc_els_flush_rscn(vport);
692 lpfc_disc_start(vport);
695 cmdiocb->context_un.ndlp = ndlp; /* Now restore ndlp for free */
696 lpfc_ct_free_iocb(phba, cmdiocb);
701 lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
702 struct lpfc_iocbq *rspiocb)
704 struct lpfc_vport *vport = cmdiocb->vport;
705 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
706 IOCB_t *irsp = &rspiocb->iocb;
707 struct lpfc_dmabuf *inp = (struct lpfc_dmabuf *) cmdiocb->context1;
708 struct lpfc_dmabuf *outp = (struct lpfc_dmabuf *) cmdiocb->context2;
709 struct lpfc_sli_ct_request *CTrsp;
712 struct lpfc_nodelist *ndlp;
714 did = ((struct lpfc_sli_ct_request *) inp->virt)->un.gff.PortId;
715 did = be32_to_cpu(did);
717 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
718 "GFF_ID cmpl: status:x%x/x%x did:x%x",
719 irsp->ulpStatus, irsp->un.ulpWord[4], did);
721 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
722 /* Good status, continue checking */
723 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
724 fbits = CTrsp->un.gff_acc.fbits[FCP_TYPE_FEATURE_OFFSET];
726 if (CTrsp->CommandResponse.bits.CmdRsp ==
727 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) {
728 if ((fbits & FC4_FEATURE_INIT) &&
729 !(fbits & FC4_FEATURE_TARGET)) {
730 lpfc_printf_vlog(vport, KERN_INFO,
733 "NameServer Rsp Data: (init) "
734 "x%x x%x\n", did, fbits,
735 vport->fc_rscn_id_cnt);
741 /* Check for retry */
742 if (cmdiocb->retry < LPFC_MAX_NS_RETRY) {
744 if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
745 switch (irsp->un.ulpWord[4]) {
746 case IOERR_NO_RESOURCES:
747 /* We don't increment the retry
748 * count for this case.
751 case IOERR_LINK_DOWN:
752 case IOERR_SLI_ABORTED:
764 /* CT command is being retried */
765 rc = lpfc_ns_cmd(vport, SLI_CTNS_GFF_ID,
766 cmdiocb->retry, did);
769 lpfc_ct_free_iocb(phba, cmdiocb);
774 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
775 "0267 NameServer GFF Rsp "
776 "x%x Error (%d %d) Data: x%x x%x\n",
777 did, irsp->ulpStatus, irsp->un.ulpWord[4],
778 vport->fc_flag, vport->fc_rscn_id_cnt);
781 /* This is a target port, unregistered port, or the GFF_ID failed */
782 ndlp = lpfc_setup_disc_node(vport, did);
784 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
785 "0242 Process x%x GFF "
786 "NameServer Rsp Data: x%x x%x x%x\n",
787 did, ndlp->nlp_flag, vport->fc_flag,
788 vport->fc_rscn_id_cnt);
790 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
792 "NameServer Rsp Data: x%x x%x\n", did,
793 vport->fc_flag, vport->fc_rscn_id_cnt);
796 /* Link up / RSCN discovery */
797 if (vport->num_disc_nodes)
798 vport->num_disc_nodes--;
799 if (vport->num_disc_nodes == 0) {
801 * The driver has cycled through all Nports in the RSCN payload.
802 * Complete the handling by cleaning up and marking the
803 * current driver state.
805 if (vport->port_state >= LPFC_DISC_AUTH) {
806 if (vport->fc_flag & FC_RSCN_MODE) {
807 lpfc_els_flush_rscn(vport);
808 spin_lock_irq(shost->host_lock);
809 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */
810 spin_unlock_irq(shost->host_lock);
813 lpfc_els_flush_rscn(vport);
815 lpfc_disc_start(vport);
817 lpfc_ct_free_iocb(phba, cmdiocb);
823 lpfc_cmpl_ct(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
824 struct lpfc_iocbq *rspiocb)
826 struct lpfc_vport *vport = cmdiocb->vport;
827 struct lpfc_dmabuf *inp;
828 struct lpfc_dmabuf *outp;
830 struct lpfc_sli_ct_request *CTrsp;
831 struct lpfc_nodelist *ndlp;
836 /* First save ndlp, before we overwrite it */
837 ndlp = cmdiocb->context_un.ndlp;
839 /* we pass cmdiocb to state machine which needs rspiocb as well */
840 cmdiocb->context_un.rsp_iocb = rspiocb;
842 inp = (struct lpfc_dmabuf *) cmdiocb->context1;
843 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
844 irsp = &rspiocb->iocb;
846 cmdcode = be16_to_cpu(((struct lpfc_sli_ct_request *) inp->virt)->
847 CommandResponse.bits.CmdRsp);
848 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
850 latt = lpfc_els_chk_latt(vport);
852 /* RFT request completes status <ulpStatus> CmdRsp <CmdRsp> */
853 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
854 "0209 CT Request completes, latt %d, "
855 "ulpStatus x%x CmdRsp x%x, Context x%x, Tag x%x\n",
856 latt, irsp->ulpStatus,
857 CTrsp->CommandResponse.bits.CmdRsp,
858 cmdiocb->iocb.ulpContext, cmdiocb->iocb.ulpIoTag);
860 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
861 "CT cmd cmpl: status:x%x/x%x cmd:x%x",
862 irsp->ulpStatus, irsp->un.ulpWord[4], cmdcode);
864 if (irsp->ulpStatus) {
865 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
866 "0268 NS cmd %x Error (%d %d)\n",
867 cmdcode, irsp->ulpStatus, irsp->un.ulpWord[4]);
869 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
870 ((irsp->un.ulpWord[4] == IOERR_SLI_DOWN) ||
871 (irsp->un.ulpWord[4] == IOERR_SLI_ABORTED)))
874 retry = cmdiocb->retry;
875 if (retry >= LPFC_MAX_NS_RETRY)
879 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
880 "0216 Retrying NS cmd %x\n", cmdcode);
881 rc = lpfc_ns_cmd(vport, cmdcode, retry, 0);
887 cmdiocb->context_un.ndlp = ndlp; /* Now restore ndlp for free */
888 lpfc_ct_free_iocb(phba, cmdiocb);
893 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
894 struct lpfc_iocbq *rspiocb)
896 IOCB_t *irsp = &rspiocb->iocb;
897 struct lpfc_vport *vport = cmdiocb->vport;
899 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
900 struct lpfc_dmabuf *outp;
901 struct lpfc_sli_ct_request *CTrsp;
903 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
904 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
905 if (CTrsp->CommandResponse.bits.CmdRsp ==
906 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
907 vport->ct_flags |= FC_CT_RFT_ID;
909 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
914 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
915 struct lpfc_iocbq *rspiocb)
917 IOCB_t *irsp = &rspiocb->iocb;
918 struct lpfc_vport *vport = cmdiocb->vport;
920 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
921 struct lpfc_dmabuf *outp;
922 struct lpfc_sli_ct_request *CTrsp;
924 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
925 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
926 if (CTrsp->CommandResponse.bits.CmdRsp ==
927 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
928 vport->ct_flags |= FC_CT_RNN_ID;
930 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
935 lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
936 struct lpfc_iocbq *rspiocb)
938 IOCB_t *irsp = &rspiocb->iocb;
939 struct lpfc_vport *vport = cmdiocb->vport;
941 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
942 struct lpfc_dmabuf *outp;
943 struct lpfc_sli_ct_request *CTrsp;
945 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
946 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
947 if (CTrsp->CommandResponse.bits.CmdRsp ==
948 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
949 vport->ct_flags |= FC_CT_RSPN_ID;
951 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
956 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
957 struct lpfc_iocbq *rspiocb)
959 IOCB_t *irsp = &rspiocb->iocb;
960 struct lpfc_vport *vport = cmdiocb->vport;
962 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
963 struct lpfc_dmabuf *outp;
964 struct lpfc_sli_ct_request *CTrsp;
966 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
967 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
968 if (CTrsp->CommandResponse.bits.CmdRsp ==
969 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
970 vport->ct_flags |= FC_CT_RSNN_NN;
972 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
977 lpfc_cmpl_ct_cmd_da_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
978 struct lpfc_iocbq *rspiocb)
980 struct lpfc_vport *vport = cmdiocb->vport;
982 /* even if it fails we will act as though it succeeded. */
984 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
989 lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
990 struct lpfc_iocbq *rspiocb)
992 IOCB_t *irsp = &rspiocb->iocb;
993 struct lpfc_vport *vport = cmdiocb->vport;
995 if (irsp->ulpStatus == IOSTAT_SUCCESS) {
996 struct lpfc_dmabuf *outp;
997 struct lpfc_sli_ct_request *CTrsp;
999 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
1000 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1001 if (CTrsp->CommandResponse.bits.CmdRsp ==
1002 be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
1003 vport->ct_flags |= FC_CT_RFF_ID;
1005 lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1010 lpfc_vport_symbolic_port_name(struct lpfc_vport *vport, char *symbol,
1014 uint8_t *wwn = vport->phba->wwpn;
1016 n = snprintf(symbol, size,
1017 "Emulex PPN-%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1018 wwn[0], wwn[1], wwn[2], wwn[3],
1019 wwn[4], wwn[5], wwn[6], wwn[7]);
1021 if (vport->port_type == LPFC_PHYSICAL_PORT)
1025 n += snprintf(symbol + n, size - n, " VPort-%d", vport->vpi);
1027 if (n < size && vport->vname)
1028 n += snprintf(symbol + n, size - n, " VName-%s", vport->vname);
1033 lpfc_vport_symbolic_node_name(struct lpfc_vport *vport, char *symbol,
1039 lpfc_decode_firmware_rev(vport->phba, fwrev, 0);
1041 n = snprintf(symbol, size, "Emulex %s FV%s DV%s",
1042 vport->phba->ModelName, fwrev, lpfc_release_version);
1049 * Issue Cmd to NameServer
1054 lpfc_ns_cmd(struct lpfc_vport *vport, int cmdcode,
1055 uint8_t retry, uint32_t context)
1057 struct lpfc_nodelist * ndlp;
1058 struct lpfc_hba *phba = vport->phba;
1059 struct lpfc_dmabuf *mp, *bmp;
1060 struct lpfc_sli_ct_request *CtReq;
1061 struct ulp_bde64 *bpl;
1062 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
1063 struct lpfc_iocbq *) = NULL;
1064 uint32_t rsp_size = 1024;
1068 ndlp = lpfc_findnode_did(vport, NameServer_DID);
1069 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)
1070 || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) {
1075 /* fill in BDEs for command */
1076 /* Allocate buffer for command payload */
1077 mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1083 INIT_LIST_HEAD(&mp->list);
1084 mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
1087 goto ns_cmd_free_mp;
1090 /* Allocate buffer for Buffer ptr list */
1091 bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1094 goto ns_cmd_free_mpvirt;
1097 INIT_LIST_HEAD(&bmp->list);
1098 bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys));
1101 goto ns_cmd_free_bmp;
1104 /* NameServer Req */
1105 lpfc_printf_vlog(vport, KERN_INFO ,LOG_DISCOVERY,
1106 "0236 NameServer Req Data: x%x x%x x%x\n",
1107 cmdcode, vport->fc_flag, vport->fc_rscn_id_cnt);
1109 bpl = (struct ulp_bde64 *) bmp->virt;
1110 memset(bpl, 0, sizeof(struct ulp_bde64));
1111 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
1112 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
1113 bpl->tus.f.bdeFlags = 0;
1114 if (cmdcode == SLI_CTNS_GID_FT)
1115 bpl->tus.f.bdeSize = GID_REQUEST_SZ;
1116 else if (cmdcode == SLI_CTNS_GFF_ID)
1117 bpl->tus.f.bdeSize = GFF_REQUEST_SZ;
1118 else if (cmdcode == SLI_CTNS_RFT_ID)
1119 bpl->tus.f.bdeSize = RFT_REQUEST_SZ;
1120 else if (cmdcode == SLI_CTNS_RNN_ID)
1121 bpl->tus.f.bdeSize = RNN_REQUEST_SZ;
1122 else if (cmdcode == SLI_CTNS_RSPN_ID)
1123 bpl->tus.f.bdeSize = RSPN_REQUEST_SZ;
1124 else if (cmdcode == SLI_CTNS_RSNN_NN)
1125 bpl->tus.f.bdeSize = RSNN_REQUEST_SZ;
1126 else if (cmdcode == SLI_CTNS_DA_ID)
1127 bpl->tus.f.bdeSize = DA_ID_REQUEST_SZ;
1128 else if (cmdcode == SLI_CTNS_RFF_ID)
1129 bpl->tus.f.bdeSize = RFF_REQUEST_SZ;
1131 bpl->tus.f.bdeSize = 0;
1132 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1134 CtReq = (struct lpfc_sli_ct_request *) mp->virt;
1135 memset(CtReq, 0, sizeof (struct lpfc_sli_ct_request));
1136 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
1137 CtReq->RevisionId.bits.InId = 0;
1138 CtReq->FsType = SLI_CT_DIRECTORY_SERVICE;
1139 CtReq->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER;
1140 CtReq->CommandResponse.bits.Size = 0;
1142 case SLI_CTNS_GID_FT:
1143 CtReq->CommandResponse.bits.CmdRsp =
1144 be16_to_cpu(SLI_CTNS_GID_FT);
1145 CtReq->un.gid.Fc4Type = SLI_CTPT_FCP;
1146 if (vport->port_state < LPFC_NS_QRY)
1147 vport->port_state = LPFC_NS_QRY;
1148 lpfc_set_disctmo(vport);
1149 cmpl = lpfc_cmpl_ct_cmd_gid_ft;
1150 rsp_size = FC_MAX_NS_RSP;
1153 case SLI_CTNS_GFF_ID:
1154 CtReq->CommandResponse.bits.CmdRsp =
1155 be16_to_cpu(SLI_CTNS_GFF_ID);
1156 CtReq->un.gff.PortId = cpu_to_be32(context);
1157 cmpl = lpfc_cmpl_ct_cmd_gff_id;
1160 case SLI_CTNS_RFT_ID:
1161 vport->ct_flags &= ~FC_CT_RFT_ID;
1162 CtReq->CommandResponse.bits.CmdRsp =
1163 be16_to_cpu(SLI_CTNS_RFT_ID);
1164 CtReq->un.rft.PortId = cpu_to_be32(vport->fc_myDID);
1165 CtReq->un.rft.fcpReg = 1;
1166 cmpl = lpfc_cmpl_ct_cmd_rft_id;
1169 case SLI_CTNS_RNN_ID:
1170 vport->ct_flags &= ~FC_CT_RNN_ID;
1171 CtReq->CommandResponse.bits.CmdRsp =
1172 be16_to_cpu(SLI_CTNS_RNN_ID);
1173 CtReq->un.rnn.PortId = cpu_to_be32(vport->fc_myDID);
1174 memcpy(CtReq->un.rnn.wwnn, &vport->fc_nodename,
1175 sizeof (struct lpfc_name));
1176 cmpl = lpfc_cmpl_ct_cmd_rnn_id;
1179 case SLI_CTNS_RSPN_ID:
1180 vport->ct_flags &= ~FC_CT_RSPN_ID;
1181 CtReq->CommandResponse.bits.CmdRsp =
1182 be16_to_cpu(SLI_CTNS_RSPN_ID);
1183 CtReq->un.rspn.PortId = cpu_to_be32(vport->fc_myDID);
1184 size = sizeof(CtReq->un.rspn.symbname);
1185 CtReq->un.rspn.len =
1186 lpfc_vport_symbolic_port_name(vport,
1187 CtReq->un.rspn.symbname, size);
1188 cmpl = lpfc_cmpl_ct_cmd_rspn_id;
1190 case SLI_CTNS_RSNN_NN:
1191 vport->ct_flags &= ~FC_CT_RSNN_NN;
1192 CtReq->CommandResponse.bits.CmdRsp =
1193 be16_to_cpu(SLI_CTNS_RSNN_NN);
1194 memcpy(CtReq->un.rsnn.wwnn, &vport->fc_nodename,
1195 sizeof (struct lpfc_name));
1196 size = sizeof(CtReq->un.rsnn.symbname);
1197 CtReq->un.rsnn.len =
1198 lpfc_vport_symbolic_node_name(vport,
1199 CtReq->un.rsnn.symbname, size);
1200 cmpl = lpfc_cmpl_ct_cmd_rsnn_nn;
1202 case SLI_CTNS_DA_ID:
1203 /* Implement DA_ID Nameserver request */
1204 CtReq->CommandResponse.bits.CmdRsp =
1205 be16_to_cpu(SLI_CTNS_DA_ID);
1206 CtReq->un.da_id.port_id = cpu_to_be32(vport->fc_myDID);
1207 cmpl = lpfc_cmpl_ct_cmd_da_id;
1209 case SLI_CTNS_RFF_ID:
1210 vport->ct_flags &= ~FC_CT_RFF_ID;
1211 CtReq->CommandResponse.bits.CmdRsp =
1212 be16_to_cpu(SLI_CTNS_RFF_ID);
1213 CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID);;
1214 CtReq->un.rff.fbits = FC4_FEATURE_INIT;
1215 CtReq->un.rff.type_code = FC_FCP_DATA;
1216 cmpl = lpfc_cmpl_ct_cmd_rff_id;
1219 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
1220 * to hold ndlp reference for the corresponding callback function.
1222 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry)) {
1223 /* On success, The cmpl function will free the buffers */
1224 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1225 "Issue CT cmd: cmd:x%x did:x%x",
1226 cmdcode, ndlp->nlp_DID, 0);
1231 /* Decrement ndlp reference count to release ndlp reference held
1232 * for the failed command's callback function.
1236 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1240 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1244 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
1245 "0266 Issue NameServer Req x%x err %d Data: x%x x%x\n",
1246 cmdcode, rc, vport->fc_flag, vport->fc_rscn_id_cnt);
1251 lpfc_cmpl_ct_cmd_fdmi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1252 struct lpfc_iocbq * rspiocb)
1254 struct lpfc_dmabuf *inp = cmdiocb->context1;
1255 struct lpfc_dmabuf *outp = cmdiocb->context2;
1256 struct lpfc_sli_ct_request *CTrsp = outp->virt;
1257 struct lpfc_sli_ct_request *CTcmd = inp->virt;
1258 struct lpfc_nodelist *ndlp;
1259 uint16_t fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp;
1260 uint16_t fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp;
1261 struct lpfc_vport *vport = cmdiocb->vport;
1262 IOCB_t *irsp = &rspiocb->iocb;
1265 latt = lpfc_els_chk_latt(vport);
1267 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1268 "FDMI cmpl: status:x%x/x%x latt:%d",
1269 irsp->ulpStatus, irsp->un.ulpWord[4], latt);
1271 if (latt || irsp->ulpStatus) {
1272 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1273 "0229 FDMI cmd %04x failed, latt = %d "
1274 "ulpStatus: x%x, rid x%x\n",
1275 be16_to_cpu(fdmi_cmd), latt, irsp->ulpStatus,
1276 irsp->un.ulpWord[4]);
1277 lpfc_ct_free_iocb(phba, cmdiocb);
1281 ndlp = lpfc_findnode_did(vport, FDMI_DID);
1282 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
1285 if (fdmi_rsp == be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) {
1286 /* FDMI rsp failed */
1287 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1288 "0220 FDMI rsp failed Data: x%x\n",
1289 be16_to_cpu(fdmi_cmd));
1292 switch (be16_to_cpu(fdmi_cmd)) {
1294 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA);
1301 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT);
1305 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RHBA);
1310 lpfc_ct_free_iocb(phba, cmdiocb);
1315 lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, int cmdcode)
1317 struct lpfc_hba *phba = vport->phba;
1318 struct lpfc_dmabuf *mp, *bmp;
1319 struct lpfc_sli_ct_request *CtReq;
1320 struct ulp_bde64 *bpl;
1324 REG_PORT_ATTRIBUTE *pab;
1325 ATTRIBUTE_BLOCK *ab;
1326 ATTRIBUTE_ENTRY *ae;
1327 void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
1328 struct lpfc_iocbq *);
1331 /* fill in BDEs for command */
1332 /* Allocate buffer for command payload */
1333 mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1337 mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys));
1339 goto fdmi_cmd_free_mp;
1341 /* Allocate buffer for Buffer ptr list */
1342 bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1344 goto fdmi_cmd_free_mpvirt;
1346 bmp->virt = lpfc_mbuf_alloc(phba, 0, &(bmp->phys));
1348 goto fdmi_cmd_free_bmp;
1350 INIT_LIST_HEAD(&mp->list);
1351 INIT_LIST_HEAD(&bmp->list);
1354 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1355 "0218 FDMI Request Data: x%x x%x x%x\n",
1356 vport->fc_flag, vport->port_state, cmdcode);
1357 CtReq = (struct lpfc_sli_ct_request *) mp->virt;
1359 memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request));
1360 CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
1361 CtReq->RevisionId.bits.InId = 0;
1363 CtReq->FsType = SLI_CT_MANAGEMENT_SERVICE;
1364 CtReq->FsSubType = SLI_CT_FDMI_Subtypes;
1370 lpfc_vpd_t *vp = &phba->vpd;
1371 uint32_t i, j, incr;
1374 CtReq->CommandResponse.bits.CmdRsp =
1375 be16_to_cpu(SLI_MGMT_RHBA);
1376 CtReq->CommandResponse.bits.Size = 0;
1377 rh = (REG_HBA *) & CtReq->un.PortID;
1378 memcpy(&rh->hi.PortName, &vport->fc_sparam.portName,
1379 sizeof (struct lpfc_name));
1380 /* One entry (port) per adapter */
1381 rh->rpl.EntryCnt = be32_to_cpu(1);
1382 memcpy(&rh->rpl.pe, &vport->fc_sparam.portName,
1383 sizeof (struct lpfc_name));
1385 /* point to the HBA attribute block */
1386 size = 2 * sizeof (struct lpfc_name) + FOURBYTES;
1387 ab = (ATTRIBUTE_BLOCK *) ((uint8_t *) rh + size);
1390 /* Point to the beginning of the first HBA attribute
1392 /* #1 HBA attribute entry */
1394 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1395 ae->ad.bits.AttrType = be16_to_cpu(NODE_NAME);
1396 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES
1397 + sizeof (struct lpfc_name));
1398 memcpy(&ae->un.NodeName, &vport->fc_sparam.nodeName,
1399 sizeof (struct lpfc_name));
1401 size += FOURBYTES + sizeof (struct lpfc_name);
1403 /* #2 HBA attribute entry */
1404 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1405 ae->ad.bits.AttrType = be16_to_cpu(MANUFACTURER);
1406 strcpy(ae->un.Manufacturer, "Emulex Corporation");
1407 len = strlen(ae->un.Manufacturer);
1408 len += (len & 3) ? (4 - (len & 3)) : 4;
1409 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1411 size += FOURBYTES + len;
1413 /* #3 HBA attribute entry */
1414 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1415 ae->ad.bits.AttrType = be16_to_cpu(SERIAL_NUMBER);
1416 strcpy(ae->un.SerialNumber, phba->SerialNumber);
1417 len = strlen(ae->un.SerialNumber);
1418 len += (len & 3) ? (4 - (len & 3)) : 4;
1419 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1421 size += FOURBYTES + len;
1423 /* #4 HBA attribute entry */
1424 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1425 ae->ad.bits.AttrType = be16_to_cpu(MODEL);
1426 strcpy(ae->un.Model, phba->ModelName);
1427 len = strlen(ae->un.Model);
1428 len += (len & 3) ? (4 - (len & 3)) : 4;
1429 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1431 size += FOURBYTES + len;
1433 /* #5 HBA attribute entry */
1434 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1435 ae->ad.bits.AttrType = be16_to_cpu(MODEL_DESCRIPTION);
1436 strcpy(ae->un.ModelDescription, phba->ModelDesc);
1437 len = strlen(ae->un.ModelDescription);
1438 len += (len & 3) ? (4 - (len & 3)) : 4;
1439 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1441 size += FOURBYTES + len;
1443 /* #6 HBA attribute entry */
1444 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1445 ae->ad.bits.AttrType = be16_to_cpu(HARDWARE_VERSION);
1446 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 8);
1447 /* Convert JEDEC ID to ascii for hardware version */
1448 incr = vp->rev.biuRev;
1449 for (i = 0; i < 8; i++) {
1452 ae->un.HardwareVersion[7 - i] =
1453 (char)((uint8_t) 0x30 +
1456 ae->un.HardwareVersion[7 - i] =
1457 (char)((uint8_t) 0x61 +
1458 (uint8_t) (j - 10));
1462 size += FOURBYTES + 8;
1464 /* #7 HBA attribute entry */
1465 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1466 ae->ad.bits.AttrType = be16_to_cpu(DRIVER_VERSION);
1467 strcpy(ae->un.DriverVersion, lpfc_release_version);
1468 len = strlen(ae->un.DriverVersion);
1469 len += (len & 3) ? (4 - (len & 3)) : 4;
1470 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1472 size += FOURBYTES + len;
1474 /* #8 HBA attribute entry */
1475 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1476 ae->ad.bits.AttrType = be16_to_cpu(OPTION_ROM_VERSION);
1477 strcpy(ae->un.OptionROMVersion, phba->OptionROMVersion);
1478 len = strlen(ae->un.OptionROMVersion);
1479 len += (len & 3) ? (4 - (len & 3)) : 4;
1480 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1482 size += FOURBYTES + len;
1484 /* #9 HBA attribute entry */
1485 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1486 ae->ad.bits.AttrType = be16_to_cpu(FIRMWARE_VERSION);
1487 lpfc_decode_firmware_rev(phba, ae->un.FirmwareVersion,
1489 len = strlen(ae->un.FirmwareVersion);
1490 len += (len & 3) ? (4 - (len & 3)) : 4;
1491 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1493 size += FOURBYTES + len;
1495 /* #10 HBA attribute entry */
1496 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1497 ae->ad.bits.AttrType = be16_to_cpu(OS_NAME_VERSION);
1498 sprintf(ae->un.OsNameVersion, "%s %s %s",
1499 init_utsname()->sysname,
1500 init_utsname()->release,
1501 init_utsname()->version);
1502 len = strlen(ae->un.OsNameVersion);
1503 len += (len & 3) ? (4 - (len & 3)) : 4;
1504 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1506 size += FOURBYTES + len;
1508 /* #11 HBA attribute entry */
1509 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1510 ae->ad.bits.AttrType = be16_to_cpu(MAX_CT_PAYLOAD_LEN);
1511 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
1512 ae->un.MaxCTPayloadLen = (65 * 4096);
1514 size += FOURBYTES + 4;
1516 ab->EntryCnt = be32_to_cpu(ab->EntryCnt);
1518 size = GID_REQUEST_SZ - 4 + size;
1525 struct serv_parm *hsp;
1530 CtReq->CommandResponse.bits.CmdRsp =
1531 be16_to_cpu(SLI_MGMT_RPA);
1532 CtReq->CommandResponse.bits.Size = 0;
1533 pab = (REG_PORT_ATTRIBUTE *) & CtReq->un.PortID;
1534 size = sizeof (struct lpfc_name) + FOURBYTES;
1535 memcpy((uint8_t *) & pab->PortName,
1536 (uint8_t *) & vport->fc_sparam.portName,
1537 sizeof (struct lpfc_name));
1538 pab->ab.EntryCnt = 0;
1540 /* #1 Port attribute entry */
1541 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1542 ae->ad.bits.AttrType = be16_to_cpu(SUPPORTED_FC4_TYPES);
1543 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 32);
1544 ae->un.SupportFC4Types[2] = 1;
1545 ae->un.SupportFC4Types[7] = 1;
1547 size += FOURBYTES + 32;
1549 /* #2 Port attribute entry */
1550 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1551 ae->ad.bits.AttrType = be16_to_cpu(SUPPORTED_SPEED);
1552 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
1554 ae->un.SupportSpeed = 0;
1555 if (phba->lmt & LMT_10Gb)
1556 ae->un.SupportSpeed = HBA_PORTSPEED_10GBIT;
1557 if (phba->lmt & LMT_8Gb)
1558 ae->un.SupportSpeed |= HBA_PORTSPEED_8GBIT;
1559 if (phba->lmt & LMT_4Gb)
1560 ae->un.SupportSpeed |= HBA_PORTSPEED_4GBIT;
1561 if (phba->lmt & LMT_2Gb)
1562 ae->un.SupportSpeed |= HBA_PORTSPEED_2GBIT;
1563 if (phba->lmt & LMT_1Gb)
1564 ae->un.SupportSpeed |= HBA_PORTSPEED_1GBIT;
1567 size += FOURBYTES + 4;
1569 /* #3 Port attribute entry */
1570 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1571 ae->ad.bits.AttrType = be16_to_cpu(PORT_SPEED);
1572 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
1573 switch(phba->fc_linkspeed) {
1575 ae->un.PortSpeed = HBA_PORTSPEED_1GBIT;
1578 ae->un.PortSpeed = HBA_PORTSPEED_2GBIT;
1581 ae->un.PortSpeed = HBA_PORTSPEED_4GBIT;
1584 ae->un.PortSpeed = HBA_PORTSPEED_8GBIT;
1588 HBA_PORTSPEED_UNKNOWN;
1592 size += FOURBYTES + 4;
1594 /* #4 Port attribute entry */
1595 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1596 ae->ad.bits.AttrType = be16_to_cpu(MAX_FRAME_SIZE);
1597 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
1598 hsp = (struct serv_parm *) & vport->fc_sparam;
1599 ae->un.MaxFrameSize =
1600 (((uint32_t) hsp->cmn.
1601 bbRcvSizeMsb) << 8) | (uint32_t) hsp->cmn.
1604 size += FOURBYTES + 4;
1606 /* #5 Port attribute entry */
1607 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1608 ae->ad.bits.AttrType = be16_to_cpu(OS_DEVICE_NAME);
1609 strcpy((char *)ae->un.OsDeviceName, LPFC_DRIVER_NAME);
1610 len = strlen((char *)ae->un.OsDeviceName);
1611 len += (len & 3) ? (4 - (len & 3)) : 4;
1612 ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1614 size += FOURBYTES + len;
1616 if (vport->cfg_fdmi_on == 2) {
1617 /* #6 Port attribute entry */
1618 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab +
1620 ae->ad.bits.AttrType = be16_to_cpu(HOST_NAME);
1621 sprintf(ae->un.HostName, "%s",
1622 init_utsname()->nodename);
1623 len = strlen(ae->un.HostName);
1624 len += (len & 3) ? (4 - (len & 3)) : 4;
1625 ae->ad.bits.AttrLen =
1626 be16_to_cpu(FOURBYTES + len);
1628 size += FOURBYTES + len;
1631 pab->ab.EntryCnt = be32_to_cpu(pab->ab.EntryCnt);
1633 size = GID_REQUEST_SZ - 4 + size;
1638 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DHBA);
1639 CtReq->CommandResponse.bits.Size = 0;
1640 pe = (PORT_ENTRY *) & CtReq->un.PortID;
1641 memcpy((uint8_t *) & pe->PortName,
1642 (uint8_t *) & vport->fc_sparam.portName,
1643 sizeof (struct lpfc_name));
1644 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name);
1648 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DPRT);
1649 CtReq->CommandResponse.bits.Size = 0;
1650 pe = (PORT_ENTRY *) & CtReq->un.PortID;
1651 memcpy((uint8_t *) & pe->PortName,
1652 (uint8_t *) & vport->fc_sparam.portName,
1653 sizeof (struct lpfc_name));
1654 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name);
1658 bpl = (struct ulp_bde64 *) bmp->virt;
1659 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
1660 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
1661 bpl->tus.f.bdeFlags = 0;
1662 bpl->tus.f.bdeSize = size;
1663 bpl->tus.w = le32_to_cpu(bpl->tus.w);
1665 cmpl = lpfc_cmpl_ct_cmd_fdmi;
1667 /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
1668 * to hold ndlp reference for the corresponding callback function.
1670 if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, FC_MAX_NS_RSP, 0))
1673 /* Decrement ndlp reference count to release ndlp reference held
1674 * for the failed command's callback function.
1678 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1681 fdmi_cmd_free_mpvirt:
1682 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1686 /* Issue FDMI request failed */
1687 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1688 "0244 Issue FDMI request failed Data: x%x\n",
1694 lpfc_fdmi_tmo(unsigned long ptr)
1696 struct lpfc_vport *vport = (struct lpfc_vport *)ptr;
1697 struct lpfc_hba *phba = vport->phba;
1698 unsigned long iflag;
1700 spin_lock_irqsave(&vport->work_port_lock, iflag);
1701 if (!(vport->work_port_events & WORKER_FDMI_TMO)) {
1702 vport->work_port_events |= WORKER_FDMI_TMO;
1703 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
1705 spin_lock_irqsave(&phba->hbalock, iflag);
1706 if (phba->work_wait)
1707 lpfc_worker_wake_up(phba);
1708 spin_unlock_irqrestore(&phba->hbalock, iflag);
1711 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
1715 lpfc_fdmi_timeout_handler(struct lpfc_vport *vport)
1717 struct lpfc_nodelist *ndlp;
1719 ndlp = lpfc_findnode_did(vport, FDMI_DID);
1720 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
1721 if (init_utsname()->nodename[0] != '\0')
1722 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA);
1724 mod_timer(&vport->fc_fdmitmo, jiffies + HZ * 60);
1730 lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag)
1732 struct lpfc_sli *psli = &phba->sli;
1733 lpfc_vpd_t *vp = &phba->vpd;
1734 uint32_t b1, b2, b3, b4, i, rev;
1736 uint32_t *ptr, str[4];
1740 if (psli->sli_flag & LPFC_SLI2_ACTIVE)
1741 rev = vp->rev.sli2FwRev;
1743 rev = vp->rev.sli1FwRev;
1745 b1 = (rev & 0x0000f000) >> 12;
1746 b2 = (rev & 0x00000f00) >> 8;
1747 b3 = (rev & 0x000000c0) >> 6;
1748 b4 = (rev & 0x00000030) >> 4;
1764 b4 = (rev & 0x0000000f);
1766 if (psli->sli_flag & LPFC_SLI2_ACTIVE)
1767 fwname = vp->rev.sli2FwName;
1769 fwname = vp->rev.sli1FwName;
1771 for (i = 0; i < 16; i++)
1772 if (fwname[i] == 0x20)
1775 ptr = (uint32_t*)fwname;
1777 for (i = 0; i < 3; i++)
1778 str[i] = be32_to_cpu(*ptr++);
1782 sprintf(fwrevision, "%d.%d%d (%s)",
1783 b1, b2, b3, (char *)str);
1785 sprintf(fwrevision, "%d.%d%d", b1,
1789 sprintf(fwrevision, "%d.%d%d%c%d (%s)",
1793 sprintf(fwrevision, "%d.%d%d%c%d",
1797 rev = vp->rev.smFwRev;
1799 b1 = (rev & 0xff000000) >> 24;
1800 b2 = (rev & 0x00f00000) >> 20;
1801 b3 = (rev & 0x000f0000) >> 16;
1802 c = (rev & 0x0000ff00) >> 8;
1803 b4 = (rev & 0x000000ff);
1806 sprintf(fwrevision, "%d.%d%d%c%d ", b1,
1809 sprintf(fwrevision, "%d.%d%d%c%d ", b1,