kernel/drivers/scsi/lpfc/lpfc_nportdisc.c

   1  /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2004-2015 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
   8  *                                                                 *
   9  * This program is free software; you can redistribute it and/or   *
  10  * modify it under the terms of version 2 of the GNU General       *
  11  * Public License as published by the Free Software Foundation.    *
  12  * This program is distributed in the hope that it will be useful. *
  13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  18  * more details, a copy of which can be found in the file COPYING  *
  19  * included with this package.                                     *
  20  *******************************************************************/
  21
  22 #include <linux/blkdev.h>
  23 #include <linux/pci.h>
  24 #include <linux/slab.h>
  25 #include <linux/interrupt.h>
  26
  27 #include <scsi/scsi.h>
  28 #include <scsi/scsi_device.h>
  29 #include <scsi/scsi_host.h>
  30 #include <scsi/scsi_transport_fc.h>
  31
  32 #include "lpfc_hw4.h"
  33 #include "lpfc_hw.h"
  34 #include "lpfc_sli.h"
  35 #include "lpfc_sli4.h"
  36 #include "lpfc_nl.h"
  37 #include "lpfc_disc.h"
  38 #include "lpfc_scsi.h"
  39 #include "lpfc.h"
  40 #include "lpfc_logmsg.h"
  41 #include "lpfc_crtn.h"
  42 #include "lpfc_vport.h"
  43 #include "lpfc_debugfs.h"
  44
  45
  46 /* Called to verify a rcv'ed ADISC was intended for us. */
  47 static int
  48 lpfc_check_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
  49                  struct lpfc_name *nn, struct lpfc_name *pn)
  50 {
  51         /* First, we MUST have a RPI registered */
  52         if (!(ndlp->nlp_flag & NLP_RPI_REGISTERED))
  53                 return 0;
  54
  55         /* Compare the ADISC rsp WWNN / WWPN matches our internal node
  56          * table entry for that node.
  57          */
  58         if (memcmp(nn, &ndlp->nlp_nodename, sizeof (struct lpfc_name)))
  59                 return 0;
  60
  61         if (memcmp(pn, &ndlp->nlp_portname, sizeof (struct lpfc_name)))
  62                 return 0;
  63
  64         /* we match, return success */
  65         return 1;
  66 }
  67
  68 int
  69 lpfc_check_sparm(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
  70                  struct serv_parm *sp, uint32_t class, int flogi)
  71 {
  72         volatile struct serv_parm *hsp = &vport->fc_sparam;
  73         uint16_t hsp_value, ssp_value = 0;
  74
  75         /*
  76          * The receive data field size and buffer-to-buffer receive data field
  77          * size entries are 16 bits but are represented as two 8-bit fields in
  78          * the driver data structure to account for rsvd bits and other control
  79          * bits.  Reconstruct and compare the fields as a 16-bit values before
  80          * correcting the byte values.
  81          */
  82         if (sp->cls1.classValid) {
  83                 if (!flogi) {
  84                         hsp_value = ((hsp->cls1.rcvDataSizeMsb << 8) |
  85                                      hsp->cls1.rcvDataSizeLsb);
  86                         ssp_value = ((sp->cls1.rcvDataSizeMsb << 8) |
  87                                      sp->cls1.rcvDataSizeLsb);
  88                         if (!ssp_value)
  89                                 goto bad_service_param;
  90                         if (ssp_value > hsp_value) {
  91                                 sp->cls1.rcvDataSizeLsb =
  92                                         hsp->cls1.rcvDataSizeLsb;
  93                                 sp->cls1.rcvDataSizeMsb =
  94                                         hsp->cls1.rcvDataSizeMsb;
  95                         }
  96                 }
  97         } else if (class == CLASS1)
  98                 goto bad_service_param;
  99         if (sp->cls2.classValid) {
 100                 if (!flogi) {
 101                         hsp_value = ((hsp->cls2.rcvDataSizeMsb << 8) |
 102                                      hsp->cls2.rcvDataSizeLsb);
 103                         ssp_value = ((sp->cls2.rcvDataSizeMsb << 8) |
 104                                      sp->cls2.rcvDataSizeLsb);
 105                         if (!ssp_value)
 106                                 goto bad_service_param;
 107                         if (ssp_value > hsp_value) {
 108                                 sp->cls2.rcvDataSizeLsb =
 109                                         hsp->cls2.rcvDataSizeLsb;
 110                                 sp->cls2.rcvDataSizeMsb =
 111                                         hsp->cls2.rcvDataSizeMsb;
 112                         }
 113                 }
 114         } else if (class == CLASS2)
 115                 goto bad_service_param;
 116         if (sp->cls3.classValid) {
 117                 if (!flogi) {
 118                         hsp_value = ((hsp->cls3.rcvDataSizeMsb << 8) |
 119                                      hsp->cls3.rcvDataSizeLsb);
 120                         ssp_value = ((sp->cls3.rcvDataSizeMsb << 8) |
 121                                      sp->cls3.rcvDataSizeLsb);
 122                         if (!ssp_value)
 123                                 goto bad_service_param;
 124                         if (ssp_value > hsp_value) {
 125                                 sp->cls3.rcvDataSizeLsb =
 126                                         hsp->cls3.rcvDataSizeLsb;
 127                                 sp->cls3.rcvDataSizeMsb =
 128                                         hsp->cls3.rcvDataSizeMsb;
 129                         }
 130                 }
 131         } else if (class == CLASS3)
 132                 goto bad_service_param;
 133
 134         /*
 135          * Preserve the upper four bits of the MSB from the PLOGI response.
 136          * These bits contain the Buffer-to-Buffer State Change Number
 137          * from the target and need to be passed to the FW.
 138          */
 139         hsp_value = (hsp->cmn.bbRcvSizeMsb << 8) | hsp->cmn.bbRcvSizeLsb;
 140         ssp_value = (sp->cmn.bbRcvSizeMsb << 8) | sp->cmn.bbRcvSizeLsb;
 141         if (ssp_value > hsp_value) {
 142                 sp->cmn.bbRcvSizeLsb = hsp->cmn.bbRcvSizeLsb;
 143                 sp->cmn.bbRcvSizeMsb = (sp->cmn.bbRcvSizeMsb & 0xF0) |
 144                                        (hsp->cmn.bbRcvSizeMsb & 0x0F);
 145         }
 146
 147         memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof (struct lpfc_name));
 148         memcpy(&ndlp->nlp_portname, &sp->portName, sizeof (struct lpfc_name));
 149         return 1;
 150 bad_service_param:
 151         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
 152                          "0207 Device %x "
 153                          "(%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x) sent "
 154                          "invalid service parameters.  Ignoring device.\n",
 155                          ndlp->nlp_DID,
 156                          sp->nodeName.u.wwn[0], sp->nodeName.u.wwn[1],
 157                          sp->nodeName.u.wwn[2], sp->nodeName.u.wwn[3],
 158                          sp->nodeName.u.wwn[4], sp->nodeName.u.wwn[5],
 159                          sp->nodeName.u.wwn[6], sp->nodeName.u.wwn[7]);
 160         return 0;
 161 }
 162
 163 static void *
 164 lpfc_check_elscmpl_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 165                         struct lpfc_iocbq *rspiocb)
 166 {
 167         struct lpfc_dmabuf *pcmd, *prsp;
 168         uint32_t *lp;
 169         void     *ptr = NULL;
 170         IOCB_t   *irsp;
 171
 172         irsp = &rspiocb->iocb;
 173         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
 174
 175         /* For lpfc_els_abort, context2 could be zero'ed to delay
 176          * freeing associated memory till after ABTS completes.
 177          */
 178         if (pcmd) {
 179                 prsp =  list_get_first(&pcmd->list, struct lpfc_dmabuf,
 180                                        list);
 181                 if (prsp) {
 182                         lp = (uint32_t *) prsp->virt;
 183                         ptr = (void *)((uint8_t *)lp + sizeof(uint32_t));
 184                 }
 185         } else {
 186                 /* Force ulpStatus error since we are returning NULL ptr */
 187                 if (!(irsp->ulpStatus)) {
 188                         irsp->ulpStatus = IOSTAT_LOCAL_REJECT;
 189                         irsp->un.ulpWord[4] = IOERR_SLI_ABORTED;
 190                 }
 191                 ptr = NULL;
 192         }
 193         return ptr;
 194 }
 195
 196
 197
 198 /*
 199  * Free resources / clean up outstanding I/Os
 200  * associated with a LPFC_NODELIST entry. This
 201  * routine effectively results in a "software abort".
 202  */
 203 int
 204 lpfc_els_abort(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
 205 {
 206         LIST_HEAD(abort_list);
 207         struct lpfc_sli  *psli = &phba->sli;
 208         struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
 209         struct lpfc_iocbq *iocb, *next_iocb;
 210
 211         /* Abort outstanding I/O on NPort <nlp_DID> */
 212         lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_DISCOVERY,
 213                          "2819 Abort outstanding I/O on NPort x%x "
 214                          "Data: x%x x%x x%x\n",
 215                          ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
 216                          ndlp->nlp_rpi);
 217         /* Clean up all fabric IOs first.*/
 218         lpfc_fabric_abort_nport(ndlp);
 219
 220         /*
 221          * Lock the ELS ring txcmplq for SLI3/SLI4 and build a local list
 222          * of all ELS IOs that need an ABTS.  The IOs need to stay on the
 223          * txcmplq so that the abort operation completes them successfully.
 224          */
 225         spin_lock_irq(&phba->hbalock);
 226         if (phba->sli_rev == LPFC_SLI_REV4)
 227                 spin_lock(&pring->ring_lock);
 228         list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
 229         /* Add to abort_list on on NDLP match. */
 230                 if (lpfc_check_sli_ndlp(phba, pring, iocb, ndlp))
 231                         list_add_tail(&iocb->dlist, &abort_list);
 232         }
 233         if (phba->sli_rev == LPFC_SLI_REV4)
 234                 spin_unlock(&pring->ring_lock);
 235         spin_unlock_irq(&phba->hbalock);
 236
 237         /* Abort the targeted IOs and remove them from the abort list. */
 238         list_for_each_entry_safe(iocb, next_iocb, &abort_list, dlist) {
 239                         spin_lock_irq(&phba->hbalock);
 240                         list_del_init(&iocb->dlist);
 241                         lpfc_sli_issue_abort_iotag(phba, pring, iocb);
 242                         spin_unlock_irq(&phba->hbalock);
 243         }
 244
 245         INIT_LIST_HEAD(&abort_list);
 246
 247         /* Now process the txq */
 248         spin_lock_irq(&phba->hbalock);
 249         if (phba->sli_rev == LPFC_SLI_REV4)
 250                 spin_lock(&pring->ring_lock);
 251
 252         list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
 253                 /* Check to see if iocb matches the nport we are looking for */
 254                 if (lpfc_check_sli_ndlp(phba, pring, iocb, ndlp)) {
 255                         list_del_init(&iocb->list);
 256                         list_add_tail(&iocb->list, &abort_list);
 257                 }
 258         }
 259
 260         if (phba->sli_rev == LPFC_SLI_REV4)
 261                 spin_unlock(&pring->ring_lock);
 262         spin_unlock_irq(&phba->hbalock);
 263
 264         /* Cancel all the IOCBs from the completions list */
 265         lpfc_sli_cancel_iocbs(phba, &abort_list,
 266                               IOSTAT_LOCAL_REJECT, IOERR_SLI_ABORTED);
 267
 268         lpfc_cancel_retry_delay_tmo(phba->pport, ndlp);
 269         return 0;
 270 }
 271
 272 static int
 273 lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 274                struct lpfc_iocbq *cmdiocb)
 275 {
 276         struct Scsi_Host   *shost = lpfc_shost_from_vport(vport);
 277         struct lpfc_hba    *phba = vport->phba;
 278         struct lpfc_dmabuf *pcmd;
 279         uint64_t nlp_portwwn = 0;
 280         uint32_t *lp;
 281         IOCB_t *icmd;
 282         struct serv_parm *sp;
 283         LPFC_MBOXQ_t *mbox;
 284         struct ls_rjt stat;
 285         int rc;
 286
 287         memset(&stat, 0, sizeof (struct ls_rjt));
 288         if (vport->port_state <= LPFC_FDISC) {
 289                 /* Before responding to PLOGI, check for pt2pt mode.
 290                  * If we are pt2pt, with an outstanding FLOGI, abort
 291                  * the FLOGI and resend it first.
 292                  */
 293                 if (vport->fc_flag & FC_PT2PT) {
 294                          lpfc_els_abort_flogi(phba);
 295                         if (!(vport->fc_flag & FC_PT2PT_PLOGI)) {
 296                                 /* If the other side is supposed to initiate
 297                                  * the PLOGI anyway, just ACC it now and
 298                                  * move on with discovery.
 299                                  */
 300                                 phba->fc_edtov = FF_DEF_EDTOV;
 301                                 phba->fc_ratov = FF_DEF_RATOV;
 302                                 /* Start discovery - this should just do
 303                                    CLEAR_LA */
 304                                 lpfc_disc_start(vport);
 305                         } else
 306                                 lpfc_initial_flogi(vport);
 307                 } else {
 308                         stat.un.b.lsRjtRsnCode = LSRJT_LOGICAL_BSY;
 309                         stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
 310                         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb,
 311                                             ndlp, NULL);
 312                         return 0;
 313                 }
 314         }
 315         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
 316         lp = (uint32_t *) pcmd->virt;
 317         sp = (struct serv_parm *) ((uint8_t *) lp + sizeof (uint32_t));
 318         if (wwn_to_u64(sp->portName.u.wwn) == 0) {
 319                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
 320                                  "0140 PLOGI Reject: invalid nname\n");
 321                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
 322                 stat.un.b.lsRjtRsnCodeExp = LSEXP_INVALID_PNAME;
 323                 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
 324                         NULL);
 325                 return 0;
 326         }
 327         if (wwn_to_u64(sp->nodeName.u.wwn) == 0) {
 328                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
 329                                  "0141 PLOGI Reject: invalid pname\n");
 330                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
 331                 stat.un.b.lsRjtRsnCodeExp = LSEXP_INVALID_NNAME;
 332                 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
 333                         NULL);
 334                 return 0;
 335         }
 336
 337         nlp_portwwn = wwn_to_u64(ndlp->nlp_portname.u.wwn);
 338         if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3, 0) == 0)) {
 339                 /* Reject this request because invalid parameters */
 340                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
 341                 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
 342                 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
 343                         NULL);
 344                 return 0;
 345         }
 346         icmd = &cmdiocb->iocb;
 347
 348         /* PLOGI chkparm OK */
 349         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
 350                          "0114 PLOGI chkparm OK Data: x%x x%x x%x "
 351                          "x%x x%x x%x\n",
 352                          ndlp->nlp_DID, ndlp->nlp_state, ndlp->nlp_flag,
 353                          ndlp->nlp_rpi, vport->port_state,
 354                          vport->fc_flag);
 355
 356         if (vport->cfg_fcp_class == 2 && sp->cls2.classValid)
 357                 ndlp->nlp_fcp_info |= CLASS2;
 358         else
 359                 ndlp->nlp_fcp_info |= CLASS3;
 360
 361         ndlp->nlp_class_sup = 0;
 362         if (sp->cls1.classValid)
 363                 ndlp->nlp_class_sup |= FC_COS_CLASS1;
 364         if (sp->cls2.classValid)
 365                 ndlp->nlp_class_sup |= FC_COS_CLASS2;
 366         if (sp->cls3.classValid)
 367                 ndlp->nlp_class_sup |= FC_COS_CLASS3;
 368         if (sp->cls4.classValid)
 369                 ndlp->nlp_class_sup |= FC_COS_CLASS4;
 370         ndlp->nlp_maxframe =
 371                 ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) | sp->cmn.bbRcvSizeLsb;
 372
 373         /* if already logged in, do implicit logout */
 374         switch (ndlp->nlp_state) {
 375         case  NLP_STE_NPR_NODE:
 376                 if (!(ndlp->nlp_flag & NLP_NPR_ADISC))
 377                         break;
 378         case  NLP_STE_REG_LOGIN_ISSUE:
 379         case  NLP_STE_PRLI_ISSUE:
 380         case  NLP_STE_UNMAPPED_NODE:
 381         case  NLP_STE_MAPPED_NODE:
 382                 /* lpfc_plogi_confirm_nport skips fabric did, handle it here */
 383                 if (!(ndlp->nlp_type & NLP_FABRIC)) {
 384                         lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb,
 385                                          ndlp, NULL);
 386                         return 1;
 387                 }
 388                 if (nlp_portwwn != 0 &&
 389                     nlp_portwwn != wwn_to_u64(sp->portName.u.wwn))
 390                         lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
 391                                          "0143 PLOGI recv'd from DID: x%x "
 392                                          "WWPN changed: old %llx new %llx\n",
 393                                          ndlp->nlp_DID,
 394                                          (unsigned long long)nlp_portwwn,
 395                                          (unsigned long long)
 396                                          wwn_to_u64(sp->portName.u.wwn));
 397
 398                 ndlp->nlp_prev_state = ndlp->nlp_state;
 399                 /* rport needs to be unregistered first */
 400                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
 401                 break;
 402         }
 403
 404         /* Check for Nport to NPort pt2pt protocol */
 405         if ((vport->fc_flag & FC_PT2PT) &&
 406             !(vport->fc_flag & FC_PT2PT_PLOGI)) {
 407
 408                 /* rcv'ed PLOGI decides what our NPortId will be */
 409                 vport->fc_myDID = icmd->un.rcvels.parmRo;
 410                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 411                 if (mbox == NULL)
 412                         goto out;
 413                 lpfc_config_link(phba, mbox);
 414                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 415                 mbox->vport = vport;
 416                 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
 417                 if (rc == MBX_NOT_FINISHED) {
 418                         mempool_free(mbox, phba->mbox_mem_pool);
 419                         goto out;
 420                 }
 421                 /*
 422                  * For SLI4, the VFI/VPI are registered AFTER the
 423                  * Nport with the higher WWPN sends us a PLOGI with
 424                  * our assigned NPortId.
 425                  */
 426                 if (phba->sli_rev == LPFC_SLI_REV4)
 427                         lpfc_issue_reg_vfi(vport);
 428
 429                 lpfc_can_disctmo(vport);
 430         }
 431         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 432         if (!mbox)
 433                 goto out;
 434
 435         /* Registering an existing RPI behaves differently for SLI3 vs SLI4 */
 436         if (phba->sli_rev == LPFC_SLI_REV4)
 437                 lpfc_unreg_rpi(vport, ndlp);
 438
 439         rc = lpfc_reg_rpi(phba, vport->vpi, icmd->un.rcvels.remoteID,
 440                             (uint8_t *) sp, mbox, ndlp->nlp_rpi);
 441         if (rc) {
 442                 mempool_free(mbox, phba->mbox_mem_pool);
 443                 goto out;
 444         }
 445
 446         /* ACC PLOGI rsp command needs to execute first,
 447          * queue this mbox command to be processed later.
 448          */
 449         mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
 450         /*
 451          * mbox->context2 = lpfc_nlp_get(ndlp) deferred until mailbox
 452          * command issued in lpfc_cmpl_els_acc().
 453          */
 454         mbox->vport = vport;
 455         spin_lock_irq(shost->host_lock);
 456         ndlp->nlp_flag |= (NLP_ACC_REGLOGIN | NLP_RCV_PLOGI);
 457         spin_unlock_irq(shost->host_lock);
 458
 459         /*
 460          * If there is an outstanding PLOGI issued, abort it before
 461          * sending ACC rsp for received PLOGI. If pending plogi
 462          * is not canceled here, the plogi will be rejected by
 463          * remote port and will be retried. On a configuration with
 464          * single discovery thread, this will cause a huge delay in
 465          * discovery. Also this will cause multiple state machines
 466          * running in parallel for this node.
 467          */
 468         if (ndlp->nlp_state == NLP_STE_PLOGI_ISSUE) {
 469                 /* software abort outstanding PLOGI */
 470                 lpfc_els_abort(phba, ndlp);
 471         }
 472
 473         if ((vport->port_type == LPFC_NPIV_PORT &&
 474              vport->cfg_restrict_login)) {
 475
 476                 /* In order to preserve RPIs, we want to cleanup
 477                  * the default RPI the firmware created to rcv
 478                  * this ELS request. The only way to do this is
 479                  * to register, then unregister the RPI.
 480                  */
 481                 spin_lock_irq(shost->host_lock);
 482                 ndlp->nlp_flag |= NLP_RM_DFLT_RPI;
 483                 spin_unlock_irq(shost->host_lock);
 484                 stat.un.b.lsRjtRsnCode = LSRJT_INVALID_CMD;
 485                 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
 486                 rc = lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb,
 487                         ndlp, mbox);
 488                 if (rc)
 489                         mempool_free(mbox, phba->mbox_mem_pool);
 490                 return 1;
 491         }
 492         rc = lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, ndlp, mbox);
 493         if (rc)
 494                 mempool_free(mbox, phba->mbox_mem_pool);
 495         return 1;
 496 out:
 497         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
 498         stat.un.b.lsRjtRsnCodeExp = LSEXP_OUT_OF_RESOURCE;
 499         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
 500         return 0;
 501 }
 502
 503 /**
 504  * lpfc_mbx_cmpl_resume_rpi - Resume RPI completion routine
 505  * @phba: pointer to lpfc hba data structure.
 506  * @mboxq: pointer to mailbox object
 507  *
 508  * This routine is invoked to issue a completion to a rcv'ed
 509  * ADISC or PDISC after the paused RPI has been resumed.
 510  **/
 511 static void
 512 lpfc_mbx_cmpl_resume_rpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 513 {
 514         struct lpfc_vport *vport;
 515         struct lpfc_iocbq *elsiocb;
 516         struct lpfc_nodelist *ndlp;
 517         uint32_t cmd;
 518
 519         elsiocb = (struct lpfc_iocbq *)mboxq->context1;
 520         ndlp = (struct lpfc_nodelist *) mboxq->context2;
 521         vport = mboxq->vport;
 522         cmd = elsiocb->drvrTimeout;
 523
 524         if (cmd == ELS_CMD_ADISC) {
 525                 lpfc_els_rsp_adisc_acc(vport, elsiocb, ndlp);
 526         } else {
 527                 lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, elsiocb,
 528                         ndlp, NULL);
 529         }
 530         kfree(elsiocb);
 531         mempool_free(mboxq, phba->mbox_mem_pool);
 532 }
 533
 534 static int
 535 lpfc_rcv_padisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 536                 struct lpfc_iocbq *cmdiocb)
 537 {
 538         struct Scsi_Host   *shost = lpfc_shost_from_vport(vport);
 539         struct lpfc_iocbq  *elsiocb;
 540         struct lpfc_dmabuf *pcmd;
 541         struct serv_parm   *sp;
 542         struct lpfc_name   *pnn, *ppn;
 543         struct ls_rjt stat;
 544         ADISC *ap;
 545         IOCB_t *icmd;
 546         uint32_t *lp;
 547         uint32_t cmd;
 548
 549         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
 550         lp = (uint32_t *) pcmd->virt;
 551
 552         cmd = *lp++;
 553         if (cmd == ELS_CMD_ADISC) {
 554                 ap = (ADISC *) lp;
 555                 pnn = (struct lpfc_name *) & ap->nodeName;
 556                 ppn = (struct lpfc_name *) & ap->portName;
 557         } else {
 558                 sp = (struct serv_parm *) lp;
 559                 pnn = (struct lpfc_name *) & sp->nodeName;
 560                 ppn = (struct lpfc_name *) & sp->portName;
 561         }
 562
 563         icmd = &cmdiocb->iocb;
 564         if (icmd->ulpStatus == 0 && lpfc_check_adisc(vport, ndlp, pnn, ppn)) {
 565
 566                 /*
 567                  * As soon as  we send ACC, the remote NPort can
 568                  * start sending us data. Thus, for SLI4 we must
 569                  * resume the RPI before the ACC goes out.
 570                  */
 571                 if (vport->phba->sli_rev == LPFC_SLI_REV4) {
 572                         elsiocb = kmalloc(sizeof(struct lpfc_iocbq),
 573                                 GFP_KERNEL);
 574                         if (elsiocb) {
 575
 576                                 /* Save info from cmd IOCB used in rsp */
 577                                 memcpy((uint8_t *)elsiocb, (uint8_t *)cmdiocb,
 578                                         sizeof(struct lpfc_iocbq));
 579
 580                                 /* Save the ELS cmd */
 581                                 elsiocb->drvrTimeout = cmd;
 582
 583                                 lpfc_sli4_resume_rpi(ndlp,
 584                                         lpfc_mbx_cmpl_resume_rpi, elsiocb);
 585                                 goto out;
 586                         }
 587                 }
 588
 589                 if (cmd == ELS_CMD_ADISC) {
 590                         lpfc_els_rsp_adisc_acc(vport, cmdiocb, ndlp);
 591                 } else {
 592                         lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb,
 593                                 ndlp, NULL);
 594                 }
 595 out:
 596                 /* If we are authenticated, move to the proper state */
 597                 if (ndlp->nlp_type & NLP_FCP_TARGET)
 598                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_MAPPED_NODE);
 599                 else
 600                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
 601
 602                 return 1;
 603         }
 604         /* Reject this request because invalid parameters */
 605         stat.un.b.lsRjtRsvd0 = 0;
 606         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
 607         stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
 608         stat.un.b.vendorUnique = 0;
 609         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
 610
 611         /* 1 sec timeout */
 612         mod_timer(&ndlp->nlp_delayfunc, jiffies + msecs_to_jiffies(1000));
 613
 614         spin_lock_irq(shost->host_lock);
 615         ndlp->nlp_flag |= NLP_DELAY_TMO;
 616         spin_unlock_irq(shost->host_lock);
 617         ndlp->nlp_last_elscmd = ELS_CMD_PLOGI;
 618         ndlp->nlp_prev_state = ndlp->nlp_state;
 619         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
 620         return 0;
 621 }
 622
 623 static int
 624 lpfc_rcv_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 625               struct lpfc_iocbq *cmdiocb, uint32_t els_cmd)
 626 {
 627         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 628         struct lpfc_hba    *phba = vport->phba;
 629         struct lpfc_vport **vports;
 630         int i, active_vlink_present = 0 ;
 631
 632         /* Put ndlp in NPR state with 1 sec timeout for plogi, ACC logo */
 633         /* Only call LOGO ACC for first LOGO, this avoids sending unnecessary
 634          * PLOGIs during LOGO storms from a device.
 635          */
 636         spin_lock_irq(shost->host_lock);
 637         ndlp->nlp_flag |= NLP_LOGO_ACC;
 638         spin_unlock_irq(shost->host_lock);
 639         if (els_cmd == ELS_CMD_PRLO)
 640                 lpfc_els_rsp_acc(vport, ELS_CMD_PRLO, cmdiocb, ndlp, NULL);
 641         else
 642                 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
 643         if (ndlp->nlp_DID == Fabric_DID) {
 644                 if (vport->port_state <= LPFC_FDISC)
 645                         goto out;
 646                 lpfc_linkdown_port(vport);
 647                 spin_lock_irq(shost->host_lock);
 648                 vport->fc_flag |= FC_VPORT_LOGO_RCVD;
 649                 spin_unlock_irq(shost->host_lock);
 650                 vports = lpfc_create_vport_work_array(phba);
 651                 if (vports) {
 652                         for (i = 0; i <= phba->max_vports && vports[i] != NULL;
 653                                         i++) {
 654                                 if ((!(vports[i]->fc_flag &
 655                                         FC_VPORT_LOGO_RCVD)) &&
 656                                         (vports[i]->port_state > LPFC_FDISC)) {
 657                                         active_vlink_present = 1;
 658                                         break;
 659                                 }
 660                         }
 661                         lpfc_destroy_vport_work_array(phba, vports);
 662                 }
 663
 664                 /*
 665                  * Don't re-instantiate if vport is marked for deletion.
 666                  * If we are here first then vport_delete is going to wait
 667                  * for discovery to complete.
 668                  */
 669                 if (!(vport->load_flag & FC_UNLOADING) &&
 670                                         active_vlink_present) {
 671                         /*
 672                          * If there are other active VLinks present,
 673                          * re-instantiate the Vlink using FDISC.
 674                          */
 675                         mod_timer(&ndlp->nlp_delayfunc,
 676                                   jiffies + msecs_to_jiffies(1000));
 677                         spin_lock_irq(shost->host_lock);
 678                         ndlp->nlp_flag |= NLP_DELAY_TMO;
 679                         spin_unlock_irq(shost->host_lock);
 680                         ndlp->nlp_last_elscmd = ELS_CMD_FDISC;
 681                         vport->port_state = LPFC_FDISC;
 682                 } else {
 683                         spin_lock_irq(shost->host_lock);
 684                         phba->pport->fc_flag &= ~FC_LOGO_RCVD_DID_CHNG;
 685                         spin_unlock_irq(shost->host_lock);
 686                         lpfc_retry_pport_discovery(phba);
 687                 }
 688         } else if ((!(ndlp->nlp_type & NLP_FABRIC) &&
 689                 ((ndlp->nlp_type & NLP_FCP_TARGET) ||
 690                 !(ndlp->nlp_type & NLP_FCP_INITIATOR))) ||
 691                 (ndlp->nlp_state == NLP_STE_ADISC_ISSUE)) {
 692                 /* Only try to re-login if this is NOT a Fabric Node */
 693                 mod_timer(&ndlp->nlp_delayfunc,
 694                           jiffies + msecs_to_jiffies(1000 * 1));
 695                 spin_lock_irq(shost->host_lock);
 696                 ndlp->nlp_flag |= NLP_DELAY_TMO;
 697                 spin_unlock_irq(shost->host_lock);
 698
 699                 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI;
 700         }
 701 out:
 702         ndlp->nlp_prev_state = ndlp->nlp_state;
 703         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
 704
 705         spin_lock_irq(shost->host_lock);
 706         ndlp->nlp_flag &= ~NLP_NPR_ADISC;
 707         spin_unlock_irq(shost->host_lock);
 708         /* The driver has to wait until the ACC completes before it continues
 709          * processing the LOGO.  The action will resume in
 710          * lpfc_cmpl_els_logo_acc routine. Since part of processing includes an
 711          * unreg_login, the driver waits so the ACC does not get aborted.
 712          */
 713         return 0;
 714 }
 715
 716 static void
 717 lpfc_rcv_prli(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 718               struct lpfc_iocbq *cmdiocb)
 719 {
 720         struct lpfc_dmabuf *pcmd;
 721         uint32_t *lp;
 722         PRLI *npr;
 723         struct fc_rport *rport = ndlp->rport;
 724         u32 roles;
 725
 726         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
 727         lp = (uint32_t *) pcmd->virt;
 728         npr = (PRLI *) ((uint8_t *) lp + sizeof (uint32_t));
 729
 730         ndlp->nlp_type &= ~(NLP_FCP_TARGET | NLP_FCP_INITIATOR);
 731         ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
 732         ndlp->nlp_flag &= ~NLP_FIRSTBURST;
 733         if (npr->prliType == PRLI_FCP_TYPE) {
 734                 if (npr->initiatorFunc)
 735                         ndlp->nlp_type |= NLP_FCP_INITIATOR;
 736                 if (npr->targetFunc) {
 737                         ndlp->nlp_type |= NLP_FCP_TARGET;
 738                         if (npr->writeXferRdyDis)
 739                                 ndlp->nlp_flag |= NLP_FIRSTBURST;
 740                 }
 741                 if (npr->Retry)
 742                         ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE;
 743         }
 744         if (rport) {
 745                 /* We need to update the rport role values */
 746                 roles = FC_RPORT_ROLE_UNKNOWN;
 747                 if (ndlp->nlp_type & NLP_FCP_INITIATOR)
 748                         roles |= FC_RPORT_ROLE_FCP_INITIATOR;
 749                 if (ndlp->nlp_type & NLP_FCP_TARGET)
 750                         roles |= FC_RPORT_ROLE_FCP_TARGET;
 751
 752                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT,
 753                         "rport rolechg:   role:x%x did:x%x flg:x%x",
 754                         roles, ndlp->nlp_DID, ndlp->nlp_flag);
 755
 756                 fc_remote_port_rolechg(rport, roles);
 757         }
 758 }
 759
 760 static uint32_t
 761 lpfc_disc_set_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
 762 {
 763         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 764
 765         if (!(ndlp->nlp_flag & NLP_RPI_REGISTERED)) {
 766                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
 767                 return 0;
 768         }
 769
 770         if (!(vport->fc_flag & FC_PT2PT)) {
 771                 /* Check config parameter use-adisc or FCP-2 */
 772                 if ((vport->cfg_use_adisc && (vport->fc_flag & FC_RSCN_MODE)) ||
 773                     ((ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) &&
 774                      (ndlp->nlp_type & NLP_FCP_TARGET))) {
 775                         spin_lock_irq(shost->host_lock);
 776                         ndlp->nlp_flag |= NLP_NPR_ADISC;
 777                         spin_unlock_irq(shost->host_lock);
 778                         return 1;
 779                 }
 780         }
 781         ndlp->nlp_flag &= ~NLP_NPR_ADISC;
 782         lpfc_unreg_rpi(vport, ndlp);
 783         return 0;
 784 }
 785
 786 /**
 787  * lpfc_release_rpi - Release a RPI by issuing unreg_login mailbox cmd.
 788  * @phba : Pointer to lpfc_hba structure.
 789  * @vport: Pointer to lpfc_vport structure.
 790  * @rpi  : rpi to be release.
 791  *
 792  * This function will send a unreg_login mailbox command to the firmware
 793  * to release a rpi.
 794  **/
 795 void
 796 lpfc_release_rpi(struct lpfc_hba *phba,
 797                 struct lpfc_vport *vport,
 798                 uint16_t rpi)
 799 {
 800         LPFC_MBOXQ_t *pmb;
 801         int rc;
 802
 803         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
 804                         GFP_KERNEL);
 805         if (!pmb)
 806                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
 807                         "2796 mailbox memory allocation failed \n");
 808         else {
 809                 lpfc_unreg_login(phba, vport->vpi, rpi, pmb);
 810                 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 811                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 812                 if (rc == MBX_NOT_FINISHED)
 813                         mempool_free(pmb, phba->mbox_mem_pool);
 814         }
 815 }
 816
 817 static uint32_t
 818 lpfc_disc_illegal(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 819                   void *arg, uint32_t evt)
 820 {
 821         struct lpfc_hba *phba;
 822         LPFC_MBOXQ_t *pmb = (LPFC_MBOXQ_t *) arg;
 823         uint16_t rpi;
 824
 825         phba = vport->phba;
 826         /* Release the RPI if reglogin completing */
 827         if (!(phba->pport->load_flag & FC_UNLOADING) &&
 828                 (evt == NLP_EVT_CMPL_REG_LOGIN) &&
 829                 (!pmb->u.mb.mbxStatus)) {
 830                 rpi = pmb->u.mb.un.varWords[0];
 831                 lpfc_release_rpi(phba, vport, rpi);
 832         }
 833         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
 834                          "0271 Illegal State Transition: node x%x "
 835                          "event x%x, state x%x Data: x%x x%x\n",
 836                          ndlp->nlp_DID, evt, ndlp->nlp_state, ndlp->nlp_rpi,
 837                          ndlp->nlp_flag);
 838         return ndlp->nlp_state;
 839 }
 840
 841 static uint32_t
 842 lpfc_cmpl_plogi_illegal(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 843                   void *arg, uint32_t evt)
 844 {
 845         /* This transition is only legal if we previously
 846          * rcv'ed a PLOGI. Since we don't want 2 discovery threads
 847          * working on the same NPortID, do nothing for this thread
 848          * to stop it.
 849          */
 850         if (!(ndlp->nlp_flag & NLP_RCV_PLOGI)) {
 851                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
 852                          "0272 Illegal State Transition: node x%x "
 853                          "event x%x, state x%x Data: x%x x%x\n",
 854                          ndlp->nlp_DID, evt, ndlp->nlp_state, ndlp->nlp_rpi,
 855                          ndlp->nlp_flag);
 856         }
 857         return ndlp->nlp_state;
 858 }
 859
 860 /* Start of Discovery State Machine routines */
 861
 862 static uint32_t
 863 lpfc_rcv_plogi_unused_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 864                            void *arg, uint32_t evt)
 865 {
 866         struct lpfc_iocbq *cmdiocb;
 867
 868         cmdiocb = (struct lpfc_iocbq *) arg;
 869
 870         if (lpfc_rcv_plogi(vport, ndlp, cmdiocb)) {
 871                 return ndlp->nlp_state;
 872         }
 873         return NLP_STE_FREED_NODE;
 874 }
 875
 876 static uint32_t
 877 lpfc_rcv_els_unused_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 878                          void *arg, uint32_t evt)
 879 {
 880         lpfc_issue_els_logo(vport, ndlp, 0);
 881         return ndlp->nlp_state;
 882 }
 883
 884 static uint32_t
 885 lpfc_rcv_logo_unused_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 886                           void *arg, uint32_t evt)
 887 {
 888         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
 889         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
 890
 891         spin_lock_irq(shost->host_lock);
 892         ndlp->nlp_flag |= NLP_LOGO_ACC;
 893         spin_unlock_irq(shost->host_lock);
 894         lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
 895
 896         return ndlp->nlp_state;
 897 }
 898
 899 static uint32_t
 900 lpfc_cmpl_logo_unused_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 901                            void *arg, uint32_t evt)
 902 {
 903         return NLP_STE_FREED_NODE;
 904 }
 905
 906 static uint32_t
 907 lpfc_device_rm_unused_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 908                            void *arg, uint32_t evt)
 909 {
 910         return NLP_STE_FREED_NODE;
 911 }
 912
 913 static uint32_t
 914 lpfc_device_recov_unused_node(struct lpfc_vport *vport,
 915                         struct lpfc_nodelist *ndlp,
 916                            void *arg, uint32_t evt)
 917 {
 918         return ndlp->nlp_state;
 919 }
 920
 921 static uint32_t
 922 lpfc_rcv_plogi_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 923                            void *arg, uint32_t evt)
 924 {
 925         struct Scsi_Host   *shost = lpfc_shost_from_vport(vport);
 926         struct lpfc_hba   *phba = vport->phba;
 927         struct lpfc_iocbq *cmdiocb = arg;
 928         struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
 929         uint32_t *lp = (uint32_t *) pcmd->virt;
 930         struct serv_parm *sp = (struct serv_parm *) (lp + 1);
 931         struct ls_rjt stat;
 932         int port_cmp;
 933
 934         memset(&stat, 0, sizeof (struct ls_rjt));
 935
 936         /* For a PLOGI, we only accept if our portname is less
 937          * than the remote portname.
 938          */
 939         phba->fc_stat.elsLogiCol++;
 940         port_cmp = memcmp(&vport->fc_portname, &sp->portName,
 941                           sizeof(struct lpfc_name));
 942
 943         if (port_cmp >= 0) {
 944                 /* Reject this request because the remote node will accept
 945                    ours */
 946                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
 947                 stat.un.b.lsRjtRsnCodeExp = LSEXP_CMD_IN_PROGRESS;
 948                 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
 949                         NULL);
 950         } else {
 951                 if (lpfc_rcv_plogi(vport, ndlp, cmdiocb) &&
 952                     (ndlp->nlp_flag & NLP_NPR_2B_DISC) &&
 953                     (vport->num_disc_nodes)) {
 954                         spin_lock_irq(shost->host_lock);
 955                         ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
 956                         spin_unlock_irq(shost->host_lock);
 957                         /* Check if there are more PLOGIs to be sent */
 958                         lpfc_more_plogi(vport);
 959                         if (vport->num_disc_nodes == 0) {
 960                                 spin_lock_irq(shost->host_lock);
 961                                 vport->fc_flag &= ~FC_NDISC_ACTIVE;
 962                                 spin_unlock_irq(shost->host_lock);
 963                                 lpfc_can_disctmo(vport);
 964                                 lpfc_end_rscn(vport);
 965                         }
 966                 }
 967         } /* If our portname was less */
 968
 969         return ndlp->nlp_state;
 970 }
 971
 972 static uint32_t
 973 lpfc_rcv_prli_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 974                           void *arg, uint32_t evt)
 975 {
 976         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
 977         struct ls_rjt     stat;
 978
 979         memset(&stat, 0, sizeof (struct ls_rjt));
 980         stat.un.b.lsRjtRsnCode = LSRJT_LOGICAL_BSY;
 981         stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
 982         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
 983         return ndlp->nlp_state;
 984 }
 985
 986 static uint32_t
 987 lpfc_rcv_logo_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 988                           void *arg, uint32_t evt)
 989 {
 990         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
 991
 992                                 /* software abort outstanding PLOGI */
 993         lpfc_els_abort(vport->phba, ndlp);
 994
 995         lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO);
 996         return ndlp->nlp_state;
 997 }
 998
 999 static uint32_t
1000 lpfc_rcv_els_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1001                          void *arg, uint32_t evt)
1002 {
1003         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1004         struct lpfc_hba   *phba = vport->phba;
1005         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1006
1007         /* software abort outstanding PLOGI */
1008         lpfc_els_abort(phba, ndlp);
1009
1010         if (evt == NLP_EVT_RCV_LOGO) {
1011                 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
1012         } else {
1013                 lpfc_issue_els_logo(vport, ndlp, 0);
1014         }
1015
1016         /* Put ndlp in npr state set plogi timer for 1 sec */
1017         mod_timer(&ndlp->nlp_delayfunc, jiffies + msecs_to_jiffies(1000 * 1));
1018         spin_lock_irq(shost->host_lock);
1019         ndlp->nlp_flag |= NLP_DELAY_TMO;
1020         spin_unlock_irq(shost->host_lock);
1021         ndlp->nlp_last_elscmd = ELS_CMD_PLOGI;
1022         ndlp->nlp_prev_state = NLP_STE_PLOGI_ISSUE;
1023         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1024
1025         return ndlp->nlp_state;
1026 }
1027
1028 static uint32_t
1029 lpfc_cmpl_plogi_plogi_issue(struct lpfc_vport *vport,
1030                             struct lpfc_nodelist *ndlp,
1031                             void *arg,
1032                             uint32_t evt)
1033 {
1034         struct lpfc_hba    *phba = vport->phba;
1035         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1036         struct lpfc_iocbq  *cmdiocb, *rspiocb;
1037         struct lpfc_dmabuf *pcmd, *prsp, *mp;
1038         uint32_t *lp;
1039         IOCB_t *irsp;
1040         struct serv_parm *sp;
1041         LPFC_MBOXQ_t *mbox;
1042
1043         cmdiocb = (struct lpfc_iocbq *) arg;
1044         rspiocb = cmdiocb->context_un.rsp_iocb;
1045
1046         if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
1047                 /* Recovery from PLOGI collision logic */
1048                 return ndlp->nlp_state;
1049         }
1050
1051         irsp = &rspiocb->iocb;
1052
1053         if (irsp->ulpStatus)
1054                 goto out;
1055
1056         pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
1057
1058         prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list);
1059         if (!prsp)
1060                 goto out;
1061
1062         lp = (uint32_t *) prsp->virt;
1063         sp = (struct serv_parm *) ((uint8_t *) lp + sizeof (uint32_t));
1064
1065         /* Some switches have FDMI servers returning 0 for WWN */
1066         if ((ndlp->nlp_DID != FDMI_DID) &&
1067                 (wwn_to_u64(sp->portName.u.wwn) == 0 ||
1068                 wwn_to_u64(sp->nodeName.u.wwn) == 0)) {
1069                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1070                                  "0142 PLOGI RSP: Invalid WWN.\n");
1071                 goto out;
1072         }
1073         if (!lpfc_check_sparm(vport, ndlp, sp, CLASS3, 0))
1074                 goto out;
1075         /* PLOGI chkparm OK */
1076         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1077                          "0121 PLOGI chkparm OK Data: x%x x%x x%x x%x\n",
1078                          ndlp->nlp_DID, ndlp->nlp_state,
1079                          ndlp->nlp_flag, ndlp->nlp_rpi);
1080         if (vport->cfg_fcp_class == 2 && (sp->cls2.classValid))
1081                 ndlp->nlp_fcp_info |= CLASS2;
1082         else
1083                 ndlp->nlp_fcp_info |= CLASS3;
1084
1085         ndlp->nlp_class_sup = 0;
1086         if (sp->cls1.classValid)
1087                 ndlp->nlp_class_sup |= FC_COS_CLASS1;
1088         if (sp->cls2.classValid)
1089                 ndlp->nlp_class_sup |= FC_COS_CLASS2;
1090         if (sp->cls3.classValid)
1091                 ndlp->nlp_class_sup |= FC_COS_CLASS3;
1092         if (sp->cls4.classValid)
1093                 ndlp->nlp_class_sup |= FC_COS_CLASS4;
1094         ndlp->nlp_maxframe =
1095                 ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) | sp->cmn.bbRcvSizeLsb;
1096
1097         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1098         if (!mbox) {
1099                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1100                         "0133 PLOGI: no memory for reg_login "
1101                         "Data: x%x x%x x%x x%x\n",
1102                         ndlp->nlp_DID, ndlp->nlp_state,
1103                         ndlp->nlp_flag, ndlp->nlp_rpi);
1104                 goto out;
1105         }
1106
1107         lpfc_unreg_rpi(vport, ndlp);
1108
1109         if (lpfc_reg_rpi(phba, vport->vpi, irsp->un.elsreq64.remoteID,
1110                          (uint8_t *) sp, mbox, ndlp->nlp_rpi) == 0) {
1111                 switch (ndlp->nlp_DID) {
1112                 case NameServer_DID:
1113                         mbox->mbox_cmpl = lpfc_mbx_cmpl_ns_reg_login;
1114                         break;
1115                 case FDMI_DID:
1116                         mbox->mbox_cmpl = lpfc_mbx_cmpl_fdmi_reg_login;
1117                         break;
1118                 default:
1119                         ndlp->nlp_flag |= NLP_REG_LOGIN_SEND;
1120                         mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
1121                 }
1122                 mbox->context2 = lpfc_nlp_get(ndlp);
1123                 mbox->vport = vport;
1124                 if (lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT)
1125                     != MBX_NOT_FINISHED) {
1126                         lpfc_nlp_set_state(vport, ndlp,
1127                                            NLP_STE_REG_LOGIN_ISSUE);
1128                         return ndlp->nlp_state;
1129                 }
1130                 if (ndlp->nlp_flag & NLP_REG_LOGIN_SEND)
1131                         ndlp->nlp_flag &= ~NLP_REG_LOGIN_SEND;
1132                 /* decrement node reference count to the failed mbox
1133                  * command
1134                  */
1135                 lpfc_nlp_put(ndlp);
1136                 mp = (struct lpfc_dmabuf *) mbox->context1;
1137                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1138                 kfree(mp);
1139                 mempool_free(mbox, phba->mbox_mem_pool);
1140
1141                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1142                                  "0134 PLOGI: cannot issue reg_login "
1143                                  "Data: x%x x%x x%x x%x\n",
1144                                  ndlp->nlp_DID, ndlp->nlp_state,
1145                                  ndlp->nlp_flag, ndlp->nlp_rpi);
1146         } else {
1147                 mempool_free(mbox, phba->mbox_mem_pool);
1148
1149                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1150                                  "0135 PLOGI: cannot format reg_login "
1151                                  "Data: x%x x%x x%x x%x\n",
1152                                  ndlp->nlp_DID, ndlp->nlp_state,
1153                                  ndlp->nlp_flag, ndlp->nlp_rpi);
1154         }
1155
1156
1157 out:
1158         if (ndlp->nlp_DID == NameServer_DID) {
1159                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1160                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1161                                  "0261 Cannot Register NameServer login\n");
1162         }
1163
1164         /*
1165         ** In case the node reference counter does not go to zero, ensure that
1166         ** the stale state for the node is not processed.
1167         */
1168
1169         ndlp->nlp_prev_state = ndlp->nlp_state;
1170         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1171         spin_lock_irq(shost->host_lock);
1172         ndlp->nlp_flag |= NLP_DEFER_RM;
1173         spin_unlock_irq(shost->host_lock);
1174         return NLP_STE_FREED_NODE;
1175 }
1176
1177 static uint32_t
1178 lpfc_cmpl_logo_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1179                            void *arg, uint32_t evt)
1180 {
1181         return ndlp->nlp_state;
1182 }
1183
1184 static uint32_t
1185 lpfc_cmpl_reglogin_plogi_issue(struct lpfc_vport *vport,
1186         struct lpfc_nodelist *ndlp, void *arg, uint32_t evt)
1187 {
1188         struct lpfc_hba *phba;
1189         LPFC_MBOXQ_t *pmb = (LPFC_MBOXQ_t *) arg;
1190         MAILBOX_t *mb = &pmb->u.mb;
1191         uint16_t rpi;
1192
1193         phba = vport->phba;
1194         /* Release the RPI */
1195         if (!(phba->pport->load_flag & FC_UNLOADING) &&
1196                 !mb->mbxStatus) {
1197                 rpi = pmb->u.mb.un.varWords[0];
1198                 lpfc_release_rpi(phba, vport, rpi);
1199         }
1200         return ndlp->nlp_state;
1201 }
1202
1203 static uint32_t
1204 lpfc_device_rm_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1205                            void *arg, uint32_t evt)
1206 {
1207         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1208
1209         if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
1210                 spin_lock_irq(shost->host_lock);
1211                 ndlp->nlp_flag |= NLP_NODEV_REMOVE;
1212                 spin_unlock_irq(shost->host_lock);
1213                 return ndlp->nlp_state;
1214         } else {
1215                 /* software abort outstanding PLOGI */
1216                 lpfc_els_abort(vport->phba, ndlp);
1217
1218                 lpfc_drop_node(vport, ndlp);
1219                 return NLP_STE_FREED_NODE;
1220         }
1221 }
1222
1223 static uint32_t
1224 lpfc_device_recov_plogi_issue(struct lpfc_vport *vport,
1225                               struct lpfc_nodelist *ndlp,
1226                               void *arg,
1227                               uint32_t evt)
1228 {
1229         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1230         struct lpfc_hba  *phba = vport->phba;
1231
1232         /* Don't do anything that will mess up processing of the
1233          * previous RSCN.
1234          */
1235         if (vport->fc_flag & FC_RSCN_DEFERRED)
1236                 return ndlp->nlp_state;
1237
1238         /* software abort outstanding PLOGI */
1239         lpfc_els_abort(phba, ndlp);
1240
1241         ndlp->nlp_prev_state = NLP_STE_PLOGI_ISSUE;
1242         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1243         spin_lock_irq(shost->host_lock);
1244         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
1245         spin_unlock_irq(shost->host_lock);
1246
1247         return ndlp->nlp_state;
1248 }
1249
1250 static uint32_t
1251 lpfc_rcv_plogi_adisc_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1252                            void *arg, uint32_t evt)
1253 {
1254         struct Scsi_Host   *shost = lpfc_shost_from_vport(vport);
1255         struct lpfc_hba   *phba = vport->phba;
1256         struct lpfc_iocbq *cmdiocb;
1257
1258         /* software abort outstanding ADISC */
1259         lpfc_els_abort(phba, ndlp);
1260
1261         cmdiocb = (struct lpfc_iocbq *) arg;
1262
1263         if (lpfc_rcv_plogi(vport, ndlp, cmdiocb)) {
1264                 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
1265                         spin_lock_irq(shost->host_lock);
1266                         ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
1267                         spin_unlock_irq(shost->host_lock);
1268                         if (vport->num_disc_nodes)
1269                                 lpfc_more_adisc(vport);
1270                 }
1271                 return ndlp->nlp_state;
1272         }
1273         ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
1274         lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
1275         lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
1276
1277         return ndlp->nlp_state;
1278 }
1279
1280 static uint32_t
1281 lpfc_rcv_prli_adisc_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1282                           void *arg, uint32_t evt)
1283 {
1284         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1285
1286         lpfc_els_rsp_prli_acc(vport, cmdiocb, ndlp);
1287         return ndlp->nlp_state;
1288 }
1289
1290 static uint32_t
1291 lpfc_rcv_logo_adisc_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1292                           void *arg, uint32_t evt)
1293 {
1294         struct lpfc_hba *phba = vport->phba;
1295         struct lpfc_iocbq *cmdiocb;
1296
1297         cmdiocb = (struct lpfc_iocbq *) arg;
1298
1299         /* software abort outstanding ADISC */
1300         lpfc_els_abort(phba, ndlp);
1301
1302         lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO);
1303         return ndlp->nlp_state;
1304 }
1305
1306 static uint32_t
1307 lpfc_rcv_padisc_adisc_issue(struct lpfc_vport *vport,
1308                             struct lpfc_nodelist *ndlp,
1309                             void *arg, uint32_t evt)
1310 {
1311         struct lpfc_iocbq *cmdiocb;
1312
1313         cmdiocb = (struct lpfc_iocbq *) arg;
1314
1315         lpfc_rcv_padisc(vport, ndlp, cmdiocb);
1316         return ndlp->nlp_state;
1317 }
1318
1319 static uint32_t
1320 lpfc_rcv_prlo_adisc_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1321                           void *arg, uint32_t evt)
1322 {
1323         struct lpfc_iocbq *cmdiocb;
1324
1325         cmdiocb = (struct lpfc_iocbq *) arg;
1326
1327         /* Treat like rcv logo */
1328         lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_PRLO);
1329         return ndlp->nlp_state;
1330 }
1331
1332 static uint32_t
1333 lpfc_cmpl_adisc_adisc_issue(struct lpfc_vport *vport,
1334                             struct lpfc_nodelist *ndlp,
1335                             void *arg, uint32_t evt)
1336 {
1337         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1338         struct lpfc_hba   *phba = vport->phba;
1339         struct lpfc_iocbq *cmdiocb, *rspiocb;
1340         IOCB_t *irsp;
1341         ADISC *ap;
1342         int rc;
1343
1344         cmdiocb = (struct lpfc_iocbq *) arg;
1345         rspiocb = cmdiocb->context_un.rsp_iocb;
1346
1347         ap = (ADISC *)lpfc_check_elscmpl_iocb(phba, cmdiocb, rspiocb);
1348         irsp = &rspiocb->iocb;
1349
1350         if ((irsp->ulpStatus) ||
1351             (!lpfc_check_adisc(vport, ndlp, &ap->nodeName, &ap->portName))) {
1352                 /* 1 sec timeout */
1353                 mod_timer(&ndlp->nlp_delayfunc,
1354                           jiffies + msecs_to_jiffies(1000));
1355                 spin_lock_irq(shost->host_lock);
1356                 ndlp->nlp_flag |= NLP_DELAY_TMO;
1357                 spin_unlock_irq(shost->host_lock);
1358                 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI;
1359
1360                 memset(&ndlp->nlp_nodename, 0, sizeof(struct lpfc_name));
1361                 memset(&ndlp->nlp_portname, 0, sizeof(struct lpfc_name));
1362
1363                 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
1364                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1365                 lpfc_unreg_rpi(vport, ndlp);
1366                 return ndlp->nlp_state;
1367         }
1368
1369         if (phba->sli_rev == LPFC_SLI_REV4) {
1370                 rc = lpfc_sli4_resume_rpi(ndlp, NULL, NULL);
1371                 if (rc) {
1372                         /* Stay in state and retry. */
1373                         ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
1374                         return ndlp->nlp_state;
1375                 }
1376         }
1377
1378         if (ndlp->nlp_type & NLP_FCP_TARGET) {
1379                 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
1380                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_MAPPED_NODE);
1381         } else {
1382                 ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
1383                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
1384         }
1385
1386         return ndlp->nlp_state;
1387 }
1388
1389 static uint32_t
1390 lpfc_device_rm_adisc_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1391                            void *arg, uint32_t evt)
1392 {
1393         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1394
1395         if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
1396                 spin_lock_irq(shost->host_lock);
1397                 ndlp->nlp_flag |= NLP_NODEV_REMOVE;
1398                 spin_unlock_irq(shost->host_lock);
1399                 return ndlp->nlp_state;
1400         } else {
1401                 /* software abort outstanding ADISC */
1402                 lpfc_els_abort(vport->phba, ndlp);
1403
1404                 lpfc_drop_node(vport, ndlp);
1405                 return NLP_STE_FREED_NODE;
1406         }
1407 }
1408
1409 static uint32_t
1410 lpfc_device_recov_adisc_issue(struct lpfc_vport *vport,
1411                               struct lpfc_nodelist *ndlp,
1412                               void *arg,
1413                               uint32_t evt)
1414 {
1415         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1416         struct lpfc_hba  *phba = vport->phba;
1417
1418         /* Don't do anything that will mess up processing of the
1419          * previous RSCN.
1420          */
1421         if (vport->fc_flag & FC_RSCN_DEFERRED)
1422                 return ndlp->nlp_state;
1423
1424         /* software abort outstanding ADISC */
1425         lpfc_els_abort(phba, ndlp);
1426
1427         ndlp->nlp_prev_state = NLP_STE_ADISC_ISSUE;
1428         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1429         spin_lock_irq(shost->host_lock);
1430         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
1431         spin_unlock_irq(shost->host_lock);
1432         lpfc_disc_set_adisc(vport, ndlp);
1433         return ndlp->nlp_state;
1434 }
1435
1436 static uint32_t
1437 lpfc_rcv_plogi_reglogin_issue(struct lpfc_vport *vport,
1438                               struct lpfc_nodelist *ndlp,
1439                               void *arg,
1440                               uint32_t evt)
1441 {
1442         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1443
1444         lpfc_rcv_plogi(vport, ndlp, cmdiocb);
1445         return ndlp->nlp_state;
1446 }
1447
1448 static uint32_t
1449 lpfc_rcv_prli_reglogin_issue(struct lpfc_vport *vport,
1450                              struct lpfc_nodelist *ndlp,
1451                              void *arg,
1452                              uint32_t evt)
1453 {
1454         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1455
1456         lpfc_els_rsp_prli_acc(vport, cmdiocb, ndlp);
1457         return ndlp->nlp_state;
1458 }
1459
1460 static uint32_t
1461 lpfc_rcv_logo_reglogin_issue(struct lpfc_vport *vport,
1462                              struct lpfc_nodelist *ndlp,
1463                              void *arg,
1464                              uint32_t evt)
1465 {
1466         struct lpfc_hba   *phba = vport->phba;
1467         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1468         LPFC_MBOXQ_t      *mb;
1469         LPFC_MBOXQ_t      *nextmb;
1470         struct lpfc_dmabuf *mp;
1471
1472         cmdiocb = (struct lpfc_iocbq *) arg;
1473
1474         /* cleanup any ndlp on mbox q waiting for reglogin cmpl */
1475         if ((mb = phba->sli.mbox_active)) {
1476                 if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&
1477                    (ndlp == (struct lpfc_nodelist *) mb->context2)) {
1478                         lpfc_nlp_put(ndlp);
1479                         mb->context2 = NULL;
1480                         mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
1481                 }
1482         }
1483
1484         spin_lock_irq(&phba->hbalock);
1485         list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
1486                 if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&
1487                    (ndlp == (struct lpfc_nodelist *) mb->context2)) {
1488                         mp = (struct lpfc_dmabuf *) (mb->context1);
1489                         if (mp) {
1490                                 __lpfc_mbuf_free(phba, mp->virt, mp->phys);
1491                                 kfree(mp);
1492                         }
1493                         lpfc_nlp_put(ndlp);
1494                         list_del(&mb->list);
1495                         phba->sli.mboxq_cnt--;
1496                         mempool_free(mb, phba->mbox_mem_pool);
1497                 }
1498         }
1499         spin_unlock_irq(&phba->hbalock);
1500
1501         lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO);
1502         return ndlp->nlp_state;
1503 }
1504
1505 static uint32_t
1506 lpfc_rcv_padisc_reglogin_issue(struct lpfc_vport *vport,
1507                                struct lpfc_nodelist *ndlp,
1508                                void *arg,
1509                                uint32_t evt)
1510 {
1511         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1512
1513         lpfc_rcv_padisc(vport, ndlp, cmdiocb);
1514         return ndlp->nlp_state;
1515 }
1516
1517 static uint32_t
1518 lpfc_rcv_prlo_reglogin_issue(struct lpfc_vport *vport,
1519                              struct lpfc_nodelist *ndlp,
1520                              void *arg,
1521                              uint32_t evt)
1522 {
1523         struct lpfc_iocbq *cmdiocb;
1524
1525         cmdiocb = (struct lpfc_iocbq *) arg;
1526         lpfc_els_rsp_acc(vport, ELS_CMD_PRLO, cmdiocb, ndlp, NULL);
1527         return ndlp->nlp_state;
1528 }
1529
1530 static uint32_t
1531 lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_vport *vport,
1532                                   struct lpfc_nodelist *ndlp,
1533                                   void *arg,
1534                                   uint32_t evt)
1535 {
1536         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1537         LPFC_MBOXQ_t *pmb = (LPFC_MBOXQ_t *) arg;
1538         MAILBOX_t *mb = &pmb->u.mb;
1539         uint32_t did  = mb->un.varWords[1];
1540
1541         if (mb->mbxStatus) {
1542                 /* RegLogin failed */
1543                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
1544                                 "0246 RegLogin failed Data: x%x x%x x%x x%x "
1545                                  "x%x\n",
1546                                  did, mb->mbxStatus, vport->port_state,
1547                                  mb->un.varRegLogin.vpi,
1548                                  mb->un.varRegLogin.rpi);
1549                 /*
1550                  * If RegLogin failed due to lack of HBA resources do not
1551                  * retry discovery.
1552                  */
1553                 if (mb->mbxStatus == MBXERR_RPI_FULL) {
1554                         ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1555                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1556                         return ndlp->nlp_state;
1557                 }
1558
1559                 /* Put ndlp in npr state set plogi timer for 1 sec */
1560                 mod_timer(&ndlp->nlp_delayfunc,
1561                           jiffies + msecs_to_jiffies(1000 * 1));
1562                 spin_lock_irq(shost->host_lock);
1563                 ndlp->nlp_flag |= NLP_DELAY_TMO;
1564                 spin_unlock_irq(shost->host_lock);
1565                 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI;
1566
1567                 lpfc_issue_els_logo(vport, ndlp, 0);
1568                 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1569                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1570                 return ndlp->nlp_state;
1571         }
1572
1573         /* SLI4 ports have preallocated logical rpis. */
1574         if (vport->phba->sli_rev < LPFC_SLI_REV4)
1575                 ndlp->nlp_rpi = mb->un.varWords[0];
1576
1577         ndlp->nlp_flag |= NLP_RPI_REGISTERED;
1578
1579         /* Only if we are not a fabric nport do we issue PRLI */
1580         if (!(ndlp->nlp_type & NLP_FABRIC)) {
1581                 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1582                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
1583                 lpfc_issue_els_prli(vport, ndlp, 0);
1584         } else {
1585                 ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1586                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
1587         }
1588         return ndlp->nlp_state;
1589 }
1590
1591 static uint32_t
1592 lpfc_device_rm_reglogin_issue(struct lpfc_vport *vport,
1593                               struct lpfc_nodelist *ndlp,
1594                               void *arg,
1595                               uint32_t evt)
1596 {
1597         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1598
1599         if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
1600                 spin_lock_irq(shost->host_lock);
1601                 ndlp->nlp_flag |= NLP_NODEV_REMOVE;
1602                 spin_unlock_irq(shost->host_lock);
1603                 return ndlp->nlp_state;
1604         } else {
1605                 lpfc_drop_node(vport, ndlp);
1606                 return NLP_STE_FREED_NODE;
1607         }
1608 }
1609
1610 static uint32_t
1611 lpfc_device_recov_reglogin_issue(struct lpfc_vport *vport,
1612                                  struct lpfc_nodelist *ndlp,
1613                                  void *arg,
1614                                  uint32_t evt)
1615 {
1616         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1617
1618         /* Don't do anything that will mess up processing of the
1619          * previous RSCN.
1620          */
1621         if (vport->fc_flag & FC_RSCN_DEFERRED)
1622                 return ndlp->nlp_state;
1623
1624         ndlp->nlp_prev_state = NLP_STE_REG_LOGIN_ISSUE;
1625         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1626         spin_lock_irq(shost->host_lock);
1627         ndlp->nlp_flag |= NLP_IGNR_REG_CMPL;
1628         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
1629         spin_unlock_irq(shost->host_lock);
1630         lpfc_disc_set_adisc(vport, ndlp);
1631         return ndlp->nlp_state;
1632 }
1633
1634 static uint32_t
1635 lpfc_rcv_plogi_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1636                           void *arg, uint32_t evt)
1637 {
1638         struct lpfc_iocbq *cmdiocb;
1639
1640         cmdiocb = (struct lpfc_iocbq *) arg;
1641
1642         lpfc_rcv_plogi(vport, ndlp, cmdiocb);
1643         return ndlp->nlp_state;
1644 }
1645
1646 static uint32_t
1647 lpfc_rcv_prli_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1648                          void *arg, uint32_t evt)
1649 {
1650         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1651
1652         lpfc_els_rsp_prli_acc(vport, cmdiocb, ndlp);
1653         return ndlp->nlp_state;
1654 }
1655
1656 static uint32_t
1657 lpfc_rcv_logo_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1658                          void *arg, uint32_t evt)
1659 {
1660         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1661
1662         /* Software abort outstanding PRLI before sending acc */
1663         lpfc_els_abort(vport->phba, ndlp);
1664
1665         lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO);
1666         return ndlp->nlp_state;
1667 }
1668
1669 static uint32_t
1670 lpfc_rcv_padisc_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1671                            void *arg, uint32_t evt)
1672 {
1673         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1674
1675         lpfc_rcv_padisc(vport, ndlp, cmdiocb);
1676         return ndlp->nlp_state;
1677 }
1678
1679 /* This routine is envoked when we rcv a PRLO request from a nport
1680  * we are logged into.  We should send back a PRLO rsp setting the
1681  * appropriate bits.
1682  * NEXT STATE = PRLI_ISSUE
1683  */
1684 static uint32_t
1685 lpfc_rcv_prlo_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1686                          void *arg, uint32_t evt)
1687 {
1688         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1689
1690         lpfc_els_rsp_acc(vport, ELS_CMD_PRLO, cmdiocb, ndlp, NULL);
1691         return ndlp->nlp_state;
1692 }
1693
1694 static uint32_t
1695 lpfc_cmpl_prli_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1696                           void *arg, uint32_t evt)
1697 {
1698         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1699         struct lpfc_iocbq *cmdiocb, *rspiocb;
1700         struct lpfc_hba   *phba = vport->phba;
1701         IOCB_t *irsp;
1702         PRLI *npr;
1703
1704         cmdiocb = (struct lpfc_iocbq *) arg;
1705         rspiocb = cmdiocb->context_un.rsp_iocb;
1706         npr = (PRLI *)lpfc_check_elscmpl_iocb(phba, cmdiocb, rspiocb);
1707
1708         irsp = &rspiocb->iocb;
1709         if (irsp->ulpStatus) {
1710                 if ((vport->port_type == LPFC_NPIV_PORT) &&
1711                     vport->cfg_restrict_login) {
1712                         goto out;
1713                 }
1714                 ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE;
1715                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
1716                 return ndlp->nlp_state;
1717         }
1718
1719         /* Check out PRLI rsp */
1720         ndlp->nlp_type &= ~(NLP_FCP_TARGET | NLP_FCP_INITIATOR);
1721         ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
1722         ndlp->nlp_flag &= ~NLP_FIRSTBURST;
1723         if ((npr->acceptRspCode == PRLI_REQ_EXECUTED) &&
1724             (npr->prliType == PRLI_FCP_TYPE)) {
1725                 if (npr->initiatorFunc)
1726                         ndlp->nlp_type |= NLP_FCP_INITIATOR;
1727                 if (npr->targetFunc) {
1728                         ndlp->nlp_type |= NLP_FCP_TARGET;
1729                         if (npr->writeXferRdyDis)
1730                                 ndlp->nlp_flag |= NLP_FIRSTBURST;
1731                 }
1732                 if (npr->Retry)
1733                         ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE;
1734         }
1735         if (!(ndlp->nlp_type & NLP_FCP_TARGET) &&
1736             (vport->port_type == LPFC_NPIV_PORT) &&
1737              vport->cfg_restrict_login) {
1738 out:
1739                 spin_lock_irq(shost->host_lock);
1740                 ndlp->nlp_flag |= NLP_TARGET_REMOVE;
1741                 spin_unlock_irq(shost->host_lock);
1742                 lpfc_issue_els_logo(vport, ndlp, 0);
1743
1744                 ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE;
1745                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1746                 return ndlp->nlp_state;
1747         }
1748
1749         ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE;
1750         if (ndlp->nlp_type & NLP_FCP_TARGET)
1751                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_MAPPED_NODE);
1752         else
1753                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
1754         return ndlp->nlp_state;
1755 }
1756
1757 /*! lpfc_device_rm_prli_issue
1758  *
1759  * \pre
1760  * \post
1761  * \param   phba
1762  * \param   ndlp
1763  * \param   arg
1764  * \param   evt
1765  * \return  uint32_t
1766  *
1767  * \b Description:
1768  *    This routine is envoked when we a request to remove a nport we are in the
1769  *    process of PRLIing. We should software abort outstanding prli, unreg
1770  *    login, send a logout. We will change node state to UNUSED_NODE, put it
1771  *    on plogi list so it can be freed when LOGO completes.
1772  *
1773  */
1774
1775 static uint32_t
1776 lpfc_device_rm_prli_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1777                           void *arg, uint32_t evt)
1778 {
1779         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1780
1781         if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
1782                 spin_lock_irq(shost->host_lock);
1783                 ndlp->nlp_flag |= NLP_NODEV_REMOVE;
1784                 spin_unlock_irq(shost->host_lock);
1785                 return ndlp->nlp_state;
1786         } else {
1787                 /* software abort outstanding PLOGI */
1788                 lpfc_els_abort(vport->phba, ndlp);
1789
1790                 lpfc_drop_node(vport, ndlp);
1791                 return NLP_STE_FREED_NODE;
1792         }
1793 }
1794
1795
1796 /*! lpfc_device_recov_prli_issue
1797  *
1798  * \pre
1799  * \post
1800  * \param   phba
1801  * \param   ndlp
1802  * \param   arg
1803  * \param   evt
1804  * \return  uint32_t
1805  *
1806  * \b Description:
1807  *    The routine is envoked when the state of a device is unknown, like
1808  *    during a link down. We should remove the nodelist entry from the
1809  *    unmapped list, issue a UNREG_LOGIN, do a software abort of the
1810  *    outstanding PRLI command, then free the node entry.
1811  */
1812 static uint32_t
1813 lpfc_device_recov_prli_issue(struct lpfc_vport *vport,
1814                              struct lpfc_nodelist *ndlp,
1815                              void *arg,
1816                              uint32_t evt)
1817 {
1818         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1819         struct lpfc_hba  *phba = vport->phba;
1820
1821         /* Don't do anything that will mess up processing of the
1822          * previous RSCN.
1823          */
1824         if (vport->fc_flag & FC_RSCN_DEFERRED)
1825                 return ndlp->nlp_state;
1826
1827         /* software abort outstanding PRLI */
1828         lpfc_els_abort(phba, ndlp);
1829
1830         ndlp->nlp_prev_state = NLP_STE_PRLI_ISSUE;
1831         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1832         spin_lock_irq(shost->host_lock);
1833         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
1834         spin_unlock_irq(shost->host_lock);
1835         lpfc_disc_set_adisc(vport, ndlp);
1836         return ndlp->nlp_state;
1837 }
1838
1839 static uint32_t
1840 lpfc_rcv_plogi_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1841                           void *arg, uint32_t evt)
1842 {
1843         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)arg;
1844         struct ls_rjt     stat;
1845
1846         memset(&stat, 0, sizeof(struct ls_rjt));
1847         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
1848         stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
1849         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
1850         return ndlp->nlp_state;
1851 }
1852
1853 static uint32_t
1854 lpfc_rcv_prli_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1855                          void *arg, uint32_t evt)
1856 {
1857         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)arg;
1858         struct ls_rjt     stat;
1859
1860         memset(&stat, 0, sizeof(struct ls_rjt));
1861         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
1862         stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
1863         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
1864         return ndlp->nlp_state;
1865 }
1866
1867 static uint32_t
1868 lpfc_rcv_logo_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1869                          void *arg, uint32_t evt)
1870 {
1871         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1872         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)arg;
1873
1874         spin_lock_irq(shost->host_lock);
1875         ndlp->nlp_flag |= NLP_LOGO_ACC;
1876         spin_unlock_irq(shost->host_lock);
1877         lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
1878         return ndlp->nlp_state;
1879 }
1880
1881 static uint32_t
1882 lpfc_rcv_padisc_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1883                            void *arg, uint32_t evt)
1884 {
1885         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)arg;
1886         struct ls_rjt     stat;
1887
1888         memset(&stat, 0, sizeof(struct ls_rjt));
1889         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
1890         stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
1891         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
1892         return ndlp->nlp_state;
1893 }
1894
1895 static uint32_t
1896 lpfc_rcv_prlo_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1897                          void *arg, uint32_t evt)
1898 {
1899         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)arg;
1900         struct ls_rjt     stat;
1901
1902         memset(&stat, 0, sizeof(struct ls_rjt));
1903         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
1904         stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
1905         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
1906         return ndlp->nlp_state;
1907 }
1908
1909 static uint32_t
1910 lpfc_cmpl_logo_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1911                           void *arg, uint32_t evt)
1912 {
1913         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1914
1915         ndlp->nlp_prev_state = NLP_STE_LOGO_ISSUE;
1916         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1917         spin_lock_irq(shost->host_lock);
1918         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
1919         spin_unlock_irq(shost->host_lock);
1920         lpfc_disc_set_adisc(vport, ndlp);
1921         return ndlp->nlp_state;
1922 }
1923
1924 static uint32_t
1925 lpfc_device_rm_logo_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1926                           void *arg, uint32_t evt)
1927 {
1928         /*
1929          * Take no action.  If a LOGO is outstanding, then possibly DevLoss has
1930          * timed out and is calling for Device Remove.  In this case, the LOGO
1931          * must be allowed to complete in state LOGO_ISSUE so that the rpi
1932          * and other NLP flags are correctly cleaned up.
1933          */
1934         return ndlp->nlp_state;
1935 }
1936
1937 static uint32_t
1938 lpfc_device_recov_logo_issue(struct lpfc_vport *vport,
1939                              struct lpfc_nodelist *ndlp,
1940                              void *arg, uint32_t evt)
1941 {
1942         /*
1943          * Device Recovery events have no meaning for a node with a LOGO
1944          * outstanding.  The LOGO has to complete first and handle the
1945          * node from that point.
1946          */
1947         return ndlp->nlp_state;
1948 }
1949
1950 static uint32_t
1951 lpfc_rcv_plogi_unmap_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1952                           void *arg, uint32_t evt)
1953 {
1954         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1955
1956         lpfc_rcv_plogi(vport, ndlp, cmdiocb);
1957         return ndlp->nlp_state;
1958 }
1959
1960 static uint32_t
1961 lpfc_rcv_prli_unmap_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1962                          void *arg, uint32_t evt)
1963 {
1964         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1965
1966         lpfc_rcv_prli(vport, ndlp, cmdiocb);
1967         lpfc_els_rsp_prli_acc(vport, cmdiocb, ndlp);
1968         return ndlp->nlp_state;
1969 }
1970
1971 static uint32_t
1972 lpfc_rcv_logo_unmap_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1973                          void *arg, uint32_t evt)
1974 {
1975         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1976
1977         lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO);
1978         return ndlp->nlp_state;
1979 }
1980
1981 static uint32_t
1982 lpfc_rcv_padisc_unmap_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1983                            void *arg, uint32_t evt)
1984 {
1985         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1986
1987         lpfc_rcv_padisc(vport, ndlp, cmdiocb);
1988         return ndlp->nlp_state;
1989 }
1990
1991 static uint32_t
1992 lpfc_rcv_prlo_unmap_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1993                          void *arg, uint32_t evt)
1994 {
1995         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
1996
1997         lpfc_els_rsp_acc(vport, ELS_CMD_PRLO, cmdiocb, ndlp, NULL);
1998         return ndlp->nlp_state;
1999 }
2000
2001 static uint32_t
2002 lpfc_device_recov_unmap_node(struct lpfc_vport *vport,
2003                              struct lpfc_nodelist *ndlp,
2004                              void *arg,
2005                              uint32_t evt)
2006 {
2007         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2008
2009         ndlp->nlp_prev_state = NLP_STE_UNMAPPED_NODE;
2010         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
2011         spin_lock_irq(shost->host_lock);
2012         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
2013         spin_unlock_irq(shost->host_lock);
2014         lpfc_disc_set_adisc(vport, ndlp);
2015
2016         return ndlp->nlp_state;
2017 }
2018
2019 static uint32_t
2020 lpfc_rcv_plogi_mapped_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2021                            void *arg, uint32_t evt)
2022 {
2023         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
2024
2025         lpfc_rcv_plogi(vport, ndlp, cmdiocb);
2026         return ndlp->nlp_state;
2027 }
2028
2029 static uint32_t
2030 lpfc_rcv_prli_mapped_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2031                           void *arg, uint32_t evt)
2032 {
2033         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
2034
2035         lpfc_els_rsp_prli_acc(vport, cmdiocb, ndlp);
2036         return ndlp->nlp_state;
2037 }
2038
2039 static uint32_t
2040 lpfc_rcv_logo_mapped_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2041                           void *arg, uint32_t evt)
2042 {
2043         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
2044
2045         lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO);
2046         return ndlp->nlp_state;
2047 }
2048
2049 static uint32_t
2050 lpfc_rcv_padisc_mapped_node(struct lpfc_vport *vport,
2051                             struct lpfc_nodelist *ndlp,
2052                             void *arg, uint32_t evt)
2053 {
2054         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
2055
2056         lpfc_rcv_padisc(vport, ndlp, cmdiocb);
2057         return ndlp->nlp_state;
2058 }
2059
2060 static uint32_t
2061 lpfc_rcv_prlo_mapped_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2062                           void *arg, uint32_t evt)
2063 {
2064         struct lpfc_hba  *phba = vport->phba;
2065         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
2066
2067         /* flush the target */
2068         lpfc_sli_abort_iocb(vport, &phba->sli.ring[phba->sli.fcp_ring],
2069                             ndlp->nlp_sid, 0, LPFC_CTX_TGT);
2070
2071         /* Treat like rcv logo */
2072         lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_PRLO);
2073         return ndlp->nlp_state;
2074 }
2075
2076 static uint32_t
2077 lpfc_device_recov_mapped_node(struct lpfc_vport *vport,
2078                               struct lpfc_nodelist *ndlp,
2079                               void *arg,
2080                               uint32_t evt)
2081 {
2082         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2083
2084         ndlp->nlp_prev_state = NLP_STE_MAPPED_NODE;
2085         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
2086         spin_lock_irq(shost->host_lock);
2087         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
2088         spin_unlock_irq(shost->host_lock);
2089         lpfc_disc_set_adisc(vport, ndlp);
2090         return ndlp->nlp_state;
2091 }
2092
2093 static uint32_t
2094 lpfc_rcv_plogi_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2095                         void *arg, uint32_t evt)
2096 {
2097         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2098         struct lpfc_iocbq *cmdiocb  = (struct lpfc_iocbq *) arg;
2099
2100         /* Ignore PLOGI if we have an outstanding LOGO */
2101         if (ndlp->nlp_flag & (NLP_LOGO_SND | NLP_LOGO_ACC))
2102                 return ndlp->nlp_state;
2103         if (lpfc_rcv_plogi(vport, ndlp, cmdiocb)) {
2104                 lpfc_cancel_retry_delay_tmo(vport, ndlp);
2105                 spin_lock_irq(shost->host_lock);
2106                 ndlp->nlp_flag &= ~(NLP_NPR_ADISC | NLP_NPR_2B_DISC);
2107                 spin_unlock_irq(shost->host_lock);
2108         } else if (!(ndlp->nlp_flag & NLP_NPR_2B_DISC)) {
2109                 /* send PLOGI immediately, move to PLOGI issue state */
2110                 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
2111                         ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
2112                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2113                         lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
2114                 }
2115         }
2116         return ndlp->nlp_state;
2117 }
2118
2119 static uint32_t
2120 lpfc_rcv_prli_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2121                        void *arg, uint32_t evt)
2122 {
2123         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
2124         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
2125         struct ls_rjt     stat;
2126
2127         memset(&stat, 0, sizeof (struct ls_rjt));
2128         stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2129         stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
2130         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
2131
2132         if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
2133                 if (ndlp->nlp_flag & NLP_NPR_ADISC) {
2134                         spin_lock_irq(shost->host_lock);
2135                         ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2136                         ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
2137                         spin_unlock_irq(shost->host_lock);
2138                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
2139                         lpfc_issue_els_adisc(vport, ndlp, 0);
2140                 } else {
2141                         ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
2142                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2143                         lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
2144                 }
2145         }
2146         return ndlp->nlp_state;
2147 }
2148
2149 static uint32_t
2150 lpfc_rcv_logo_npr_node(struct lpfc_vport *vport,  struct lpfc_nodelist *ndlp,
2151                        void *arg, uint32_t evt)
2152 {
2153         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
2154
2155         lpfc_rcv_logo(vport, ndlp, cmdiocb, ELS_CMD_LOGO);
2156         return ndlp->nlp_state;
2157 }
2158
2159 static uint32_t
2160 lpfc_rcv_padisc_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2161                          void *arg, uint32_t evt)
2162 {
2163         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
2164
2165         lpfc_rcv_padisc(vport, ndlp, cmdiocb);
2166         /*
2167          * Do not start discovery if discovery is about to start
2168          * or discovery in progress for this node. Starting discovery
2169          * here will affect the counting of discovery threads.
2170          */
2171         if (!(ndlp->nlp_flag & NLP_DELAY_TMO) &&
2172             !(ndlp->nlp_flag & NLP_NPR_2B_DISC)) {
2173                 if (ndlp->nlp_flag & NLP_NPR_ADISC) {
2174                         ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2175                         ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
2176                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
2177                         lpfc_issue_els_adisc(vport, ndlp, 0);
2178                 } else {
2179                         ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
2180                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2181                         lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
2182                 }
2183         }
2184         return ndlp->nlp_state;
2185 }
2186
2187 static uint32_t
2188 lpfc_rcv_prlo_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2189                        void *arg, uint32_t evt)
2190 {
2191         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2192         struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *) arg;
2193
2194         spin_lock_irq(shost->host_lock);
2195         ndlp->nlp_flag |= NLP_LOGO_ACC;
2196         spin_unlock_irq(shost->host_lock);
2197
2198         lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
2199
2200         if ((ndlp->nlp_flag & NLP_DELAY_TMO) == 0) {
2201                 mod_timer(&ndlp->nlp_delayfunc,
2202                           jiffies + msecs_to_jiffies(1000 * 1));
2203                 spin_lock_irq(shost->host_lock);
2204                 ndlp->nlp_flag |= NLP_DELAY_TMO;
2205                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2206                 spin_unlock_irq(shost->host_lock);
2207                 ndlp->nlp_last_elscmd = ELS_CMD_PLOGI;
2208         } else {
2209                 spin_lock_irq(shost->host_lock);
2210                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2211                 spin_unlock_irq(shost->host_lock);
2212         }
2213         return ndlp->nlp_state;
2214 }
2215
2216 static uint32_t
2217 lpfc_cmpl_plogi_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2218                          void *arg, uint32_t evt)
2219 {
2220         struct lpfc_iocbq *cmdiocb, *rspiocb;
2221         IOCB_t *irsp;
2222         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2223
2224         cmdiocb = (struct lpfc_iocbq *) arg;
2225         rspiocb = cmdiocb->context_un.rsp_iocb;
2226
2227         irsp = &rspiocb->iocb;
2228         if (irsp->ulpStatus) {
2229                 spin_lock_irq(shost->host_lock);
2230                 ndlp->nlp_flag |= NLP_DEFER_RM;
2231                 spin_unlock_irq(shost->host_lock);
2232                 return NLP_STE_FREED_NODE;
2233         }
2234         return ndlp->nlp_state;
2235 }
2236
2237 static uint32_t
2238 lpfc_cmpl_prli_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2239                         void *arg, uint32_t evt)
2240 {
2241         struct lpfc_iocbq *cmdiocb, *rspiocb;
2242         IOCB_t *irsp;
2243
2244         cmdiocb = (struct lpfc_iocbq *) arg;
2245         rspiocb = cmdiocb->context_un.rsp_iocb;
2246
2247         irsp = &rspiocb->iocb;
2248         if (irsp->ulpStatus && (ndlp->nlp_flag & NLP_NODEV_REMOVE)) {
2249                 lpfc_drop_node(vport, ndlp);
2250                 return NLP_STE_FREED_NODE;
2251         }
2252         return ndlp->nlp_state;
2253 }
2254
2255 static uint32_t
2256 lpfc_cmpl_logo_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2257                         void *arg, uint32_t evt)
2258 {
2259         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2260
2261         /* For the fabric port just clear the fc flags. */
2262         if (ndlp->nlp_DID == Fabric_DID) {
2263                 spin_lock_irq(shost->host_lock);
2264                 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
2265                 spin_unlock_irq(shost->host_lock);
2266         }
2267         lpfc_unreg_rpi(vport, ndlp);
2268         return ndlp->nlp_state;
2269 }
2270
2271 static uint32_t
2272 lpfc_cmpl_adisc_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2273                          void *arg, uint32_t evt)
2274 {
2275         struct lpfc_iocbq *cmdiocb, *rspiocb;
2276         IOCB_t *irsp;
2277
2278         cmdiocb = (struct lpfc_iocbq *) arg;
2279         rspiocb = cmdiocb->context_un.rsp_iocb;
2280
2281         irsp = &rspiocb->iocb;
2282         if (irsp->ulpStatus && (ndlp->nlp_flag & NLP_NODEV_REMOVE)) {
2283                 lpfc_drop_node(vport, ndlp);
2284                 return NLP_STE_FREED_NODE;
2285         }
2286         return ndlp->nlp_state;
2287 }
2288
2289 static uint32_t
2290 lpfc_cmpl_reglogin_npr_node(struct lpfc_vport *vport,
2291                             struct lpfc_nodelist *ndlp,
2292                             void *arg, uint32_t evt)
2293 {
2294         LPFC_MBOXQ_t *pmb = (LPFC_MBOXQ_t *) arg;
2295         MAILBOX_t    *mb = &pmb->u.mb;
2296
2297         if (!mb->mbxStatus) {
2298                 /* SLI4 ports have preallocated logical rpis. */
2299                 if (vport->phba->sli_rev < LPFC_SLI_REV4)
2300                         ndlp->nlp_rpi = mb->un.varWords[0];
2301                 ndlp->nlp_flag |= NLP_RPI_REGISTERED;
2302         } else {
2303                 if (ndlp->nlp_flag & NLP_NODEV_REMOVE) {
2304                         lpfc_drop_node(vport, ndlp);
2305                         return NLP_STE_FREED_NODE;
2306                 }
2307         }
2308         return ndlp->nlp_state;
2309 }
2310
2311 static uint32_t
2312 lpfc_device_rm_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2313                         void *arg, uint32_t evt)
2314 {
2315         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2316
2317         if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
2318                 spin_lock_irq(shost->host_lock);
2319                 ndlp->nlp_flag |= NLP_NODEV_REMOVE;
2320                 spin_unlock_irq(shost->host_lock);
2321                 return ndlp->nlp_state;
2322         }
2323         lpfc_drop_node(vport, ndlp);
2324         return NLP_STE_FREED_NODE;
2325 }
2326
2327 static uint32_t
2328 lpfc_device_recov_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2329                            void *arg, uint32_t evt)
2330 {
2331         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2332
2333         /* Don't do anything that will mess up processing of the
2334          * previous RSCN.
2335          */
2336         if (vport->fc_flag & FC_RSCN_DEFERRED)
2337                 return ndlp->nlp_state;
2338
2339         lpfc_cancel_retry_delay_tmo(vport, ndlp);
2340         spin_lock_irq(shost->host_lock);
2341         ndlp->nlp_flag &= ~(NLP_NODEV_REMOVE | NLP_NPR_2B_DISC);
2342         spin_unlock_irq(shost->host_lock);
2343         return ndlp->nlp_state;
2344 }
2345
2346
2347 /* This next section defines the NPort Discovery State Machine */
2348
2349 /* There are 4 different double linked lists nodelist entries can reside on.
2350  * The plogi list and adisc list are used when Link Up discovery or RSCN
2351  * processing is needed. Each list holds the nodes that we will send PLOGI
2352  * or ADISC on. These lists will keep track of what nodes will be effected
2353  * by an RSCN, or a Link Up (Typically, all nodes are effected on Link Up).
2354  * The unmapped_list will contain all nodes that we have successfully logged
2355  * into at the Fibre Channel level. The mapped_list will contain all nodes
2356  * that are mapped FCP targets.
2357  */
2358 /*
2359  * The bind list is a list of undiscovered (potentially non-existent) nodes
2360  * that we have saved binding information on. This information is used when
2361  * nodes transition from the unmapped to the mapped list.
2362  */
2363 /* For UNUSED_NODE state, the node has just been allocated .
2364  * For PLOGI_ISSUE and REG_LOGIN_ISSUE, the node is on
2365  * the PLOGI list. For REG_LOGIN_COMPL, the node is taken off the PLOGI list
2366  * and put on the unmapped list. For ADISC processing, the node is taken off
2367  * the ADISC list and placed on either the mapped or unmapped list (depending
2368  * on its previous state). Once on the unmapped list, a PRLI is issued and the
2369  * state changed to PRLI_ISSUE. When the PRLI completion occurs, the state is
2370  * changed to UNMAPPED_NODE. If the completion indicates a mapped
2371  * node, the node is taken off the unmapped list. The binding list is checked
2372  * for a valid binding, or a binding is automatically assigned. If binding
2373  * assignment is unsuccessful, the node is left on the unmapped list. If
2374  * binding assignment is successful, the associated binding list entry (if
2375  * any) is removed, and the node is placed on the mapped list.
2376  */
2377 /*
2378  * For a Link Down, all nodes on the ADISC, PLOGI, unmapped or mapped
2379  * lists will receive a DEVICE_RECOVERY event. If the linkdown or devloss timers
2380  * expire, all effected nodes will receive a DEVICE_RM event.
2381  */
2382 /*
2383  * For a Link Up or RSCN, all nodes will move from the mapped / unmapped lists
2384  * to either the ADISC or PLOGI list.  After a Nameserver query or ALPA loopmap
2385  * check, additional nodes may be added or removed (via DEVICE_RM) to / from
2386  * the PLOGI or ADISC lists. Once the PLOGI and ADISC lists are populated,
2387  * we will first process the ADISC list.  32 entries are processed initially and
2388  * ADISC is initited for each one.  Completions / Events for each node are
2389  * funnelled thru the state machine.  As each node finishes ADISC processing, it
2390  * starts ADISC for any nodes waiting for ADISC processing. If no nodes are
2391  * waiting, and the ADISC list count is identically 0, then we are done. For
2392  * Link Up discovery, since all nodes on the PLOGI list are UNREG_LOGIN'ed, we
2393  * can issue a CLEAR_LA and reenable Link Events. Next we will process the PLOGI
2394  * list.  32 entries are processed initially and PLOGI is initited for each one.
2395  * Completions / Events for each node are funnelled thru the state machine.  As
2396  * each node finishes PLOGI processing, it starts PLOGI for any nodes waiting
2397  * for PLOGI processing. If no nodes are waiting, and the PLOGI list count is
2398  * indentically 0, then we are done. We have now completed discovery / RSCN
2399  * handling. Upon completion, ALL nodes should be on either the mapped or
2400  * unmapped lists.
2401  */
2402
2403 static uint32_t (*lpfc_disc_action[NLP_STE_MAX_STATE * NLP_EVT_MAX_EVENT])
2404      (struct lpfc_vport *, struct lpfc_nodelist *, void *, uint32_t) = {
2405         /* Action routine                  Event       Current State  */
2406         lpfc_rcv_plogi_unused_node,     /* RCV_PLOGI   UNUSED_NODE    */
2407         lpfc_rcv_els_unused_node,       /* RCV_PRLI        */
2408         lpfc_rcv_logo_unused_node,      /* RCV_LOGO        */
2409         lpfc_rcv_els_unused_node,       /* RCV_ADISC       */
2410         lpfc_rcv_els_unused_node,       /* RCV_PDISC       */
2411         lpfc_rcv_els_unused_node,       /* RCV_PRLO        */
2412         lpfc_disc_illegal,              /* CMPL_PLOGI      */
2413         lpfc_disc_illegal,              /* CMPL_PRLI       */
2414         lpfc_cmpl_logo_unused_node,     /* CMPL_LOGO       */
2415         lpfc_disc_illegal,              /* CMPL_ADISC      */
2416         lpfc_disc_illegal,              /* CMPL_REG_LOGIN  */
2417         lpfc_device_rm_unused_node,     /* DEVICE_RM       */
2418         lpfc_device_recov_unused_node,  /* DEVICE_RECOVERY */
2419
2420         lpfc_rcv_plogi_plogi_issue,     /* RCV_PLOGI   PLOGI_ISSUE    */
2421         lpfc_rcv_prli_plogi_issue,      /* RCV_PRLI        */
2422         lpfc_rcv_logo_plogi_issue,      /* RCV_LOGO        */
2423         lpfc_rcv_els_plogi_issue,       /* RCV_ADISC       */
2424         lpfc_rcv_els_plogi_issue,       /* RCV_PDISC       */
2425         lpfc_rcv_els_plogi_issue,       /* RCV_PRLO        */
2426         lpfc_cmpl_plogi_plogi_issue,    /* CMPL_PLOGI      */
2427         lpfc_disc_illegal,              /* CMPL_PRLI       */
2428         lpfc_cmpl_logo_plogi_issue,     /* CMPL_LOGO       */
2429         lpfc_disc_illegal,              /* CMPL_ADISC      */
2430         lpfc_cmpl_reglogin_plogi_issue,/* CMPL_REG_LOGIN  */
2431         lpfc_device_rm_plogi_issue,     /* DEVICE_RM       */
2432         lpfc_device_recov_plogi_issue,  /* DEVICE_RECOVERY */
2433
2434         lpfc_rcv_plogi_adisc_issue,     /* RCV_PLOGI   ADISC_ISSUE    */
2435         lpfc_rcv_prli_adisc_issue,      /* RCV_PRLI        */
2436         lpfc_rcv_logo_adisc_issue,      /* RCV_LOGO        */
2437         lpfc_rcv_padisc_adisc_issue,    /* RCV_ADISC       */
2438         lpfc_rcv_padisc_adisc_issue,    /* RCV_PDISC       */
2439         lpfc_rcv_prlo_adisc_issue,      /* RCV_PRLO        */
2440         lpfc_disc_illegal,              /* CMPL_PLOGI      */
2441         lpfc_disc_illegal,              /* CMPL_PRLI       */
2442         lpfc_disc_illegal,              /* CMPL_LOGO       */
2443         lpfc_cmpl_adisc_adisc_issue,    /* CMPL_ADISC      */
2444         lpfc_disc_illegal,              /* CMPL_REG_LOGIN  */
2445         lpfc_device_rm_adisc_issue,     /* DEVICE_RM       */
2446         lpfc_device_recov_adisc_issue,  /* DEVICE_RECOVERY */
2447
2448         lpfc_rcv_plogi_reglogin_issue,  /* RCV_PLOGI  REG_LOGIN_ISSUE */
2449         lpfc_rcv_prli_reglogin_issue,   /* RCV_PLOGI       */
2450         lpfc_rcv_logo_reglogin_issue,   /* RCV_LOGO        */
2451         lpfc_rcv_padisc_reglogin_issue, /* RCV_ADISC       */
2452         lpfc_rcv_padisc_reglogin_issue, /* RCV_PDISC       */
2453         lpfc_rcv_prlo_reglogin_issue,   /* RCV_PRLO        */
2454         lpfc_cmpl_plogi_illegal,        /* CMPL_PLOGI      */
2455         lpfc_disc_illegal,              /* CMPL_PRLI       */
2456         lpfc_disc_illegal,              /* CMPL_LOGO       */
2457         lpfc_disc_illegal,              /* CMPL_ADISC      */
2458         lpfc_cmpl_reglogin_reglogin_issue,/* CMPL_REG_LOGIN  */
2459         lpfc_device_rm_reglogin_issue,  /* DEVICE_RM       */
2460         lpfc_device_recov_reglogin_issue,/* DEVICE_RECOVERY */
2461
2462         lpfc_rcv_plogi_prli_issue,      /* RCV_PLOGI   PRLI_ISSUE     */
2463         lpfc_rcv_prli_prli_issue,       /* RCV_PRLI        */
2464         lpfc_rcv_logo_prli_issue,       /* RCV_LOGO        */
2465         lpfc_rcv_padisc_prli_issue,     /* RCV_ADISC       */
2466         lpfc_rcv_padisc_prli_issue,     /* RCV_PDISC       */
2467         lpfc_rcv_prlo_prli_issue,       /* RCV_PRLO        */
2468         lpfc_cmpl_plogi_illegal,        /* CMPL_PLOGI      */
2469         lpfc_cmpl_prli_prli_issue,      /* CMPL_PRLI       */
2470         lpfc_disc_illegal,              /* CMPL_LOGO       */
2471         lpfc_disc_illegal,              /* CMPL_ADISC      */
2472         lpfc_disc_illegal,              /* CMPL_REG_LOGIN  */
2473         lpfc_device_rm_prli_issue,      /* DEVICE_RM       */
2474         lpfc_device_recov_prli_issue,   /* DEVICE_RECOVERY */
2475
2476         lpfc_rcv_plogi_logo_issue,      /* RCV_PLOGI   LOGO_ISSUE     */
2477         lpfc_rcv_prli_logo_issue,       /* RCV_PRLI        */
2478         lpfc_rcv_logo_logo_issue,       /* RCV_LOGO        */
2479         lpfc_rcv_padisc_logo_issue,     /* RCV_ADISC       */
2480         lpfc_rcv_padisc_logo_issue,     /* RCV_PDISC       */
2481         lpfc_rcv_prlo_logo_issue,       /* RCV_PRLO        */
2482         lpfc_cmpl_plogi_illegal,        /* CMPL_PLOGI      */
2483         lpfc_disc_illegal,              /* CMPL_PRLI       */
2484         lpfc_cmpl_logo_logo_issue,      /* CMPL_LOGO       */
2485         lpfc_disc_illegal,              /* CMPL_ADISC      */
2486         lpfc_disc_illegal,              /* CMPL_REG_LOGIN  */
2487         lpfc_device_rm_logo_issue,      /* DEVICE_RM       */
2488         lpfc_device_recov_logo_issue,   /* DEVICE_RECOVERY */
2489
2490         lpfc_rcv_plogi_unmap_node,      /* RCV_PLOGI   UNMAPPED_NODE  */
2491         lpfc_rcv_prli_unmap_node,       /* RCV_PRLI        */
2492         lpfc_rcv_logo_unmap_node,       /* RCV_LOGO        */
2493         lpfc_rcv_padisc_unmap_node,     /* RCV_ADISC       */
2494         lpfc_rcv_padisc_unmap_node,     /* RCV_PDISC       */
2495         lpfc_rcv_prlo_unmap_node,       /* RCV_PRLO        */
2496         lpfc_disc_illegal,              /* CMPL_PLOGI      */
2497         lpfc_disc_illegal,              /* CMPL_PRLI       */
2498         lpfc_disc_illegal,              /* CMPL_LOGO       */
2499         lpfc_disc_illegal,              /* CMPL_ADISC      */
2500         lpfc_disc_illegal,              /* CMPL_REG_LOGIN  */
2501         lpfc_disc_illegal,              /* DEVICE_RM       */
2502         lpfc_device_recov_unmap_node,   /* DEVICE_RECOVERY */
2503
2504         lpfc_rcv_plogi_mapped_node,     /* RCV_PLOGI   MAPPED_NODE    */
2505         lpfc_rcv_prli_mapped_node,      /* RCV_PRLI        */
2506         lpfc_rcv_logo_mapped_node,      /* RCV_LOGO        */
2507         lpfc_rcv_padisc_mapped_node,    /* RCV_ADISC       */
2508         lpfc_rcv_padisc_mapped_node,    /* RCV_PDISC       */
2509         lpfc_rcv_prlo_mapped_node,      /* RCV_PRLO        */
2510         lpfc_disc_illegal,              /* CMPL_PLOGI      */
2511         lpfc_disc_illegal,              /* CMPL_PRLI       */
2512         lpfc_disc_illegal,              /* CMPL_LOGO       */
2513         lpfc_disc_illegal,              /* CMPL_ADISC      */
2514         lpfc_disc_illegal,              /* CMPL_REG_LOGIN  */
2515         lpfc_disc_illegal,              /* DEVICE_RM       */
2516         lpfc_device_recov_mapped_node,  /* DEVICE_RECOVERY */
2517
2518         lpfc_rcv_plogi_npr_node,        /* RCV_PLOGI   NPR_NODE    */
2519         lpfc_rcv_prli_npr_node,         /* RCV_PRLI        */
2520         lpfc_rcv_logo_npr_node,         /* RCV_LOGO        */
2521         lpfc_rcv_padisc_npr_node,       /* RCV_ADISC       */
2522         lpfc_rcv_padisc_npr_node,       /* RCV_PDISC       */
2523         lpfc_rcv_prlo_npr_node,         /* RCV_PRLO        */
2524         lpfc_cmpl_plogi_npr_node,       /* CMPL_PLOGI      */
2525         lpfc_cmpl_prli_npr_node,        /* CMPL_PRLI       */
2526         lpfc_cmpl_logo_npr_node,        /* CMPL_LOGO       */
2527         lpfc_cmpl_adisc_npr_node,       /* CMPL_ADISC      */
2528         lpfc_cmpl_reglogin_npr_node,    /* CMPL_REG_LOGIN  */
2529         lpfc_device_rm_npr_node,        /* DEVICE_RM       */
2530         lpfc_device_recov_npr_node,     /* DEVICE_RECOVERY */
2531 };
2532
2533 int
2534 lpfc_disc_state_machine(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2535                         void *arg, uint32_t evt)
2536 {
2537         uint32_t cur_state, rc;
2538         uint32_t(*func) (struct lpfc_vport *, struct lpfc_nodelist *, void *,
2539                          uint32_t);
2540         uint32_t got_ndlp = 0;
2541
2542         if (lpfc_nlp_get(ndlp))
2543                 got_ndlp = 1;
2544
2545         cur_state = ndlp->nlp_state;
2546
2547         /* DSM in event <evt> on NPort <nlp_DID> in state <cur_state> */
2548         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2549                          "0211 DSM in event x%x on NPort x%x in "
2550                          "state %d Data: x%x\n",
2551                          evt, ndlp->nlp_DID, cur_state, ndlp->nlp_flag);
2552
2553         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_DSM,
2554                  "DSM in:          evt:%d ste:%d did:x%x",
2555                 evt, cur_state, ndlp->nlp_DID);
2556
2557         func = lpfc_disc_action[(cur_state * NLP_EVT_MAX_EVENT) + evt];
2558         rc = (func) (vport, ndlp, arg, evt);
2559
2560         /* DSM out state <rc> on NPort <nlp_DID> */
2561         if (got_ndlp) {
2562                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2563                          "0212 DSM out state %d on NPort x%x Data: x%x\n",
2564                          rc, ndlp->nlp_DID, ndlp->nlp_flag);
2565
2566                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_DSM,
2567                         "DSM out:         ste:%d did:x%x flg:x%x",
2568                         rc, ndlp->nlp_DID, ndlp->nlp_flag);
2569                 /* Decrement the ndlp reference count held for this function */
2570                 lpfc_nlp_put(ndlp);
2571         } else {
2572                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2573                         "0213 DSM out state %d on NPort free\n", rc);
2574
2575                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_DSM,
2576                         "DSM out:         ste:%d did:x%x flg:x%x",
2577                         rc, 0, 0);
2578         }
2579
2580         return rc;
2581 }