drivers/scsi/lpfc/lpfc_ct.c

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