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