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