1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2008 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
26 #include <scsi/scsi.h>
27 #include <scsi/scsi_device.h>
28 #include <scsi/scsi_host.h>
29 #include <scsi/scsi_transport_fc.h>
33 #include "lpfc_disc.h"
34 #include "lpfc_scsi.h"
36 #include "lpfc_logmsg.h"
37 #include "lpfc_crtn.h"
38 #include "lpfc_vport.h"
39 #include "lpfc_debugfs.h"
42 /* Called to verify a rcv'ed ADISC was intended for us. */
44 lpfc_check_adisc(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
45 struct lpfc_name
*nn
, struct lpfc_name
*pn
)
47 /* Compare the ADISC rsp WWNN / WWPN matches our internal node
48 * table entry for that node.
50 if (memcmp(nn
, &ndlp
->nlp_nodename
, sizeof (struct lpfc_name
)))
53 if (memcmp(pn
, &ndlp
->nlp_portname
, sizeof (struct lpfc_name
)))
56 /* we match, return success */
61 lpfc_check_sparm(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
62 struct serv_parm
* sp
, uint32_t class)
64 volatile struct serv_parm
*hsp
= &vport
->fc_sparam
;
65 uint16_t hsp_value
, ssp_value
= 0;
68 * The receive data field size and buffer-to-buffer receive data field
69 * size entries are 16 bits but are represented as two 8-bit fields in
70 * the driver data structure to account for rsvd bits and other control
71 * bits. Reconstruct and compare the fields as a 16-bit values before
72 * correcting the byte values.
74 if (sp
->cls1
.classValid
) {
75 hsp_value
= (hsp
->cls1
.rcvDataSizeMsb
<< 8) |
76 hsp
->cls1
.rcvDataSizeLsb
;
77 ssp_value
= (sp
->cls1
.rcvDataSizeMsb
<< 8) |
78 sp
->cls1
.rcvDataSizeLsb
;
80 goto bad_service_param
;
81 if (ssp_value
> hsp_value
) {
82 sp
->cls1
.rcvDataSizeLsb
= hsp
->cls1
.rcvDataSizeLsb
;
83 sp
->cls1
.rcvDataSizeMsb
= hsp
->cls1
.rcvDataSizeMsb
;
85 } else if (class == CLASS1
) {
86 goto bad_service_param
;
89 if (sp
->cls2
.classValid
) {
90 hsp_value
= (hsp
->cls2
.rcvDataSizeMsb
<< 8) |
91 hsp
->cls2
.rcvDataSizeLsb
;
92 ssp_value
= (sp
->cls2
.rcvDataSizeMsb
<< 8) |
93 sp
->cls2
.rcvDataSizeLsb
;
95 goto bad_service_param
;
96 if (ssp_value
> hsp_value
) {
97 sp
->cls2
.rcvDataSizeLsb
= hsp
->cls2
.rcvDataSizeLsb
;
98 sp
->cls2
.rcvDataSizeMsb
= hsp
->cls2
.rcvDataSizeMsb
;
100 } else if (class == CLASS2
) {
101 goto bad_service_param
;
104 if (sp
->cls3
.classValid
) {
105 hsp_value
= (hsp
->cls3
.rcvDataSizeMsb
<< 8) |
106 hsp
->cls3
.rcvDataSizeLsb
;
107 ssp_value
= (sp
->cls3
.rcvDataSizeMsb
<< 8) |
108 sp
->cls3
.rcvDataSizeLsb
;
110 goto bad_service_param
;
111 if (ssp_value
> hsp_value
) {
112 sp
->cls3
.rcvDataSizeLsb
= hsp
->cls3
.rcvDataSizeLsb
;
113 sp
->cls3
.rcvDataSizeMsb
= hsp
->cls3
.rcvDataSizeMsb
;
115 } else if (class == CLASS3
) {
116 goto bad_service_param
;
120 * Preserve the upper four bits of the MSB from the PLOGI response.
121 * These bits contain the Buffer-to-Buffer State Change Number
122 * from the target and need to be passed to the FW.
124 hsp_value
= (hsp
->cmn
.bbRcvSizeMsb
<< 8) | hsp
->cmn
.bbRcvSizeLsb
;
125 ssp_value
= (sp
->cmn
.bbRcvSizeMsb
<< 8) | sp
->cmn
.bbRcvSizeLsb
;
126 if (ssp_value
> hsp_value
) {
127 sp
->cmn
.bbRcvSizeLsb
= hsp
->cmn
.bbRcvSizeLsb
;
128 sp
->cmn
.bbRcvSizeMsb
= (sp
->cmn
.bbRcvSizeMsb
& 0xF0) |
129 (hsp
->cmn
.bbRcvSizeMsb
& 0x0F);
132 memcpy(&ndlp
->nlp_nodename
, &sp
->nodeName
, sizeof (struct lpfc_name
));
133 memcpy(&ndlp
->nlp_portname
, &sp
->portName
, sizeof (struct lpfc_name
));
136 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_DISCOVERY
,
138 "(%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x) sent "
139 "invalid service parameters. Ignoring device.\n",
141 sp
->nodeName
.u
.wwn
[0], sp
->nodeName
.u
.wwn
[1],
142 sp
->nodeName
.u
.wwn
[2], sp
->nodeName
.u
.wwn
[3],
143 sp
->nodeName
.u
.wwn
[4], sp
->nodeName
.u
.wwn
[5],
144 sp
->nodeName
.u
.wwn
[6], sp
->nodeName
.u
.wwn
[7]);
149 lpfc_check_elscmpl_iocb(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
150 struct lpfc_iocbq
*rspiocb
)
152 struct lpfc_dmabuf
*pcmd
, *prsp
;
157 irsp
= &rspiocb
->iocb
;
158 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
160 /* For lpfc_els_abort, context2 could be zero'ed to delay
161 * freeing associated memory till after ABTS completes.
164 prsp
= list_get_first(&pcmd
->list
, struct lpfc_dmabuf
,
167 lp
= (uint32_t *) prsp
->virt
;
168 ptr
= (void *)((uint8_t *)lp
+ sizeof(uint32_t));
171 /* Force ulpStatus error since we are returning NULL ptr */
172 if (!(irsp
->ulpStatus
)) {
173 irsp
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
174 irsp
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
183 * Free resources / clean up outstanding I/Os
184 * associated with a LPFC_NODELIST entry. This
185 * routine effectively results in a "software abort".
188 lpfc_els_abort(struct lpfc_hba
*phba
, struct lpfc_nodelist
*ndlp
)
190 LIST_HEAD(completions
);
191 struct lpfc_sli
*psli
= &phba
->sli
;
192 struct lpfc_sli_ring
*pring
= &psli
->ring
[LPFC_ELS_RING
];
193 struct lpfc_iocbq
*iocb
, *next_iocb
;
196 /* Abort outstanding I/O on NPort <nlp_DID> */
197 lpfc_printf_vlog(ndlp
->vport
, KERN_INFO
, LOG_DISCOVERY
,
198 "0205 Abort outstanding I/O on NPort x%x "
199 "Data: x%x x%x x%x\n",
200 ndlp
->nlp_DID
, ndlp
->nlp_flag
, ndlp
->nlp_state
,
203 lpfc_fabric_abort_nport(ndlp
);
205 /* First check the txq */
206 spin_lock_irq(&phba
->hbalock
);
207 list_for_each_entry_safe(iocb
, next_iocb
, &pring
->txq
, list
) {
208 /* Check to see if iocb matches the nport we are looking for */
209 if (lpfc_check_sli_ndlp(phba
, pring
, iocb
, ndlp
)) {
210 /* It matches, so deque and call compl with anp error */
211 list_move_tail(&iocb
->list
, &completions
);
216 /* Next check the txcmplq */
217 list_for_each_entry_safe(iocb
, next_iocb
, &pring
->txcmplq
, list
) {
218 /* Check to see if iocb matches the nport we are looking for */
219 if (lpfc_check_sli_ndlp(phba
, pring
, iocb
, ndlp
)) {
220 lpfc_sli_issue_abort_iotag(phba
, pring
, iocb
);
223 spin_unlock_irq(&phba
->hbalock
);
225 while (!list_empty(&completions
)) {
226 iocb
= list_get_first(&completions
, struct lpfc_iocbq
, list
);
228 list_del_init(&iocb
->list
);
230 if (!iocb
->iocb_cmpl
)
231 lpfc_sli_release_iocbq(phba
, iocb
);
233 cmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
234 cmd
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
235 (iocb
->iocb_cmpl
) (phba
, iocb
, iocb
);
239 /* If we are delaying issuing an ELS command, cancel it */
240 if (ndlp
->nlp_flag
& NLP_DELAY_TMO
)
241 lpfc_cancel_retry_delay_tmo(phba
->pport
, ndlp
);
246 lpfc_rcv_plogi(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
247 struct lpfc_iocbq
*cmdiocb
)
249 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
250 struct lpfc_hba
*phba
= vport
->phba
;
251 struct lpfc_dmabuf
*pcmd
;
252 struct lpfc_work_evt
*evtp
;
255 struct serv_parm
*sp
;
260 memset(&stat
, 0, sizeof (struct ls_rjt
));
261 if (vport
->port_state
<= LPFC_FLOGI
) {
262 /* Before responding to PLOGI, check for pt2pt mode.
263 * If we are pt2pt, with an outstanding FLOGI, abort
264 * the FLOGI and resend it first.
266 if (vport
->fc_flag
& FC_PT2PT
) {
267 lpfc_els_abort_flogi(phba
);
268 if (!(vport
->fc_flag
& FC_PT2PT_PLOGI
)) {
269 /* If the other side is supposed to initiate
270 * the PLOGI anyway, just ACC it now and
271 * move on with discovery.
273 phba
->fc_edtov
= FF_DEF_EDTOV
;
274 phba
->fc_ratov
= FF_DEF_RATOV
;
275 /* Start discovery - this should just do
277 lpfc_disc_start(vport
);
279 lpfc_initial_flogi(vport
);
281 stat
.un
.b
.lsRjtRsnCode
= LSRJT_LOGICAL_BSY
;
282 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
283 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
,
288 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
289 lp
= (uint32_t *) pcmd
->virt
;
290 sp
= (struct serv_parm
*) ((uint8_t *) lp
+ sizeof (uint32_t));
291 if (wwn_to_u64(sp
->portName
.u
.wwn
) == 0) {
292 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
293 "0140 PLOGI Reject: invalid nname\n");
294 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
295 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_INVALID_PNAME
;
296 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
,
300 if (wwn_to_u64(sp
->nodeName
.u
.wwn
) == 0) {
301 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
302 "0141 PLOGI Reject: invalid pname\n");
303 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
304 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_INVALID_NNAME
;
305 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
,
309 if ((lpfc_check_sparm(vport
, ndlp
, sp
, CLASS3
) == 0)) {
310 /* Reject this request because invalid parameters */
311 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
312 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_SPARM_OPTIONS
;
313 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
,
317 icmd
= &cmdiocb
->iocb
;
319 /* PLOGI chkparm OK */
320 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
321 "0114 PLOGI chkparm OK Data: x%x x%x x%x x%x\n",
322 ndlp
->nlp_DID
, ndlp
->nlp_state
, ndlp
->nlp_flag
,
325 if (vport
->cfg_fcp_class
== 2 && sp
->cls2
.classValid
)
326 ndlp
->nlp_fcp_info
|= CLASS2
;
328 ndlp
->nlp_fcp_info
|= CLASS3
;
330 ndlp
->nlp_class_sup
= 0;
331 if (sp
->cls1
.classValid
)
332 ndlp
->nlp_class_sup
|= FC_COS_CLASS1
;
333 if (sp
->cls2
.classValid
)
334 ndlp
->nlp_class_sup
|= FC_COS_CLASS2
;
335 if (sp
->cls3
.classValid
)
336 ndlp
->nlp_class_sup
|= FC_COS_CLASS3
;
337 if (sp
->cls4
.classValid
)
338 ndlp
->nlp_class_sup
|= FC_COS_CLASS4
;
340 ((sp
->cmn
.bbRcvSizeMsb
& 0x0F) << 8) | sp
->cmn
.bbRcvSizeLsb
;
342 /* no need to reg_login if we are already in one of these states */
343 switch (ndlp
->nlp_state
) {
344 case NLP_STE_NPR_NODE
:
345 if (!(ndlp
->nlp_flag
& NLP_NPR_ADISC
))
347 case NLP_STE_REG_LOGIN_ISSUE
:
348 case NLP_STE_PRLI_ISSUE
:
349 case NLP_STE_UNMAPPED_NODE
:
350 case NLP_STE_MAPPED_NODE
:
351 lpfc_els_rsp_acc(vport
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
, NULL
);
355 if ((vport
->fc_flag
& FC_PT2PT
) &&
356 !(vport
->fc_flag
& FC_PT2PT_PLOGI
)) {
357 /* rcv'ed PLOGI decides what our NPortId will be */
358 vport
->fc_myDID
= icmd
->un
.rcvels
.parmRo
;
359 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
362 lpfc_config_link(phba
, mbox
);
363 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
365 rc
= lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
);
366 if (rc
== MBX_NOT_FINISHED
) {
367 mempool_free(mbox
, phba
->mbox_mem_pool
);
371 lpfc_can_disctmo(vport
);
373 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
377 rc
= lpfc_reg_login(phba
, vport
->vpi
, icmd
->un
.rcvels
.remoteID
,
378 (uint8_t *) sp
, mbox
, 0);
380 mempool_free(mbox
, phba
->mbox_mem_pool
);
384 /* ACC PLOGI rsp command needs to execute first,
385 * queue this mbox command to be processed later.
387 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_reg_login
;
389 * mbox->context2 = lpfc_nlp_get(ndlp) deferred until mailbox
390 * command issued in lpfc_cmpl_els_acc().
393 spin_lock_irq(shost
->host_lock
);
394 ndlp
->nlp_flag
|= (NLP_ACC_REGLOGIN
| NLP_RCV_PLOGI
);
395 spin_unlock_irq(shost
->host_lock
);
398 * If there is an outstanding PLOGI issued, abort it before
399 * sending ACC rsp for received PLOGI. If pending plogi
400 * is not canceled here, the plogi will be rejected by
401 * remote port and will be retried. On a configuration with
402 * single discovery thread, this will cause a huge delay in
403 * discovery. Also this will cause multiple state machines
404 * running in parallel for this node.
406 if (ndlp
->nlp_state
== NLP_STE_PLOGI_ISSUE
) {
407 /* software abort outstanding PLOGI */
408 lpfc_els_abort(phba
, ndlp
);
411 if ((vport
->port_type
== LPFC_NPIV_PORT
&&
412 vport
->cfg_restrict_login
)) {
414 /* In order to preserve RPIs, we want to cleanup
415 * the default RPI the firmware created to rcv
416 * this ELS request. The only way to do this is
417 * to register, then unregister the RPI.
419 spin_lock_irq(shost
->host_lock
);
420 ndlp
->nlp_flag
|= NLP_RM_DFLT_RPI
;
421 spin_unlock_irq(shost
->host_lock
);
422 stat
.un
.b
.lsRjtRsnCode
= LSRJT_INVALID_CMD
;
423 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
424 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
,
429 /* If the remote NPort logs into us, before we can initiate
430 * discovery to them, cleanup the NPort from discovery accordingly.
432 if (ndlp
->nlp_state
== NLP_STE_NPR_NODE
) {
433 spin_lock_irq(shost
->host_lock
);
434 ndlp
->nlp_flag
&= ~NLP_DELAY_TMO
;
435 spin_unlock_irq(shost
->host_lock
);
436 del_timer_sync(&ndlp
->nlp_delayfunc
);
437 ndlp
->nlp_last_elscmd
= 0;
439 if (!list_empty(&ndlp
->els_retry_evt
.evt_listp
)) {
440 list_del_init(&ndlp
->els_retry_evt
.evt_listp
);
441 /* Decrement ndlp reference count held for the
444 evtp
= &ndlp
->els_retry_evt
;
445 lpfc_nlp_put((struct lpfc_nodelist
*)evtp
->evt_arg1
);
448 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
449 spin_lock_irq(shost
->host_lock
);
450 ndlp
->nlp_flag
&= ~NLP_NPR_2B_DISC
;
451 spin_unlock_irq(shost
->host_lock
);
453 if ((ndlp
->nlp_flag
& NLP_ADISC_SND
) &&
454 (vport
->num_disc_nodes
)) {
455 /* Check to see if there are more
458 lpfc_more_adisc(vport
);
460 if ((vport
->num_disc_nodes
== 0) &&
462 lpfc_els_disc_plogi(vport
);
464 if (vport
->num_disc_nodes
== 0) {
465 spin_lock_irq(shost
->host_lock
);
466 vport
->fc_flag
&= ~FC_NDISC_ACTIVE
;
467 spin_unlock_irq(shost
->host_lock
);
468 lpfc_can_disctmo(vport
);
469 lpfc_end_rscn(vport
);
473 } else if ((ndlp
->nlp_state
== NLP_STE_PLOGI_ISSUE
) &&
474 (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) &&
475 (vport
->num_disc_nodes
)) {
476 spin_lock_irq(shost
->host_lock
);
477 ndlp
->nlp_flag
&= ~NLP_NPR_2B_DISC
;
478 spin_unlock_irq(shost
->host_lock
);
479 /* Check to see if there are more
482 lpfc_more_plogi(vport
);
483 if (vport
->num_disc_nodes
== 0) {
484 spin_lock_irq(shost
->host_lock
);
485 vport
->fc_flag
&= ~FC_NDISC_ACTIVE
;
486 spin_unlock_irq(shost
->host_lock
);
487 lpfc_can_disctmo(vport
);
488 lpfc_end_rscn(vport
);
492 lpfc_els_rsp_acc(vport
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
, mbox
);
496 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
497 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_OUT_OF_RESOURCE
;
498 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
, NULL
);
503 lpfc_rcv_padisc(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
504 struct lpfc_iocbq
*cmdiocb
)
506 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
507 struct lpfc_dmabuf
*pcmd
;
508 struct serv_parm
*sp
;
509 struct lpfc_name
*pnn
, *ppn
;
516 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
517 lp
= (uint32_t *) pcmd
->virt
;
520 if (cmd
== ELS_CMD_ADISC
) {
522 pnn
= (struct lpfc_name
*) & ap
->nodeName
;
523 ppn
= (struct lpfc_name
*) & ap
->portName
;
525 sp
= (struct serv_parm
*) lp
;
526 pnn
= (struct lpfc_name
*) & sp
->nodeName
;
527 ppn
= (struct lpfc_name
*) & sp
->portName
;
530 icmd
= &cmdiocb
->iocb
;
531 if (icmd
->ulpStatus
== 0 && lpfc_check_adisc(vport
, ndlp
, pnn
, ppn
)) {
532 if (cmd
== ELS_CMD_ADISC
) {
533 lpfc_els_rsp_adisc_acc(vport
, cmdiocb
, ndlp
);
535 lpfc_els_rsp_acc(vport
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
,
540 /* Reject this request because invalid parameters */
541 stat
.un
.b
.lsRjtRsvd0
= 0;
542 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
543 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_SPARM_OPTIONS
;
544 stat
.un
.b
.vendorUnique
= 0;
545 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
, NULL
);
548 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
);
550 spin_lock_irq(shost
->host_lock
);
551 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
552 spin_unlock_irq(shost
->host_lock
);
553 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
554 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
555 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
560 lpfc_rcv_logo(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
561 struct lpfc_iocbq
*cmdiocb
, uint32_t els_cmd
)
563 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
565 /* Put ndlp in NPR state with 1 sec timeout for plogi, ACC logo */
566 /* Only call LOGO ACC for first LOGO, this avoids sending unnecessary
567 * PLOGIs during LOGO storms from a device.
569 spin_lock_irq(shost
->host_lock
);
570 ndlp
->nlp_flag
|= NLP_LOGO_ACC
;
571 spin_unlock_irq(shost
->host_lock
);
572 if (els_cmd
== ELS_CMD_PRLO
)
573 lpfc_els_rsp_acc(vport
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
);
575 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
);
577 if (!(ndlp
->nlp_type
& NLP_FABRIC
) ||
578 (ndlp
->nlp_state
== NLP_STE_ADISC_ISSUE
)) {
579 /* Only try to re-login if this is NOT a Fabric Node */
580 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
581 spin_lock_irq(shost
->host_lock
);
582 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
583 spin_unlock_irq(shost
->host_lock
);
585 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
587 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
588 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
590 spin_lock_irq(shost
->host_lock
);
591 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
592 spin_unlock_irq(shost
->host_lock
);
593 /* The driver has to wait until the ACC completes before it continues
594 * processing the LOGO. The action will resume in
595 * lpfc_cmpl_els_logo_acc routine. Since part of processing includes an
596 * unreg_login, the driver waits so the ACC does not get aborted.
602 lpfc_rcv_prli(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
603 struct lpfc_iocbq
*cmdiocb
)
605 struct lpfc_dmabuf
*pcmd
;
608 struct fc_rport
*rport
= ndlp
->rport
;
611 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
612 lp
= (uint32_t *) pcmd
->virt
;
613 npr
= (PRLI
*) ((uint8_t *) lp
+ sizeof (uint32_t));
615 ndlp
->nlp_type
&= ~(NLP_FCP_TARGET
| NLP_FCP_INITIATOR
);
616 ndlp
->nlp_fcp_info
&= ~NLP_FCP_2_DEVICE
;
617 if (npr
->prliType
== PRLI_FCP_TYPE
) {
618 if (npr
->initiatorFunc
)
619 ndlp
->nlp_type
|= NLP_FCP_INITIATOR
;
621 ndlp
->nlp_type
|= NLP_FCP_TARGET
;
623 ndlp
->nlp_fcp_info
|= NLP_FCP_2_DEVICE
;
626 /* We need to update the rport role values */
627 roles
= FC_RPORT_ROLE_UNKNOWN
;
628 if (ndlp
->nlp_type
& NLP_FCP_INITIATOR
)
629 roles
|= FC_RPORT_ROLE_FCP_INITIATOR
;
630 if (ndlp
->nlp_type
& NLP_FCP_TARGET
)
631 roles
|= FC_RPORT_ROLE_FCP_TARGET
;
633 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_RPORT
,
634 "rport rolechg: role:x%x did:x%x flg:x%x",
635 roles
, ndlp
->nlp_DID
, ndlp
->nlp_flag
);
637 fc_remote_port_rolechg(rport
, roles
);
642 lpfc_disc_set_adisc(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
)
644 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
646 if (!ndlp
->nlp_rpi
) {
647 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
651 if (!(vport
->fc_flag
& FC_PT2PT
)) {
652 /* Check config parameter use-adisc or FCP-2 */
653 if ((vport
->cfg_use_adisc
&& (vport
->fc_flag
& FC_RSCN_MODE
)) ||
654 ndlp
->nlp_fcp_info
& NLP_FCP_2_DEVICE
) {
655 spin_lock_irq(shost
->host_lock
);
656 ndlp
->nlp_flag
|= NLP_NPR_ADISC
;
657 spin_unlock_irq(shost
->host_lock
);
661 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
662 lpfc_unreg_rpi(vport
, ndlp
);
667 lpfc_disc_illegal(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
668 void *arg
, uint32_t evt
)
670 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_DISCOVERY
,
671 "0271 Illegal State Transition: node x%x "
672 "event x%x, state x%x Data: x%x x%x\n",
673 ndlp
->nlp_DID
, evt
, ndlp
->nlp_state
, ndlp
->nlp_rpi
,
675 return ndlp
->nlp_state
;
679 lpfc_cmpl_plogi_illegal(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
680 void *arg
, uint32_t evt
)
682 /* This transition is only legal if we previously
683 * rcv'ed a PLOGI. Since we don't want 2 discovery threads
684 * working on the same NPortID, do nothing for this thread
687 if (!(ndlp
->nlp_flag
& NLP_RCV_PLOGI
)) {
688 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_DISCOVERY
,
689 "0272 Illegal State Transition: node x%x "
690 "event x%x, state x%x Data: x%x x%x\n",
691 ndlp
->nlp_DID
, evt
, ndlp
->nlp_state
, ndlp
->nlp_rpi
,
694 return ndlp
->nlp_state
;
697 /* Start of Discovery State Machine routines */
700 lpfc_rcv_plogi_unused_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
701 void *arg
, uint32_t evt
)
703 struct lpfc_iocbq
*cmdiocb
;
705 cmdiocb
= (struct lpfc_iocbq
*) arg
;
707 if (lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
)) {
708 return ndlp
->nlp_state
;
710 return NLP_STE_FREED_NODE
;
714 lpfc_rcv_els_unused_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
715 void *arg
, uint32_t evt
)
717 lpfc_issue_els_logo(vport
, ndlp
, 0);
718 return ndlp
->nlp_state
;
722 lpfc_rcv_logo_unused_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
723 void *arg
, uint32_t evt
)
725 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
726 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
728 spin_lock_irq(shost
->host_lock
);
729 ndlp
->nlp_flag
|= NLP_LOGO_ACC
;
730 spin_unlock_irq(shost
->host_lock
);
731 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
);
733 return ndlp
->nlp_state
;
737 lpfc_cmpl_logo_unused_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
738 void *arg
, uint32_t evt
)
740 return NLP_STE_FREED_NODE
;
744 lpfc_device_rm_unused_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
745 void *arg
, uint32_t evt
)
747 return NLP_STE_FREED_NODE
;
751 lpfc_rcv_plogi_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
752 void *arg
, uint32_t evt
)
754 struct lpfc_hba
*phba
= vport
->phba
;
755 struct lpfc_iocbq
*cmdiocb
= arg
;
756 struct lpfc_dmabuf
*pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
757 uint32_t *lp
= (uint32_t *) pcmd
->virt
;
758 struct serv_parm
*sp
= (struct serv_parm
*) (lp
+ 1);
762 memset(&stat
, 0, sizeof (struct ls_rjt
));
764 /* For a PLOGI, we only accept if our portname is less
765 * than the remote portname.
767 phba
->fc_stat
.elsLogiCol
++;
768 port_cmp
= memcmp(&vport
->fc_portname
, &sp
->portName
,
769 sizeof(struct lpfc_name
));
772 /* Reject this request because the remote node will accept
774 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
775 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CMD_IN_PROGRESS
;
776 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
,
779 lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
);
780 } /* If our portname was less */
782 return ndlp
->nlp_state
;
786 lpfc_rcv_prli_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
787 void *arg
, uint32_t evt
)
789 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
792 memset(&stat
, 0, sizeof (struct ls_rjt
));
793 stat
.un
.b
.lsRjtRsnCode
= LSRJT_LOGICAL_BSY
;
794 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
795 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
, NULL
);
796 return ndlp
->nlp_state
;
800 lpfc_rcv_logo_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
801 void *arg
, uint32_t evt
)
803 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
805 /* software abort outstanding PLOGI */
806 lpfc_els_abort(vport
->phba
, ndlp
);
808 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
809 return ndlp
->nlp_state
;
813 lpfc_rcv_els_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
814 void *arg
, uint32_t evt
)
816 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
817 struct lpfc_hba
*phba
= vport
->phba
;
818 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
820 /* software abort outstanding PLOGI */
821 lpfc_els_abort(phba
, ndlp
);
823 if (evt
== NLP_EVT_RCV_LOGO
) {
824 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
);
826 lpfc_issue_els_logo(vport
, ndlp
, 0);
829 /* Put ndlp in npr state set plogi timer for 1 sec */
830 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
831 spin_lock_irq(shost
->host_lock
);
832 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
833 spin_unlock_irq(shost
->host_lock
);
834 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
835 ndlp
->nlp_prev_state
= NLP_STE_PLOGI_ISSUE
;
836 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
838 return ndlp
->nlp_state
;
842 lpfc_cmpl_plogi_plogi_issue(struct lpfc_vport
*vport
,
843 struct lpfc_nodelist
*ndlp
,
847 struct lpfc_hba
*phba
= vport
->phba
;
848 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
849 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
850 struct lpfc_dmabuf
*pcmd
, *prsp
, *mp
;
853 struct serv_parm
*sp
;
856 cmdiocb
= (struct lpfc_iocbq
*) arg
;
857 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
859 if (ndlp
->nlp_flag
& NLP_ACC_REGLOGIN
) {
860 /* Recovery from PLOGI collision logic */
861 return ndlp
->nlp_state
;
864 irsp
= &rspiocb
->iocb
;
869 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
871 prsp
= list_get_first(&pcmd
->list
, struct lpfc_dmabuf
, list
);
873 lp
= (uint32_t *) prsp
->virt
;
874 sp
= (struct serv_parm
*) ((uint8_t *) lp
+ sizeof (uint32_t));
876 /* Some switches have FDMI servers returning 0 for WWN */
877 if ((ndlp
->nlp_DID
!= FDMI_DID
) &&
878 (wwn_to_u64(sp
->portName
.u
.wwn
) == 0 ||
879 wwn_to_u64(sp
->nodeName
.u
.wwn
) == 0)) {
880 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
881 "0142 PLOGI RSP: Invalid WWN.\n");
884 if (!lpfc_check_sparm(vport
, ndlp
, sp
, CLASS3
))
886 /* PLOGI chkparm OK */
887 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
888 "0121 PLOGI chkparm OK Data: x%x x%x x%x x%x\n",
889 ndlp
->nlp_DID
, ndlp
->nlp_state
,
890 ndlp
->nlp_flag
, ndlp
->nlp_rpi
);
891 if (vport
->cfg_fcp_class
== 2 && (sp
->cls2
.classValid
))
892 ndlp
->nlp_fcp_info
|= CLASS2
;
894 ndlp
->nlp_fcp_info
|= CLASS3
;
896 ndlp
->nlp_class_sup
= 0;
897 if (sp
->cls1
.classValid
)
898 ndlp
->nlp_class_sup
|= FC_COS_CLASS1
;
899 if (sp
->cls2
.classValid
)
900 ndlp
->nlp_class_sup
|= FC_COS_CLASS2
;
901 if (sp
->cls3
.classValid
)
902 ndlp
->nlp_class_sup
|= FC_COS_CLASS3
;
903 if (sp
->cls4
.classValid
)
904 ndlp
->nlp_class_sup
|= FC_COS_CLASS4
;
906 ((sp
->cmn
.bbRcvSizeMsb
& 0x0F) << 8) | sp
->cmn
.bbRcvSizeLsb
;
908 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
910 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
911 "0133 PLOGI: no memory for reg_login "
912 "Data: x%x x%x x%x x%x\n",
913 ndlp
->nlp_DID
, ndlp
->nlp_state
,
914 ndlp
->nlp_flag
, ndlp
->nlp_rpi
);
918 lpfc_unreg_rpi(vport
, ndlp
);
920 if (lpfc_reg_login(phba
, vport
->vpi
, irsp
->un
.elsreq64
.remoteID
,
921 (uint8_t *) sp
, mbox
, 0) == 0) {
922 switch (ndlp
->nlp_DID
) {
924 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_ns_reg_login
;
927 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_fdmi_reg_login
;
930 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_reg_login
;
932 mbox
->context2
= lpfc_nlp_get(ndlp
);
934 if (lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
)
935 != MBX_NOT_FINISHED
) {
936 lpfc_nlp_set_state(vport
, ndlp
,
937 NLP_STE_REG_LOGIN_ISSUE
);
938 return ndlp
->nlp_state
;
940 /* decrement node reference count to the failed mbox
944 mp
= (struct lpfc_dmabuf
*) mbox
->context1
;
945 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
947 mempool_free(mbox
, phba
->mbox_mem_pool
);
949 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
950 "0134 PLOGI: cannot issue reg_login "
951 "Data: x%x x%x x%x x%x\n",
952 ndlp
->nlp_DID
, ndlp
->nlp_state
,
953 ndlp
->nlp_flag
, ndlp
->nlp_rpi
);
955 mempool_free(mbox
, phba
->mbox_mem_pool
);
957 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
958 "0135 PLOGI: cannot format reg_login "
959 "Data: x%x x%x x%x x%x\n",
960 ndlp
->nlp_DID
, ndlp
->nlp_state
,
961 ndlp
->nlp_flag
, ndlp
->nlp_rpi
);
966 if (ndlp
->nlp_DID
== NameServer_DID
) {
967 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
968 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
969 "0261 Cannot Register NameServer login\n");
972 spin_lock_irq(shost
->host_lock
);
973 ndlp
->nlp_flag
|= NLP_DEFER_RM
;
974 spin_unlock_irq(shost
->host_lock
);
975 return NLP_STE_FREED_NODE
;
979 lpfc_cmpl_logo_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
980 void *arg
, uint32_t evt
)
982 return ndlp
->nlp_state
;
986 lpfc_cmpl_reglogin_plogi_issue(struct lpfc_vport
*vport
,
987 struct lpfc_nodelist
*ndlp
, void *arg
, uint32_t evt
)
989 return ndlp
->nlp_state
;
993 lpfc_device_rm_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
994 void *arg
, uint32_t evt
)
996 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
998 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
999 spin_lock_irq(shost
->host_lock
);
1000 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1001 spin_unlock_irq(shost
->host_lock
);
1002 return ndlp
->nlp_state
;
1004 /* software abort outstanding PLOGI */
1005 lpfc_els_abort(vport
->phba
, ndlp
);
1007 lpfc_drop_node(vport
, ndlp
);
1008 return NLP_STE_FREED_NODE
;
1013 lpfc_device_recov_plogi_issue(struct lpfc_vport
*vport
,
1014 struct lpfc_nodelist
*ndlp
,
1018 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1019 struct lpfc_hba
*phba
= vport
->phba
;
1021 /* Don't do anything that will mess up processing of the
1024 if (vport
->fc_flag
& FC_RSCN_DEFERRED
)
1025 return ndlp
->nlp_state
;
1027 /* software abort outstanding PLOGI */
1028 lpfc_els_abort(phba
, ndlp
);
1030 ndlp
->nlp_prev_state
= NLP_STE_PLOGI_ISSUE
;
1031 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1032 spin_lock_irq(shost
->host_lock
);
1033 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1034 spin_unlock_irq(shost
->host_lock
);
1036 return ndlp
->nlp_state
;
1040 lpfc_rcv_plogi_adisc_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1041 void *arg
, uint32_t evt
)
1043 struct lpfc_hba
*phba
= vport
->phba
;
1044 struct lpfc_iocbq
*cmdiocb
;
1046 /* software abort outstanding ADISC */
1047 lpfc_els_abort(phba
, ndlp
);
1049 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1051 if (lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
))
1052 return ndlp
->nlp_state
;
1054 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
1055 lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0);
1056 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
1058 return ndlp
->nlp_state
;
1062 lpfc_rcv_prli_adisc_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1063 void *arg
, uint32_t evt
)
1065 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1067 lpfc_els_rsp_prli_acc(vport
, cmdiocb
, ndlp
);
1068 return ndlp
->nlp_state
;
1072 lpfc_rcv_logo_adisc_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1073 void *arg
, uint32_t evt
)
1075 struct lpfc_hba
*phba
= vport
->phba
;
1076 struct lpfc_iocbq
*cmdiocb
;
1078 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1080 /* software abort outstanding ADISC */
1081 lpfc_els_abort(phba
, ndlp
);
1083 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1084 return ndlp
->nlp_state
;
1088 lpfc_rcv_padisc_adisc_issue(struct lpfc_vport
*vport
,
1089 struct lpfc_nodelist
*ndlp
,
1090 void *arg
, uint32_t evt
)
1092 struct lpfc_iocbq
*cmdiocb
;
1094 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1096 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1097 return ndlp
->nlp_state
;
1101 lpfc_rcv_prlo_adisc_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1102 void *arg
, uint32_t evt
)
1104 struct lpfc_iocbq
*cmdiocb
;
1106 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1108 /* Treat like rcv logo */
1109 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_PRLO
);
1110 return ndlp
->nlp_state
;
1114 lpfc_cmpl_adisc_adisc_issue(struct lpfc_vport
*vport
,
1115 struct lpfc_nodelist
*ndlp
,
1116 void *arg
, uint32_t evt
)
1118 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1119 struct lpfc_hba
*phba
= vport
->phba
;
1120 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1124 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1125 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1127 ap
= (ADISC
*)lpfc_check_elscmpl_iocb(phba
, cmdiocb
, rspiocb
);
1128 irsp
= &rspiocb
->iocb
;
1130 if ((irsp
->ulpStatus
) ||
1131 (!lpfc_check_adisc(vport
, ndlp
, &ap
->nodeName
, &ap
->portName
))) {
1133 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
);
1134 spin_lock_irq(shost
->host_lock
);
1135 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
1136 spin_unlock_irq(shost
->host_lock
);
1137 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
1139 memset(&ndlp
->nlp_nodename
, 0, sizeof(struct lpfc_name
));
1140 memset(&ndlp
->nlp_portname
, 0, sizeof(struct lpfc_name
));
1142 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
1143 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1144 lpfc_unreg_rpi(vport
, ndlp
);
1145 return ndlp
->nlp_state
;
1148 if (ndlp
->nlp_type
& NLP_FCP_TARGET
) {
1149 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
1150 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_MAPPED_NODE
);
1152 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
1153 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNMAPPED_NODE
);
1155 return ndlp
->nlp_state
;
1159 lpfc_device_rm_adisc_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1160 void *arg
, uint32_t evt
)
1162 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1164 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1165 spin_lock_irq(shost
->host_lock
);
1166 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1167 spin_unlock_irq(shost
->host_lock
);
1168 return ndlp
->nlp_state
;
1170 /* software abort outstanding ADISC */
1171 lpfc_els_abort(vport
->phba
, ndlp
);
1173 lpfc_drop_node(vport
, ndlp
);
1174 return NLP_STE_FREED_NODE
;
1179 lpfc_device_recov_adisc_issue(struct lpfc_vport
*vport
,
1180 struct lpfc_nodelist
*ndlp
,
1184 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1185 struct lpfc_hba
*phba
= vport
->phba
;
1187 /* Don't do anything that will mess up processing of the
1190 if (vport
->fc_flag
& FC_RSCN_DEFERRED
)
1191 return ndlp
->nlp_state
;
1193 /* software abort outstanding ADISC */
1194 lpfc_els_abort(phba
, ndlp
);
1196 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
1197 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1198 spin_lock_irq(shost
->host_lock
);
1199 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1200 spin_unlock_irq(shost
->host_lock
);
1201 lpfc_disc_set_adisc(vport
, ndlp
);
1202 return ndlp
->nlp_state
;
1206 lpfc_rcv_plogi_reglogin_issue(struct lpfc_vport
*vport
,
1207 struct lpfc_nodelist
*ndlp
,
1211 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1213 lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
);
1214 return ndlp
->nlp_state
;
1218 lpfc_rcv_prli_reglogin_issue(struct lpfc_vport
*vport
,
1219 struct lpfc_nodelist
*ndlp
,
1223 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1225 lpfc_els_rsp_prli_acc(vport
, cmdiocb
, ndlp
);
1226 return ndlp
->nlp_state
;
1230 lpfc_rcv_logo_reglogin_issue(struct lpfc_vport
*vport
,
1231 struct lpfc_nodelist
*ndlp
,
1235 struct lpfc_hba
*phba
= vport
->phba
;
1236 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1238 LPFC_MBOXQ_t
*nextmb
;
1239 struct lpfc_dmabuf
*mp
;
1241 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1243 /* cleanup any ndlp on mbox q waiting for reglogin cmpl */
1244 if ((mb
= phba
->sli
.mbox_active
)) {
1245 if ((mb
->mb
.mbxCommand
== MBX_REG_LOGIN64
) &&
1246 (ndlp
== (struct lpfc_nodelist
*) mb
->context2
)) {
1248 mb
->context2
= NULL
;
1249 mb
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
1253 spin_lock_irq(&phba
->hbalock
);
1254 list_for_each_entry_safe(mb
, nextmb
, &phba
->sli
.mboxq
, list
) {
1255 if ((mb
->mb
.mbxCommand
== MBX_REG_LOGIN64
) &&
1256 (ndlp
== (struct lpfc_nodelist
*) mb
->context2
)) {
1257 mp
= (struct lpfc_dmabuf
*) (mb
->context1
);
1259 __lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
1263 list_del(&mb
->list
);
1264 mempool_free(mb
, phba
->mbox_mem_pool
);
1267 spin_unlock_irq(&phba
->hbalock
);
1269 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1270 return ndlp
->nlp_state
;
1274 lpfc_rcv_padisc_reglogin_issue(struct lpfc_vport
*vport
,
1275 struct lpfc_nodelist
*ndlp
,
1279 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1281 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1282 return ndlp
->nlp_state
;
1286 lpfc_rcv_prlo_reglogin_issue(struct lpfc_vport
*vport
,
1287 struct lpfc_nodelist
*ndlp
,
1291 struct lpfc_iocbq
*cmdiocb
;
1293 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1294 lpfc_els_rsp_acc(vport
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
);
1295 return ndlp
->nlp_state
;
1299 lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_vport
*vport
,
1300 struct lpfc_nodelist
*ndlp
,
1304 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1305 LPFC_MBOXQ_t
*pmb
= (LPFC_MBOXQ_t
*) arg
;
1306 MAILBOX_t
*mb
= &pmb
->mb
;
1307 uint32_t did
= mb
->un
.varWords
[1];
1309 if (mb
->mbxStatus
) {
1310 /* RegLogin failed */
1311 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_DISCOVERY
,
1312 "0246 RegLogin failed Data: x%x x%x x%x\n",
1313 did
, mb
->mbxStatus
, vport
->port_state
);
1315 * If RegLogin failed due to lack of HBA resources do not
1318 if (mb
->mbxStatus
== MBXERR_RPI_FULL
) {
1319 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1320 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1321 return ndlp
->nlp_state
;
1324 /* Put ndlp in npr state set plogi timer for 1 sec */
1325 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
1326 spin_lock_irq(shost
->host_lock
);
1327 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
1328 spin_unlock_irq(shost
->host_lock
);
1329 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
1331 lpfc_issue_els_logo(vport
, ndlp
, 0);
1332 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1333 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1334 return ndlp
->nlp_state
;
1337 ndlp
->nlp_rpi
= mb
->un
.varWords
[0];
1339 /* Only if we are not a fabric nport do we issue PRLI */
1340 if (!(ndlp
->nlp_type
& NLP_FABRIC
)) {
1341 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1342 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PRLI_ISSUE
);
1343 lpfc_issue_els_prli(vport
, ndlp
, 0);
1345 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1346 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNMAPPED_NODE
);
1348 return ndlp
->nlp_state
;
1352 lpfc_device_rm_reglogin_issue(struct lpfc_vport
*vport
,
1353 struct lpfc_nodelist
*ndlp
,
1357 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1359 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1360 spin_lock_irq(shost
->host_lock
);
1361 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1362 spin_unlock_irq(shost
->host_lock
);
1363 return ndlp
->nlp_state
;
1365 lpfc_drop_node(vport
, ndlp
);
1366 return NLP_STE_FREED_NODE
;
1371 lpfc_device_recov_reglogin_issue(struct lpfc_vport
*vport
,
1372 struct lpfc_nodelist
*ndlp
,
1376 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1378 /* Don't do anything that will mess up processing of the
1381 if (vport
->fc_flag
& FC_RSCN_DEFERRED
)
1382 return ndlp
->nlp_state
;
1384 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1385 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1386 spin_lock_irq(shost
->host_lock
);
1387 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1388 spin_unlock_irq(shost
->host_lock
);
1389 lpfc_disc_set_adisc(vport
, ndlp
);
1390 return ndlp
->nlp_state
;
1394 lpfc_rcv_plogi_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1395 void *arg
, uint32_t evt
)
1397 struct lpfc_iocbq
*cmdiocb
;
1399 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1401 lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
);
1402 return ndlp
->nlp_state
;
1406 lpfc_rcv_prli_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1407 void *arg
, uint32_t evt
)
1409 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1411 lpfc_els_rsp_prli_acc(vport
, cmdiocb
, ndlp
);
1412 return ndlp
->nlp_state
;
1416 lpfc_rcv_logo_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1417 void *arg
, uint32_t evt
)
1419 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1421 /* Software abort outstanding PRLI before sending acc */
1422 lpfc_els_abort(vport
->phba
, ndlp
);
1424 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1425 return ndlp
->nlp_state
;
1429 lpfc_rcv_padisc_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1430 void *arg
, uint32_t evt
)
1432 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1434 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1435 return ndlp
->nlp_state
;
1438 /* This routine is envoked when we rcv a PRLO request from a nport
1439 * we are logged into. We should send back a PRLO rsp setting the
1441 * NEXT STATE = PRLI_ISSUE
1444 lpfc_rcv_prlo_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1445 void *arg
, uint32_t evt
)
1447 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1449 lpfc_els_rsp_acc(vport
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
);
1450 return ndlp
->nlp_state
;
1454 lpfc_cmpl_prli_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1455 void *arg
, uint32_t evt
)
1457 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1458 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1459 struct lpfc_hba
*phba
= vport
->phba
;
1463 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1464 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1465 npr
= (PRLI
*)lpfc_check_elscmpl_iocb(phba
, cmdiocb
, rspiocb
);
1467 irsp
= &rspiocb
->iocb
;
1468 if (irsp
->ulpStatus
) {
1469 if ((vport
->port_type
== LPFC_NPIV_PORT
) &&
1470 vport
->cfg_restrict_login
) {
1473 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1474 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNMAPPED_NODE
);
1475 return ndlp
->nlp_state
;
1478 /* Check out PRLI rsp */
1479 ndlp
->nlp_type
&= ~(NLP_FCP_TARGET
| NLP_FCP_INITIATOR
);
1480 ndlp
->nlp_fcp_info
&= ~NLP_FCP_2_DEVICE
;
1481 if ((npr
->acceptRspCode
== PRLI_REQ_EXECUTED
) &&
1482 (npr
->prliType
== PRLI_FCP_TYPE
)) {
1483 if (npr
->initiatorFunc
)
1484 ndlp
->nlp_type
|= NLP_FCP_INITIATOR
;
1485 if (npr
->targetFunc
)
1486 ndlp
->nlp_type
|= NLP_FCP_TARGET
;
1488 ndlp
->nlp_fcp_info
|= NLP_FCP_2_DEVICE
;
1490 if (!(ndlp
->nlp_type
& NLP_FCP_TARGET
) &&
1491 (vport
->port_type
== LPFC_NPIV_PORT
) &&
1492 vport
->cfg_restrict_login
) {
1494 spin_lock_irq(shost
->host_lock
);
1495 ndlp
->nlp_flag
|= NLP_TARGET_REMOVE
;
1496 spin_unlock_irq(shost
->host_lock
);
1497 lpfc_issue_els_logo(vport
, ndlp
, 0);
1499 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1500 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1501 return ndlp
->nlp_state
;
1504 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1505 if (ndlp
->nlp_type
& NLP_FCP_TARGET
)
1506 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_MAPPED_NODE
);
1508 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNMAPPED_NODE
);
1509 return ndlp
->nlp_state
;
1512 /*! lpfc_device_rm_prli_issue
1523 * This routine is envoked when we a request to remove a nport we are in the
1524 * process of PRLIing. We should software abort outstanding prli, unreg
1525 * login, send a logout. We will change node state to UNUSED_NODE, put it
1526 * on plogi list so it can be freed when LOGO completes.
1531 lpfc_device_rm_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1532 void *arg
, uint32_t evt
)
1534 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1536 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1537 spin_lock_irq(shost
->host_lock
);
1538 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1539 spin_unlock_irq(shost
->host_lock
);
1540 return ndlp
->nlp_state
;
1542 /* software abort outstanding PLOGI */
1543 lpfc_els_abort(vport
->phba
, ndlp
);
1545 lpfc_drop_node(vport
, ndlp
);
1546 return NLP_STE_FREED_NODE
;
1551 /*! lpfc_device_recov_prli_issue
1562 * The routine is envoked when the state of a device is unknown, like
1563 * during a link down. We should remove the nodelist entry from the
1564 * unmapped list, issue a UNREG_LOGIN, do a software abort of the
1565 * outstanding PRLI command, then free the node entry.
1568 lpfc_device_recov_prli_issue(struct lpfc_vport
*vport
,
1569 struct lpfc_nodelist
*ndlp
,
1573 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1574 struct lpfc_hba
*phba
= vport
->phba
;
1576 /* Don't do anything that will mess up processing of the
1579 if (vport
->fc_flag
& FC_RSCN_DEFERRED
)
1580 return ndlp
->nlp_state
;
1582 /* software abort outstanding PRLI */
1583 lpfc_els_abort(phba
, ndlp
);
1585 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1586 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1587 spin_lock_irq(shost
->host_lock
);
1588 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1589 spin_unlock_irq(shost
->host_lock
);
1590 lpfc_disc_set_adisc(vport
, ndlp
);
1591 return ndlp
->nlp_state
;
1595 lpfc_rcv_plogi_unmap_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1596 void *arg
, uint32_t evt
)
1598 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1600 lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
);
1601 return ndlp
->nlp_state
;
1605 lpfc_rcv_prli_unmap_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1606 void *arg
, uint32_t evt
)
1608 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1610 lpfc_rcv_prli(vport
, ndlp
, cmdiocb
);
1611 lpfc_els_rsp_prli_acc(vport
, cmdiocb
, ndlp
);
1612 return ndlp
->nlp_state
;
1616 lpfc_rcv_logo_unmap_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1617 void *arg
, uint32_t evt
)
1619 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1621 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1622 return ndlp
->nlp_state
;
1626 lpfc_rcv_padisc_unmap_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1627 void *arg
, uint32_t evt
)
1629 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1631 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1632 return ndlp
->nlp_state
;
1636 lpfc_rcv_prlo_unmap_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1637 void *arg
, uint32_t evt
)
1639 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1641 lpfc_els_rsp_acc(vport
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
);
1642 return ndlp
->nlp_state
;
1646 lpfc_device_recov_unmap_node(struct lpfc_vport
*vport
,
1647 struct lpfc_nodelist
*ndlp
,
1651 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1653 ndlp
->nlp_prev_state
= NLP_STE_UNMAPPED_NODE
;
1654 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1655 spin_lock_irq(shost
->host_lock
);
1656 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1657 spin_unlock_irq(shost
->host_lock
);
1658 lpfc_disc_set_adisc(vport
, ndlp
);
1660 return ndlp
->nlp_state
;
1664 lpfc_rcv_plogi_mapped_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1665 void *arg
, uint32_t evt
)
1667 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1669 lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
);
1670 return ndlp
->nlp_state
;
1674 lpfc_rcv_prli_mapped_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1675 void *arg
, uint32_t evt
)
1677 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1679 lpfc_els_rsp_prli_acc(vport
, cmdiocb
, ndlp
);
1680 return ndlp
->nlp_state
;
1684 lpfc_rcv_logo_mapped_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1685 void *arg
, uint32_t evt
)
1687 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1689 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1690 return ndlp
->nlp_state
;
1694 lpfc_rcv_padisc_mapped_node(struct lpfc_vport
*vport
,
1695 struct lpfc_nodelist
*ndlp
,
1696 void *arg
, uint32_t evt
)
1698 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1700 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1701 return ndlp
->nlp_state
;
1705 lpfc_rcv_prlo_mapped_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1706 void *arg
, uint32_t evt
)
1708 struct lpfc_hba
*phba
= vport
->phba
;
1709 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1711 /* flush the target */
1712 lpfc_sli_abort_iocb(vport
, &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
1713 ndlp
->nlp_sid
, 0, LPFC_CTX_TGT
);
1715 /* Treat like rcv logo */
1716 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_PRLO
);
1717 return ndlp
->nlp_state
;
1721 lpfc_device_recov_mapped_node(struct lpfc_vport
*vport
,
1722 struct lpfc_nodelist
*ndlp
,
1726 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1728 ndlp
->nlp_prev_state
= NLP_STE_MAPPED_NODE
;
1729 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1730 spin_lock_irq(shost
->host_lock
);
1731 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1732 spin_unlock_irq(shost
->host_lock
);
1733 lpfc_disc_set_adisc(vport
, ndlp
);
1734 return ndlp
->nlp_state
;
1738 lpfc_rcv_plogi_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1739 void *arg
, uint32_t evt
)
1741 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1742 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1744 /* Ignore PLOGI if we have an outstanding LOGO */
1745 if (ndlp
->nlp_flag
& (NLP_LOGO_SND
| NLP_LOGO_ACC
)) {
1746 return ndlp
->nlp_state
;
1749 if (lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
)) {
1750 spin_lock_irq(shost
->host_lock
);
1751 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1752 spin_unlock_irq(shost
->host_lock
);
1753 return ndlp
->nlp_state
;
1756 /* send PLOGI immediately, move to PLOGI issue state */
1757 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
)) {
1758 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1759 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
1760 lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0);
1763 return ndlp
->nlp_state
;
1767 lpfc_rcv_prli_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1768 void *arg
, uint32_t evt
)
1770 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1771 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1774 memset(&stat
, 0, sizeof (struct ls_rjt
));
1775 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
1776 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
1777 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
, NULL
);
1779 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
)) {
1780 if (ndlp
->nlp_flag
& NLP_NPR_ADISC
) {
1781 spin_lock_irq(shost
->host_lock
);
1782 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1783 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1784 spin_unlock_irq(shost
->host_lock
);
1785 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_ADISC_ISSUE
);
1786 lpfc_issue_els_adisc(vport
, ndlp
, 0);
1788 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1789 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
1790 lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0);
1793 return ndlp
->nlp_state
;
1797 lpfc_rcv_logo_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1798 void *arg
, uint32_t evt
)
1800 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1802 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1803 return ndlp
->nlp_state
;
1807 lpfc_rcv_padisc_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1808 void *arg
, uint32_t evt
)
1810 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1812 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1815 * Do not start discovery if discovery is about to start
1816 * or discovery in progress for this node. Starting discovery
1817 * here will affect the counting of discovery threads.
1819 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
) &&
1820 !(ndlp
->nlp_flag
& NLP_NPR_2B_DISC
)) {
1821 if (ndlp
->nlp_flag
& NLP_NPR_ADISC
) {
1822 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1823 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1824 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_ADISC_ISSUE
);
1825 lpfc_issue_els_adisc(vport
, ndlp
, 0);
1827 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1828 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
1829 lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0);
1832 return ndlp
->nlp_state
;
1836 lpfc_rcv_prlo_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1837 void *arg
, uint32_t evt
)
1839 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1840 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1842 spin_lock_irq(shost
->host_lock
);
1843 ndlp
->nlp_flag
|= NLP_LOGO_ACC
;
1844 spin_unlock_irq(shost
->host_lock
);
1846 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
);
1848 if ((ndlp
->nlp_flag
& NLP_DELAY_TMO
) == 0) {
1849 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
1850 spin_lock_irq(shost
->host_lock
);
1851 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
1852 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1853 spin_unlock_irq(shost
->host_lock
);
1854 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
1856 spin_lock_irq(shost
->host_lock
);
1857 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1858 spin_unlock_irq(shost
->host_lock
);
1860 return ndlp
->nlp_state
;
1864 lpfc_cmpl_plogi_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1865 void *arg
, uint32_t evt
)
1867 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1870 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1871 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1873 irsp
= &rspiocb
->iocb
;
1874 if (irsp
->ulpStatus
) {
1875 ndlp
->nlp_flag
|= NLP_DEFER_RM
;
1876 return NLP_STE_FREED_NODE
;
1878 return ndlp
->nlp_state
;
1882 lpfc_cmpl_prli_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1883 void *arg
, uint32_t evt
)
1885 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1888 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1889 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1891 irsp
= &rspiocb
->iocb
;
1892 if (irsp
->ulpStatus
&& (ndlp
->nlp_flag
& NLP_NODEV_REMOVE
)) {
1893 lpfc_drop_node(vport
, ndlp
);
1894 return NLP_STE_FREED_NODE
;
1896 return ndlp
->nlp_state
;
1900 lpfc_cmpl_logo_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1901 void *arg
, uint32_t evt
)
1903 lpfc_unreg_rpi(vport
, ndlp
);
1904 /* This routine does nothing, just return the current state */
1905 return ndlp
->nlp_state
;
1909 lpfc_cmpl_adisc_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1910 void *arg
, uint32_t evt
)
1912 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1915 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1916 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1918 irsp
= &rspiocb
->iocb
;
1919 if (irsp
->ulpStatus
&& (ndlp
->nlp_flag
& NLP_NODEV_REMOVE
)) {
1920 lpfc_drop_node(vport
, ndlp
);
1921 return NLP_STE_FREED_NODE
;
1923 return ndlp
->nlp_state
;
1927 lpfc_cmpl_reglogin_npr_node(struct lpfc_vport
*vport
,
1928 struct lpfc_nodelist
*ndlp
,
1929 void *arg
, uint32_t evt
)
1931 LPFC_MBOXQ_t
*pmb
= (LPFC_MBOXQ_t
*) arg
;
1932 MAILBOX_t
*mb
= &pmb
->mb
;
1935 ndlp
->nlp_rpi
= mb
->un
.varWords
[0];
1937 if (ndlp
->nlp_flag
& NLP_NODEV_REMOVE
) {
1938 lpfc_drop_node(vport
, ndlp
);
1939 return NLP_STE_FREED_NODE
;
1942 return ndlp
->nlp_state
;
1946 lpfc_device_rm_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1947 void *arg
, uint32_t evt
)
1949 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1951 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1952 spin_lock_irq(shost
->host_lock
);
1953 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1954 spin_unlock_irq(shost
->host_lock
);
1955 return ndlp
->nlp_state
;
1957 lpfc_drop_node(vport
, ndlp
);
1958 return NLP_STE_FREED_NODE
;
1962 lpfc_device_recov_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1963 void *arg
, uint32_t evt
)
1965 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1967 /* Don't do anything that will mess up processing of the
1970 if (vport
->fc_flag
& FC_RSCN_DEFERRED
)
1971 return ndlp
->nlp_state
;
1973 spin_lock_irq(shost
->host_lock
);
1974 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1975 spin_unlock_irq(shost
->host_lock
);
1976 if (ndlp
->nlp_flag
& NLP_DELAY_TMO
) {
1977 lpfc_cancel_retry_delay_tmo(vport
, ndlp
);
1979 return ndlp
->nlp_state
;
1983 /* This next section defines the NPort Discovery State Machine */
1985 /* There are 4 different double linked lists nodelist entries can reside on.
1986 * The plogi list and adisc list are used when Link Up discovery or RSCN
1987 * processing is needed. Each list holds the nodes that we will send PLOGI
1988 * or ADISC on. These lists will keep track of what nodes will be effected
1989 * by an RSCN, or a Link Up (Typically, all nodes are effected on Link Up).
1990 * The unmapped_list will contain all nodes that we have successfully logged
1991 * into at the Fibre Channel level. The mapped_list will contain all nodes
1992 * that are mapped FCP targets.
1995 * The bind list is a list of undiscovered (potentially non-existent) nodes
1996 * that we have saved binding information on. This information is used when
1997 * nodes transition from the unmapped to the mapped list.
1999 /* For UNUSED_NODE state, the node has just been allocated .
2000 * For PLOGI_ISSUE and REG_LOGIN_ISSUE, the node is on
2001 * the PLOGI list. For REG_LOGIN_COMPL, the node is taken off the PLOGI list
2002 * and put on the unmapped list. For ADISC processing, the node is taken off
2003 * the ADISC list and placed on either the mapped or unmapped list (depending
2004 * on its previous state). Once on the unmapped list, a PRLI is issued and the
2005 * state changed to PRLI_ISSUE. When the PRLI completion occurs, the state is
2006 * changed to UNMAPPED_NODE. If the completion indicates a mapped
2007 * node, the node is taken off the unmapped list. The binding list is checked
2008 * for a valid binding, or a binding is automatically assigned. If binding
2009 * assignment is unsuccessful, the node is left on the unmapped list. If
2010 * binding assignment is successful, the associated binding list entry (if
2011 * any) is removed, and the node is placed on the mapped list.
2014 * For a Link Down, all nodes on the ADISC, PLOGI, unmapped or mapped
2015 * lists will receive a DEVICE_RECOVERY event. If the linkdown or devloss timers
2016 * expire, all effected nodes will receive a DEVICE_RM event.
2019 * For a Link Up or RSCN, all nodes will move from the mapped / unmapped lists
2020 * to either the ADISC or PLOGI list. After a Nameserver query or ALPA loopmap
2021 * check, additional nodes may be added or removed (via DEVICE_RM) to / from
2022 * the PLOGI or ADISC lists. Once the PLOGI and ADISC lists are populated,
2023 * we will first process the ADISC list. 32 entries are processed initially and
2024 * ADISC is initited for each one. Completions / Events for each node are
2025 * funnelled thru the state machine. As each node finishes ADISC processing, it
2026 * starts ADISC for any nodes waiting for ADISC processing. If no nodes are
2027 * waiting, and the ADISC list count is identically 0, then we are done. For
2028 * Link Up discovery, since all nodes on the PLOGI list are UNREG_LOGIN'ed, we
2029 * can issue a CLEAR_LA and reenable Link Events. Next we will process the PLOGI
2030 * list. 32 entries are processed initially and PLOGI is initited for each one.
2031 * Completions / Events for each node are funnelled thru the state machine. As
2032 * each node finishes PLOGI processing, it starts PLOGI for any nodes waiting
2033 * for PLOGI processing. If no nodes are waiting, and the PLOGI list count is
2034 * indentically 0, then we are done. We have now completed discovery / RSCN
2035 * handling. Upon completion, ALL nodes should be on either the mapped or
2039 static uint32_t (*lpfc_disc_action
[NLP_STE_MAX_STATE
* NLP_EVT_MAX_EVENT
])
2040 (struct lpfc_vport
*, struct lpfc_nodelist
*, void *, uint32_t) = {
2041 /* Action routine Event Current State */
2042 lpfc_rcv_plogi_unused_node
, /* RCV_PLOGI UNUSED_NODE */
2043 lpfc_rcv_els_unused_node
, /* RCV_PRLI */
2044 lpfc_rcv_logo_unused_node
, /* RCV_LOGO */
2045 lpfc_rcv_els_unused_node
, /* RCV_ADISC */
2046 lpfc_rcv_els_unused_node
, /* RCV_PDISC */
2047 lpfc_rcv_els_unused_node
, /* RCV_PRLO */
2048 lpfc_disc_illegal
, /* CMPL_PLOGI */
2049 lpfc_disc_illegal
, /* CMPL_PRLI */
2050 lpfc_cmpl_logo_unused_node
, /* CMPL_LOGO */
2051 lpfc_disc_illegal
, /* CMPL_ADISC */
2052 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
2053 lpfc_device_rm_unused_node
, /* DEVICE_RM */
2054 lpfc_disc_illegal
, /* DEVICE_RECOVERY */
2056 lpfc_rcv_plogi_plogi_issue
, /* RCV_PLOGI PLOGI_ISSUE */
2057 lpfc_rcv_prli_plogi_issue
, /* RCV_PRLI */
2058 lpfc_rcv_logo_plogi_issue
, /* RCV_LOGO */
2059 lpfc_rcv_els_plogi_issue
, /* RCV_ADISC */
2060 lpfc_rcv_els_plogi_issue
, /* RCV_PDISC */
2061 lpfc_rcv_els_plogi_issue
, /* RCV_PRLO */
2062 lpfc_cmpl_plogi_plogi_issue
, /* CMPL_PLOGI */
2063 lpfc_disc_illegal
, /* CMPL_PRLI */
2064 lpfc_cmpl_logo_plogi_issue
, /* CMPL_LOGO */
2065 lpfc_disc_illegal
, /* CMPL_ADISC */
2066 lpfc_cmpl_reglogin_plogi_issue
,/* CMPL_REG_LOGIN */
2067 lpfc_device_rm_plogi_issue
, /* DEVICE_RM */
2068 lpfc_device_recov_plogi_issue
, /* DEVICE_RECOVERY */
2070 lpfc_rcv_plogi_adisc_issue
, /* RCV_PLOGI ADISC_ISSUE */
2071 lpfc_rcv_prli_adisc_issue
, /* RCV_PRLI */
2072 lpfc_rcv_logo_adisc_issue
, /* RCV_LOGO */
2073 lpfc_rcv_padisc_adisc_issue
, /* RCV_ADISC */
2074 lpfc_rcv_padisc_adisc_issue
, /* RCV_PDISC */
2075 lpfc_rcv_prlo_adisc_issue
, /* RCV_PRLO */
2076 lpfc_disc_illegal
, /* CMPL_PLOGI */
2077 lpfc_disc_illegal
, /* CMPL_PRLI */
2078 lpfc_disc_illegal
, /* CMPL_LOGO */
2079 lpfc_cmpl_adisc_adisc_issue
, /* CMPL_ADISC */
2080 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
2081 lpfc_device_rm_adisc_issue
, /* DEVICE_RM */
2082 lpfc_device_recov_adisc_issue
, /* DEVICE_RECOVERY */
2084 lpfc_rcv_plogi_reglogin_issue
, /* RCV_PLOGI REG_LOGIN_ISSUE */
2085 lpfc_rcv_prli_reglogin_issue
, /* RCV_PLOGI */
2086 lpfc_rcv_logo_reglogin_issue
, /* RCV_LOGO */
2087 lpfc_rcv_padisc_reglogin_issue
, /* RCV_ADISC */
2088 lpfc_rcv_padisc_reglogin_issue
, /* RCV_PDISC */
2089 lpfc_rcv_prlo_reglogin_issue
, /* RCV_PRLO */
2090 lpfc_cmpl_plogi_illegal
, /* CMPL_PLOGI */
2091 lpfc_disc_illegal
, /* CMPL_PRLI */
2092 lpfc_disc_illegal
, /* CMPL_LOGO */
2093 lpfc_disc_illegal
, /* CMPL_ADISC */
2094 lpfc_cmpl_reglogin_reglogin_issue
,/* CMPL_REG_LOGIN */
2095 lpfc_device_rm_reglogin_issue
, /* DEVICE_RM */
2096 lpfc_device_recov_reglogin_issue
,/* DEVICE_RECOVERY */
2098 lpfc_rcv_plogi_prli_issue
, /* RCV_PLOGI PRLI_ISSUE */
2099 lpfc_rcv_prli_prli_issue
, /* RCV_PRLI */
2100 lpfc_rcv_logo_prli_issue
, /* RCV_LOGO */
2101 lpfc_rcv_padisc_prli_issue
, /* RCV_ADISC */
2102 lpfc_rcv_padisc_prli_issue
, /* RCV_PDISC */
2103 lpfc_rcv_prlo_prli_issue
, /* RCV_PRLO */
2104 lpfc_cmpl_plogi_illegal
, /* CMPL_PLOGI */
2105 lpfc_cmpl_prli_prli_issue
, /* CMPL_PRLI */
2106 lpfc_disc_illegal
, /* CMPL_LOGO */
2107 lpfc_disc_illegal
, /* CMPL_ADISC */
2108 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
2109 lpfc_device_rm_prli_issue
, /* DEVICE_RM */
2110 lpfc_device_recov_prli_issue
, /* DEVICE_RECOVERY */
2112 lpfc_rcv_plogi_unmap_node
, /* RCV_PLOGI UNMAPPED_NODE */
2113 lpfc_rcv_prli_unmap_node
, /* RCV_PRLI */
2114 lpfc_rcv_logo_unmap_node
, /* RCV_LOGO */
2115 lpfc_rcv_padisc_unmap_node
, /* RCV_ADISC */
2116 lpfc_rcv_padisc_unmap_node
, /* RCV_PDISC */
2117 lpfc_rcv_prlo_unmap_node
, /* RCV_PRLO */
2118 lpfc_disc_illegal
, /* CMPL_PLOGI */
2119 lpfc_disc_illegal
, /* CMPL_PRLI */
2120 lpfc_disc_illegal
, /* CMPL_LOGO */
2121 lpfc_disc_illegal
, /* CMPL_ADISC */
2122 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
2123 lpfc_disc_illegal
, /* DEVICE_RM */
2124 lpfc_device_recov_unmap_node
, /* DEVICE_RECOVERY */
2126 lpfc_rcv_plogi_mapped_node
, /* RCV_PLOGI MAPPED_NODE */
2127 lpfc_rcv_prli_mapped_node
, /* RCV_PRLI */
2128 lpfc_rcv_logo_mapped_node
, /* RCV_LOGO */
2129 lpfc_rcv_padisc_mapped_node
, /* RCV_ADISC */
2130 lpfc_rcv_padisc_mapped_node
, /* RCV_PDISC */
2131 lpfc_rcv_prlo_mapped_node
, /* RCV_PRLO */
2132 lpfc_disc_illegal
, /* CMPL_PLOGI */
2133 lpfc_disc_illegal
, /* CMPL_PRLI */
2134 lpfc_disc_illegal
, /* CMPL_LOGO */
2135 lpfc_disc_illegal
, /* CMPL_ADISC */
2136 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
2137 lpfc_disc_illegal
, /* DEVICE_RM */
2138 lpfc_device_recov_mapped_node
, /* DEVICE_RECOVERY */
2140 lpfc_rcv_plogi_npr_node
, /* RCV_PLOGI NPR_NODE */
2141 lpfc_rcv_prli_npr_node
, /* RCV_PRLI */
2142 lpfc_rcv_logo_npr_node
, /* RCV_LOGO */
2143 lpfc_rcv_padisc_npr_node
, /* RCV_ADISC */
2144 lpfc_rcv_padisc_npr_node
, /* RCV_PDISC */
2145 lpfc_rcv_prlo_npr_node
, /* RCV_PRLO */
2146 lpfc_cmpl_plogi_npr_node
, /* CMPL_PLOGI */
2147 lpfc_cmpl_prli_npr_node
, /* CMPL_PRLI */
2148 lpfc_cmpl_logo_npr_node
, /* CMPL_LOGO */
2149 lpfc_cmpl_adisc_npr_node
, /* CMPL_ADISC */
2150 lpfc_cmpl_reglogin_npr_node
, /* CMPL_REG_LOGIN */
2151 lpfc_device_rm_npr_node
, /* DEVICE_RM */
2152 lpfc_device_recov_npr_node
, /* DEVICE_RECOVERY */
2156 lpfc_disc_state_machine(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
2157 void *arg
, uint32_t evt
)
2159 uint32_t cur_state
, rc
;
2160 uint32_t(*func
) (struct lpfc_vport
*, struct lpfc_nodelist
*, void *,
2162 uint32_t got_ndlp
= 0;
2164 if (lpfc_nlp_get(ndlp
))
2167 cur_state
= ndlp
->nlp_state
;
2169 /* DSM in event <evt> on NPort <nlp_DID> in state <cur_state> */
2170 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_DISCOVERY
,
2171 "0211 DSM in event x%x on NPort x%x in "
2172 "state %d Data: x%x\n",
2173 evt
, ndlp
->nlp_DID
, cur_state
, ndlp
->nlp_flag
);
2175 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_DSM
,
2176 "DSM in: evt:%d ste:%d did:x%x",
2177 evt
, cur_state
, ndlp
->nlp_DID
);
2179 func
= lpfc_disc_action
[(cur_state
* NLP_EVT_MAX_EVENT
) + evt
];
2180 rc
= (func
) (vport
, ndlp
, arg
, evt
);
2182 /* DSM out state <rc> on NPort <nlp_DID> */
2184 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_DISCOVERY
,
2185 "0212 DSM out state %d on NPort x%x Data: x%x\n",
2186 rc
, ndlp
->nlp_DID
, ndlp
->nlp_flag
);
2188 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_DSM
,
2189 "DSM out: ste:%d did:x%x flg:x%x",
2190 rc
, ndlp
->nlp_DID
, ndlp
->nlp_flag
);
2191 /* Decrement the ndlp reference count held for this function */
2194 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_DISCOVERY
,
2195 "0212 DSM out state %d on NPort free\n", rc
);
2197 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_DSM
,
2198 "DSM out: ste:%d did:x%x flg:x%x",