1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2006 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"
40 /* Called to verify a rcv'ed ADISC was intended for us. */
42 lpfc_check_adisc(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
43 struct lpfc_name
* nn
, struct lpfc_name
* pn
)
45 /* Compare the ADISC rsp WWNN / WWPN matches our internal node
46 * table entry for that node.
48 if (memcmp(nn
, &ndlp
->nlp_nodename
, sizeof (struct lpfc_name
)) != 0)
51 if (memcmp(pn
, &ndlp
->nlp_portname
, sizeof (struct lpfc_name
)) != 0)
54 /* we match, return success */
59 lpfc_check_sparm(struct lpfc_hba
* phba
,
60 struct lpfc_nodelist
* ndlp
, struct serv_parm
* sp
,
63 volatile struct serv_parm
*hsp
= &phba
->fc_sparam
;
64 uint16_t hsp_value
, ssp_value
= 0;
67 * The receive data field size and buffer-to-buffer receive data field
68 * size entries are 16 bits but are represented as two 8-bit fields in
69 * the driver data structure to account for rsvd bits and other control
70 * bits. Reconstruct and compare the fields as a 16-bit values before
71 * correcting the byte values.
73 if (sp
->cls1
.classValid
) {
74 hsp_value
= (hsp
->cls1
.rcvDataSizeMsb
<< 8) |
75 hsp
->cls1
.rcvDataSizeLsb
;
76 ssp_value
= (sp
->cls1
.rcvDataSizeMsb
<< 8) |
77 sp
->cls1
.rcvDataSizeLsb
;
78 if (ssp_value
> hsp_value
) {
79 sp
->cls1
.rcvDataSizeLsb
= hsp
->cls1
.rcvDataSizeLsb
;
80 sp
->cls1
.rcvDataSizeMsb
= hsp
->cls1
.rcvDataSizeMsb
;
82 } else if (class == CLASS1
) {
86 if (sp
->cls2
.classValid
) {
87 hsp_value
= (hsp
->cls2
.rcvDataSizeMsb
<< 8) |
88 hsp
->cls2
.rcvDataSizeLsb
;
89 ssp_value
= (sp
->cls2
.rcvDataSizeMsb
<< 8) |
90 sp
->cls2
.rcvDataSizeLsb
;
91 if (ssp_value
> hsp_value
) {
92 sp
->cls2
.rcvDataSizeLsb
= hsp
->cls2
.rcvDataSizeLsb
;
93 sp
->cls2
.rcvDataSizeMsb
= hsp
->cls2
.rcvDataSizeMsb
;
95 } else if (class == CLASS2
) {
99 if (sp
->cls3
.classValid
) {
100 hsp_value
= (hsp
->cls3
.rcvDataSizeMsb
<< 8) |
101 hsp
->cls3
.rcvDataSizeLsb
;
102 ssp_value
= (sp
->cls3
.rcvDataSizeMsb
<< 8) |
103 sp
->cls3
.rcvDataSizeLsb
;
104 if (ssp_value
> hsp_value
) {
105 sp
->cls3
.rcvDataSizeLsb
= hsp
->cls3
.rcvDataSizeLsb
;
106 sp
->cls3
.rcvDataSizeMsb
= hsp
->cls3
.rcvDataSizeMsb
;
108 } else if (class == CLASS3
) {
113 * Preserve the upper four bits of the MSB from the PLOGI response.
114 * These bits contain the Buffer-to-Buffer State Change Number
115 * from the target and need to be passed to the FW.
117 hsp_value
= (hsp
->cmn
.bbRcvSizeMsb
<< 8) | hsp
->cmn
.bbRcvSizeLsb
;
118 ssp_value
= (sp
->cmn
.bbRcvSizeMsb
<< 8) | sp
->cmn
.bbRcvSizeLsb
;
119 if (ssp_value
> hsp_value
) {
120 sp
->cmn
.bbRcvSizeLsb
= hsp
->cmn
.bbRcvSizeLsb
;
121 sp
->cmn
.bbRcvSizeMsb
= (sp
->cmn
.bbRcvSizeMsb
& 0xF0) |
122 (hsp
->cmn
.bbRcvSizeMsb
& 0x0F);
125 memcpy(&ndlp
->nlp_nodename
, &sp
->nodeName
, sizeof (struct lpfc_name
));
126 memcpy(&ndlp
->nlp_portname
, &sp
->portName
, sizeof (struct lpfc_name
));
131 lpfc_check_elscmpl_iocb(struct lpfc_hba
* phba
,
132 struct lpfc_iocbq
*cmdiocb
,
133 struct lpfc_iocbq
*rspiocb
)
135 struct lpfc_dmabuf
*pcmd
, *prsp
;
140 irsp
= &rspiocb
->iocb
;
141 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
143 /* For lpfc_els_abort, context2 could be zero'ed to delay
144 * freeing associated memory till after ABTS completes.
147 prsp
= list_get_first(&pcmd
->list
, struct lpfc_dmabuf
,
150 lp
= (uint32_t *) prsp
->virt
;
151 ptr
= (void *)((uint8_t *)lp
+ sizeof(uint32_t));
154 /* Force ulpStatus error since we are returning NULL ptr */
155 if (!(irsp
->ulpStatus
)) {
156 irsp
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
157 irsp
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
166 * Free resources / clean up outstanding I/Os
167 * associated with a LPFC_NODELIST entry. This
168 * routine effectively results in a "software abort".
171 lpfc_els_abort(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
174 struct lpfc_sli
*psli
;
175 struct lpfc_sli_ring
*pring
;
176 struct lpfc_iocbq
*iocb
, *next_iocb
;
180 /* Abort outstanding I/O on NPort <nlp_DID> */
181 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
182 "%d:0205 Abort outstanding I/O on NPort x%x "
183 "Data: x%x x%x x%x\n",
184 phba
->brd_no
, ndlp
->nlp_DID
, ndlp
->nlp_flag
,
185 ndlp
->nlp_state
, ndlp
->nlp_rpi
);
188 pring
= &psli
->ring
[LPFC_ELS_RING
];
190 /* First check the txq */
193 spin_lock_irq(phba
->host
->host_lock
);
194 list_for_each_entry_safe(iocb
, next_iocb
, &pring
->txq
, list
) {
195 /* Check to see if iocb matches the nport we are looking
197 if ((lpfc_check_sli_ndlp(phba
, pring
, iocb
, ndlp
))) {
199 /* It matches, so deque and call compl with an
201 list_del(&iocb
->list
);
203 if (iocb
->iocb_cmpl
) {
205 icmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
206 icmd
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
207 spin_unlock_irq(phba
->host
->host_lock
);
208 (iocb
->iocb_cmpl
) (phba
, iocb
, iocb
);
209 spin_lock_irq(phba
->host
->host_lock
);
211 lpfc_sli_release_iocbq(phba
, iocb
);
215 spin_unlock_irq(phba
->host
->host_lock
);
218 /* Everything on txcmplq will be returned by firmware
219 * with a no rpi / linkdown / abort error. For ring 0,
220 * ELS discovery, we want to get rid of it right here.
222 /* Next check the txcmplq */
225 spin_lock_irq(phba
->host
->host_lock
);
226 list_for_each_entry_safe(iocb
, next_iocb
, &pring
->txcmplq
,
228 /* Check to see if iocb matches the nport we are looking
230 if ((lpfc_check_sli_ndlp (phba
, pring
, iocb
, ndlp
))) {
232 /* It matches, so deque and call compl with an
234 list_del(&iocb
->list
);
235 pring
->txcmplq_cnt
--;
238 /* If the driver is completing an ELS
239 * command early, flush it out of the firmware.
242 (icmd
->ulpCommand
== CMD_ELS_REQUEST64_CR
) &&
243 (icmd
->un
.elsreq64
.bdl
.ulpIoTag32
)) {
244 lpfc_sli_issue_abort_iotag32(phba
,
247 if (iocb
->iocb_cmpl
) {
248 icmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
249 icmd
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
250 spin_unlock_irq(phba
->host
->host_lock
);
251 (iocb
->iocb_cmpl
) (phba
, iocb
, iocb
);
252 spin_lock_irq(phba
->host
->host_lock
);
254 lpfc_sli_release_iocbq(phba
, iocb
);
258 spin_unlock_irq(phba
->host
->host_lock
);
261 /* If we are delaying issuing an ELS command, cancel it */
262 if (ndlp
->nlp_flag
& NLP_DELAY_TMO
)
263 lpfc_cancel_retry_delay_tmo(phba
, ndlp
);
268 lpfc_rcv_plogi(struct lpfc_hba
* phba
,
269 struct lpfc_nodelist
* ndlp
,
270 struct lpfc_iocbq
*cmdiocb
)
272 struct lpfc_dmabuf
*pcmd
;
275 struct serv_parm
*sp
;
280 memset(&stat
, 0, sizeof (struct ls_rjt
));
281 if (phba
->hba_state
<= LPFC_FLOGI
) {
282 /* Before responding to PLOGI, check for pt2pt mode.
283 * If we are pt2pt, with an outstanding FLOGI, abort
284 * the FLOGI and resend it first.
286 if (phba
->fc_flag
& FC_PT2PT
) {
287 lpfc_els_abort_flogi(phba
);
288 if (!(phba
->fc_flag
& FC_PT2PT_PLOGI
)) {
289 /* If the other side is supposed to initiate
290 * the PLOGI anyway, just ACC it now and
291 * move on with discovery.
293 phba
->fc_edtov
= FF_DEF_EDTOV
;
294 phba
->fc_ratov
= FF_DEF_RATOV
;
295 /* Start discovery - this should just do
297 lpfc_disc_start(phba
);
299 lpfc_initial_flogi(phba
);
302 stat
.un
.b
.lsRjtRsnCode
= LSRJT_LOGICAL_BSY
;
303 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
304 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
,
309 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
310 lp
= (uint32_t *) pcmd
->virt
;
311 sp
= (struct serv_parm
*) ((uint8_t *) lp
+ sizeof (uint32_t));
312 if ((lpfc_check_sparm(phba
, ndlp
, sp
, CLASS3
) == 0)) {
313 /* Reject this request because invalid parameters */
314 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
315 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_SPARM_OPTIONS
;
316 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
319 icmd
= &cmdiocb
->iocb
;
321 /* PLOGI chkparm OK */
322 lpfc_printf_log(phba
,
325 "%d:0114 PLOGI chkparm OK Data: x%x x%x x%x x%x\n",
327 ndlp
->nlp_DID
, ndlp
->nlp_state
, ndlp
->nlp_flag
,
330 if ((phba
->cfg_fcp_class
== 2) &&
331 (sp
->cls2
.classValid
)) {
332 ndlp
->nlp_fcp_info
|= CLASS2
;
334 ndlp
->nlp_fcp_info
|= CLASS3
;
336 ndlp
->nlp_class_sup
= 0;
337 if (sp
->cls1
.classValid
)
338 ndlp
->nlp_class_sup
|= FC_COS_CLASS1
;
339 if (sp
->cls2
.classValid
)
340 ndlp
->nlp_class_sup
|= FC_COS_CLASS2
;
341 if (sp
->cls3
.classValid
)
342 ndlp
->nlp_class_sup
|= FC_COS_CLASS3
;
343 if (sp
->cls4
.classValid
)
344 ndlp
->nlp_class_sup
|= FC_COS_CLASS4
;
346 ((sp
->cmn
.bbRcvSizeMsb
& 0x0F) << 8) | sp
->cmn
.bbRcvSizeLsb
;
348 /* no need to reg_login if we are already in one of these states */
349 switch (ndlp
->nlp_state
) {
350 case NLP_STE_NPR_NODE
:
351 if (!(ndlp
->nlp_flag
& NLP_NPR_ADISC
))
353 case NLP_STE_REG_LOGIN_ISSUE
:
354 case NLP_STE_PRLI_ISSUE
:
355 case NLP_STE_UNMAPPED_NODE
:
356 case NLP_STE_MAPPED_NODE
:
357 lpfc_els_rsp_acc(phba
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
, NULL
, 0);
361 if ((phba
->fc_flag
& FC_PT2PT
)
362 && !(phba
->fc_flag
& FC_PT2PT_PLOGI
)) {
363 /* rcv'ed PLOGI decides what our NPortId will be */
364 phba
->fc_myDID
= icmd
->un
.rcvels
.parmRo
;
365 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
368 lpfc_config_link(phba
, mbox
);
369 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
370 rc
= lpfc_sli_issue_mbox
371 (phba
, mbox
, (MBX_NOWAIT
| MBX_STOP_IOCB
));
372 if (rc
== MBX_NOT_FINISHED
) {
373 mempool_free( mbox
, phba
->mbox_mem_pool
);
377 lpfc_can_disctmo(phba
);
379 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
383 if (lpfc_reg_login(phba
, icmd
->un
.rcvels
.remoteID
,
384 (uint8_t *) sp
, mbox
, 0)) {
385 mempool_free( mbox
, phba
->mbox_mem_pool
);
389 /* ACC PLOGI rsp command needs to execute first,
390 * queue this mbox command to be processed later.
392 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_reg_login
;
393 mbox
->context2
= ndlp
;
394 ndlp
->nlp_flag
|= (NLP_ACC_REGLOGIN
| NLP_RCV_PLOGI
);
397 * If there is an outstanding PLOGI issued, abort it before
398 * sending ACC rsp for received PLOGI. If pending plogi
399 * is not canceled here, the plogi will be rejected by
400 * remote port and will be retried. On a configuration with
401 * single discovery thread, this will cause a huge delay in
402 * discovery. Also this will cause multiple state machines
403 * running in parallel for this node.
405 if (ndlp
->nlp_state
== NLP_STE_PLOGI_ISSUE
) {
406 /* software abort outstanding PLOGI */
407 lpfc_els_abort(phba
, ndlp
, 1);
410 lpfc_els_rsp_acc(phba
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
, mbox
, 0);
414 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
415 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_OUT_OF_RESOURCE
;
416 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
421 lpfc_rcv_padisc(struct lpfc_hba
* phba
,
422 struct lpfc_nodelist
* ndlp
,
423 struct lpfc_iocbq
*cmdiocb
)
425 struct lpfc_dmabuf
*pcmd
;
426 struct serv_parm
*sp
;
427 struct lpfc_name
*pnn
, *ppn
;
434 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
435 lp
= (uint32_t *) pcmd
->virt
;
438 if (cmd
== ELS_CMD_ADISC
) {
440 pnn
= (struct lpfc_name
*) & ap
->nodeName
;
441 ppn
= (struct lpfc_name
*) & ap
->portName
;
443 sp
= (struct serv_parm
*) lp
;
444 pnn
= (struct lpfc_name
*) & sp
->nodeName
;
445 ppn
= (struct lpfc_name
*) & sp
->portName
;
448 icmd
= &cmdiocb
->iocb
;
449 if ((icmd
->ulpStatus
== 0) &&
450 (lpfc_check_adisc(phba
, ndlp
, pnn
, ppn
))) {
451 if (cmd
== ELS_CMD_ADISC
) {
452 lpfc_els_rsp_adisc_acc(phba
, cmdiocb
, ndlp
);
454 lpfc_els_rsp_acc(phba
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
,
459 /* Reject this request because invalid parameters */
460 stat
.un
.b
.lsRjtRsvd0
= 0;
461 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
462 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_SPARM_OPTIONS
;
463 stat
.un
.b
.vendorUnique
= 0;
464 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
467 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
);
469 spin_lock_irq(phba
->host
->host_lock
);
470 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
471 spin_unlock_irq(phba
->host
->host_lock
);
472 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
473 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
474 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
475 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
480 lpfc_rcv_logo(struct lpfc_hba
* phba
,
481 struct lpfc_nodelist
* ndlp
,
482 struct lpfc_iocbq
*cmdiocb
,
485 /* Put ndlp on NPR list with 1 sec timeout for plogi, ACC logo */
486 /* Only call LOGO ACC for first LOGO, this avoids sending unnecessary
487 * PLOGIs during LOGO storms from a device.
489 ndlp
->nlp_flag
|= NLP_LOGO_ACC
;
490 if (els_cmd
== ELS_CMD_PRLO
)
491 lpfc_els_rsp_acc(phba
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
, 0);
493 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
495 if (!(ndlp
->nlp_type
& NLP_FABRIC
) ||
496 (ndlp
->nlp_state
== NLP_STE_ADISC_ISSUE
)) {
497 /* Only try to re-login if this is NOT a Fabric Node */
498 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
499 spin_lock_irq(phba
->host
->host_lock
);
500 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
501 spin_unlock_irq(phba
->host
->host_lock
);
503 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
504 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
505 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
506 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
508 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
509 ndlp
->nlp_state
= NLP_STE_UNUSED_NODE
;
510 lpfc_nlp_list(phba
, ndlp
, NLP_UNUSED_LIST
);
513 spin_lock_irq(phba
->host
->host_lock
);
514 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
515 spin_unlock_irq(phba
->host
->host_lock
);
516 /* The driver has to wait until the ACC completes before it continues
517 * processing the LOGO. The action will resume in
518 * lpfc_cmpl_els_logo_acc routine. Since part of processing includes an
519 * unreg_login, the driver waits so the ACC does not get aborted.
525 lpfc_rcv_prli(struct lpfc_hba
* phba
,
526 struct lpfc_nodelist
* ndlp
,
527 struct lpfc_iocbq
*cmdiocb
)
529 struct lpfc_dmabuf
*pcmd
;
532 struct fc_rport
*rport
= ndlp
->rport
;
535 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
536 lp
= (uint32_t *) pcmd
->virt
;
537 npr
= (PRLI
*) ((uint8_t *) lp
+ sizeof (uint32_t));
539 ndlp
->nlp_type
&= ~(NLP_FCP_TARGET
| NLP_FCP_INITIATOR
);
540 ndlp
->nlp_fcp_info
&= ~NLP_FCP_2_DEVICE
;
541 if ((npr
->acceptRspCode
== PRLI_REQ_EXECUTED
) &&
542 (npr
->prliType
== PRLI_FCP_TYPE
)) {
543 if (npr
->initiatorFunc
)
544 ndlp
->nlp_type
|= NLP_FCP_INITIATOR
;
546 ndlp
->nlp_type
|= NLP_FCP_TARGET
;
548 ndlp
->nlp_fcp_info
|= NLP_FCP_2_DEVICE
;
551 /* We need to update the rport role values */
552 roles
= FC_RPORT_ROLE_UNKNOWN
;
553 if (ndlp
->nlp_type
& NLP_FCP_INITIATOR
)
554 roles
|= FC_RPORT_ROLE_FCP_INITIATOR
;
555 if (ndlp
->nlp_type
& NLP_FCP_TARGET
)
556 roles
|= FC_RPORT_ROLE_FCP_TARGET
;
557 fc_remote_port_rolechg(rport
, roles
);
562 lpfc_disc_set_adisc(struct lpfc_hba
* phba
,
563 struct lpfc_nodelist
* ndlp
)
565 /* Check config parameter use-adisc or FCP-2 */
566 if ((phba
->cfg_use_adisc
== 0) &&
567 !(phba
->fc_flag
& FC_RSCN_MODE
)) {
568 if (!(ndlp
->nlp_fcp_info
& NLP_FCP_2_DEVICE
))
571 spin_lock_irq(phba
->host
->host_lock
);
572 ndlp
->nlp_flag
|= NLP_NPR_ADISC
;
573 spin_unlock_irq(phba
->host
->host_lock
);
578 lpfc_disc_illegal(struct lpfc_hba
* phba
,
579 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
581 lpfc_printf_log(phba
,
584 "%d:0253 Illegal State Transition: node x%x event x%x, "
585 "state x%x Data: x%x x%x\n",
587 ndlp
->nlp_DID
, evt
, ndlp
->nlp_state
, ndlp
->nlp_rpi
,
589 return ndlp
->nlp_state
;
592 /* Start of Discovery State Machine routines */
595 lpfc_rcv_plogi_unused_node(struct lpfc_hba
* phba
,
596 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
598 struct lpfc_iocbq
*cmdiocb
;
600 cmdiocb
= (struct lpfc_iocbq
*) arg
;
602 if (lpfc_rcv_plogi(phba
, ndlp
, cmdiocb
)) {
603 ndlp
->nlp_prev_state
= NLP_STE_UNUSED_NODE
;
604 ndlp
->nlp_state
= NLP_STE_UNUSED_NODE
;
605 lpfc_nlp_list(phba
, ndlp
, NLP_UNUSED_LIST
);
606 return ndlp
->nlp_state
;
608 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
609 return NLP_STE_FREED_NODE
;
613 lpfc_rcv_els_unused_node(struct lpfc_hba
* phba
,
614 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
616 lpfc_issue_els_logo(phba
, ndlp
, 0);
617 lpfc_nlp_list(phba
, ndlp
, NLP_UNUSED_LIST
);
618 return ndlp
->nlp_state
;
622 lpfc_rcv_logo_unused_node(struct lpfc_hba
* phba
,
623 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
625 struct lpfc_iocbq
*cmdiocb
;
627 cmdiocb
= (struct lpfc_iocbq
*) arg
;
629 spin_lock_irq(phba
->host
->host_lock
);
630 ndlp
->nlp_flag
|= NLP_LOGO_ACC
;
631 spin_unlock_irq(phba
->host
->host_lock
);
632 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
633 lpfc_nlp_list(phba
, ndlp
, NLP_UNUSED_LIST
);
635 return ndlp
->nlp_state
;
639 lpfc_cmpl_logo_unused_node(struct lpfc_hba
* phba
,
640 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
642 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
643 return NLP_STE_FREED_NODE
;
647 lpfc_device_rm_unused_node(struct lpfc_hba
* phba
,
648 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
650 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
651 return NLP_STE_FREED_NODE
;
655 lpfc_rcv_plogi_plogi_issue(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
656 void *arg
, uint32_t evt
)
658 struct lpfc_iocbq
*cmdiocb
= arg
;
659 struct lpfc_dmabuf
*pcmd
;
660 struct serv_parm
*sp
;
665 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
666 lp
= (uint32_t *) pcmd
->virt
;
667 sp
= (struct serv_parm
*) ((uint8_t *) lp
+ sizeof (uint32_t));
669 memset(&stat
, 0, sizeof (struct ls_rjt
));
671 /* For a PLOGI, we only accept if our portname is less
672 * than the remote portname.
674 phba
->fc_stat
.elsLogiCol
++;
675 port_cmp
= memcmp(&phba
->fc_portname
, &sp
->portName
,
676 sizeof (struct lpfc_name
));
679 /* Reject this request because the remote node will accept
681 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
682 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CMD_IN_PROGRESS
;
683 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
685 lpfc_rcv_plogi(phba
, ndlp
, cmdiocb
);
686 } /* if our portname was less */
688 return ndlp
->nlp_state
;
692 lpfc_rcv_logo_plogi_issue(struct lpfc_hba
* phba
,
693 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
695 struct lpfc_iocbq
*cmdiocb
;
697 cmdiocb
= (struct lpfc_iocbq
*) arg
;
699 /* software abort outstanding PLOGI */
700 lpfc_els_abort(phba
, ndlp
, 1);
702 lpfc_rcv_logo(phba
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
703 return ndlp
->nlp_state
;
707 lpfc_rcv_els_plogi_issue(struct lpfc_hba
* phba
,
708 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
710 struct lpfc_iocbq
*cmdiocb
;
712 cmdiocb
= (struct lpfc_iocbq
*) arg
;
714 /* software abort outstanding PLOGI */
715 lpfc_els_abort(phba
, ndlp
, 1);
717 if (evt
== NLP_EVT_RCV_LOGO
) {
718 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
720 lpfc_issue_els_logo(phba
, ndlp
, 0);
723 /* Put ndlp in npr list set plogi timer for 1 sec */
724 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
725 spin_lock_irq(phba
->host
->host_lock
);
726 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
727 spin_unlock_irq(phba
->host
->host_lock
);
728 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
729 ndlp
->nlp_prev_state
= NLP_STE_PLOGI_ISSUE
;
730 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
731 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
733 return ndlp
->nlp_state
;
737 lpfc_cmpl_plogi_plogi_issue(struct lpfc_hba
* phba
,
738 struct lpfc_nodelist
* ndlp
, void *arg
,
741 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
742 struct lpfc_dmabuf
*pcmd
, *prsp
;
745 struct serv_parm
*sp
;
748 cmdiocb
= (struct lpfc_iocbq
*) arg
;
749 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
751 if (ndlp
->nlp_flag
& NLP_ACC_REGLOGIN
) {
752 /* Recovery from PLOGI collision logic */
753 return ndlp
->nlp_state
;
756 irsp
= &rspiocb
->iocb
;
761 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
763 prsp
= list_get_first(&pcmd
->list
,
766 lp
= (uint32_t *) prsp
->virt
;
768 sp
= (struct serv_parm
*) ((uint8_t *) lp
+ sizeof (uint32_t));
769 if (!lpfc_check_sparm(phba
, ndlp
, sp
, CLASS3
))
772 /* PLOGI chkparm OK */
773 lpfc_printf_log(phba
,
776 "%d:0121 PLOGI chkparm OK "
777 "Data: x%x x%x x%x x%x\n",
779 ndlp
->nlp_DID
, ndlp
->nlp_state
,
780 ndlp
->nlp_flag
, ndlp
->nlp_rpi
);
782 if ((phba
->cfg_fcp_class
== 2) &&
783 (sp
->cls2
.classValid
)) {
784 ndlp
->nlp_fcp_info
|= CLASS2
;
786 ndlp
->nlp_fcp_info
|= CLASS3
;
788 ndlp
->nlp_class_sup
= 0;
789 if (sp
->cls1
.classValid
)
790 ndlp
->nlp_class_sup
|= FC_COS_CLASS1
;
791 if (sp
->cls2
.classValid
)
792 ndlp
->nlp_class_sup
|= FC_COS_CLASS2
;
793 if (sp
->cls3
.classValid
)
794 ndlp
->nlp_class_sup
|= FC_COS_CLASS3
;
795 if (sp
->cls4
.classValid
)
796 ndlp
->nlp_class_sup
|= FC_COS_CLASS4
;
798 ((sp
->cmn
.bbRcvSizeMsb
& 0x0F) << 8) |
799 sp
->cmn
.bbRcvSizeLsb
;
801 if (!(mbox
= mempool_alloc(phba
->mbox_mem_pool
,
805 lpfc_unreg_rpi(phba
, ndlp
);
807 (phba
, irsp
->un
.elsreq64
.remoteID
,
808 (uint8_t *) sp
, mbox
, 0) == 0) {
809 switch (ndlp
->nlp_DID
) {
812 lpfc_mbx_cmpl_ns_reg_login
;
816 lpfc_mbx_cmpl_fdmi_reg_login
;
820 lpfc_mbx_cmpl_reg_login
;
822 mbox
->context2
= ndlp
;
823 if (lpfc_sli_issue_mbox(phba
, mbox
,
824 (MBX_NOWAIT
| MBX_STOP_IOCB
))
825 != MBX_NOT_FINISHED
) {
827 NLP_STE_REG_LOGIN_ISSUE
;
828 lpfc_nlp_list(phba
, ndlp
,
830 return ndlp
->nlp_state
;
832 mempool_free(mbox
, phba
->mbox_mem_pool
);
834 mempool_free(mbox
, phba
->mbox_mem_pool
);
839 /* Free this node since the driver cannot login or has the wrong
841 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
842 return NLP_STE_FREED_NODE
;
846 lpfc_device_rm_plogi_issue(struct lpfc_hba
* phba
,
847 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
849 if(ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
850 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
851 return ndlp
->nlp_state
;
854 /* software abort outstanding PLOGI */
855 lpfc_els_abort(phba
, ndlp
, 1);
857 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
858 return NLP_STE_FREED_NODE
;
863 lpfc_device_recov_plogi_issue(struct lpfc_hba
* phba
,
864 struct lpfc_nodelist
* ndlp
, void *arg
,
867 /* software abort outstanding PLOGI */
868 lpfc_els_abort(phba
, ndlp
, 1);
870 ndlp
->nlp_prev_state
= NLP_STE_PLOGI_ISSUE
;
871 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
872 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
873 spin_lock_irq(phba
->host
->host_lock
);
874 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
875 spin_unlock_irq(phba
->host
->host_lock
);
877 return ndlp
->nlp_state
;
881 lpfc_rcv_plogi_adisc_issue(struct lpfc_hba
* phba
,
882 struct lpfc_nodelist
* ndlp
, void *arg
,
885 struct lpfc_iocbq
*cmdiocb
;
887 /* software abort outstanding ADISC */
888 lpfc_els_abort(phba
, ndlp
, 1);
890 cmdiocb
= (struct lpfc_iocbq
*) arg
;
892 if (lpfc_rcv_plogi(phba
, ndlp
, cmdiocb
)) {
893 return ndlp
->nlp_state
;
895 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
896 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
897 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
898 lpfc_issue_els_plogi(phba
, ndlp
->nlp_DID
, 0);
900 return ndlp
->nlp_state
;
904 lpfc_rcv_prli_adisc_issue(struct lpfc_hba
* phba
,
905 struct lpfc_nodelist
* ndlp
, void *arg
,
908 struct lpfc_iocbq
*cmdiocb
;
910 cmdiocb
= (struct lpfc_iocbq
*) arg
;
912 lpfc_els_rsp_prli_acc(phba
, cmdiocb
, ndlp
);
913 return ndlp
->nlp_state
;
917 lpfc_rcv_logo_adisc_issue(struct lpfc_hba
* phba
,
918 struct lpfc_nodelist
* ndlp
, void *arg
,
921 struct lpfc_iocbq
*cmdiocb
;
923 cmdiocb
= (struct lpfc_iocbq
*) arg
;
925 /* software abort outstanding ADISC */
926 lpfc_els_abort(phba
, ndlp
, 0);
928 lpfc_rcv_logo(phba
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
929 return ndlp
->nlp_state
;
933 lpfc_rcv_padisc_adisc_issue(struct lpfc_hba
* phba
,
934 struct lpfc_nodelist
* ndlp
, void *arg
,
937 struct lpfc_iocbq
*cmdiocb
;
939 cmdiocb
= (struct lpfc_iocbq
*) arg
;
941 lpfc_rcv_padisc(phba
, ndlp
, cmdiocb
);
942 return ndlp
->nlp_state
;
946 lpfc_rcv_prlo_adisc_issue(struct lpfc_hba
* phba
,
947 struct lpfc_nodelist
* ndlp
, void *arg
,
950 struct lpfc_iocbq
*cmdiocb
;
952 cmdiocb
= (struct lpfc_iocbq
*) arg
;
954 /* Treat like rcv logo */
955 lpfc_rcv_logo(phba
, ndlp
, cmdiocb
, ELS_CMD_PRLO
);
956 return ndlp
->nlp_state
;
960 lpfc_cmpl_adisc_adisc_issue(struct lpfc_hba
* phba
,
961 struct lpfc_nodelist
* ndlp
, void *arg
,
964 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
968 cmdiocb
= (struct lpfc_iocbq
*) arg
;
969 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
971 ap
= (ADISC
*)lpfc_check_elscmpl_iocb(phba
, cmdiocb
, rspiocb
);
972 irsp
= &rspiocb
->iocb
;
974 if ((irsp
->ulpStatus
) ||
975 (!lpfc_check_adisc(phba
, ndlp
, &ap
->nodeName
, &ap
->portName
))) {
977 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
);
978 spin_lock_irq(phba
->host
->host_lock
);
979 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
980 spin_unlock_irq(phba
->host
->host_lock
);
981 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
983 memset(&ndlp
->nlp_nodename
, 0, sizeof (struct lpfc_name
));
984 memset(&ndlp
->nlp_portname
, 0, sizeof (struct lpfc_name
));
986 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
987 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
988 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
989 lpfc_unreg_rpi(phba
, ndlp
);
990 return ndlp
->nlp_state
;
993 if (ndlp
->nlp_type
& NLP_FCP_TARGET
) {
994 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
995 ndlp
->nlp_state
= NLP_STE_MAPPED_NODE
;
996 lpfc_nlp_list(phba
, ndlp
, NLP_MAPPED_LIST
);
998 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
999 ndlp
->nlp_state
= NLP_STE_UNMAPPED_NODE
;
1000 lpfc_nlp_list(phba
, ndlp
, NLP_UNMAPPED_LIST
);
1002 return ndlp
->nlp_state
;
1006 lpfc_device_rm_adisc_issue(struct lpfc_hba
* phba
,
1007 struct lpfc_nodelist
* ndlp
, void *arg
,
1010 if(ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1011 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1012 return ndlp
->nlp_state
;
1015 /* software abort outstanding ADISC */
1016 lpfc_els_abort(phba
, ndlp
, 1);
1018 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1019 return NLP_STE_FREED_NODE
;
1024 lpfc_device_recov_adisc_issue(struct lpfc_hba
* phba
,
1025 struct lpfc_nodelist
* ndlp
, void *arg
,
1028 /* software abort outstanding ADISC */
1029 lpfc_els_abort(phba
, ndlp
, 1);
1031 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
1032 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1033 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1034 spin_lock_irq(phba
->host
->host_lock
);
1035 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1036 ndlp
->nlp_flag
|= NLP_NPR_ADISC
;
1037 spin_unlock_irq(phba
->host
->host_lock
);
1039 return ndlp
->nlp_state
;
1043 lpfc_rcv_plogi_reglogin_issue(struct lpfc_hba
* phba
,
1044 struct lpfc_nodelist
* ndlp
, void *arg
,
1047 struct lpfc_iocbq
*cmdiocb
;
1049 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1051 lpfc_rcv_plogi(phba
, ndlp
, cmdiocb
);
1052 return ndlp
->nlp_state
;
1056 lpfc_rcv_prli_reglogin_issue(struct lpfc_hba
* phba
,
1057 struct lpfc_nodelist
* ndlp
, void *arg
,
1060 struct lpfc_iocbq
*cmdiocb
;
1062 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1064 lpfc_els_rsp_prli_acc(phba
, cmdiocb
, ndlp
);
1065 return ndlp
->nlp_state
;
1069 lpfc_rcv_logo_reglogin_issue(struct lpfc_hba
* phba
,
1070 struct lpfc_nodelist
* ndlp
, void *arg
,
1073 struct lpfc_iocbq
*cmdiocb
;
1075 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1077 lpfc_rcv_logo(phba
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1078 return ndlp
->nlp_state
;
1082 lpfc_rcv_padisc_reglogin_issue(struct lpfc_hba
* phba
,
1083 struct lpfc_nodelist
* ndlp
, void *arg
,
1086 struct lpfc_iocbq
*cmdiocb
;
1088 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1090 lpfc_rcv_padisc(phba
, ndlp
, cmdiocb
);
1091 return ndlp
->nlp_state
;
1095 lpfc_rcv_prlo_reglogin_issue(struct lpfc_hba
* phba
,
1096 struct lpfc_nodelist
* ndlp
, void *arg
,
1099 struct lpfc_iocbq
*cmdiocb
;
1101 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1102 lpfc_els_rsp_acc(phba
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
, 0);
1103 return ndlp
->nlp_state
;
1107 lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_hba
* phba
,
1108 struct lpfc_nodelist
* ndlp
,
1109 void *arg
, uint32_t evt
)
1115 pmb
= (LPFC_MBOXQ_t
*) arg
;
1117 did
= mb
->un
.varWords
[1];
1118 if (mb
->mbxStatus
) {
1119 /* RegLogin failed */
1120 lpfc_printf_log(phba
,
1123 "%d:0246 RegLogin failed Data: x%x x%x x%x\n",
1125 did
, mb
->mbxStatus
, phba
->hba_state
);
1128 * If RegLogin failed due to lack of HBA resources do not
1131 if (mb
->mbxStatus
== MBXERR_RPI_FULL
) {
1132 ndlp
->nlp_prev_state
= NLP_STE_UNUSED_NODE
;
1133 ndlp
->nlp_state
= NLP_STE_UNUSED_NODE
;
1134 lpfc_nlp_list(phba
, ndlp
, NLP_UNUSED_LIST
);
1135 return ndlp
->nlp_state
;
1138 /* Put ndlp in npr list set plogi timer for 1 sec */
1139 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
1140 spin_lock_irq(phba
->host
->host_lock
);
1141 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
1142 spin_unlock_irq(phba
->host
->host_lock
);
1143 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
1145 lpfc_issue_els_logo(phba
, ndlp
, 0);
1146 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1147 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1148 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1149 return ndlp
->nlp_state
;
1152 ndlp
->nlp_rpi
= mb
->un
.varWords
[0];
1154 /* Only if we are not a fabric nport do we issue PRLI */
1155 if (!(ndlp
->nlp_type
& NLP_FABRIC
)) {
1156 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1157 ndlp
->nlp_state
= NLP_STE_PRLI_ISSUE
;
1158 lpfc_nlp_list(phba
, ndlp
, NLP_PRLI_LIST
);
1159 lpfc_issue_els_prli(phba
, ndlp
, 0);
1161 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1162 ndlp
->nlp_state
= NLP_STE_UNMAPPED_NODE
;
1163 lpfc_nlp_list(phba
, ndlp
, NLP_UNMAPPED_LIST
);
1165 return ndlp
->nlp_state
;
1169 lpfc_device_rm_reglogin_issue(struct lpfc_hba
* phba
,
1170 struct lpfc_nodelist
* ndlp
, void *arg
,
1173 if(ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1174 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1175 return ndlp
->nlp_state
;
1178 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1179 return NLP_STE_FREED_NODE
;
1184 lpfc_device_recov_reglogin_issue(struct lpfc_hba
* phba
,
1185 struct lpfc_nodelist
* ndlp
, void *arg
,
1188 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1189 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1190 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1191 spin_lock_irq(phba
->host
->host_lock
);
1192 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1193 spin_unlock_irq(phba
->host
->host_lock
);
1194 return ndlp
->nlp_state
;
1198 lpfc_rcv_plogi_prli_issue(struct lpfc_hba
* phba
,
1199 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1201 struct lpfc_iocbq
*cmdiocb
;
1203 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1205 lpfc_rcv_plogi(phba
, ndlp
, cmdiocb
);
1206 return ndlp
->nlp_state
;
1210 lpfc_rcv_prli_prli_issue(struct lpfc_hba
* phba
,
1211 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1213 struct lpfc_iocbq
*cmdiocb
;
1215 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1217 lpfc_els_rsp_prli_acc(phba
, cmdiocb
, ndlp
);
1218 return ndlp
->nlp_state
;
1222 lpfc_rcv_logo_prli_issue(struct lpfc_hba
* phba
,
1223 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1225 struct lpfc_iocbq
*cmdiocb
;
1227 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1229 /* Software abort outstanding PRLI before sending acc */
1230 lpfc_els_abort(phba
, ndlp
, 1);
1232 lpfc_rcv_logo(phba
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1233 return ndlp
->nlp_state
;
1237 lpfc_rcv_padisc_prli_issue(struct lpfc_hba
* phba
,
1238 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1240 struct lpfc_iocbq
*cmdiocb
;
1242 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1244 lpfc_rcv_padisc(phba
, ndlp
, cmdiocb
);
1245 return ndlp
->nlp_state
;
1248 /* This routine is envoked when we rcv a PRLO request from a nport
1249 * we are logged into. We should send back a PRLO rsp setting the
1251 * NEXT STATE = PRLI_ISSUE
1254 lpfc_rcv_prlo_prli_issue(struct lpfc_hba
* phba
,
1255 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1257 struct lpfc_iocbq
*cmdiocb
;
1259 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1260 lpfc_els_rsp_acc(phba
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
, 0);
1261 return ndlp
->nlp_state
;
1265 lpfc_cmpl_prli_prli_issue(struct lpfc_hba
* phba
,
1266 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1268 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1272 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1273 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1274 npr
= (PRLI
*)lpfc_check_elscmpl_iocb(phba
, cmdiocb
, rspiocb
);
1276 irsp
= &rspiocb
->iocb
;
1277 if (irsp
->ulpStatus
) {
1278 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1279 ndlp
->nlp_state
= NLP_STE_UNMAPPED_NODE
;
1280 lpfc_nlp_list(phba
, ndlp
, NLP_UNMAPPED_LIST
);
1281 return ndlp
->nlp_state
;
1284 /* Check out PRLI rsp */
1285 ndlp
->nlp_type
&= ~(NLP_FCP_TARGET
| NLP_FCP_INITIATOR
);
1286 ndlp
->nlp_fcp_info
&= ~NLP_FCP_2_DEVICE
;
1287 if ((npr
->acceptRspCode
== PRLI_REQ_EXECUTED
) &&
1288 (npr
->prliType
== PRLI_FCP_TYPE
)) {
1289 if (npr
->initiatorFunc
)
1290 ndlp
->nlp_type
|= NLP_FCP_INITIATOR
;
1291 if (npr
->targetFunc
)
1292 ndlp
->nlp_type
|= NLP_FCP_TARGET
;
1294 ndlp
->nlp_fcp_info
|= NLP_FCP_2_DEVICE
;
1297 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1298 ndlp
->nlp_state
= NLP_STE_MAPPED_NODE
;
1299 lpfc_nlp_list(phba
, ndlp
, NLP_MAPPED_LIST
);
1300 return ndlp
->nlp_state
;
1303 /*! lpfc_device_rm_prli_issue
1314 * This routine is envoked when we a request to remove a nport we are in the
1315 * process of PRLIing. We should software abort outstanding prli, unreg
1316 * login, send a logout. We will change node state to UNUSED_NODE, put it
1317 * on plogi list so it can be freed when LOGO completes.
1321 lpfc_device_rm_prli_issue(struct lpfc_hba
* phba
,
1322 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1324 if(ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1325 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1326 return ndlp
->nlp_state
;
1329 /* software abort outstanding PLOGI */
1330 lpfc_els_abort(phba
, ndlp
, 1);
1332 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1333 return NLP_STE_FREED_NODE
;
1338 /*! lpfc_device_recov_prli_issue
1349 * The routine is envoked when the state of a device is unknown, like
1350 * during a link down. We should remove the nodelist entry from the
1351 * unmapped list, issue a UNREG_LOGIN, do a software abort of the
1352 * outstanding PRLI command, then free the node entry.
1355 lpfc_device_recov_prli_issue(struct lpfc_hba
* phba
,
1356 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1358 /* software abort outstanding PRLI */
1359 lpfc_els_abort(phba
, ndlp
, 1);
1361 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1362 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1363 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1364 spin_lock_irq(phba
->host
->host_lock
);
1365 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1366 spin_unlock_irq(phba
->host
->host_lock
);
1367 return ndlp
->nlp_state
;
1371 lpfc_rcv_plogi_unmap_node(struct lpfc_hba
* phba
,
1372 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1374 struct lpfc_iocbq
*cmdiocb
;
1376 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1378 lpfc_rcv_plogi(phba
, ndlp
, cmdiocb
);
1379 return ndlp
->nlp_state
;
1383 lpfc_rcv_prli_unmap_node(struct lpfc_hba
* phba
,
1384 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1386 struct lpfc_iocbq
*cmdiocb
;
1388 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1390 lpfc_rcv_prli(phba
, ndlp
, cmdiocb
);
1391 lpfc_els_rsp_prli_acc(phba
, cmdiocb
, ndlp
);
1392 return ndlp
->nlp_state
;
1396 lpfc_rcv_logo_unmap_node(struct lpfc_hba
* phba
,
1397 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1399 struct lpfc_iocbq
*cmdiocb
;
1401 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1403 lpfc_rcv_logo(phba
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1404 return ndlp
->nlp_state
;
1408 lpfc_rcv_padisc_unmap_node(struct lpfc_hba
* phba
,
1409 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1411 struct lpfc_iocbq
*cmdiocb
;
1413 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1415 lpfc_rcv_padisc(phba
, ndlp
, cmdiocb
);
1416 return ndlp
->nlp_state
;
1420 lpfc_rcv_prlo_unmap_node(struct lpfc_hba
* phba
,
1421 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1423 struct lpfc_iocbq
*cmdiocb
;
1425 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1427 lpfc_els_rsp_acc(phba
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
, 0);
1428 return ndlp
->nlp_state
;
1432 lpfc_device_recov_unmap_node(struct lpfc_hba
* phba
,
1433 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1435 ndlp
->nlp_prev_state
= NLP_STE_UNMAPPED_NODE
;
1436 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1437 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1438 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1439 lpfc_disc_set_adisc(phba
, ndlp
);
1441 return ndlp
->nlp_state
;
1445 lpfc_rcv_plogi_mapped_node(struct lpfc_hba
* phba
,
1446 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1448 struct lpfc_iocbq
*cmdiocb
;
1450 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1452 lpfc_rcv_plogi(phba
, ndlp
, cmdiocb
);
1453 return ndlp
->nlp_state
;
1457 lpfc_rcv_prli_mapped_node(struct lpfc_hba
* phba
,
1458 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1460 struct lpfc_iocbq
*cmdiocb
;
1462 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1464 lpfc_els_rsp_prli_acc(phba
, cmdiocb
, ndlp
);
1465 return ndlp
->nlp_state
;
1469 lpfc_rcv_logo_mapped_node(struct lpfc_hba
* phba
,
1470 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1472 struct lpfc_iocbq
*cmdiocb
;
1474 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1476 lpfc_rcv_logo(phba
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1477 return ndlp
->nlp_state
;
1481 lpfc_rcv_padisc_mapped_node(struct lpfc_hba
* phba
,
1482 struct lpfc_nodelist
* ndlp
, void *arg
,
1485 struct lpfc_iocbq
*cmdiocb
;
1487 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1489 lpfc_rcv_padisc(phba
, ndlp
, cmdiocb
);
1490 return ndlp
->nlp_state
;
1494 lpfc_rcv_prlo_mapped_node(struct lpfc_hba
* phba
,
1495 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1497 struct lpfc_iocbq
*cmdiocb
;
1499 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1501 /* flush the target */
1502 spin_lock_irq(phba
->host
->host_lock
);
1503 lpfc_sli_abort_iocb(phba
, &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
1504 ndlp
->nlp_sid
, 0, 0, LPFC_CTX_TGT
);
1505 spin_unlock_irq(phba
->host
->host_lock
);
1507 /* Treat like rcv logo */
1508 lpfc_rcv_logo(phba
, ndlp
, cmdiocb
, ELS_CMD_PRLO
);
1509 return ndlp
->nlp_state
;
1513 lpfc_device_recov_mapped_node(struct lpfc_hba
* phba
,
1514 struct lpfc_nodelist
* ndlp
, void *arg
,
1517 ndlp
->nlp_prev_state
= NLP_STE_MAPPED_NODE
;
1518 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1519 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1520 spin_lock_irq(phba
->host
->host_lock
);
1521 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1522 spin_unlock_irq(phba
->host
->host_lock
);
1523 lpfc_disc_set_adisc(phba
, ndlp
);
1524 return ndlp
->nlp_state
;
1528 lpfc_rcv_plogi_npr_node(struct lpfc_hba
* phba
,
1529 struct lpfc_nodelist
* ndlp
, void *arg
,
1532 struct lpfc_iocbq
*cmdiocb
;
1534 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1536 /* Ignore PLOGI if we have an outstanding LOGO */
1537 if (ndlp
->nlp_flag
& NLP_LOGO_SND
) {
1538 return ndlp
->nlp_state
;
1541 if (lpfc_rcv_plogi(phba
, ndlp
, cmdiocb
)) {
1542 spin_lock_irq(phba
->host
->host_lock
);
1543 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1544 spin_unlock_irq(phba
->host
->host_lock
);
1545 return ndlp
->nlp_state
;
1548 /* send PLOGI immediately, move to PLOGI issue state */
1549 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
)) {
1550 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1551 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
1552 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
1553 lpfc_issue_els_plogi(phba
, ndlp
->nlp_DID
, 0);
1556 return ndlp
->nlp_state
;
1560 lpfc_rcv_prli_npr_node(struct lpfc_hba
* phba
,
1561 struct lpfc_nodelist
* ndlp
, void *arg
,
1564 struct lpfc_iocbq
*cmdiocb
;
1567 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1569 memset(&stat
, 0, sizeof (struct ls_rjt
));
1570 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
1571 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
1572 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
1574 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
)) {
1575 if (ndlp
->nlp_flag
& NLP_NPR_ADISC
) {
1576 spin_lock_irq(phba
->host
->host_lock
);
1577 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1578 spin_unlock_irq(phba
->host
->host_lock
);
1579 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1580 ndlp
->nlp_state
= NLP_STE_ADISC_ISSUE
;
1581 lpfc_nlp_list(phba
, ndlp
, NLP_ADISC_LIST
);
1582 lpfc_issue_els_adisc(phba
, ndlp
, 0);
1584 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1585 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
1586 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
1587 lpfc_issue_els_plogi(phba
, ndlp
->nlp_DID
, 0);
1591 return ndlp
->nlp_state
;
1595 lpfc_rcv_logo_npr_node(struct lpfc_hba
* phba
,
1596 struct lpfc_nodelist
* ndlp
, void *arg
,
1599 struct lpfc_iocbq
*cmdiocb
;
1601 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1603 lpfc_rcv_logo(phba
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1604 return ndlp
->nlp_state
;
1608 lpfc_rcv_padisc_npr_node(struct lpfc_hba
* phba
,
1609 struct lpfc_nodelist
* ndlp
, void *arg
,
1612 struct lpfc_iocbq
*cmdiocb
;
1614 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1616 lpfc_rcv_padisc(phba
, ndlp
, cmdiocb
);
1619 * Do not start discovery if discovery is about to start
1620 * or discovery in progress for this node. Starting discovery
1621 * here will affect the counting of discovery threads.
1623 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
) &&
1624 !(ndlp
->nlp_flag
& NLP_NPR_2B_DISC
)){
1625 if (ndlp
->nlp_flag
& NLP_NPR_ADISC
) {
1626 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1627 ndlp
->nlp_state
= NLP_STE_ADISC_ISSUE
;
1628 lpfc_nlp_list(phba
, ndlp
, NLP_ADISC_LIST
);
1629 lpfc_issue_els_adisc(phba
, ndlp
, 0);
1631 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1632 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
1633 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
1634 lpfc_issue_els_plogi(phba
, ndlp
->nlp_DID
, 0);
1637 return ndlp
->nlp_state
;
1641 lpfc_rcv_prlo_npr_node(struct lpfc_hba
* phba
,
1642 struct lpfc_nodelist
* ndlp
, void *arg
,
1645 struct lpfc_iocbq
*cmdiocb
;
1647 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1649 spin_lock_irq(phba
->host
->host_lock
);
1650 ndlp
->nlp_flag
|= NLP_LOGO_ACC
;
1651 spin_unlock_irq(phba
->host
->host_lock
);
1653 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
1655 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
)) {
1656 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
1657 spin_lock_irq(phba
->host
->host_lock
);
1658 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
1659 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1660 spin_unlock_irq(phba
->host
->host_lock
);
1661 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
1663 spin_lock_irq(phba
->host
->host_lock
);
1664 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1665 spin_unlock_irq(phba
->host
->host_lock
);
1667 return ndlp
->nlp_state
;
1671 lpfc_cmpl_plogi_npr_node(struct lpfc_hba
* phba
,
1672 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1674 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1677 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1678 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1680 irsp
= &rspiocb
->iocb
;
1681 if (irsp
->ulpStatus
) {
1682 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1683 return NLP_STE_FREED_NODE
;
1685 return ndlp
->nlp_state
;
1689 lpfc_cmpl_prli_npr_node(struct lpfc_hba
* phba
,
1690 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1692 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1695 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1696 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1698 irsp
= &rspiocb
->iocb
;
1699 if (irsp
->ulpStatus
&& (ndlp
->nlp_flag
& NLP_NODEV_REMOVE
)) {
1700 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1701 return NLP_STE_FREED_NODE
;
1703 return ndlp
->nlp_state
;
1707 lpfc_cmpl_logo_npr_node(struct lpfc_hba
* phba
,
1708 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1710 lpfc_unreg_rpi(phba
, ndlp
);
1711 /* This routine does nothing, just return the current state */
1712 return ndlp
->nlp_state
;
1716 lpfc_cmpl_adisc_npr_node(struct lpfc_hba
* phba
,
1717 struct lpfc_nodelist
* ndlp
, void *arg
,
1720 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1723 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1724 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1726 irsp
= &rspiocb
->iocb
;
1727 if (irsp
->ulpStatus
&& (ndlp
->nlp_flag
& NLP_NODEV_REMOVE
)) {
1728 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1729 return NLP_STE_FREED_NODE
;
1731 return ndlp
->nlp_state
;
1735 lpfc_cmpl_reglogin_npr_node(struct lpfc_hba
* phba
,
1736 struct lpfc_nodelist
* ndlp
, void *arg
,
1742 pmb
= (LPFC_MBOXQ_t
*) arg
;
1746 ndlp
->nlp_rpi
= mb
->un
.varWords
[0];
1748 if (ndlp
->nlp_flag
& NLP_NODEV_REMOVE
) {
1749 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1750 return NLP_STE_FREED_NODE
;
1753 return ndlp
->nlp_state
;
1757 lpfc_device_rm_npr_node(struct lpfc_hba
* phba
,
1758 struct lpfc_nodelist
* ndlp
, void *arg
,
1761 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1762 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1763 return ndlp
->nlp_state
;
1765 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1766 return NLP_STE_FREED_NODE
;
1770 lpfc_device_recov_npr_node(struct lpfc_hba
* phba
,
1771 struct lpfc_nodelist
* ndlp
, void *arg
,
1774 spin_lock_irq(phba
->host
->host_lock
);
1775 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1776 spin_unlock_irq(phba
->host
->host_lock
);
1777 if (ndlp
->nlp_flag
& NLP_DELAY_TMO
) {
1778 lpfc_cancel_retry_delay_tmo(phba
, ndlp
);
1780 return ndlp
->nlp_state
;
1784 /* This next section defines the NPort Discovery State Machine */
1786 /* There are 4 different double linked lists nodelist entries can reside on.
1787 * The plogi list and adisc list are used when Link Up discovery or RSCN
1788 * processing is needed. Each list holds the nodes that we will send PLOGI
1789 * or ADISC on. These lists will keep track of what nodes will be effected
1790 * by an RSCN, or a Link Up (Typically, all nodes are effected on Link Up).
1791 * The unmapped_list will contain all nodes that we have successfully logged
1792 * into at the Fibre Channel level. The mapped_list will contain all nodes
1793 * that are mapped FCP targets.
1796 * The bind list is a list of undiscovered (potentially non-existent) nodes
1797 * that we have saved binding information on. This information is used when
1798 * nodes transition from the unmapped to the mapped list.
1800 /* For UNUSED_NODE state, the node has just been allocated .
1801 * For PLOGI_ISSUE and REG_LOGIN_ISSUE, the node is on
1802 * the PLOGI list. For REG_LOGIN_COMPL, the node is taken off the PLOGI list
1803 * and put on the unmapped list. For ADISC processing, the node is taken off
1804 * the ADISC list and placed on either the mapped or unmapped list (depending
1805 * on its previous state). Once on the unmapped list, a PRLI is issued and the
1806 * state changed to PRLI_ISSUE. When the PRLI completion occurs, the state is
1807 * changed to UNMAPPED_NODE. If the completion indicates a mapped
1808 * node, the node is taken off the unmapped list. The binding list is checked
1809 * for a valid binding, or a binding is automatically assigned. If binding
1810 * assignment is unsuccessful, the node is left on the unmapped list. If
1811 * binding assignment is successful, the associated binding list entry (if
1812 * any) is removed, and the node is placed on the mapped list.
1815 * For a Link Down, all nodes on the ADISC, PLOGI, unmapped or mapped
1816 * lists will receive a DEVICE_RECOVERY event. If the linkdown or devloss timers
1817 * expire, all effected nodes will receive a DEVICE_RM event.
1820 * For a Link Up or RSCN, all nodes will move from the mapped / unmapped lists
1821 * to either the ADISC or PLOGI list. After a Nameserver query or ALPA loopmap
1822 * check, additional nodes may be added or removed (via DEVICE_RM) to / from
1823 * the PLOGI or ADISC lists. Once the PLOGI and ADISC lists are populated,
1824 * we will first process the ADISC list. 32 entries are processed initially and
1825 * ADISC is initited for each one. Completions / Events for each node are
1826 * funnelled thru the state machine. As each node finishes ADISC processing, it
1827 * starts ADISC for any nodes waiting for ADISC processing. If no nodes are
1828 * waiting, and the ADISC list count is identically 0, then we are done. For
1829 * Link Up discovery, since all nodes on the PLOGI list are UNREG_LOGIN'ed, we
1830 * can issue a CLEAR_LA and reenable Link Events. Next we will process the PLOGI
1831 * list. 32 entries are processed initially and PLOGI is initited for each one.
1832 * Completions / Events for each node are funnelled thru the state machine. As
1833 * each node finishes PLOGI processing, it starts PLOGI for any nodes waiting
1834 * for PLOGI processing. If no nodes are waiting, and the PLOGI list count is
1835 * indentically 0, then we are done. We have now completed discovery / RSCN
1836 * handling. Upon completion, ALL nodes should be on either the mapped or
1840 static uint32_t (*lpfc_disc_action
[NLP_STE_MAX_STATE
* NLP_EVT_MAX_EVENT
])
1841 (struct lpfc_hba
*, struct lpfc_nodelist
*, void *, uint32_t) = {
1842 /* Action routine Event Current State */
1843 lpfc_rcv_plogi_unused_node
, /* RCV_PLOGI UNUSED_NODE */
1844 lpfc_rcv_els_unused_node
, /* RCV_PRLI */
1845 lpfc_rcv_logo_unused_node
, /* RCV_LOGO */
1846 lpfc_rcv_els_unused_node
, /* RCV_ADISC */
1847 lpfc_rcv_els_unused_node
, /* RCV_PDISC */
1848 lpfc_rcv_els_unused_node
, /* RCV_PRLO */
1849 lpfc_disc_illegal
, /* CMPL_PLOGI */
1850 lpfc_disc_illegal
, /* CMPL_PRLI */
1851 lpfc_cmpl_logo_unused_node
, /* CMPL_LOGO */
1852 lpfc_disc_illegal
, /* CMPL_ADISC */
1853 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
1854 lpfc_device_rm_unused_node
, /* DEVICE_RM */
1855 lpfc_disc_illegal
, /* DEVICE_RECOVERY */
1857 lpfc_rcv_plogi_plogi_issue
, /* RCV_PLOGI PLOGI_ISSUE */
1858 lpfc_rcv_els_plogi_issue
, /* RCV_PRLI */
1859 lpfc_rcv_logo_plogi_issue
, /* RCV_LOGO */
1860 lpfc_rcv_els_plogi_issue
, /* RCV_ADISC */
1861 lpfc_rcv_els_plogi_issue
, /* RCV_PDISC */
1862 lpfc_rcv_els_plogi_issue
, /* RCV_PRLO */
1863 lpfc_cmpl_plogi_plogi_issue
, /* CMPL_PLOGI */
1864 lpfc_disc_illegal
, /* CMPL_PRLI */
1865 lpfc_disc_illegal
, /* CMPL_LOGO */
1866 lpfc_disc_illegal
, /* CMPL_ADISC */
1867 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
1868 lpfc_device_rm_plogi_issue
, /* DEVICE_RM */
1869 lpfc_device_recov_plogi_issue
, /* DEVICE_RECOVERY */
1871 lpfc_rcv_plogi_adisc_issue
, /* RCV_PLOGI ADISC_ISSUE */
1872 lpfc_rcv_prli_adisc_issue
, /* RCV_PRLI */
1873 lpfc_rcv_logo_adisc_issue
, /* RCV_LOGO */
1874 lpfc_rcv_padisc_adisc_issue
, /* RCV_ADISC */
1875 lpfc_rcv_padisc_adisc_issue
, /* RCV_PDISC */
1876 lpfc_rcv_prlo_adisc_issue
, /* RCV_PRLO */
1877 lpfc_disc_illegal
, /* CMPL_PLOGI */
1878 lpfc_disc_illegal
, /* CMPL_PRLI */
1879 lpfc_disc_illegal
, /* CMPL_LOGO */
1880 lpfc_cmpl_adisc_adisc_issue
, /* CMPL_ADISC */
1881 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
1882 lpfc_device_rm_adisc_issue
, /* DEVICE_RM */
1883 lpfc_device_recov_adisc_issue
, /* DEVICE_RECOVERY */
1885 lpfc_rcv_plogi_reglogin_issue
, /* RCV_PLOGI REG_LOGIN_ISSUE */
1886 lpfc_rcv_prli_reglogin_issue
, /* RCV_PLOGI */
1887 lpfc_rcv_logo_reglogin_issue
, /* RCV_LOGO */
1888 lpfc_rcv_padisc_reglogin_issue
, /* RCV_ADISC */
1889 lpfc_rcv_padisc_reglogin_issue
, /* RCV_PDISC */
1890 lpfc_rcv_prlo_reglogin_issue
, /* RCV_PRLO */
1891 lpfc_disc_illegal
, /* CMPL_PLOGI */
1892 lpfc_disc_illegal
, /* CMPL_PRLI */
1893 lpfc_disc_illegal
, /* CMPL_LOGO */
1894 lpfc_disc_illegal
, /* CMPL_ADISC */
1895 lpfc_cmpl_reglogin_reglogin_issue
,/* CMPL_REG_LOGIN */
1896 lpfc_device_rm_reglogin_issue
, /* DEVICE_RM */
1897 lpfc_device_recov_reglogin_issue
,/* DEVICE_RECOVERY */
1899 lpfc_rcv_plogi_prli_issue
, /* RCV_PLOGI PRLI_ISSUE */
1900 lpfc_rcv_prli_prli_issue
, /* RCV_PRLI */
1901 lpfc_rcv_logo_prli_issue
, /* RCV_LOGO */
1902 lpfc_rcv_padisc_prli_issue
, /* RCV_ADISC */
1903 lpfc_rcv_padisc_prli_issue
, /* RCV_PDISC */
1904 lpfc_rcv_prlo_prli_issue
, /* RCV_PRLO */
1905 lpfc_disc_illegal
, /* CMPL_PLOGI */
1906 lpfc_cmpl_prli_prli_issue
, /* CMPL_PRLI */
1907 lpfc_disc_illegal
, /* CMPL_LOGO */
1908 lpfc_disc_illegal
, /* CMPL_ADISC */
1909 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
1910 lpfc_device_rm_prli_issue
, /* DEVICE_RM */
1911 lpfc_device_recov_prli_issue
, /* DEVICE_RECOVERY */
1913 lpfc_rcv_plogi_unmap_node
, /* RCV_PLOGI UNMAPPED_NODE */
1914 lpfc_rcv_prli_unmap_node
, /* RCV_PRLI */
1915 lpfc_rcv_logo_unmap_node
, /* RCV_LOGO */
1916 lpfc_rcv_padisc_unmap_node
, /* RCV_ADISC */
1917 lpfc_rcv_padisc_unmap_node
, /* RCV_PDISC */
1918 lpfc_rcv_prlo_unmap_node
, /* RCV_PRLO */
1919 lpfc_disc_illegal
, /* CMPL_PLOGI */
1920 lpfc_disc_illegal
, /* CMPL_PRLI */
1921 lpfc_disc_illegal
, /* CMPL_LOGO */
1922 lpfc_disc_illegal
, /* CMPL_ADISC */
1923 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
1924 lpfc_disc_illegal
, /* DEVICE_RM */
1925 lpfc_device_recov_unmap_node
, /* DEVICE_RECOVERY */
1927 lpfc_rcv_plogi_mapped_node
, /* RCV_PLOGI MAPPED_NODE */
1928 lpfc_rcv_prli_mapped_node
, /* RCV_PRLI */
1929 lpfc_rcv_logo_mapped_node
, /* RCV_LOGO */
1930 lpfc_rcv_padisc_mapped_node
, /* RCV_ADISC */
1931 lpfc_rcv_padisc_mapped_node
, /* RCV_PDISC */
1932 lpfc_rcv_prlo_mapped_node
, /* RCV_PRLO */
1933 lpfc_disc_illegal
, /* CMPL_PLOGI */
1934 lpfc_disc_illegal
, /* CMPL_PRLI */
1935 lpfc_disc_illegal
, /* CMPL_LOGO */
1936 lpfc_disc_illegal
, /* CMPL_ADISC */
1937 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
1938 lpfc_disc_illegal
, /* DEVICE_RM */
1939 lpfc_device_recov_mapped_node
, /* DEVICE_RECOVERY */
1941 lpfc_rcv_plogi_npr_node
, /* RCV_PLOGI NPR_NODE */
1942 lpfc_rcv_prli_npr_node
, /* RCV_PRLI */
1943 lpfc_rcv_logo_npr_node
, /* RCV_LOGO */
1944 lpfc_rcv_padisc_npr_node
, /* RCV_ADISC */
1945 lpfc_rcv_padisc_npr_node
, /* RCV_PDISC */
1946 lpfc_rcv_prlo_npr_node
, /* RCV_PRLO */
1947 lpfc_cmpl_plogi_npr_node
, /* CMPL_PLOGI */
1948 lpfc_cmpl_prli_npr_node
, /* CMPL_PRLI */
1949 lpfc_cmpl_logo_npr_node
, /* CMPL_LOGO */
1950 lpfc_cmpl_adisc_npr_node
, /* CMPL_ADISC */
1951 lpfc_cmpl_reglogin_npr_node
, /* CMPL_REG_LOGIN */
1952 lpfc_device_rm_npr_node
, /* DEVICE_RM */
1953 lpfc_device_recov_npr_node
, /* DEVICE_RECOVERY */
1957 lpfc_disc_state_machine(struct lpfc_hba
* phba
,
1958 struct lpfc_nodelist
* ndlp
, void *arg
, uint32_t evt
)
1960 uint32_t cur_state
, rc
;
1961 uint32_t(*func
) (struct lpfc_hba
*, struct lpfc_nodelist
*, void *,
1964 ndlp
->nlp_disc_refcnt
++;
1965 cur_state
= ndlp
->nlp_state
;
1967 /* DSM in event <evt> on NPort <nlp_DID> in state <cur_state> */
1968 lpfc_printf_log(phba
,
1971 "%d:0211 DSM in event x%x on NPort x%x in state %d "
1974 evt
, ndlp
->nlp_DID
, cur_state
, ndlp
->nlp_flag
);
1976 func
= lpfc_disc_action
[(cur_state
* NLP_EVT_MAX_EVENT
) + evt
];
1977 rc
= (func
) (phba
, ndlp
, arg
, evt
);
1979 /* DSM out state <rc> on NPort <nlp_DID> */
1980 lpfc_printf_log(phba
,
1983 "%d:0212 DSM out state %d on NPort x%x Data: x%x\n",
1985 rc
, ndlp
->nlp_DID
, ndlp
->nlp_flag
);
1987 ndlp
->nlp_disc_refcnt
--;
1989 /* Check to see if ndlp removal is deferred */
1990 if ((ndlp
->nlp_disc_refcnt
== 0)
1991 && (ndlp
->nlp_flag
& NLP_DELAY_REMOVE
)) {
1992 spin_lock_irq(phba
->host
->host_lock
);
1993 ndlp
->nlp_flag
&= ~NLP_DELAY_REMOVE
;
1994 spin_unlock_irq(phba
->host
->host_lock
);
1995 lpfc_nlp_remove(phba
, ndlp
);
1996 return NLP_STE_FREED_NODE
;
1998 if (rc
== NLP_STE_FREED_NODE
)
1999 return NLP_STE_FREED_NODE
;