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