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) 2004-2010 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  *                                                                 *
   8  * This program is free software; you can redistribute it and/or   *
   9  * modify it under the terms of version 2 of the GNU General       *
  10  * Public License as published by the Free Software Foundation.    *
  11  * This program is distributed in the hope that it will be useful. *
  12  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  13  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  14  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  15  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  16  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  17  * more details, a copy of which can be found in the file COPYING  *
  18  * included with this package.                                     *
  19  *******************************************************************/
  20
  21 /*
  22  * Fibre Channel SCSI LAN Device Driver CT support: FC Generic Services FC-GS
  23  */
  24
  25 #include <linux/blkdev.h>
  26 #include <linux/pci.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/slab.h>
  29 #include <linux/utsname.h>
  30
  31 #include <scsi/scsi.h>
  32 #include <scsi/scsi_device.h>
  33 #include <scsi/scsi_host.h>
  34 #include <scsi/scsi_transport_fc.h>
  35 #include <scsi/fc/fc_fs.h>
  36
  37 #include "lpfc_hw4.h"
  38 #include "lpfc_hw.h"
  39 #include "lpfc_sli.h"
  40 #include "lpfc_sli4.h"
  41 #include "lpfc_nl.h"
  42 #include "lpfc_disc.h"
  43 #include "lpfc_scsi.h"
  44 #include "lpfc.h"
  45 #include "lpfc_logmsg.h"
  46 #include "lpfc_crtn.h"
  47 #include "lpfc_version.h"
  48 #include "lpfc_vport.h"
  49 #include "lpfc_debugfs.h"
  50
  51 /* FDMI Port Speed definitions */
  52 #define HBA_PORTSPEED_1GBIT             0x0001  /* 1 GBit/sec */
  53 #define HBA_PORTSPEED_2GBIT             0x0002  /* 2 GBit/sec */
  54 #define HBA_PORTSPEED_4GBIT             0x0008  /* 4 GBit/sec */
  55 #define HBA_PORTSPEED_10GBIT            0x0004  /* 10 GBit/sec */
  56 #define HBA_PORTSPEED_8GBIT             0x0010  /* 8 GBit/sec */
  57 #define HBA_PORTSPEED_16GBIT            0x0020  /* 16 GBit/sec */
  58 #define HBA_PORTSPEED_UNKNOWN           0x0800  /* Unknown */
  59
  60 #define FOURBYTES       4
  61
  62
  63 static char *lpfc_release_version = LPFC_DRIVER_VERSION;
  64
  65 static void
  66 lpfc_ct_ignore_hbq_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
  67                           struct lpfc_dmabuf *mp, uint32_t size)
  68 {
  69         if (!mp) {
  70                 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
  71                                 "0146 Ignoring unsolicited CT No HBQ "
  72                                 "status = x%x\n",
  73                                 piocbq->iocb.ulpStatus);
  74         }
  75         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
  76                         "0145 Ignoring unsolicted CT HBQ Size:%d "
  77                         "status = x%x\n",
  78                         size, piocbq->iocb.ulpStatus);
  79 }
  80
  81 static void
  82 lpfc_ct_unsol_buffer(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
  83                      struct lpfc_dmabuf *mp, uint32_t size)
  84 {
  85         lpfc_ct_ignore_hbq_buffer(phba, piocbq, mp, size);
  86 }
  87
  88 void
  89 lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
  90                     struct lpfc_iocbq *piocbq)
  91 {
  92         struct lpfc_dmabuf *mp = NULL;
  93         IOCB_t *icmd = &piocbq->iocb;
  94         int i;
  95         struct lpfc_iocbq *iocbq;
  96         dma_addr_t paddr;
  97         uint32_t size;
  98         struct list_head head;
  99         struct lpfc_dmabuf *bdeBuf;
 100
 101         if (lpfc_bsg_ct_unsol_event(phba, pring, piocbq) == 0)
 102                 return;
 103
 104         if (unlikely(icmd->ulpStatus == IOSTAT_NEED_BUFFER)) {
 105                 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
 106         } else if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
 107                    ((icmd->un.ulpWord[4] & IOERR_PARAM_MASK) ==
 108                    IOERR_RCV_BUFFER_WAITING)) {
 109                 /* Not enough posted buffers; Try posting more buffers */
 110                 phba->fc_stat.NoRcvBuf++;
 111                 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
 112                         lpfc_post_buffer(phba, pring, 2);
 113                 return;
 114         }
 115
 116         /* If there are no BDEs associated with this IOCB,
 117          * there is nothing to do.
 118          */
 119         if (icmd->ulpBdeCount == 0)
 120                 return;
 121
 122         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
 123                 INIT_LIST_HEAD(&head);
 124                 list_add_tail(&head, &piocbq->list);
 125                 list_for_each_entry(iocbq, &head, list) {
 126                         icmd = &iocbq->iocb;
 127                         if (icmd->ulpBdeCount == 0)
 128                                 continue;
 129                         bdeBuf = iocbq->context2;
 130                         iocbq->context2 = NULL;
 131                         size  = icmd->un.cont64[0].tus.f.bdeSize;
 132                         lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf, size);
 133                         lpfc_in_buf_free(phba, bdeBuf);
 134                         if (icmd->ulpBdeCount == 2) {
 135                                 bdeBuf = iocbq->context3;
 136                                 iocbq->context3 = NULL;
 137                                 size  = icmd->unsli3.rcvsli3.bde2.tus.f.bdeSize;
 138                                 lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf,
 139                                                      size);
 140                                 lpfc_in_buf_free(phba, bdeBuf);
 141                         }
 142                 }
 143                 list_del(&head);
 144         } else {
 145                 INIT_LIST_HEAD(&head);
 146                 list_add_tail(&head, &piocbq->list);
 147                 list_for_each_entry(iocbq, &head, list) {
 148                         icmd = &iocbq->iocb;
 149                         if (icmd->ulpBdeCount == 0)
 150                                 lpfc_ct_unsol_buffer(phba, iocbq, NULL, 0);
 151                         for (i = 0; i < icmd->ulpBdeCount; i++) {
 152                                 paddr = getPaddr(icmd->un.cont64[i].addrHigh,
 153                                                  icmd->un.cont64[i].addrLow);
 154                                 mp = lpfc_sli_ringpostbuf_get(phba, pring,
 155                                                               paddr);
 156                                 size = icmd->un.cont64[i].tus.f.bdeSize;
 157                                 lpfc_ct_unsol_buffer(phba, iocbq, mp, size);
 158                                 lpfc_in_buf_free(phba, mp);
 159                         }
 160                         lpfc_post_buffer(phba, pring, i);
 161                 }
 162                 list_del(&head);
 163         }
 164 }
 165
 166 /**
 167  * lpfc_ct_handle_unsol_abort - ct upper level protocol abort handler
 168  * @phba: Pointer to HBA context object.
 169  * @dmabuf: pointer to a dmabuf that describes the FC sequence
 170  *
 171  * This function serves as the upper level protocol abort handler for CT
 172  * protocol.
 173  *
 174  * Return 1 if abort has been handled, 0 otherwise.
 175  **/
 176 int
 177 lpfc_ct_handle_unsol_abort(struct lpfc_hba *phba, struct hbq_dmabuf *dmabuf)
 178 {
 179         int handled;
 180
 181         /* CT upper level goes through BSG */
 182         handled = lpfc_bsg_ct_unsol_abort(phba, dmabuf);
 183
 184         return handled;
 185 }
 186
 187 static void
 188 lpfc_free_ct_rsp(struct lpfc_hba *phba, struct lpfc_dmabuf *mlist)
 189 {
 190         struct lpfc_dmabuf *mlast, *next_mlast;
 191
 192         list_for_each_entry_safe(mlast, next_mlast, &mlist->list, list) {
 193                 lpfc_mbuf_free(phba, mlast->virt, mlast->phys);
 194                 list_del(&mlast->list);
 195                 kfree(mlast);
 196         }
 197         lpfc_mbuf_free(phba, mlist->virt, mlist->phys);
 198         kfree(mlist);
 199         return;
 200 }
 201
 202 static struct lpfc_dmabuf *
 203 lpfc_alloc_ct_rsp(struct lpfc_hba *phba, int cmdcode, struct ulp_bde64 *bpl,
 204                   uint32_t size, int *entries)
 205 {
 206         struct lpfc_dmabuf *mlist = NULL;
 207         struct lpfc_dmabuf *mp;
 208         int cnt, i = 0;
 209
 210         /* We get chunks of FCELSSIZE */
 211         cnt = size > FCELSSIZE ? FCELSSIZE: size;
 212
 213         while (size) {
 214                 /* Allocate buffer for rsp payload */
 215                 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
 216                 if (!mp) {
 217                         if (mlist)
 218                                 lpfc_free_ct_rsp(phba, mlist);
 219                         return NULL;
 220                 }
 221
 222                 INIT_LIST_HEAD(&mp->list);
 223
 224                 if (cmdcode == be16_to_cpu(SLI_CTNS_GID_FT) ||
 225                     cmdcode == be16_to_cpu(SLI_CTNS_GFF_ID))
 226                         mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
 227                 else
 228                         mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys));
 229
 230                 if (!mp->virt) {
 231                         kfree(mp);
 232                         if (mlist)
 233                                 lpfc_free_ct_rsp(phba, mlist);
 234                         return NULL;
 235                 }
 236
 237                 /* Queue it to a linked list */
 238                 if (!mlist)
 239                         mlist = mp;
 240                 else
 241                         list_add_tail(&mp->list, &mlist->list);
 242
 243                 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
 244                 /* build buffer ptr list for IOCB */
 245                 bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
 246                 bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
 247                 bpl->tus.f.bdeSize = (uint16_t) cnt;
 248                 bpl->tus.w = le32_to_cpu(bpl->tus.w);
 249                 bpl++;
 250
 251                 i++;
 252                 size -= cnt;
 253         }
 254
 255         *entries = i;
 256         return mlist;
 257 }
 258
 259 int
 260 lpfc_ct_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *ctiocb)
 261 {
 262         struct lpfc_dmabuf *buf_ptr;
 263
 264         if (ctiocb->context_un.ndlp) {
 265                 lpfc_nlp_put(ctiocb->context_un.ndlp);
 266                 ctiocb->context_un.ndlp = NULL;
 267         }
 268         if (ctiocb->context1) {
 269                 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context1;
 270                 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
 271                 kfree(buf_ptr);
 272                 ctiocb->context1 = NULL;
 273         }
 274         if (ctiocb->context2) {
 275                 lpfc_free_ct_rsp(phba, (struct lpfc_dmabuf *) ctiocb->context2);
 276                 ctiocb->context2 = NULL;
 277         }
 278
 279         if (ctiocb->context3) {
 280                 buf_ptr = (struct lpfc_dmabuf *) ctiocb->context3;
 281                 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
 282                 kfree(buf_ptr);
 283                 ctiocb->context1 = NULL;
 284         }
 285         lpfc_sli_release_iocbq(phba, ctiocb);
 286         return 0;
 287 }
 288
 289 static int
 290 lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp,
 291              struct lpfc_dmabuf *inp, struct lpfc_dmabuf *outp,
 292              void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
 293                      struct lpfc_iocbq *),
 294              struct lpfc_nodelist *ndlp, uint32_t usr_flg, uint32_t num_entry,
 295              uint32_t tmo, uint8_t retry)
 296 {
 297         struct lpfc_hba  *phba = vport->phba;
 298         IOCB_t *icmd;
 299         struct lpfc_iocbq *geniocb;
 300         int rc;
 301
 302         /* Allocate buffer for  command iocb */
 303         geniocb = lpfc_sli_get_iocbq(phba);
 304
 305         if (geniocb == NULL)
 306                 return 1;
 307
 308         icmd = &geniocb->iocb;
 309         icmd->un.genreq64.bdl.ulpIoTag32 = 0;
 310         icmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
 311         icmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys);
 312         icmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
 313         icmd->un.genreq64.bdl.bdeSize = (num_entry * sizeof (struct ulp_bde64));
 314
 315         if (usr_flg)
 316                 geniocb->context3 = NULL;
 317         else
 318                 geniocb->context3 = (uint8_t *) bmp;
 319
 320         /* Save for completion so we can release these resources */
 321         geniocb->context1 = (uint8_t *) inp;
 322         geniocb->context2 = (uint8_t *) outp;
 323         geniocb->context_un.ndlp = lpfc_nlp_get(ndlp);
 324
 325         /* Fill in payload, bp points to frame payload */
 326         icmd->ulpCommand = CMD_GEN_REQUEST64_CR;
 327
 328         /* Fill in rest of iocb */
 329         icmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
 330         icmd->un.genreq64.w5.hcsw.Dfctl = 0;
 331         icmd->un.genreq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
 332         icmd->un.genreq64.w5.hcsw.Type = FC_TYPE_CT;
 333
 334         if (!tmo) {
 335                  /* FC spec states we need 3 * ratov for CT requests */
 336                 tmo = (3 * phba->fc_ratov);
 337         }
 338         icmd->ulpTimeout = tmo;
 339         icmd->ulpBdeCount = 1;
 340         icmd->ulpLe = 1;
 341         icmd->ulpClass = CLASS3;
 342         icmd->ulpContext = ndlp->nlp_rpi;
 343         if (phba->sli_rev == LPFC_SLI_REV4)
 344                 icmd->ulpContext = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
 345
 346         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
 347                 /* For GEN_REQUEST64_CR, use the RPI */
 348                 icmd->ulpCt_h = 0;
 349                 icmd->ulpCt_l = 0;
 350         }
 351
 352         /* Issue GEN REQ IOCB for NPORT <did> */
 353         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
 354                          "0119 Issue GEN REQ IOCB to NPORT x%x "
 355                          "Data: x%x x%x\n",
 356                          ndlp->nlp_DID, icmd->ulpIoTag,
 357                          vport->port_state);
 358         geniocb->iocb_cmpl = cmpl;
 359         geniocb->drvrTimeout = icmd->ulpTimeout + LPFC_DRVR_TIMEOUT;
 360         geniocb->vport = vport;
 361         geniocb->retry = retry;
 362         rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, geniocb, 0);
 363
 364         if (rc == IOCB_ERROR) {
 365                 lpfc_sli_release_iocbq(phba, geniocb);
 366                 return 1;
 367         }
 368
 369         return 0;
 370 }
 371
 372 static int
 373 lpfc_ct_cmd(struct lpfc_vport *vport, struct lpfc_dmabuf *inmp,
 374             struct lpfc_dmabuf *bmp, struct lpfc_nodelist *ndlp,
 375             void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
 376                           struct lpfc_iocbq *),
 377             uint32_t rsp_size, uint8_t retry)
 378 {
 379         struct lpfc_hba  *phba = vport->phba;
 380         struct ulp_bde64 *bpl = (struct ulp_bde64 *) bmp->virt;
 381         struct lpfc_dmabuf *outmp;
 382         int cnt = 0, status;
 383         int cmdcode = ((struct lpfc_sli_ct_request *) inmp->virt)->
 384                 CommandResponse.bits.CmdRsp;
 385
 386         bpl++;                  /* Skip past ct request */
 387
 388         /* Put buffer(s) for ct rsp in bpl */
 389         outmp = lpfc_alloc_ct_rsp(phba, cmdcode, bpl, rsp_size, &cnt);
 390         if (!outmp)
 391                 return -ENOMEM;
 392         /*
 393          * Form the CT IOCB.  The total number of BDEs in this IOCB
 394          * is the single command plus response count from
 395          * lpfc_alloc_ct_rsp.
 396          */
 397         cnt += 1;
 398         status = lpfc_gen_req(vport, bmp, inmp, outmp, cmpl, ndlp, 0,
 399                               cnt, 0, retry);
 400         if (status) {
 401                 lpfc_free_ct_rsp(phba, outmp);
 402                 return -ENOMEM;
 403         }
 404         return 0;
 405 }
 406
 407 struct lpfc_vport *
 408 lpfc_find_vport_by_did(struct lpfc_hba *phba, uint32_t did) {
 409         struct lpfc_vport *vport_curr;
 410         unsigned long flags;
 411
 412         spin_lock_irqsave(&phba->hbalock, flags);
 413         list_for_each_entry(vport_curr, &phba->port_list, listentry) {
 414                 if ((vport_curr->fc_myDID) && (vport_curr->fc_myDID == did)) {
 415                         spin_unlock_irqrestore(&phba->hbalock, flags);
 416                         return vport_curr;
 417                 }
 418         }
 419         spin_unlock_irqrestore(&phba->hbalock, flags);
 420         return NULL;
 421 }
 422
 423 static int
 424 lpfc_ns_rsp(struct lpfc_vport *vport, struct lpfc_dmabuf *mp, uint32_t Size)
 425 {
 426         struct lpfc_hba  *phba = vport->phba;
 427         struct lpfc_sli_ct_request *Response =
 428                 (struct lpfc_sli_ct_request *) mp->virt;
 429         struct lpfc_nodelist *ndlp = NULL;
 430         struct lpfc_dmabuf *mlast, *next_mp;
 431         uint32_t *ctptr = (uint32_t *) & Response->un.gid.PortType;
 432         uint32_t Did, CTentry;
 433         int Cnt;
 434         struct list_head head;
 435
 436         lpfc_set_disctmo(vport);
 437         vport->num_disc_nodes = 0;
 438         vport->fc_ns_retry = 0;
 439
 440
 441         list_add_tail(&head, &mp->list);
 442         list_for_each_entry_safe(mp, next_mp, &head, list) {
 443                 mlast = mp;
 444
 445                 Cnt = Size  > FCELSSIZE ? FCELSSIZE : Size;
 446
 447                 Size -= Cnt;
 448
 449                 if (!ctptr) {
 450                         ctptr = (uint32_t *) mlast->virt;
 451                 } else
 452                         Cnt -= 16;      /* subtract length of CT header */
 453
 454                 /* Loop through entire NameServer list of DIDs */
 455                 while (Cnt >= sizeof (uint32_t)) {
 456                         /* Get next DID from NameServer List */
 457                         CTentry = *ctptr++;
 458                         Did = ((be32_to_cpu(CTentry)) & Mask_DID);
 459
 460                         ndlp = NULL;
 461
 462                         /*
 463                          * Check for rscn processing or not
 464                          * To conserve rpi's, filter out addresses for other
 465                          * vports on the same physical HBAs.
 466                          */
 467                         if ((Did != vport->fc_myDID) &&
 468                             ((lpfc_find_vport_by_did(phba, Did) == NULL) ||
 469                              vport->cfg_peer_port_login)) {
 470                                 if ((vport->port_type != LPFC_NPIV_PORT) ||
 471                                     (!(vport->ct_flags & FC_CT_RFF_ID)) ||
 472                                     (!vport->cfg_restrict_login)) {
 473                                         ndlp = lpfc_setup_disc_node(vport, Did);
 474                                         if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
 475                                                 lpfc_debugfs_disc_trc(vport,
 476                                                 LPFC_DISC_TRC_CT,
 477                                                 "Parse GID_FTrsp: "
 478                                                 "did:x%x flg:x%x x%x",
 479                                                 Did, ndlp->nlp_flag,
 480                                                 vport->fc_flag);
 481
 482                                                 lpfc_printf_vlog(vport,
 483                                                         KERN_INFO,
 484                                                         LOG_DISCOVERY,
 485                                                         "0238 Process "
 486                                                         "x%x NameServer Rsp"
 487                                                         "Data: x%x x%x x%x\n",
 488                                                         Did, ndlp->nlp_flag,
 489                                                         vport->fc_flag,
 490                                                         vport->fc_rscn_id_cnt);
 491                                         } else {
 492                                                 lpfc_debugfs_disc_trc(vport,
 493                                                 LPFC_DISC_TRC_CT,
 494                                                 "Skip1 GID_FTrsp: "
 495                                                 "did:x%x flg:x%x cnt:%d",
 496                                                 Did, vport->fc_flag,
 497                                                 vport->fc_rscn_id_cnt);
 498
 499                                                 lpfc_printf_vlog(vport,
 500                                                         KERN_INFO,
 501                                                         LOG_DISCOVERY,
 502                                                         "0239 Skip x%x "
 503                                                         "NameServer Rsp Data: "
 504                                                         "x%x x%x\n",
 505                                                         Did, vport->fc_flag,
 506                                                         vport->fc_rscn_id_cnt);
 507                                         }
 508
 509                                 } else {
 510                                         if (!(vport->fc_flag & FC_RSCN_MODE) ||
 511                                         (lpfc_rscn_payload_check(vport, Did))) {
 512                                                 lpfc_debugfs_disc_trc(vport,
 513                                                 LPFC_DISC_TRC_CT,
 514                                                 "Query GID_FTrsp: "
 515                                                 "did:x%x flg:x%x cnt:%d",
 516                                                 Did, vport->fc_flag,
 517                                                 vport->fc_rscn_id_cnt);
 518
 519                                                 /* This NPortID was previously
 520                                                  * a FCP target, * Don't even
 521                                                  * bother to send GFF_ID.
 522                                                  */
 523                                                 ndlp = lpfc_findnode_did(vport,
 524                                                         Did);
 525                                                 if (ndlp &&
 526                                                     NLP_CHK_NODE_ACT(ndlp)
 527                                                     && (ndlp->nlp_type &
 528                                                      NLP_FCP_TARGET))
 529                                                         lpfc_setup_disc_node
 530                                                                 (vport, Did);
 531                                                 else if (lpfc_ns_cmd(vport,
 532                                                         SLI_CTNS_GFF_ID,
 533                                                         0, Did) == 0)
 534                                                         vport->num_disc_nodes++;
 535                                                 else
 536                                                         lpfc_setup_disc_node
 537                                                                 (vport, Did);
 538                                         }
 539                                         else {
 540                                                 lpfc_debugfs_disc_trc(vport,
 541                                                 LPFC_DISC_TRC_CT,
 542                                                 "Skip2 GID_FTrsp: "
 543                                                 "did:x%x flg:x%x cnt:%d",
 544                                                 Did, vport->fc_flag,
 545                                                 vport->fc_rscn_id_cnt);
 546
 547                                                 lpfc_printf_vlog(vport,
 548                                                         KERN_INFO,
 549                                                         LOG_DISCOVERY,
 550                                                         "0245 Skip x%x "
 551                                                         "NameServer Rsp Data: "
 552                                                         "x%x x%x\n",
 553                                                         Did, vport->fc_flag,
 554                                                         vport->fc_rscn_id_cnt);
 555                                         }
 556                                 }
 557                         }
 558                         if (CTentry & (be32_to_cpu(SLI_CT_LAST_ENTRY)))
 559                                 goto nsout1;
 560                         Cnt -= sizeof (uint32_t);
 561                 }
 562                 ctptr = NULL;
 563
 564         }
 565
 566 nsout1:
 567         list_del(&head);
 568         return 0;
 569 }
 570
 571 static void
 572 lpfc_cmpl_ct_cmd_gid_ft(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 573                         struct lpfc_iocbq *rspiocb)
 574 {
 575         struct lpfc_vport *vport = cmdiocb->vport;
 576         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 577         IOCB_t *irsp;
 578         struct lpfc_dmabuf *bmp;
 579         struct lpfc_dmabuf *outp;
 580         struct lpfc_sli_ct_request *CTrsp;
 581         struct lpfc_nodelist *ndlp;
 582         int rc;
 583
 584         /* First save ndlp, before we overwrite it */
 585         ndlp = cmdiocb->context_un.ndlp;
 586
 587         /* we pass cmdiocb to state machine which needs rspiocb as well */
 588         cmdiocb->context_un.rsp_iocb = rspiocb;
 589
 590         outp = (struct lpfc_dmabuf *) cmdiocb->context2;
 591         bmp = (struct lpfc_dmabuf *) cmdiocb->context3;
 592         irsp = &rspiocb->iocb;
 593
 594         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
 595                  "GID_FT cmpl:     status:x%x/x%x rtry:%d",
 596                 irsp->ulpStatus, irsp->un.ulpWord[4], vport->fc_ns_retry);
 597
 598         /* Don't bother processing response if vport is being torn down. */
 599         if (vport->load_flag & FC_UNLOADING) {
 600                 if (vport->fc_flag & FC_RSCN_MODE)
 601                         lpfc_els_flush_rscn(vport);
 602                 goto out;
 603         }
 604
 605         if (lpfc_els_chk_latt(vport)) {
 606                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 607                                  "0216 Link event during NS query\n");
 608                 if (vport->fc_flag & FC_RSCN_MODE)
 609                         lpfc_els_flush_rscn(vport);
 610                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
 611                 goto out;
 612         }
 613         if (lpfc_error_lost_link(irsp)) {
 614                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 615                                  "0226 NS query failed due to link event\n");
 616                 if (vport->fc_flag & FC_RSCN_MODE)
 617                         lpfc_els_flush_rscn(vport);
 618                 goto out;
 619         }
 620         if (irsp->ulpStatus) {
 621                 /* Check for retry */
 622                 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) {
 623                         if (irsp->ulpStatus != IOSTAT_LOCAL_REJECT ||
 624                             (irsp->un.ulpWord[4] & IOERR_PARAM_MASK) !=
 625                             IOERR_NO_RESOURCES)
 626                                 vport->fc_ns_retry++;
 627
 628                         /* CT command is being retried */
 629                         rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT,
 630                                          vport->fc_ns_retry, 0);
 631                         if (rc == 0)
 632                                 goto out;
 633                 }
 634                 if (vport->fc_flag & FC_RSCN_MODE)
 635                         lpfc_els_flush_rscn(vport);
 636                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
 637                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
 638                                  "0257 GID_FT Query error: 0x%x 0x%x\n",
 639                                  irsp->ulpStatus, vport->fc_ns_retry);
 640         } else {
 641                 /* Good status, continue checking */
 642                 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
 643                 if (CTrsp->CommandResponse.bits.CmdRsp ==
 644                     be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) {
 645                         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 646                                          "0208 NameServer Rsp Data: x%x\n",
 647                                          vport->fc_flag);
 648                         lpfc_ns_rsp(vport, outp,
 649                                     (uint32_t) (irsp->un.genreq64.bdl.bdeSize));
 650                 } else if (CTrsp->CommandResponse.bits.CmdRsp ==
 651                            be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) {
 652                         /* NameServer Rsp Error */
 653                         if ((CTrsp->ReasonCode == SLI_CT_UNABLE_TO_PERFORM_REQ)
 654                             && (CTrsp->Explanation == SLI_CT_NO_FC4_TYPES)) {
 655                                 lpfc_printf_vlog(vport, KERN_INFO,
 656                                         LOG_DISCOVERY,
 657                                         "0269 No NameServer Entries "
 658                                         "Data: x%x x%x x%x x%x\n",
 659                                         CTrsp->CommandResponse.bits.CmdRsp,
 660                                         (uint32_t) CTrsp->ReasonCode,
 661                                         (uint32_t) CTrsp->Explanation,
 662                                         vport->fc_flag);
 663
 664                                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
 665                                 "GID_FT no entry  cmd:x%x rsn:x%x exp:x%x",
 666                                 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp,
 667                                 (uint32_t) CTrsp->ReasonCode,
 668                                 (uint32_t) CTrsp->Explanation);
 669                         } else {
 670                                 lpfc_printf_vlog(vport, KERN_INFO,
 671                                         LOG_DISCOVERY,
 672                                         "0240 NameServer Rsp Error "
 673                                         "Data: x%x x%x x%x x%x\n",
 674                                         CTrsp->CommandResponse.bits.CmdRsp,
 675                                         (uint32_t) CTrsp->ReasonCode,
 676                                         (uint32_t) CTrsp->Explanation,
 677                                         vport->fc_flag);
 678
 679                                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
 680                                 "GID_FT rsp err1  cmd:x%x rsn:x%x exp:x%x",
 681                                 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp,
 682                                 (uint32_t) CTrsp->ReasonCode,
 683                                 (uint32_t) CTrsp->Explanation);
 684                         }
 685
 686
 687                 } else {
 688                         /* NameServer Rsp Error */
 689                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
 690                                         "0241 NameServer Rsp Error "
 691                                         "Data: x%x x%x x%x x%x\n",
 692                                         CTrsp->CommandResponse.bits.CmdRsp,
 693                                         (uint32_t) CTrsp->ReasonCode,
 694                                         (uint32_t) CTrsp->Explanation,
 695                                         vport->fc_flag);
 696
 697                         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
 698                                 "GID_FT rsp err2  cmd:x%x rsn:x%x exp:x%x",
 699                                 (uint32_t)CTrsp->CommandResponse.bits.CmdRsp,
 700                                 (uint32_t) CTrsp->ReasonCode,
 701                                 (uint32_t) CTrsp->Explanation);
 702                 }
 703         }
 704         /* Link up / RSCN discovery */
 705         if (vport->num_disc_nodes == 0) {
 706                 /*
 707                  * The driver has cycled through all Nports in the RSCN payload.
 708                  * Complete the handling by cleaning up and marking the
 709                  * current driver state.
 710                  */
 711                 if (vport->port_state >= LPFC_DISC_AUTH) {
 712                         if (vport->fc_flag & FC_RSCN_MODE) {
 713                                 lpfc_els_flush_rscn(vport);
 714                                 spin_lock_irq(shost->host_lock);
 715                                 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */
 716                                 spin_unlock_irq(shost->host_lock);
 717                         }
 718                         else
 719                                 lpfc_els_flush_rscn(vport);
 720                 }
 721
 722                 lpfc_disc_start(vport);
 723         }
 724 out:
 725         cmdiocb->context_un.ndlp = ndlp; /* Now restore ndlp for free */
 726         lpfc_ct_free_iocb(phba, cmdiocb);
 727         return;
 728 }
 729
 730 static void
 731 lpfc_cmpl_ct_cmd_gff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 732                         struct lpfc_iocbq *rspiocb)
 733 {
 734         struct lpfc_vport *vport = cmdiocb->vport;
 735         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 736         IOCB_t *irsp = &rspiocb->iocb;
 737         struct lpfc_dmabuf *inp = (struct lpfc_dmabuf *) cmdiocb->context1;
 738         struct lpfc_dmabuf *outp = (struct lpfc_dmabuf *) cmdiocb->context2;
 739         struct lpfc_sli_ct_request *CTrsp;
 740         int did, rc, retry;
 741         uint8_t fbits;
 742         struct lpfc_nodelist *ndlp;
 743
 744         did = ((struct lpfc_sli_ct_request *) inp->virt)->un.gff.PortId;
 745         did = be32_to_cpu(did);
 746
 747         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
 748                 "GFF_ID cmpl:     status:x%x/x%x did:x%x",
 749                 irsp->ulpStatus, irsp->un.ulpWord[4], did);
 750
 751         if (irsp->ulpStatus == IOSTAT_SUCCESS) {
 752                 /* Good status, continue checking */
 753                 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
 754                 fbits = CTrsp->un.gff_acc.fbits[FCP_TYPE_FEATURE_OFFSET];
 755
 756                 if (CTrsp->CommandResponse.bits.CmdRsp ==
 757                     be16_to_cpu(SLI_CT_RESPONSE_FS_ACC)) {
 758                         if ((fbits & FC4_FEATURE_INIT) &&
 759                             !(fbits & FC4_FEATURE_TARGET)) {
 760                                 lpfc_printf_vlog(vport, KERN_INFO,
 761                                                  LOG_DISCOVERY,
 762                                                  "0270 Skip x%x GFF "
 763                                                  "NameServer Rsp Data: (init) "
 764                                                  "x%x x%x\n", did, fbits,
 765                                                  vport->fc_rscn_id_cnt);
 766                                 goto out;
 767                         }
 768                 }
 769         }
 770         else {
 771                 /* Check for retry */
 772                 if (cmdiocb->retry < LPFC_MAX_NS_RETRY) {
 773                         retry = 1;
 774                         if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
 775                                 switch ((irsp->un.ulpWord[4] &
 776                                         IOERR_PARAM_MASK)) {
 777
 778                                 case IOERR_NO_RESOURCES:
 779                                         /* We don't increment the retry
 780                                          * count for this case.
 781                                          */
 782                                         break;
 783                                 case IOERR_LINK_DOWN:
 784                                 case IOERR_SLI_ABORTED:
 785                                 case IOERR_SLI_DOWN:
 786                                         retry = 0;
 787                                         break;
 788                                 default:
 789                                         cmdiocb->retry++;
 790                                 }
 791                         }
 792                         else
 793                                 cmdiocb->retry++;
 794
 795                         if (retry) {
 796                                 /* CT command is being retried */
 797                                 rc = lpfc_ns_cmd(vport, SLI_CTNS_GFF_ID,
 798                                          cmdiocb->retry, did);
 799                                 if (rc == 0) {
 800                                         /* success */
 801                                         lpfc_ct_free_iocb(phba, cmdiocb);
 802                                         return;
 803                                 }
 804                         }
 805                 }
 806                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
 807                                  "0267 NameServer GFF Rsp "
 808                                  "x%x Error (%d %d) Data: x%x x%x\n",
 809                                  did, irsp->ulpStatus, irsp->un.ulpWord[4],
 810                                  vport->fc_flag, vport->fc_rscn_id_cnt);
 811         }
 812
 813         /* This is a target port, unregistered port, or the GFF_ID failed */
 814         ndlp = lpfc_setup_disc_node(vport, did);
 815         if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
 816                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 817                                  "0242 Process x%x GFF "
 818                                  "NameServer Rsp Data: x%x x%x x%x\n",
 819                                  did, ndlp->nlp_flag, vport->fc_flag,
 820                                  vport->fc_rscn_id_cnt);
 821         } else {
 822                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 823                                  "0243 Skip x%x GFF "
 824                                  "NameServer Rsp Data: x%x x%x\n", did,
 825                                  vport->fc_flag, vport->fc_rscn_id_cnt);
 826         }
 827 out:
 828         /* Link up / RSCN discovery */
 829         if (vport->num_disc_nodes)
 830                 vport->num_disc_nodes--;
 831         if (vport->num_disc_nodes == 0) {
 832                 /*
 833                  * The driver has cycled through all Nports in the RSCN payload.
 834                  * Complete the handling by cleaning up and marking the
 835                  * current driver state.
 836                  */
 837                 if (vport->port_state >= LPFC_DISC_AUTH) {
 838                         if (vport->fc_flag & FC_RSCN_MODE) {
 839                                 lpfc_els_flush_rscn(vport);
 840                                 spin_lock_irq(shost->host_lock);
 841                                 vport->fc_flag |= FC_RSCN_MODE; /* RSCN still */
 842                                 spin_unlock_irq(shost->host_lock);
 843                         }
 844                         else
 845                                 lpfc_els_flush_rscn(vport);
 846                 }
 847                 lpfc_disc_start(vport);
 848         }
 849         lpfc_ct_free_iocb(phba, cmdiocb);
 850         return;
 851 }
 852
 853
 854 static void
 855 lpfc_cmpl_ct(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 856              struct lpfc_iocbq *rspiocb)
 857 {
 858         struct lpfc_vport *vport = cmdiocb->vport;
 859         struct lpfc_dmabuf *inp;
 860         struct lpfc_dmabuf *outp;
 861         IOCB_t *irsp;
 862         struct lpfc_sli_ct_request *CTrsp;
 863         struct lpfc_nodelist *ndlp;
 864         int cmdcode, rc;
 865         uint8_t retry;
 866         uint32_t latt;
 867
 868         /* First save ndlp, before we overwrite it */
 869         ndlp = cmdiocb->context_un.ndlp;
 870
 871         /* we pass cmdiocb to state machine which needs rspiocb as well */
 872         cmdiocb->context_un.rsp_iocb = rspiocb;
 873
 874         inp = (struct lpfc_dmabuf *) cmdiocb->context1;
 875         outp = (struct lpfc_dmabuf *) cmdiocb->context2;
 876         irsp = &rspiocb->iocb;
 877
 878         cmdcode = be16_to_cpu(((struct lpfc_sli_ct_request *) inp->virt)->
 879                                         CommandResponse.bits.CmdRsp);
 880         CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
 881
 882         latt = lpfc_els_chk_latt(vport);
 883
 884         /* RFT request completes status <ulpStatus> CmdRsp <CmdRsp> */
 885         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 886                          "0209 CT Request completes, latt %d, "
 887                          "ulpStatus x%x CmdRsp x%x, Context x%x, Tag x%x\n",
 888                          latt, irsp->ulpStatus,
 889                          CTrsp->CommandResponse.bits.CmdRsp,
 890                          cmdiocb->iocb.ulpContext, cmdiocb->iocb.ulpIoTag);
 891
 892         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
 893                 "CT cmd cmpl:     status:x%x/x%x cmd:x%x",
 894                 irsp->ulpStatus, irsp->un.ulpWord[4], cmdcode);
 895
 896         if (irsp->ulpStatus) {
 897                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
 898                                  "0268 NS cmd %x Error (%d %d)\n",
 899                                  cmdcode, irsp->ulpStatus, irsp->un.ulpWord[4]);
 900
 901                 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
 902                         (((irsp->un.ulpWord[4] & IOERR_PARAM_MASK) ==
 903                           IOERR_SLI_DOWN) ||
 904                          ((irsp->un.ulpWord[4] & IOERR_PARAM_MASK) ==
 905                           IOERR_SLI_ABORTED)))
 906                         goto out;
 907
 908                 retry = cmdiocb->retry;
 909                 if (retry >= LPFC_MAX_NS_RETRY)
 910                         goto out;
 911
 912                 retry++;
 913                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 914                                  "0250 Retrying NS cmd %x\n", cmdcode);
 915                 rc = lpfc_ns_cmd(vport, cmdcode, retry, 0);
 916                 if (rc == 0)
 917                         goto out;
 918         }
 919
 920 out:
 921         cmdiocb->context_un.ndlp = ndlp; /* Now restore ndlp for free */
 922         lpfc_ct_free_iocb(phba, cmdiocb);
 923         return;
 924 }
 925
 926 static void
 927 lpfc_cmpl_ct_cmd_rft_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 928                         struct lpfc_iocbq *rspiocb)
 929 {
 930         IOCB_t *irsp = &rspiocb->iocb;
 931         struct lpfc_vport *vport = cmdiocb->vport;
 932
 933         if (irsp->ulpStatus == IOSTAT_SUCCESS) {
 934                 struct lpfc_dmabuf *outp;
 935                 struct lpfc_sli_ct_request *CTrsp;
 936
 937                 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
 938                 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
 939                 if (CTrsp->CommandResponse.bits.CmdRsp ==
 940                     be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
 941                         vport->ct_flags |= FC_CT_RFT_ID;
 942         }
 943         lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
 944         return;
 945 }
 946
 947 static void
 948 lpfc_cmpl_ct_cmd_rnn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 949                         struct lpfc_iocbq *rspiocb)
 950 {
 951         IOCB_t *irsp = &rspiocb->iocb;
 952         struct lpfc_vport *vport = cmdiocb->vport;
 953
 954         if (irsp->ulpStatus == IOSTAT_SUCCESS) {
 955                 struct lpfc_dmabuf *outp;
 956                 struct lpfc_sli_ct_request *CTrsp;
 957
 958                 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
 959                 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
 960                 if (CTrsp->CommandResponse.bits.CmdRsp ==
 961                     be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
 962                         vport->ct_flags |= FC_CT_RNN_ID;
 963         }
 964         lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
 965         return;
 966 }
 967
 968 static void
 969 lpfc_cmpl_ct_cmd_rspn_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 970                          struct lpfc_iocbq *rspiocb)
 971 {
 972         IOCB_t *irsp = &rspiocb->iocb;
 973         struct lpfc_vport *vport = cmdiocb->vport;
 974
 975         if (irsp->ulpStatus == IOSTAT_SUCCESS) {
 976                 struct lpfc_dmabuf *outp;
 977                 struct lpfc_sli_ct_request *CTrsp;
 978
 979                 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
 980                 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
 981                 if (CTrsp->CommandResponse.bits.CmdRsp ==
 982                     be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
 983                         vport->ct_flags |= FC_CT_RSPN_ID;
 984         }
 985         lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
 986         return;
 987 }
 988
 989 static void
 990 lpfc_cmpl_ct_cmd_rsnn_nn(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 991                          struct lpfc_iocbq *rspiocb)
 992 {
 993         IOCB_t *irsp = &rspiocb->iocb;
 994         struct lpfc_vport *vport = cmdiocb->vport;
 995
 996         if (irsp->ulpStatus == IOSTAT_SUCCESS) {
 997                 struct lpfc_dmabuf *outp;
 998                 struct lpfc_sli_ct_request *CTrsp;
 999
1000                 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
1001                 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1002                 if (CTrsp->CommandResponse.bits.CmdRsp ==
1003                     be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
1004                         vport->ct_flags |= FC_CT_RSNN_NN;
1005         }
1006         lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1007         return;
1008 }
1009
1010 static void
1011 lpfc_cmpl_ct_cmd_da_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1012  struct lpfc_iocbq *rspiocb)
1013 {
1014         struct lpfc_vport *vport = cmdiocb->vport;
1015
1016         /* even if it fails we will act as though it succeeded. */
1017         vport->ct_flags = 0;
1018         lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1019         return;
1020 }
1021
1022 static void
1023 lpfc_cmpl_ct_cmd_rff_id(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1024                         struct lpfc_iocbq *rspiocb)
1025 {
1026         IOCB_t *irsp = &rspiocb->iocb;
1027         struct lpfc_vport *vport = cmdiocb->vport;
1028
1029         if (irsp->ulpStatus == IOSTAT_SUCCESS) {
1030                 struct lpfc_dmabuf *outp;
1031                 struct lpfc_sli_ct_request *CTrsp;
1032
1033                 outp = (struct lpfc_dmabuf *) cmdiocb->context2;
1034                 CTrsp = (struct lpfc_sli_ct_request *) outp->virt;
1035                 if (CTrsp->CommandResponse.bits.CmdRsp ==
1036                     be16_to_cpu(SLI_CT_RESPONSE_FS_ACC))
1037                         vport->ct_flags |= FC_CT_RFF_ID;
1038         }
1039         lpfc_cmpl_ct(phba, cmdiocb, rspiocb);
1040         return;
1041 }
1042
1043 int
1044 lpfc_vport_symbolic_port_name(struct lpfc_vport *vport, char *symbol,
1045         size_t size)
1046 {
1047         int n;
1048         uint8_t *wwn = vport->phba->wwpn;
1049
1050         n = snprintf(symbol, size,
1051                      "Emulex PPN-%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1052                      wwn[0], wwn[1], wwn[2], wwn[3],
1053                      wwn[4], wwn[5], wwn[6], wwn[7]);
1054
1055         if (vport->port_type == LPFC_PHYSICAL_PORT)
1056                 return n;
1057
1058         if (n < size)
1059                 n += snprintf(symbol + n, size - n, " VPort-%d", vport->vpi);
1060
1061         if (n < size &&
1062             strlen(vport->fc_vport->symbolic_name))
1063                 n += snprintf(symbol + n, size - n, " VName-%s",
1064                               vport->fc_vport->symbolic_name);
1065         return n;
1066 }
1067
1068 int
1069 lpfc_vport_symbolic_node_name(struct lpfc_vport *vport, char *symbol,
1070         size_t size)
1071 {
1072         char fwrev[FW_REV_STR_SIZE];
1073         int n;
1074
1075         lpfc_decode_firmware_rev(vport->phba, fwrev, 0);
1076
1077         n = snprintf(symbol, size, "Emulex %s FV%s DV%s",
1078                 vport->phba->ModelName, fwrev, lpfc_release_version);
1079         return n;
1080 }
1081
1082 /*
1083  * lpfc_ns_cmd
1084  * Description:
1085  *    Issue Cmd to NameServer
1086  *       SLI_CTNS_GID_FT
1087  *       LI_CTNS_RFT_ID
1088  */
1089 int
1090 lpfc_ns_cmd(struct lpfc_vport *vport, int cmdcode,
1091             uint8_t retry, uint32_t context)
1092 {
1093         struct lpfc_nodelist * ndlp;
1094         struct lpfc_hba *phba = vport->phba;
1095         struct lpfc_dmabuf *mp, *bmp;
1096         struct lpfc_sli_ct_request *CtReq;
1097         struct ulp_bde64 *bpl;
1098         void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
1099                       struct lpfc_iocbq *) = NULL;
1100         uint32_t rsp_size = 1024;
1101         size_t   size;
1102         int rc = 0;
1103
1104         ndlp = lpfc_findnode_did(vport, NameServer_DID);
1105         if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)
1106             || ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) {
1107                 rc=1;
1108                 goto ns_cmd_exit;
1109         }
1110
1111         /* fill in BDEs for command */
1112         /* Allocate buffer for command payload */
1113         mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1114         if (!mp) {
1115                 rc=2;
1116                 goto ns_cmd_exit;
1117         }
1118
1119         INIT_LIST_HEAD(&mp->list);
1120         mp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(mp->phys));
1121         if (!mp->virt) {
1122                 rc=3;
1123                 goto ns_cmd_free_mp;
1124         }
1125
1126         /* Allocate buffer for Buffer ptr list */
1127         bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1128         if (!bmp) {
1129                 rc=4;
1130                 goto ns_cmd_free_mpvirt;
1131         }
1132
1133         INIT_LIST_HEAD(&bmp->list);
1134         bmp->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &(bmp->phys));
1135         if (!bmp->virt) {
1136                 rc=5;
1137                 goto ns_cmd_free_bmp;
1138         }
1139
1140         /* NameServer Req */
1141         lpfc_printf_vlog(vport, KERN_INFO ,LOG_DISCOVERY,
1142                          "0236 NameServer Req Data: x%x x%x x%x\n",
1143                          cmdcode, vport->fc_flag, vport->fc_rscn_id_cnt);
1144
1145         bpl = (struct ulp_bde64 *) bmp->virt;
1146         memset(bpl, 0, sizeof(struct ulp_bde64));
1147         bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
1148         bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
1149         bpl->tus.f.bdeFlags = 0;
1150         if (cmdcode == SLI_CTNS_GID_FT)
1151                 bpl->tus.f.bdeSize = GID_REQUEST_SZ;
1152         else if (cmdcode == SLI_CTNS_GFF_ID)
1153                 bpl->tus.f.bdeSize = GFF_REQUEST_SZ;
1154         else if (cmdcode == SLI_CTNS_RFT_ID)
1155                 bpl->tus.f.bdeSize = RFT_REQUEST_SZ;
1156         else if (cmdcode == SLI_CTNS_RNN_ID)
1157                 bpl->tus.f.bdeSize = RNN_REQUEST_SZ;
1158         else if (cmdcode == SLI_CTNS_RSPN_ID)
1159                 bpl->tus.f.bdeSize = RSPN_REQUEST_SZ;
1160         else if (cmdcode == SLI_CTNS_RSNN_NN)
1161                 bpl->tus.f.bdeSize = RSNN_REQUEST_SZ;
1162         else if (cmdcode == SLI_CTNS_DA_ID)
1163                 bpl->tus.f.bdeSize = DA_ID_REQUEST_SZ;
1164         else if (cmdcode == SLI_CTNS_RFF_ID)
1165                 bpl->tus.f.bdeSize = RFF_REQUEST_SZ;
1166         else
1167                 bpl->tus.f.bdeSize = 0;
1168         bpl->tus.w = le32_to_cpu(bpl->tus.w);
1169
1170         CtReq = (struct lpfc_sli_ct_request *) mp->virt;
1171         memset(CtReq, 0, sizeof (struct lpfc_sli_ct_request));
1172         CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
1173         CtReq->RevisionId.bits.InId = 0;
1174         CtReq->FsType = SLI_CT_DIRECTORY_SERVICE;
1175         CtReq->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER;
1176         CtReq->CommandResponse.bits.Size = 0;
1177         switch (cmdcode) {
1178         case SLI_CTNS_GID_FT:
1179                 CtReq->CommandResponse.bits.CmdRsp =
1180                     be16_to_cpu(SLI_CTNS_GID_FT);
1181                 CtReq->un.gid.Fc4Type = SLI_CTPT_FCP;
1182                 if (vport->port_state < LPFC_NS_QRY)
1183                         vport->port_state = LPFC_NS_QRY;
1184                 lpfc_set_disctmo(vport);
1185                 cmpl = lpfc_cmpl_ct_cmd_gid_ft;
1186                 rsp_size = FC_MAX_NS_RSP;
1187                 break;
1188
1189         case SLI_CTNS_GFF_ID:
1190                 CtReq->CommandResponse.bits.CmdRsp =
1191                         be16_to_cpu(SLI_CTNS_GFF_ID);
1192                 CtReq->un.gff.PortId = cpu_to_be32(context);
1193                 cmpl = lpfc_cmpl_ct_cmd_gff_id;
1194                 break;
1195
1196         case SLI_CTNS_RFT_ID:
1197                 vport->ct_flags &= ~FC_CT_RFT_ID;
1198                 CtReq->CommandResponse.bits.CmdRsp =
1199                     be16_to_cpu(SLI_CTNS_RFT_ID);
1200                 CtReq->un.rft.PortId = cpu_to_be32(vport->fc_myDID);
1201                 CtReq->un.rft.fcpReg = 1;
1202                 cmpl = lpfc_cmpl_ct_cmd_rft_id;
1203                 break;
1204
1205         case SLI_CTNS_RNN_ID:
1206                 vport->ct_flags &= ~FC_CT_RNN_ID;
1207                 CtReq->CommandResponse.bits.CmdRsp =
1208                     be16_to_cpu(SLI_CTNS_RNN_ID);
1209                 CtReq->un.rnn.PortId = cpu_to_be32(vport->fc_myDID);
1210                 memcpy(CtReq->un.rnn.wwnn,  &vport->fc_nodename,
1211                        sizeof (struct lpfc_name));
1212                 cmpl = lpfc_cmpl_ct_cmd_rnn_id;
1213                 break;
1214
1215         case SLI_CTNS_RSPN_ID:
1216                 vport->ct_flags &= ~FC_CT_RSPN_ID;
1217                 CtReq->CommandResponse.bits.CmdRsp =
1218                     be16_to_cpu(SLI_CTNS_RSPN_ID);
1219                 CtReq->un.rspn.PortId = cpu_to_be32(vport->fc_myDID);
1220                 size = sizeof(CtReq->un.rspn.symbname);
1221                 CtReq->un.rspn.len =
1222                         lpfc_vport_symbolic_port_name(vport,
1223                         CtReq->un.rspn.symbname, size);
1224                 cmpl = lpfc_cmpl_ct_cmd_rspn_id;
1225                 break;
1226         case SLI_CTNS_RSNN_NN:
1227                 vport->ct_flags &= ~FC_CT_RSNN_NN;
1228                 CtReq->CommandResponse.bits.CmdRsp =
1229                     be16_to_cpu(SLI_CTNS_RSNN_NN);
1230                 memcpy(CtReq->un.rsnn.wwnn, &vport->fc_nodename,
1231                        sizeof (struct lpfc_name));
1232                 size = sizeof(CtReq->un.rsnn.symbname);
1233                 CtReq->un.rsnn.len =
1234                         lpfc_vport_symbolic_node_name(vport,
1235                         CtReq->un.rsnn.symbname, size);
1236                 cmpl = lpfc_cmpl_ct_cmd_rsnn_nn;
1237                 break;
1238         case SLI_CTNS_DA_ID:
1239                 /* Implement DA_ID Nameserver request */
1240                 CtReq->CommandResponse.bits.CmdRsp =
1241                         be16_to_cpu(SLI_CTNS_DA_ID);
1242                 CtReq->un.da_id.port_id = cpu_to_be32(vport->fc_myDID);
1243                 cmpl = lpfc_cmpl_ct_cmd_da_id;
1244                 break;
1245         case SLI_CTNS_RFF_ID:
1246                 vport->ct_flags &= ~FC_CT_RFF_ID;
1247                 CtReq->CommandResponse.bits.CmdRsp =
1248                     be16_to_cpu(SLI_CTNS_RFF_ID);
1249                 CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID);
1250                 CtReq->un.rff.fbits = FC4_FEATURE_INIT;
1251                 CtReq->un.rff.type_code = FC_TYPE_FCP;
1252                 cmpl = lpfc_cmpl_ct_cmd_rff_id;
1253                 break;
1254         }
1255         /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
1256          * to hold ndlp reference for the corresponding callback function.
1257          */
1258         if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, rsp_size, retry)) {
1259                 /* On success, The cmpl function will free the buffers */
1260                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1261                         "Issue CT cmd:    cmd:x%x did:x%x",
1262                         cmdcode, ndlp->nlp_DID, 0);
1263                 return 0;
1264         }
1265         rc=6;
1266
1267         /* Decrement ndlp reference count to release ndlp reference held
1268          * for the failed command's callback function.
1269          */
1270         lpfc_nlp_put(ndlp);
1271
1272         lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1273 ns_cmd_free_bmp:
1274         kfree(bmp);
1275 ns_cmd_free_mpvirt:
1276         lpfc_mbuf_free(phba, mp->virt, mp->phys);
1277 ns_cmd_free_mp:
1278         kfree(mp);
1279 ns_cmd_exit:
1280         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
1281                          "0266 Issue NameServer Req x%x err %d Data: x%x x%x\n",
1282                          cmdcode, rc, vport->fc_flag, vport->fc_rscn_id_cnt);
1283         return 1;
1284 }
1285
1286 static void
1287 lpfc_cmpl_ct_cmd_fdmi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1288                       struct lpfc_iocbq * rspiocb)
1289 {
1290         struct lpfc_dmabuf *inp = cmdiocb->context1;
1291         struct lpfc_dmabuf *outp = cmdiocb->context2;
1292         struct lpfc_sli_ct_request *CTrsp = outp->virt;
1293         struct lpfc_sli_ct_request *CTcmd = inp->virt;
1294         struct lpfc_nodelist *ndlp;
1295         uint16_t fdmi_cmd = CTcmd->CommandResponse.bits.CmdRsp;
1296         uint16_t fdmi_rsp = CTrsp->CommandResponse.bits.CmdRsp;
1297         struct lpfc_vport *vport = cmdiocb->vport;
1298         IOCB_t *irsp = &rspiocb->iocb;
1299         uint32_t latt;
1300
1301         latt = lpfc_els_chk_latt(vport);
1302
1303         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_CT,
1304                 "FDMI cmpl:       status:x%x/x%x latt:%d",
1305                 irsp->ulpStatus, irsp->un.ulpWord[4], latt);
1306
1307         if (latt || irsp->ulpStatus) {
1308                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1309                                  "0229 FDMI cmd %04x failed, latt = %d "
1310                                  "ulpStatus: x%x, rid x%x\n",
1311                                  be16_to_cpu(fdmi_cmd), latt, irsp->ulpStatus,
1312                                  irsp->un.ulpWord[4]);
1313                 lpfc_ct_free_iocb(phba, cmdiocb);
1314                 return;
1315         }
1316
1317         ndlp = lpfc_findnode_did(vport, FDMI_DID);
1318         if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
1319                 goto fail_out;
1320
1321         if (fdmi_rsp == be16_to_cpu(SLI_CT_RESPONSE_FS_RJT)) {
1322                 /* FDMI rsp failed */
1323                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1324                                  "0220 FDMI rsp failed Data: x%x\n",
1325                                  be16_to_cpu(fdmi_cmd));
1326         }
1327
1328         switch (be16_to_cpu(fdmi_cmd)) {
1329         case SLI_MGMT_RHBA:
1330                 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RPA);
1331                 break;
1332
1333         case SLI_MGMT_RPA:
1334                 break;
1335
1336         case SLI_MGMT_DHBA:
1337                 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DPRT);
1338                 break;
1339
1340         case SLI_MGMT_DPRT:
1341                 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_RHBA);
1342                 break;
1343         }
1344
1345 fail_out:
1346         lpfc_ct_free_iocb(phba, cmdiocb);
1347         return;
1348 }
1349
1350 int
1351 lpfc_fdmi_cmd(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, int cmdcode)
1352 {
1353         struct lpfc_hba *phba = vport->phba;
1354         struct lpfc_dmabuf *mp, *bmp;
1355         struct lpfc_sli_ct_request *CtReq;
1356         struct ulp_bde64 *bpl;
1357         uint32_t size;
1358         REG_HBA *rh;
1359         PORT_ENTRY *pe;
1360         REG_PORT_ATTRIBUTE *pab;
1361         ATTRIBUTE_BLOCK *ab;
1362         ATTRIBUTE_ENTRY *ae;
1363         void (*cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
1364                       struct lpfc_iocbq *);
1365
1366
1367         /* fill in BDEs for command */
1368         /* Allocate buffer for command payload */
1369         mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1370         if (!mp)
1371                 goto fdmi_cmd_exit;
1372
1373         mp->virt = lpfc_mbuf_alloc(phba, 0, &(mp->phys));
1374         if (!mp->virt)
1375                 goto fdmi_cmd_free_mp;
1376
1377         /* Allocate buffer for Buffer ptr list */
1378         bmp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1379         if (!bmp)
1380                 goto fdmi_cmd_free_mpvirt;
1381
1382         bmp->virt = lpfc_mbuf_alloc(phba, 0, &(bmp->phys));
1383         if (!bmp->virt)
1384                 goto fdmi_cmd_free_bmp;
1385
1386         INIT_LIST_HEAD(&mp->list);
1387         INIT_LIST_HEAD(&bmp->list);
1388
1389         /* FDMI request */
1390         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1391                          "0218 FDMI Request Data: x%x x%x x%x\n",
1392                          vport->fc_flag, vport->port_state, cmdcode);
1393         CtReq = (struct lpfc_sli_ct_request *) mp->virt;
1394
1395         memset(CtReq, 0, sizeof(struct lpfc_sli_ct_request));
1396         CtReq->RevisionId.bits.Revision = SLI_CT_REVISION;
1397         CtReq->RevisionId.bits.InId = 0;
1398
1399         CtReq->FsType = SLI_CT_MANAGEMENT_SERVICE;
1400         CtReq->FsSubType = SLI_CT_FDMI_Subtypes;
1401         size = 0;
1402
1403         switch (cmdcode) {
1404         case SLI_MGMT_RHBA:
1405                 {
1406                         lpfc_vpd_t *vp = &phba->vpd;
1407                         uint32_t i, j, incr;
1408                         int len;
1409
1410                         CtReq->CommandResponse.bits.CmdRsp =
1411                             be16_to_cpu(SLI_MGMT_RHBA);
1412                         CtReq->CommandResponse.bits.Size = 0;
1413                         rh = (REG_HBA *) & CtReq->un.PortID;
1414                         memcpy(&rh->hi.PortName, &vport->fc_sparam.portName,
1415                                sizeof (struct lpfc_name));
1416                         /* One entry (port) per adapter */
1417                         rh->rpl.EntryCnt = be32_to_cpu(1);
1418                         memcpy(&rh->rpl.pe, &vport->fc_sparam.portName,
1419                                sizeof (struct lpfc_name));
1420
1421                         /* point to the HBA attribute block */
1422                         size = 2 * sizeof (struct lpfc_name) + FOURBYTES;
1423                         ab = (ATTRIBUTE_BLOCK *) ((uint8_t *) rh + size);
1424                         ab->EntryCnt = 0;
1425
1426                         /* Point to the beginning of the first HBA attribute
1427                            entry */
1428                         /* #1 HBA attribute entry */
1429                         size += FOURBYTES;
1430                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1431                         ae->ad.bits.AttrType = be16_to_cpu(NODE_NAME);
1432                         ae->ad.bits.AttrLen =  be16_to_cpu(FOURBYTES
1433                                                 + sizeof (struct lpfc_name));
1434                         memcpy(&ae->un.NodeName, &vport->fc_sparam.nodeName,
1435                                sizeof (struct lpfc_name));
1436                         ab->EntryCnt++;
1437                         size += FOURBYTES + sizeof (struct lpfc_name);
1438
1439                         /* #2 HBA attribute entry */
1440                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1441                         ae->ad.bits.AttrType = be16_to_cpu(MANUFACTURER);
1442                         strcpy(ae->un.Manufacturer, "Emulex Corporation");
1443                         len = strlen(ae->un.Manufacturer);
1444                         len += (len & 3) ? (4 - (len & 3)) : 4;
1445                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1446                         ab->EntryCnt++;
1447                         size += FOURBYTES + len;
1448
1449                         /* #3 HBA attribute entry */
1450                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1451                         ae->ad.bits.AttrType = be16_to_cpu(SERIAL_NUMBER);
1452                         strcpy(ae->un.SerialNumber, phba->SerialNumber);
1453                         len = strlen(ae->un.SerialNumber);
1454                         len += (len & 3) ? (4 - (len & 3)) : 4;
1455                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1456                         ab->EntryCnt++;
1457                         size += FOURBYTES + len;
1458
1459                         /* #4 HBA attribute entry */
1460                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1461                         ae->ad.bits.AttrType = be16_to_cpu(MODEL);
1462                         strcpy(ae->un.Model, phba->ModelName);
1463                         len = strlen(ae->un.Model);
1464                         len += (len & 3) ? (4 - (len & 3)) : 4;
1465                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1466                         ab->EntryCnt++;
1467                         size += FOURBYTES + len;
1468
1469                         /* #5 HBA attribute entry */
1470                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1471                         ae->ad.bits.AttrType = be16_to_cpu(MODEL_DESCRIPTION);
1472                         strcpy(ae->un.ModelDescription, phba->ModelDesc);
1473                         len = strlen(ae->un.ModelDescription);
1474                         len += (len & 3) ? (4 - (len & 3)) : 4;
1475                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1476                         ab->EntryCnt++;
1477                         size += FOURBYTES + len;
1478
1479                         /* #6 HBA attribute entry */
1480                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1481                         ae->ad.bits.AttrType = be16_to_cpu(HARDWARE_VERSION);
1482                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 8);
1483                         /* Convert JEDEC ID to ascii for hardware version */
1484                         incr = vp->rev.biuRev;
1485                         for (i = 0; i < 8; i++) {
1486                                 j = (incr & 0xf);
1487                                 if (j <= 9)
1488                                         ae->un.HardwareVersion[7 - i] =
1489                                             (char)((uint8_t) 0x30 +
1490                                                    (uint8_t) j);
1491                                 else
1492                                         ae->un.HardwareVersion[7 - i] =
1493                                             (char)((uint8_t) 0x61 +
1494                                                    (uint8_t) (j - 10));
1495                                 incr = (incr >> 4);
1496                         }
1497                         ab->EntryCnt++;
1498                         size += FOURBYTES + 8;
1499
1500                         /* #7 HBA attribute entry */
1501                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1502                         ae->ad.bits.AttrType = be16_to_cpu(DRIVER_VERSION);
1503                         strcpy(ae->un.DriverVersion, lpfc_release_version);
1504                         len = strlen(ae->un.DriverVersion);
1505                         len += (len & 3) ? (4 - (len & 3)) : 4;
1506                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1507                         ab->EntryCnt++;
1508                         size += FOURBYTES + len;
1509
1510                         /* #8 HBA attribute entry */
1511                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1512                         ae->ad.bits.AttrType = be16_to_cpu(OPTION_ROM_VERSION);
1513                         strcpy(ae->un.OptionROMVersion, phba->OptionROMVersion);
1514                         len = strlen(ae->un.OptionROMVersion);
1515                         len += (len & 3) ? (4 - (len & 3)) : 4;
1516                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1517                         ab->EntryCnt++;
1518                         size += FOURBYTES + len;
1519
1520                         /* #9 HBA attribute entry */
1521                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1522                         ae->ad.bits.AttrType = be16_to_cpu(FIRMWARE_VERSION);
1523                         lpfc_decode_firmware_rev(phba, ae->un.FirmwareVersion,
1524                                 1);
1525                         len = strlen(ae->un.FirmwareVersion);
1526                         len += (len & 3) ? (4 - (len & 3)) : 4;
1527                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1528                         ab->EntryCnt++;
1529                         size += FOURBYTES + len;
1530
1531                         /* #10 HBA attribute entry */
1532                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1533                         ae->ad.bits.AttrType = be16_to_cpu(OS_NAME_VERSION);
1534                         sprintf(ae->un.OsNameVersion, "%s %s %s",
1535                                 init_utsname()->sysname,
1536                                 init_utsname()->release,
1537                                 init_utsname()->version);
1538                         len = strlen(ae->un.OsNameVersion);
1539                         len += (len & 3) ? (4 - (len & 3)) : 4;
1540                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1541                         ab->EntryCnt++;
1542                         size += FOURBYTES + len;
1543
1544                         /* #11 HBA attribute entry */
1545                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) rh + size);
1546                         ae->ad.bits.AttrType = be16_to_cpu(MAX_CT_PAYLOAD_LEN);
1547                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
1548                         ae->un.MaxCTPayloadLen = (65 * 4096);
1549                         ab->EntryCnt++;
1550                         size += FOURBYTES + 4;
1551
1552                         ab->EntryCnt = be32_to_cpu(ab->EntryCnt);
1553                         /* Total size */
1554                         size = GID_REQUEST_SZ - 4 + size;
1555                 }
1556                 break;
1557
1558         case SLI_MGMT_RPA:
1559                 {
1560                         lpfc_vpd_t *vp;
1561                         struct serv_parm *hsp;
1562                         int len;
1563
1564                         vp = &phba->vpd;
1565
1566                         CtReq->CommandResponse.bits.CmdRsp =
1567                             be16_to_cpu(SLI_MGMT_RPA);
1568                         CtReq->CommandResponse.bits.Size = 0;
1569                         pab = (REG_PORT_ATTRIBUTE *) & CtReq->un.PortID;
1570                         size = sizeof (struct lpfc_name) + FOURBYTES;
1571                         memcpy((uint8_t *) & pab->PortName,
1572                                (uint8_t *) & vport->fc_sparam.portName,
1573                                sizeof (struct lpfc_name));
1574                         pab->ab.EntryCnt = 0;
1575
1576                         /* #1 Port attribute entry */
1577                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1578                         ae->ad.bits.AttrType = be16_to_cpu(SUPPORTED_FC4_TYPES);
1579                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 32);
1580                         ae->un.SupportFC4Types[2] = 1;
1581                         ae->un.SupportFC4Types[7] = 1;
1582                         pab->ab.EntryCnt++;
1583                         size += FOURBYTES + 32;
1584
1585                         /* #2 Port attribute entry */
1586                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1587                         ae->ad.bits.AttrType = be16_to_cpu(SUPPORTED_SPEED);
1588                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
1589
1590                         ae->un.SupportSpeed = 0;
1591                         if (phba->lmt & LMT_16Gb)
1592                                 ae->un.SupportSpeed |= HBA_PORTSPEED_16GBIT;
1593                         if (phba->lmt & LMT_10Gb)
1594                                 ae->un.SupportSpeed |= HBA_PORTSPEED_10GBIT;
1595                         if (phba->lmt & LMT_8Gb)
1596                                 ae->un.SupportSpeed |= HBA_PORTSPEED_8GBIT;
1597                         if (phba->lmt & LMT_4Gb)
1598                                 ae->un.SupportSpeed |= HBA_PORTSPEED_4GBIT;
1599                         if (phba->lmt & LMT_2Gb)
1600                                 ae->un.SupportSpeed |= HBA_PORTSPEED_2GBIT;
1601                         if (phba->lmt & LMT_1Gb)
1602                                 ae->un.SupportSpeed |= HBA_PORTSPEED_1GBIT;
1603
1604                         pab->ab.EntryCnt++;
1605                         size += FOURBYTES + 4;
1606
1607                         /* #3 Port attribute entry */
1608                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1609                         ae->ad.bits.AttrType = be16_to_cpu(PORT_SPEED);
1610                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
1611                         switch(phba->fc_linkspeed) {
1612                         case LPFC_LINK_SPEED_1GHZ:
1613                                 ae->un.PortSpeed = HBA_PORTSPEED_1GBIT;
1614                                 break;
1615                         case LPFC_LINK_SPEED_2GHZ:
1616                                 ae->un.PortSpeed = HBA_PORTSPEED_2GBIT;
1617                                 break;
1618                         case LPFC_LINK_SPEED_4GHZ:
1619                                 ae->un.PortSpeed = HBA_PORTSPEED_4GBIT;
1620                                 break;
1621                         case LPFC_LINK_SPEED_8GHZ:
1622                                 ae->un.PortSpeed = HBA_PORTSPEED_8GBIT;
1623                                 break;
1624                         case LPFC_LINK_SPEED_10GHZ:
1625                                 ae->un.PortSpeed = HBA_PORTSPEED_10GBIT;
1626                                 break;
1627                         case LPFC_LINK_SPEED_16GHZ:
1628                                 ae->un.PortSpeed = HBA_PORTSPEED_16GBIT;
1629                                 break;
1630                         default:
1631                                 ae->un.PortSpeed = HBA_PORTSPEED_UNKNOWN;
1632                                 break;
1633                         }
1634                         pab->ab.EntryCnt++;
1635                         size += FOURBYTES + 4;
1636
1637                         /* #4 Port attribute entry */
1638                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1639                         ae->ad.bits.AttrType = be16_to_cpu(MAX_FRAME_SIZE);
1640                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + 4);
1641                         hsp = (struct serv_parm *) & vport->fc_sparam;
1642                         ae->un.MaxFrameSize =
1643                             (((uint32_t) hsp->cmn.
1644                               bbRcvSizeMsb) << 8) | (uint32_t) hsp->cmn.
1645                             bbRcvSizeLsb;
1646                         pab->ab.EntryCnt++;
1647                         size += FOURBYTES + 4;
1648
1649                         /* #5 Port attribute entry */
1650                         ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab + size);
1651                         ae->ad.bits.AttrType = be16_to_cpu(OS_DEVICE_NAME);
1652                         strcpy((char *)ae->un.OsDeviceName, LPFC_DRIVER_NAME);
1653                         len = strlen((char *)ae->un.OsDeviceName);
1654                         len += (len & 3) ? (4 - (len & 3)) : 4;
1655                         ae->ad.bits.AttrLen = be16_to_cpu(FOURBYTES + len);
1656                         pab->ab.EntryCnt++;
1657                         size += FOURBYTES + len;
1658
1659                         if (vport->cfg_fdmi_on == 2) {
1660                                 /* #6 Port attribute entry */
1661                                 ae = (ATTRIBUTE_ENTRY *) ((uint8_t *) pab +
1662                                                           size);
1663                                 ae->ad.bits.AttrType = be16_to_cpu(HOST_NAME);
1664                                 sprintf(ae->un.HostName, "%s",
1665                                         init_utsname()->nodename);
1666                                 len = strlen(ae->un.HostName);
1667                                 len += (len & 3) ? (4 - (len & 3)) : 4;
1668                                 ae->ad.bits.AttrLen =
1669                                     be16_to_cpu(FOURBYTES + len);
1670                                 pab->ab.EntryCnt++;
1671                                 size += FOURBYTES + len;
1672                         }
1673
1674                         pab->ab.EntryCnt = be32_to_cpu(pab->ab.EntryCnt);
1675                         /* Total size */
1676                         size = GID_REQUEST_SZ - 4 + size;
1677                 }
1678                 break;
1679
1680         case SLI_MGMT_DHBA:
1681                 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DHBA);
1682                 CtReq->CommandResponse.bits.Size = 0;
1683                 pe = (PORT_ENTRY *) & CtReq->un.PortID;
1684                 memcpy((uint8_t *) & pe->PortName,
1685                        (uint8_t *) & vport->fc_sparam.portName,
1686                        sizeof (struct lpfc_name));
1687                 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name);
1688                 break;
1689
1690         case SLI_MGMT_DPRT:
1691                 CtReq->CommandResponse.bits.CmdRsp = be16_to_cpu(SLI_MGMT_DPRT);
1692                 CtReq->CommandResponse.bits.Size = 0;
1693                 pe = (PORT_ENTRY *) & CtReq->un.PortID;
1694                 memcpy((uint8_t *) & pe->PortName,
1695                        (uint8_t *) & vport->fc_sparam.portName,
1696                        sizeof (struct lpfc_name));
1697                 size = GID_REQUEST_SZ - 4 + sizeof (struct lpfc_name);
1698                 break;
1699         }
1700
1701         bpl = (struct ulp_bde64 *) bmp->virt;
1702         bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys) );
1703         bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys) );
1704         bpl->tus.f.bdeFlags = 0;
1705         bpl->tus.f.bdeSize = size;
1706         bpl->tus.w = le32_to_cpu(bpl->tus.w);
1707
1708         cmpl = lpfc_cmpl_ct_cmd_fdmi;
1709
1710         /* The lpfc_ct_cmd/lpfc_get_req shall increment ndlp reference count
1711          * to hold ndlp reference for the corresponding callback function.
1712          */
1713         if (!lpfc_ct_cmd(vport, mp, bmp, ndlp, cmpl, FC_MAX_NS_RSP, 0))
1714                 return 0;
1715
1716         /* Decrement ndlp reference count to release ndlp reference held
1717          * for the failed command's callback function.
1718          */
1719         lpfc_nlp_put(ndlp);
1720
1721         lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
1722 fdmi_cmd_free_bmp:
1723         kfree(bmp);
1724 fdmi_cmd_free_mpvirt:
1725         lpfc_mbuf_free(phba, mp->virt, mp->phys);
1726 fdmi_cmd_free_mp:
1727         kfree(mp);
1728 fdmi_cmd_exit:
1729         /* Issue FDMI request failed */
1730         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1731                          "0244 Issue FDMI request failed Data: x%x\n",
1732                          cmdcode);
1733         return 1;
1734 }
1735
1736 /**
1737  * lpfc_delayed_disc_tmo - Timeout handler for delayed discovery timer.
1738  * @ptr - Context object of the timer.
1739  *
1740  * This function set the WORKER_DELAYED_DISC_TMO flag and wake up
1741  * the worker thread.
1742  **/
1743 void
1744 lpfc_delayed_disc_tmo(unsigned long ptr)
1745 {
1746         struct lpfc_vport *vport = (struct lpfc_vport *)ptr;
1747         struct lpfc_hba   *phba = vport->phba;
1748         uint32_t tmo_posted;
1749         unsigned long iflag;
1750
1751         spin_lock_irqsave(&vport->work_port_lock, iflag);
1752         tmo_posted = vport->work_port_events & WORKER_DELAYED_DISC_TMO;
1753         if (!tmo_posted)
1754                 vport->work_port_events |= WORKER_DELAYED_DISC_TMO;
1755         spin_unlock_irqrestore(&vport->work_port_lock, iflag);
1756
1757         if (!tmo_posted)
1758                 lpfc_worker_wake_up(phba);
1759         return;
1760 }
1761
1762 /**
1763  * lpfc_delayed_disc_timeout_handler - Function called by worker thread to
1764  *      handle delayed discovery.
1765  * @vport: pointer to a host virtual N_Port data structure.
1766  *
1767  * This function start nport discovery of the vport.
1768  **/
1769 void
1770 lpfc_delayed_disc_timeout_handler(struct lpfc_vport *vport)
1771 {
1772         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1773
1774         spin_lock_irq(shost->host_lock);
1775         if (!(vport->fc_flag & FC_DISC_DELAYED)) {
1776                 spin_unlock_irq(shost->host_lock);
1777                 return;
1778         }
1779         vport->fc_flag &= ~FC_DISC_DELAYED;
1780         spin_unlock_irq(shost->host_lock);
1781
1782         lpfc_do_scr_ns_plogi(vport->phba, vport);
1783 }
1784
1785 void
1786 lpfc_fdmi_tmo(unsigned long ptr)
1787 {
1788         struct lpfc_vport *vport = (struct lpfc_vport *)ptr;
1789         struct lpfc_hba   *phba = vport->phba;
1790         uint32_t tmo_posted;
1791         unsigned long iflag;
1792
1793         spin_lock_irqsave(&vport->work_port_lock, iflag);
1794         tmo_posted = vport->work_port_events & WORKER_FDMI_TMO;
1795         if (!tmo_posted)
1796                 vport->work_port_events |= WORKER_FDMI_TMO;
1797         spin_unlock_irqrestore(&vport->work_port_lock, iflag);
1798
1799         if (!tmo_posted)
1800                 lpfc_worker_wake_up(phba);
1801         return;
1802 }
1803
1804 void
1805 lpfc_fdmi_timeout_handler(struct lpfc_vport *vport)
1806 {
1807         struct lpfc_nodelist *ndlp;
1808
1809         ndlp = lpfc_findnode_did(vport, FDMI_DID);
1810         if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
1811                 if (init_utsname()->nodename[0] != '\0')
1812                         lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA);
1813                 else
1814                         mod_timer(&vport->fc_fdmitmo, jiffies +
1815                                   msecs_to_jiffies(1000 * 60));
1816         }
1817         return;
1818 }
1819
1820 void
1821 lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag)
1822 {
1823         struct lpfc_sli *psli = &phba->sli;
1824         lpfc_vpd_t *vp = &phba->vpd;
1825         uint32_t b1, b2, b3, b4, i, rev;
1826         char c;
1827         uint32_t *ptr, str[4];
1828         uint8_t *fwname;
1829
1830         if (phba->sli_rev == LPFC_SLI_REV4)
1831                 snprintf(fwrevision, FW_REV_STR_SIZE, "%s", vp->rev.opFwName);
1832         else if (vp->rev.rBit) {
1833                 if (psli->sli_flag & LPFC_SLI_ACTIVE)
1834                         rev = vp->rev.sli2FwRev;
1835                 else
1836                         rev = vp->rev.sli1FwRev;
1837
1838                 b1 = (rev & 0x0000f000) >> 12;
1839                 b2 = (rev & 0x00000f00) >> 8;
1840                 b3 = (rev & 0x000000c0) >> 6;
1841                 b4 = (rev & 0x00000030) >> 4;
1842
1843                 switch (b4) {
1844                 case 0:
1845                         c = 'N';
1846                         break;
1847                 case 1:
1848                         c = 'A';
1849                         break;
1850                 case 2:
1851                         c = 'B';
1852                         break;
1853                 case 3:
1854                         c = 'X';
1855                         break;
1856                 default:
1857                         c = 0;
1858                         break;
1859                 }
1860                 b4 = (rev & 0x0000000f);
1861
1862                 if (psli->sli_flag & LPFC_SLI_ACTIVE)
1863                         fwname = vp->rev.sli2FwName;
1864                 else
1865                         fwname = vp->rev.sli1FwName;
1866
1867                 for (i = 0; i < 16; i++)
1868                         if (fwname[i] == 0x20)
1869                                 fwname[i] = 0;
1870
1871                 ptr = (uint32_t*)fwname;
1872
1873                 for (i = 0; i < 3; i++)
1874                         str[i] = be32_to_cpu(*ptr++);
1875
1876                 if (c == 0) {
1877                         if (flag)
1878                                 sprintf(fwrevision, "%d.%d%d (%s)",
1879                                         b1, b2, b3, (char *)str);
1880                         else
1881                                 sprintf(fwrevision, "%d.%d%d", b1,
1882                                         b2, b3);
1883                 } else {
1884                         if (flag)
1885                                 sprintf(fwrevision, "%d.%d%d%c%d (%s)",
1886                                         b1, b2, b3, c,
1887                                         b4, (char *)str);
1888                         else
1889                                 sprintf(fwrevision, "%d.%d%d%c%d",
1890                                         b1, b2, b3, c, b4);
1891                 }
1892         } else {
1893                 rev = vp->rev.smFwRev;
1894
1895                 b1 = (rev & 0xff000000) >> 24;
1896                 b2 = (rev & 0x00f00000) >> 20;
1897                 b3 = (rev & 0x000f0000) >> 16;
1898                 c  = (rev & 0x0000ff00) >> 8;
1899                 b4 = (rev & 0x000000ff);
1900
1901                 sprintf(fwrevision, "%d.%d%d%c%d", b1, b2, b3, c, b4);
1902         }
1903         return;
1904 }