1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2007 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_log(vport
->phba
, KERN_ERR
, LOG_DISCOVERY
,
137 "%d (%d):0207 Device %x "
138 "(%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x) sent "
139 "invalid service parameters. Ignoring device.\n",
140 vport
->phba
->brd_no
, ndlp
->vport
->vpi
, ndlp
->nlp_DID
,
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_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
198 "%d (%d):0205 Abort outstanding I/O on NPort x%x "
199 "Data: x%x x%x x%x\n",
200 phba
->brd_no
, ndlp
->vport
->vpi
, ndlp
->nlp_DID
,
201 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
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
;
254 struct serv_parm
*sp
;
259 memset(&stat
, 0, sizeof (struct ls_rjt
));
260 if (vport
->port_state
<= LPFC_FLOGI
) {
261 /* Before responding to PLOGI, check for pt2pt mode.
262 * If we are pt2pt, with an outstanding FLOGI, abort
263 * the FLOGI and resend it first.
265 if (vport
->fc_flag
& FC_PT2PT
) {
266 lpfc_els_abort_flogi(phba
);
267 if (!(vport
->fc_flag
& FC_PT2PT_PLOGI
)) {
268 /* If the other side is supposed to initiate
269 * the PLOGI anyway, just ACC it now and
270 * move on with discovery.
272 phba
->fc_edtov
= FF_DEF_EDTOV
;
273 phba
->fc_ratov
= FF_DEF_RATOV
;
274 /* Start discovery - this should just do
276 lpfc_disc_start(vport
);
278 lpfc_initial_flogi(vport
);
280 stat
.un
.b
.lsRjtRsnCode
= LSRJT_LOGICAL_BSY
;
281 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
282 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
,
287 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
288 lp
= (uint32_t *) pcmd
->virt
;
289 sp
= (struct serv_parm
*) ((uint8_t *) lp
+ sizeof (uint32_t));
290 if ((lpfc_check_sparm(vport
, ndlp
, sp
, CLASS3
) == 0)) {
291 /* Reject this request because invalid parameters */
292 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
293 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_SPARM_OPTIONS
;
294 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
,
298 icmd
= &cmdiocb
->iocb
;
300 /* PLOGI chkparm OK */
301 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
302 "%d (%d):0114 PLOGI chkparm OK Data: x%x x%x x%x x%x\n",
303 phba
->brd_no
, vport
->vpi
,
304 ndlp
->nlp_DID
, ndlp
->nlp_state
, ndlp
->nlp_flag
,
307 if (phba
->cfg_fcp_class
== 2 && sp
->cls2
.classValid
)
308 ndlp
->nlp_fcp_info
|= CLASS2
;
310 ndlp
->nlp_fcp_info
|= CLASS3
;
312 ndlp
->nlp_class_sup
= 0;
313 if (sp
->cls1
.classValid
)
314 ndlp
->nlp_class_sup
|= FC_COS_CLASS1
;
315 if (sp
->cls2
.classValid
)
316 ndlp
->nlp_class_sup
|= FC_COS_CLASS2
;
317 if (sp
->cls3
.classValid
)
318 ndlp
->nlp_class_sup
|= FC_COS_CLASS3
;
319 if (sp
->cls4
.classValid
)
320 ndlp
->nlp_class_sup
|= FC_COS_CLASS4
;
322 ((sp
->cmn
.bbRcvSizeMsb
& 0x0F) << 8) | sp
->cmn
.bbRcvSizeLsb
;
324 /* no need to reg_login if we are already in one of these states */
325 switch (ndlp
->nlp_state
) {
326 case NLP_STE_NPR_NODE
:
327 if (!(ndlp
->nlp_flag
& NLP_NPR_ADISC
))
329 case NLP_STE_REG_LOGIN_ISSUE
:
330 case NLP_STE_PRLI_ISSUE
:
331 case NLP_STE_UNMAPPED_NODE
:
332 case NLP_STE_MAPPED_NODE
:
333 lpfc_els_rsp_acc(vport
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
, NULL
, 0);
337 if ((vport
->fc_flag
& FC_PT2PT
) &&
338 !(vport
->fc_flag
& FC_PT2PT_PLOGI
)) {
339 /* rcv'ed PLOGI decides what our NPortId will be */
340 vport
->fc_myDID
= icmd
->un
.rcvels
.parmRo
;
341 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
344 lpfc_config_link(phba
, mbox
);
345 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
347 rc
= lpfc_sli_issue_mbox
348 (phba
, mbox
, (MBX_NOWAIT
| MBX_STOP_IOCB
));
349 if (rc
== MBX_NOT_FINISHED
) {
350 mempool_free(mbox
, phba
->mbox_mem_pool
);
354 lpfc_can_disctmo(vport
);
356 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
360 rc
= lpfc_reg_login(phba
, vport
->vpi
, icmd
->un
.rcvels
.remoteID
,
361 (uint8_t *) sp
, mbox
, 0);
363 mempool_free(mbox
, phba
->mbox_mem_pool
);
367 /* ACC PLOGI rsp command needs to execute first,
368 * queue this mbox command to be processed later.
370 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_reg_login
;
372 * mbox->context2 = lpfc_nlp_get(ndlp) deferred until mailbox
373 * command issued in lpfc_cmpl_els_acc().
376 spin_lock_irq(shost
->host_lock
);
377 ndlp
->nlp_flag
|= (NLP_ACC_REGLOGIN
| NLP_RCV_PLOGI
);
378 spin_unlock_irq(shost
->host_lock
);
381 * If there is an outstanding PLOGI issued, abort it before
382 * sending ACC rsp for received PLOGI. If pending plogi
383 * is not canceled here, the plogi will be rejected by
384 * remote port and will be retried. On a configuration with
385 * single discovery thread, this will cause a huge delay in
386 * discovery. Also this will cause multiple state machines
387 * running in parallel for this node.
389 if (ndlp
->nlp_state
== NLP_STE_PLOGI_ISSUE
) {
390 /* software abort outstanding PLOGI */
391 lpfc_els_abort(phba
, ndlp
);
394 if ((vport
->port_type
== LPFC_NPIV_PORT
&&
395 phba
->cfg_vport_restrict_login
)) {
397 /* In order to preserve RPIs, we want to cleanup
398 * the default RPI the firmware created to rcv
399 * this ELS request. The only way to do this is
400 * to register, then unregister the RPI.
402 spin_lock_irq(shost
->host_lock
);
403 ndlp
->nlp_flag
|= NLP_RM_DFLT_RPI
;
404 spin_unlock_irq(shost
->host_lock
);
405 stat
.un
.b
.lsRjtRsnCode
= LSRJT_INVALID_CMD
;
406 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
407 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
,
411 lpfc_els_rsp_acc(vport
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
, mbox
, 0);
415 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
416 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_OUT_OF_RESOURCE
;
417 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
, NULL
);
422 lpfc_rcv_padisc(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
423 struct lpfc_iocbq
*cmdiocb
)
425 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
426 struct lpfc_dmabuf
*pcmd
;
427 struct serv_parm
*sp
;
428 struct lpfc_name
*pnn
, *ppn
;
435 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
436 lp
= (uint32_t *) pcmd
->virt
;
439 if (cmd
== ELS_CMD_ADISC
) {
441 pnn
= (struct lpfc_name
*) & ap
->nodeName
;
442 ppn
= (struct lpfc_name
*) & ap
->portName
;
444 sp
= (struct serv_parm
*) lp
;
445 pnn
= (struct lpfc_name
*) & sp
->nodeName
;
446 ppn
= (struct lpfc_name
*) & sp
->portName
;
449 icmd
= &cmdiocb
->iocb
;
450 if (icmd
->ulpStatus
== 0 && lpfc_check_adisc(vport
, ndlp
, pnn
, ppn
)) {
451 if (cmd
== ELS_CMD_ADISC
) {
452 lpfc_els_rsp_adisc_acc(vport
, cmdiocb
, ndlp
);
454 lpfc_els_rsp_acc(vport
, 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(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
, NULL
);
467 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
);
469 spin_lock_irq(shost
->host_lock
);
470 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
471 spin_unlock_irq(shost
->host_lock
);
472 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
473 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
474 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
479 lpfc_rcv_logo(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
480 struct lpfc_iocbq
*cmdiocb
, uint32_t els_cmd
)
482 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
484 /* Put ndlp in NPR state with 1 sec timeout for plogi, ACC logo */
485 /* Only call LOGO ACC for first LOGO, this avoids sending unnecessary
486 * PLOGIs during LOGO storms from a device.
488 spin_lock_irq(shost
->host_lock
);
489 ndlp
->nlp_flag
|= NLP_LOGO_ACC
;
490 spin_unlock_irq(shost
->host_lock
);
491 if (els_cmd
== ELS_CMD_PRLO
)
492 lpfc_els_rsp_acc(vport
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
, 0);
494 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
496 if (!(ndlp
->nlp_type
& NLP_FABRIC
) ||
497 (ndlp
->nlp_state
== NLP_STE_ADISC_ISSUE
)) {
498 /* Only try to re-login if this is NOT a Fabric Node */
499 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
500 spin_lock_irq(shost
->host_lock
);
501 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
502 spin_unlock_irq(shost
->host_lock
);
504 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
505 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
506 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
508 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
509 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
512 spin_lock_irq(shost
->host_lock
);
513 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
514 spin_unlock_irq(shost
->host_lock
);
515 /* The driver has to wait until the ACC completes before it continues
516 * processing the LOGO. The action will resume in
517 * lpfc_cmpl_els_logo_acc routine. Since part of processing includes an
518 * unreg_login, the driver waits so the ACC does not get aborted.
524 lpfc_rcv_prli(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
525 struct lpfc_iocbq
*cmdiocb
)
527 struct lpfc_dmabuf
*pcmd
;
530 struct fc_rport
*rport
= ndlp
->rport
;
533 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
534 lp
= (uint32_t *) pcmd
->virt
;
535 npr
= (PRLI
*) ((uint8_t *) lp
+ sizeof (uint32_t));
537 ndlp
->nlp_type
&= ~(NLP_FCP_TARGET
| NLP_FCP_INITIATOR
);
538 ndlp
->nlp_fcp_info
&= ~NLP_FCP_2_DEVICE
;
539 if (npr
->prliType
== PRLI_FCP_TYPE
) {
540 if (npr
->initiatorFunc
)
541 ndlp
->nlp_type
|= NLP_FCP_INITIATOR
;
543 ndlp
->nlp_type
|= NLP_FCP_TARGET
;
545 ndlp
->nlp_fcp_info
|= NLP_FCP_2_DEVICE
;
548 /* We need to update the rport role values */
549 roles
= FC_RPORT_ROLE_UNKNOWN
;
550 if (ndlp
->nlp_type
& NLP_FCP_INITIATOR
)
551 roles
|= FC_RPORT_ROLE_FCP_INITIATOR
;
552 if (ndlp
->nlp_type
& NLP_FCP_TARGET
)
553 roles
|= FC_RPORT_ROLE_FCP_TARGET
;
555 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_RPORT
,
556 "rport rolechg: role:x%x did:x%x flg:x%x",
557 roles
, ndlp
->nlp_DID
, ndlp
->nlp_flag
);
559 fc_remote_port_rolechg(rport
, roles
);
564 lpfc_disc_set_adisc(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
)
566 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
567 struct lpfc_hba
*phba
= vport
->phba
;
569 /* Check config parameter use-adisc or FCP-2 */
570 if ((phba
->cfg_use_adisc
&& (vport
->fc_flag
& FC_RSCN_MODE
)) ||
571 ndlp
->nlp_fcp_info
& NLP_FCP_2_DEVICE
) {
572 spin_lock_irq(shost
->host_lock
);
573 ndlp
->nlp_flag
|= NLP_NPR_ADISC
;
574 spin_unlock_irq(shost
->host_lock
);
577 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
578 lpfc_unreg_rpi(vport
, ndlp
);
583 lpfc_disc_illegal(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
584 void *arg
, uint32_t evt
)
586 lpfc_printf_log(vport
->phba
, KERN_ERR
, LOG_DISCOVERY
,
587 "%d (%d):0253 Illegal State Transition: node x%x "
588 "event x%x, state x%x Data: x%x x%x\n",
589 vport
->phba
->brd_no
, vport
->vpi
,
590 ndlp
->nlp_DID
, evt
, ndlp
->nlp_state
, ndlp
->nlp_rpi
,
592 return ndlp
->nlp_state
;
595 /* Start of Discovery State Machine routines */
598 lpfc_rcv_plogi_unused_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
599 void *arg
, uint32_t evt
)
601 struct lpfc_iocbq
*cmdiocb
;
603 cmdiocb
= (struct lpfc_iocbq
*) arg
;
605 if (lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
)) {
606 ndlp
->nlp_prev_state
= NLP_STE_UNUSED_NODE
;
607 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
608 return ndlp
->nlp_state
;
610 lpfc_drop_node(vport
, ndlp
);
611 return NLP_STE_FREED_NODE
;
615 lpfc_rcv_els_unused_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
616 void *arg
, uint32_t evt
)
618 lpfc_issue_els_logo(vport
, ndlp
, 0);
619 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
620 return ndlp
->nlp_state
;
624 lpfc_rcv_logo_unused_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
625 void *arg
, uint32_t evt
)
627 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
628 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
630 spin_lock_irq(shost
->host_lock
);
631 ndlp
->nlp_flag
|= NLP_LOGO_ACC
;
632 spin_unlock_irq(shost
->host_lock
);
633 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
634 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
636 return ndlp
->nlp_state
;
640 lpfc_cmpl_logo_unused_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
641 void *arg
, uint32_t evt
)
643 lpfc_drop_node(vport
, ndlp
);
644 return NLP_STE_FREED_NODE
;
648 lpfc_device_rm_unused_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
649 void *arg
, uint32_t evt
)
651 lpfc_drop_node(vport
, ndlp
);
652 return NLP_STE_FREED_NODE
;
656 lpfc_rcv_plogi_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
657 void *arg
, uint32_t evt
)
659 struct lpfc_hba
*phba
= vport
->phba
;
660 struct lpfc_iocbq
*cmdiocb
= arg
;
661 struct lpfc_dmabuf
*pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
662 uint32_t *lp
= (uint32_t *) pcmd
->virt
;
663 struct serv_parm
*sp
= (struct serv_parm
*) (lp
+ 1);
667 memset(&stat
, 0, sizeof (struct ls_rjt
));
669 /* For a PLOGI, we only accept if our portname is less
670 * than the remote portname.
672 phba
->fc_stat
.elsLogiCol
++;
673 port_cmp
= memcmp(&vport
->fc_portname
, &sp
->portName
,
674 sizeof(struct lpfc_name
));
677 /* Reject this request because the remote node will accept
679 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
680 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CMD_IN_PROGRESS
;
681 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
,
684 lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
);
685 } /* If our portname was less */
687 return ndlp
->nlp_state
;
691 lpfc_rcv_prli_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
692 void *arg
, uint32_t evt
)
694 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
697 memset(&stat
, 0, sizeof (struct ls_rjt
));
698 stat
.un
.b
.lsRjtRsnCode
= LSRJT_LOGICAL_BSY
;
699 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
700 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
, NULL
);
701 return ndlp
->nlp_state
;
705 lpfc_rcv_logo_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
706 void *arg
, uint32_t evt
)
708 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
710 /* software abort outstanding PLOGI */
711 lpfc_els_abort(vport
->phba
, ndlp
);
713 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
714 return ndlp
->nlp_state
;
718 lpfc_rcv_els_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
719 void *arg
, uint32_t evt
)
721 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
722 struct lpfc_hba
*phba
= vport
->phba
;
723 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
725 /* software abort outstanding PLOGI */
726 lpfc_els_abort(phba
, ndlp
);
728 if (evt
== NLP_EVT_RCV_LOGO
) {
729 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
731 lpfc_issue_els_logo(vport
, ndlp
, 0);
734 /* Put ndlp in npr state set plogi timer for 1 sec */
735 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
736 spin_lock_irq(shost
->host_lock
);
737 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
738 spin_unlock_irq(shost
->host_lock
);
739 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
740 ndlp
->nlp_prev_state
= NLP_STE_PLOGI_ISSUE
;
741 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
743 return ndlp
->nlp_state
;
747 lpfc_cmpl_plogi_plogi_issue(struct lpfc_vport
*vport
,
748 struct lpfc_nodelist
*ndlp
,
752 struct lpfc_hba
*phba
= vport
->phba
;
753 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
754 struct lpfc_dmabuf
*pcmd
, *prsp
, *mp
;
757 struct serv_parm
*sp
;
760 cmdiocb
= (struct lpfc_iocbq
*) arg
;
761 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
763 if (ndlp
->nlp_flag
& NLP_ACC_REGLOGIN
) {
764 /* Recovery from PLOGI collision logic */
765 return ndlp
->nlp_state
;
768 irsp
= &rspiocb
->iocb
;
773 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
775 prsp
= list_get_first(&pcmd
->list
, struct lpfc_dmabuf
, list
);
777 lp
= (uint32_t *) prsp
->virt
;
778 sp
= (struct serv_parm
*) ((uint8_t *) lp
+ sizeof (uint32_t));
779 if (!lpfc_check_sparm(vport
, ndlp
, sp
, CLASS3
))
782 /* PLOGI chkparm OK */
783 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
784 "%d (%d):0121 PLOGI chkparm OK "
785 "Data: x%x x%x x%x x%x\n",
786 phba
->brd_no
, vport
->vpi
,
787 ndlp
->nlp_DID
, ndlp
->nlp_state
,
788 ndlp
->nlp_flag
, ndlp
->nlp_rpi
);
790 if (phba
->cfg_fcp_class
== 2 && (sp
->cls2
.classValid
))
791 ndlp
->nlp_fcp_info
|= CLASS2
;
793 ndlp
->nlp_fcp_info
|= CLASS3
;
795 ndlp
->nlp_class_sup
= 0;
796 if (sp
->cls1
.classValid
)
797 ndlp
->nlp_class_sup
|= FC_COS_CLASS1
;
798 if (sp
->cls2
.classValid
)
799 ndlp
->nlp_class_sup
|= FC_COS_CLASS2
;
800 if (sp
->cls3
.classValid
)
801 ndlp
->nlp_class_sup
|= FC_COS_CLASS3
;
802 if (sp
->cls4
.classValid
)
803 ndlp
->nlp_class_sup
|= FC_COS_CLASS4
;
805 ((sp
->cmn
.bbRcvSizeMsb
& 0x0F) << 8) | sp
->cmn
.bbRcvSizeLsb
;
807 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
809 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
810 "%d (%d):0133 PLOGI: no memory for reg_login "
811 "Data: x%x x%x x%x x%x\n",
812 phba
->brd_no
, vport
->vpi
,
813 ndlp
->nlp_DID
, ndlp
->nlp_state
,
814 ndlp
->nlp_flag
, ndlp
->nlp_rpi
);
818 lpfc_unreg_rpi(vport
, ndlp
);
820 if (lpfc_reg_login(phba
, vport
->vpi
, irsp
->un
.elsreq64
.remoteID
,
821 (uint8_t *) sp
, mbox
, 0) == 0) {
822 switch (ndlp
->nlp_DID
) {
824 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_ns_reg_login
;
827 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_fdmi_reg_login
;
830 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_reg_login
;
832 mbox
->context2
= lpfc_nlp_get(ndlp
);
834 if (lpfc_sli_issue_mbox(phba
, mbox
,
835 (MBX_NOWAIT
| MBX_STOP_IOCB
))
836 != MBX_NOT_FINISHED
) {
837 lpfc_nlp_set_state(vport
, ndlp
,
838 NLP_STE_REG_LOGIN_ISSUE
);
839 return ndlp
->nlp_state
;
842 mp
= (struct lpfc_dmabuf
*) mbox
->context1
;
843 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
845 mempool_free(mbox
, phba
->mbox_mem_pool
);
847 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
848 "%d (%d):0134 PLOGI: cannot issue reg_login "
849 "Data: x%x x%x x%x x%x\n",
850 phba
->brd_no
, vport
->vpi
,
851 ndlp
->nlp_DID
, ndlp
->nlp_state
,
852 ndlp
->nlp_flag
, ndlp
->nlp_rpi
);
854 mempool_free(mbox
, phba
->mbox_mem_pool
);
856 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
857 "%d (%d):0135 PLOGI: cannot format reg_login "
858 "Data: x%x x%x x%x x%x\n",
859 phba
->brd_no
, vport
->vpi
,
860 ndlp
->nlp_DID
, ndlp
->nlp_state
,
861 ndlp
->nlp_flag
, ndlp
->nlp_rpi
);
866 if (ndlp
->nlp_DID
== NameServer_DID
) {
867 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
868 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
869 "%d (%d):0261 Cannot Register NameServer login\n",
870 phba
->brd_no
, vport
->vpi
);
873 /* Free this node since the driver cannot login or has the wrong
875 lpfc_drop_node(vport
, ndlp
);
876 return NLP_STE_FREED_NODE
;
880 lpfc_device_rm_plogi_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
881 void *arg
, uint32_t evt
)
883 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
885 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
886 spin_lock_irq(shost
->host_lock
);
887 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
888 spin_unlock_irq(shost
->host_lock
);
889 return ndlp
->nlp_state
;
891 /* software abort outstanding PLOGI */
892 lpfc_els_abort(vport
->phba
, ndlp
);
894 lpfc_drop_node(vport
, ndlp
);
895 return NLP_STE_FREED_NODE
;
900 lpfc_device_recov_plogi_issue(struct lpfc_vport
*vport
,
901 struct lpfc_nodelist
*ndlp
,
905 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
906 struct lpfc_hba
*phba
= vport
->phba
;
908 /* Don't do anything that will mess up processing of the
911 if (vport
->fc_flag
& FC_RSCN_DEFERRED
)
912 return ndlp
->nlp_state
;
914 /* software abort outstanding PLOGI */
915 lpfc_els_abort(phba
, ndlp
);
917 ndlp
->nlp_prev_state
= NLP_STE_PLOGI_ISSUE
;
918 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
919 spin_lock_irq(shost
->host_lock
);
920 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
921 spin_unlock_irq(shost
->host_lock
);
923 return ndlp
->nlp_state
;
927 lpfc_rcv_plogi_adisc_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
928 void *arg
, uint32_t evt
)
930 struct lpfc_hba
*phba
= vport
->phba
;
931 struct lpfc_iocbq
*cmdiocb
;
933 /* software abort outstanding ADISC */
934 lpfc_els_abort(phba
, ndlp
);
936 cmdiocb
= (struct lpfc_iocbq
*) arg
;
938 if (lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
))
939 return ndlp
->nlp_state
;
941 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
942 lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0);
943 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
945 return ndlp
->nlp_state
;
949 lpfc_rcv_prli_adisc_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
950 void *arg
, uint32_t evt
)
952 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
954 lpfc_els_rsp_prli_acc(vport
, cmdiocb
, ndlp
);
955 return ndlp
->nlp_state
;
959 lpfc_rcv_logo_adisc_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
960 void *arg
, uint32_t evt
)
962 struct lpfc_hba
*phba
= vport
->phba
;
963 struct lpfc_iocbq
*cmdiocb
;
965 cmdiocb
= (struct lpfc_iocbq
*) arg
;
967 /* software abort outstanding ADISC */
968 lpfc_els_abort(phba
, ndlp
);
970 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
971 return ndlp
->nlp_state
;
975 lpfc_rcv_padisc_adisc_issue(struct lpfc_vport
*vport
,
976 struct lpfc_nodelist
*ndlp
,
977 void *arg
, uint32_t evt
)
979 struct lpfc_iocbq
*cmdiocb
;
981 cmdiocb
= (struct lpfc_iocbq
*) arg
;
983 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
984 return ndlp
->nlp_state
;
988 lpfc_rcv_prlo_adisc_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
989 void *arg
, uint32_t evt
)
991 struct lpfc_iocbq
*cmdiocb
;
993 cmdiocb
= (struct lpfc_iocbq
*) arg
;
995 /* Treat like rcv logo */
996 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_PRLO
);
997 return ndlp
->nlp_state
;
1001 lpfc_cmpl_adisc_adisc_issue(struct lpfc_vport
*vport
,
1002 struct lpfc_nodelist
*ndlp
,
1003 void *arg
, uint32_t evt
)
1005 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1006 struct lpfc_hba
*phba
= vport
->phba
;
1007 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1011 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1012 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1014 ap
= (ADISC
*)lpfc_check_elscmpl_iocb(phba
, cmdiocb
, rspiocb
);
1015 irsp
= &rspiocb
->iocb
;
1017 if ((irsp
->ulpStatus
) ||
1018 (!lpfc_check_adisc(vport
, ndlp
, &ap
->nodeName
, &ap
->portName
))) {
1020 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
);
1021 spin_lock_irq(shost
->host_lock
);
1022 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
1023 spin_unlock_irq(shost
->host_lock
);
1024 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
1026 memset(&ndlp
->nlp_nodename
, 0, sizeof(struct lpfc_name
));
1027 memset(&ndlp
->nlp_portname
, 0, sizeof(struct lpfc_name
));
1029 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
1030 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1031 lpfc_unreg_rpi(vport
, ndlp
);
1032 return ndlp
->nlp_state
;
1035 if (ndlp
->nlp_type
& NLP_FCP_TARGET
) {
1036 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
1037 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_MAPPED_NODE
);
1039 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
1040 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNMAPPED_NODE
);
1042 return ndlp
->nlp_state
;
1046 lpfc_device_rm_adisc_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1047 void *arg
, uint32_t evt
)
1049 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1051 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1052 spin_lock_irq(shost
->host_lock
);
1053 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1054 spin_unlock_irq(shost
->host_lock
);
1055 return ndlp
->nlp_state
;
1057 /* software abort outstanding ADISC */
1058 lpfc_els_abort(vport
->phba
, ndlp
);
1060 lpfc_drop_node(vport
, ndlp
);
1061 return NLP_STE_FREED_NODE
;
1066 lpfc_device_recov_adisc_issue(struct lpfc_vport
*vport
,
1067 struct lpfc_nodelist
*ndlp
,
1071 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1072 struct lpfc_hba
*phba
= vport
->phba
;
1074 /* Don't do anything that will mess up processing of the
1077 if (vport
->fc_flag
& FC_RSCN_DEFERRED
)
1078 return ndlp
->nlp_state
;
1080 /* software abort outstanding ADISC */
1081 lpfc_els_abort(phba
, ndlp
);
1083 ndlp
->nlp_prev_state
= NLP_STE_ADISC_ISSUE
;
1084 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1085 spin_lock_irq(shost
->host_lock
);
1086 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1087 spin_unlock_irq(shost
->host_lock
);
1088 lpfc_disc_set_adisc(vport
, ndlp
);
1089 return ndlp
->nlp_state
;
1093 lpfc_rcv_plogi_reglogin_issue(struct lpfc_vport
*vport
,
1094 struct lpfc_nodelist
*ndlp
,
1098 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1100 lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
);
1101 return ndlp
->nlp_state
;
1105 lpfc_rcv_prli_reglogin_issue(struct lpfc_vport
*vport
,
1106 struct lpfc_nodelist
*ndlp
,
1110 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1112 lpfc_els_rsp_prli_acc(vport
, cmdiocb
, ndlp
);
1113 return ndlp
->nlp_state
;
1117 lpfc_rcv_logo_reglogin_issue(struct lpfc_vport
*vport
,
1118 struct lpfc_nodelist
*ndlp
,
1122 struct lpfc_hba
*phba
= vport
->phba
;
1123 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1125 LPFC_MBOXQ_t
*nextmb
;
1126 struct lpfc_dmabuf
*mp
;
1128 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1130 /* cleanup any ndlp on mbox q waiting for reglogin cmpl */
1131 if ((mb
= phba
->sli
.mbox_active
)) {
1132 if ((mb
->mb
.mbxCommand
== MBX_REG_LOGIN64
) &&
1133 (ndlp
== (struct lpfc_nodelist
*) mb
->context2
)) {
1135 mb
->context2
= NULL
;
1136 mb
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
1140 spin_lock_irq(&phba
->hbalock
);
1141 list_for_each_entry_safe(mb
, nextmb
, &phba
->sli
.mboxq
, list
) {
1142 if ((mb
->mb
.mbxCommand
== MBX_REG_LOGIN64
) &&
1143 (ndlp
== (struct lpfc_nodelist
*) mb
->context2
)) {
1144 mp
= (struct lpfc_dmabuf
*) (mb
->context1
);
1146 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
1150 list_del(&mb
->list
);
1151 mempool_free(mb
, phba
->mbox_mem_pool
);
1154 spin_unlock_irq(&phba
->hbalock
);
1156 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1157 return ndlp
->nlp_state
;
1161 lpfc_rcv_padisc_reglogin_issue(struct lpfc_vport
*vport
,
1162 struct lpfc_nodelist
*ndlp
,
1166 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1168 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1169 return ndlp
->nlp_state
;
1173 lpfc_rcv_prlo_reglogin_issue(struct lpfc_vport
*vport
,
1174 struct lpfc_nodelist
*ndlp
,
1178 struct lpfc_iocbq
*cmdiocb
;
1180 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1181 lpfc_els_rsp_acc(vport
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
, 0);
1182 return ndlp
->nlp_state
;
1186 lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_vport
*vport
,
1187 struct lpfc_nodelist
*ndlp
,
1191 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1192 struct lpfc_hba
*phba
= vport
->phba
;
1193 LPFC_MBOXQ_t
*pmb
= (LPFC_MBOXQ_t
*) arg
;
1194 MAILBOX_t
*mb
= &pmb
->mb
;
1195 uint32_t did
= mb
->un
.varWords
[1];
1197 if (mb
->mbxStatus
) {
1198 /* RegLogin failed */
1199 lpfc_printf_log(phba
, KERN_ERR
, LOG_DISCOVERY
,
1200 "%d (%d):0246 RegLogin failed Data: x%x x%x "
1202 phba
->brd_no
, vport
->vpi
,
1203 did
, mb
->mbxStatus
, vport
->port_state
);
1206 * If RegLogin failed due to lack of HBA resources do not
1209 if (mb
->mbxStatus
== MBXERR_RPI_FULL
) {
1210 ndlp
->nlp_prev_state
= NLP_STE_UNUSED_NODE
;
1211 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
1212 return ndlp
->nlp_state
;
1215 /* Put ndlp in npr state set plogi timer for 1 sec */
1216 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
1217 spin_lock_irq(shost
->host_lock
);
1218 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
1219 spin_unlock_irq(shost
->host_lock
);
1220 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
1222 lpfc_issue_els_logo(vport
, ndlp
, 0);
1223 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1224 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1225 return ndlp
->nlp_state
;
1228 ndlp
->nlp_rpi
= mb
->un
.varWords
[0];
1230 /* Only if we are not a fabric nport do we issue PRLI */
1231 if (!(ndlp
->nlp_type
& NLP_FABRIC
)) {
1232 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1233 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PRLI_ISSUE
);
1234 lpfc_issue_els_prli(vport
, ndlp
, 0);
1236 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1237 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNMAPPED_NODE
);
1239 return ndlp
->nlp_state
;
1243 lpfc_device_rm_reglogin_issue(struct lpfc_vport
*vport
,
1244 struct lpfc_nodelist
*ndlp
,
1248 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1250 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1251 spin_lock_irq(shost
->host_lock
);
1252 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1253 spin_unlock_irq(shost
->host_lock
);
1254 return ndlp
->nlp_state
;
1256 lpfc_drop_node(vport
, ndlp
);
1257 return NLP_STE_FREED_NODE
;
1262 lpfc_device_recov_reglogin_issue(struct lpfc_vport
*vport
,
1263 struct lpfc_nodelist
*ndlp
,
1267 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1269 /* Don't do anything that will mess up processing of the
1272 if (vport
->fc_flag
& FC_RSCN_DEFERRED
)
1273 return ndlp
->nlp_state
;
1275 ndlp
->nlp_prev_state
= NLP_STE_REG_LOGIN_ISSUE
;
1276 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1277 spin_lock_irq(shost
->host_lock
);
1278 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1279 spin_unlock_irq(shost
->host_lock
);
1280 lpfc_disc_set_adisc(vport
, ndlp
);
1281 return ndlp
->nlp_state
;
1285 lpfc_rcv_plogi_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1286 void *arg
, uint32_t evt
)
1288 struct lpfc_iocbq
*cmdiocb
;
1290 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1292 lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
);
1293 return ndlp
->nlp_state
;
1297 lpfc_rcv_prli_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1298 void *arg
, uint32_t evt
)
1300 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1302 lpfc_els_rsp_prli_acc(vport
, cmdiocb
, ndlp
);
1303 return ndlp
->nlp_state
;
1307 lpfc_rcv_logo_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1308 void *arg
, uint32_t evt
)
1310 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1312 /* Software abort outstanding PRLI before sending acc */
1313 lpfc_els_abort(vport
->phba
, ndlp
);
1315 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1316 return ndlp
->nlp_state
;
1320 lpfc_rcv_padisc_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1321 void *arg
, uint32_t evt
)
1323 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1325 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1326 return ndlp
->nlp_state
;
1329 /* This routine is envoked when we rcv a PRLO request from a nport
1330 * we are logged into. We should send back a PRLO rsp setting the
1332 * NEXT STATE = PRLI_ISSUE
1335 lpfc_rcv_prlo_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1336 void *arg
, uint32_t evt
)
1338 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1340 lpfc_els_rsp_acc(vport
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
, 0);
1341 return ndlp
->nlp_state
;
1345 lpfc_cmpl_prli_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1346 void *arg
, uint32_t evt
)
1348 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1349 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1350 struct lpfc_hba
*phba
= vport
->phba
;
1354 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1355 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1356 npr
= (PRLI
*)lpfc_check_elscmpl_iocb(phba
, cmdiocb
, rspiocb
);
1358 irsp
= &rspiocb
->iocb
;
1359 if (irsp
->ulpStatus
) {
1360 if ((vport
->port_type
== LPFC_NPIV_PORT
) &&
1361 phba
->cfg_vport_restrict_login
) {
1364 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1365 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNMAPPED_NODE
);
1366 return ndlp
->nlp_state
;
1369 /* Check out PRLI rsp */
1370 ndlp
->nlp_type
&= ~(NLP_FCP_TARGET
| NLP_FCP_INITIATOR
);
1371 ndlp
->nlp_fcp_info
&= ~NLP_FCP_2_DEVICE
;
1372 if ((npr
->acceptRspCode
== PRLI_REQ_EXECUTED
) &&
1373 (npr
->prliType
== PRLI_FCP_TYPE
)) {
1374 if (npr
->initiatorFunc
)
1375 ndlp
->nlp_type
|= NLP_FCP_INITIATOR
;
1376 if (npr
->targetFunc
)
1377 ndlp
->nlp_type
|= NLP_FCP_TARGET
;
1379 ndlp
->nlp_fcp_info
|= NLP_FCP_2_DEVICE
;
1381 if (!(ndlp
->nlp_type
& NLP_FCP_TARGET
) &&
1382 (vport
->port_type
== LPFC_NPIV_PORT
) &&
1383 phba
->cfg_vport_restrict_login
) {
1385 spin_lock_irq(shost
->host_lock
);
1386 ndlp
->nlp_flag
|= NLP_TARGET_REMOVE
;
1387 spin_unlock_irq(shost
->host_lock
);
1388 lpfc_issue_els_logo(vport
, ndlp
, 0);
1390 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1391 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
1392 return ndlp
->nlp_state
;
1395 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1396 if (ndlp
->nlp_type
& NLP_FCP_TARGET
)
1397 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_MAPPED_NODE
);
1399 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNMAPPED_NODE
);
1400 return ndlp
->nlp_state
;
1403 /*! lpfc_device_rm_prli_issue
1414 * This routine is envoked when we a request to remove a nport we are in the
1415 * process of PRLIing. We should software abort outstanding prli, unreg
1416 * login, send a logout. We will change node state to UNUSED_NODE, put it
1417 * on plogi list so it can be freed when LOGO completes.
1422 lpfc_device_rm_prli_issue(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1423 void *arg
, uint32_t evt
)
1425 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1427 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1428 spin_lock_irq(shost
->host_lock
);
1429 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1430 spin_unlock_irq(shost
->host_lock
);
1431 return ndlp
->nlp_state
;
1433 /* software abort outstanding PLOGI */
1434 lpfc_els_abort(vport
->phba
, ndlp
);
1436 lpfc_drop_node(vport
, ndlp
);
1437 return NLP_STE_FREED_NODE
;
1442 /*! lpfc_device_recov_prli_issue
1453 * The routine is envoked when the state of a device is unknown, like
1454 * during a link down. We should remove the nodelist entry from the
1455 * unmapped list, issue a UNREG_LOGIN, do a software abort of the
1456 * outstanding PRLI command, then free the node entry.
1459 lpfc_device_recov_prli_issue(struct lpfc_vport
*vport
,
1460 struct lpfc_nodelist
*ndlp
,
1464 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1465 struct lpfc_hba
*phba
= vport
->phba
;
1467 /* Don't do anything that will mess up processing of the
1470 if (vport
->fc_flag
& FC_RSCN_DEFERRED
)
1471 return ndlp
->nlp_state
;
1473 /* software abort outstanding PRLI */
1474 lpfc_els_abort(phba
, ndlp
);
1476 ndlp
->nlp_prev_state
= NLP_STE_PRLI_ISSUE
;
1477 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1478 spin_lock_irq(shost
->host_lock
);
1479 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1480 spin_unlock_irq(shost
->host_lock
);
1481 lpfc_disc_set_adisc(vport
, ndlp
);
1482 return ndlp
->nlp_state
;
1486 lpfc_rcv_plogi_unmap_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1487 void *arg
, uint32_t evt
)
1489 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1491 lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
);
1492 return ndlp
->nlp_state
;
1496 lpfc_rcv_prli_unmap_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1497 void *arg
, uint32_t evt
)
1499 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1501 lpfc_rcv_prli(vport
, ndlp
, cmdiocb
);
1502 lpfc_els_rsp_prli_acc(vport
, cmdiocb
, ndlp
);
1503 return ndlp
->nlp_state
;
1507 lpfc_rcv_logo_unmap_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1508 void *arg
, uint32_t evt
)
1510 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1512 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1513 return ndlp
->nlp_state
;
1517 lpfc_rcv_padisc_unmap_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1518 void *arg
, uint32_t evt
)
1520 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1522 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1523 return ndlp
->nlp_state
;
1527 lpfc_rcv_prlo_unmap_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1528 void *arg
, uint32_t evt
)
1530 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1532 lpfc_els_rsp_acc(vport
, ELS_CMD_PRLO
, cmdiocb
, ndlp
, NULL
, 0);
1533 return ndlp
->nlp_state
;
1537 lpfc_device_recov_unmap_node(struct lpfc_vport
*vport
,
1538 struct lpfc_nodelist
*ndlp
,
1542 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1544 ndlp
->nlp_prev_state
= NLP_STE_UNMAPPED_NODE
;
1545 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1546 spin_lock_irq(shost
->host_lock
);
1547 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1548 spin_unlock_irq(shost
->host_lock
);
1549 lpfc_disc_set_adisc(vport
, ndlp
);
1551 return ndlp
->nlp_state
;
1555 lpfc_rcv_plogi_mapped_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1556 void *arg
, uint32_t evt
)
1558 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1560 lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
);
1561 return ndlp
->nlp_state
;
1565 lpfc_rcv_prli_mapped_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1566 void *arg
, uint32_t evt
)
1568 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1570 lpfc_els_rsp_prli_acc(vport
, cmdiocb
, ndlp
);
1571 return ndlp
->nlp_state
;
1575 lpfc_rcv_logo_mapped_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1576 void *arg
, uint32_t evt
)
1578 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1580 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1581 return ndlp
->nlp_state
;
1585 lpfc_rcv_padisc_mapped_node(struct lpfc_vport
*vport
,
1586 struct lpfc_nodelist
*ndlp
,
1587 void *arg
, uint32_t evt
)
1589 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1591 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1592 return ndlp
->nlp_state
;
1596 lpfc_rcv_prlo_mapped_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1597 void *arg
, uint32_t evt
)
1599 struct lpfc_hba
*phba
= vport
->phba
;
1600 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1602 /* flush the target */
1603 lpfc_sli_abort_iocb(phba
, &phba
->sli
.ring
[phba
->sli
.fcp_ring
],
1604 ndlp
->nlp_sid
, 0, 0, LPFC_CTX_TGT
);
1606 /* Treat like rcv logo */
1607 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_PRLO
);
1608 return ndlp
->nlp_state
;
1612 lpfc_device_recov_mapped_node(struct lpfc_vport
*vport
,
1613 struct lpfc_nodelist
*ndlp
,
1617 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1619 ndlp
->nlp_prev_state
= NLP_STE_MAPPED_NODE
;
1620 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1621 spin_lock_irq(shost
->host_lock
);
1622 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1623 spin_unlock_irq(shost
->host_lock
);
1624 lpfc_disc_set_adisc(vport
, ndlp
);
1625 return ndlp
->nlp_state
;
1629 lpfc_rcv_plogi_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1630 void *arg
, uint32_t evt
)
1632 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1633 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1635 /* Ignore PLOGI if we have an outstanding LOGO */
1636 if (ndlp
->nlp_flag
& (NLP_LOGO_SND
| NLP_LOGO_ACC
)) {
1637 return ndlp
->nlp_state
;
1640 if (lpfc_rcv_plogi(vport
, ndlp
, cmdiocb
)) {
1641 spin_lock_irq(shost
->host_lock
);
1642 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1643 spin_unlock_irq(shost
->host_lock
);
1644 return ndlp
->nlp_state
;
1647 /* send PLOGI immediately, move to PLOGI issue state */
1648 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
)) {
1649 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1650 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
1651 lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0);
1654 return ndlp
->nlp_state
;
1658 lpfc_rcv_prli_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1659 void *arg
, uint32_t evt
)
1661 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1662 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1665 memset(&stat
, 0, sizeof (struct ls_rjt
));
1666 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
1667 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
1668 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
, NULL
);
1670 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
)) {
1671 if (ndlp
->nlp_flag
& NLP_NPR_ADISC
) {
1672 spin_lock_irq(shost
->host_lock
);
1673 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1674 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1675 spin_unlock_irq(shost
->host_lock
);
1676 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_ADISC_ISSUE
);
1677 lpfc_issue_els_adisc(vport
, ndlp
, 0);
1679 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1680 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
1681 lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0);
1684 return ndlp
->nlp_state
;
1688 lpfc_rcv_logo_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1689 void *arg
, uint32_t evt
)
1691 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1693 lpfc_rcv_logo(vport
, ndlp
, cmdiocb
, ELS_CMD_LOGO
);
1694 return ndlp
->nlp_state
;
1698 lpfc_rcv_padisc_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1699 void *arg
, uint32_t evt
)
1701 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1703 lpfc_rcv_padisc(vport
, ndlp
, cmdiocb
);
1706 * Do not start discovery if discovery is about to start
1707 * or discovery in progress for this node. Starting discovery
1708 * here will affect the counting of discovery threads.
1710 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
) &&
1711 !(ndlp
->nlp_flag
& NLP_NPR_2B_DISC
)) {
1712 if (ndlp
->nlp_flag
& NLP_NPR_ADISC
) {
1713 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1714 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1715 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_ADISC_ISSUE
);
1716 lpfc_issue_els_adisc(vport
, ndlp
, 0);
1718 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
1719 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
1720 lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0);
1723 return ndlp
->nlp_state
;
1727 lpfc_rcv_prlo_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1728 void *arg
, uint32_t evt
)
1730 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1731 struct lpfc_iocbq
*cmdiocb
= (struct lpfc_iocbq
*) arg
;
1733 spin_lock_irq(shost
->host_lock
);
1734 ndlp
->nlp_flag
|= NLP_LOGO_ACC
;
1735 spin_unlock_irq(shost
->host_lock
);
1737 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
1739 if ((ndlp
->nlp_flag
& NLP_DELAY_TMO
) == 0) {
1740 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
* 1);
1741 spin_lock_irq(shost
->host_lock
);
1742 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
1743 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1744 spin_unlock_irq(shost
->host_lock
);
1745 ndlp
->nlp_last_elscmd
= ELS_CMD_PLOGI
;
1747 spin_lock_irq(shost
->host_lock
);
1748 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
1749 spin_unlock_irq(shost
->host_lock
);
1751 return ndlp
->nlp_state
;
1755 lpfc_cmpl_plogi_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1756 void *arg
, uint32_t evt
)
1758 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1761 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1762 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1764 irsp
= &rspiocb
->iocb
;
1765 if (irsp
->ulpStatus
) {
1766 lpfc_drop_node(vport
, ndlp
);
1767 return NLP_STE_FREED_NODE
;
1769 return ndlp
->nlp_state
;
1773 lpfc_cmpl_prli_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1774 void *arg
, uint32_t evt
)
1776 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1779 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1780 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1782 irsp
= &rspiocb
->iocb
;
1783 if (irsp
->ulpStatus
&& (ndlp
->nlp_flag
& NLP_NODEV_REMOVE
)) {
1784 lpfc_drop_node(vport
, ndlp
);
1785 return NLP_STE_FREED_NODE
;
1787 return ndlp
->nlp_state
;
1791 lpfc_cmpl_logo_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1792 void *arg
, uint32_t evt
)
1794 lpfc_unreg_rpi(vport
, ndlp
);
1795 /* This routine does nothing, just return the current state */
1796 return ndlp
->nlp_state
;
1800 lpfc_cmpl_adisc_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1801 void *arg
, uint32_t evt
)
1803 struct lpfc_iocbq
*cmdiocb
, *rspiocb
;
1806 cmdiocb
= (struct lpfc_iocbq
*) arg
;
1807 rspiocb
= cmdiocb
->context_un
.rsp_iocb
;
1809 irsp
= &rspiocb
->iocb
;
1810 if (irsp
->ulpStatus
&& (ndlp
->nlp_flag
& NLP_NODEV_REMOVE
)) {
1811 lpfc_drop_node(vport
, ndlp
);
1812 return NLP_STE_FREED_NODE
;
1814 return ndlp
->nlp_state
;
1818 lpfc_cmpl_reglogin_npr_node(struct lpfc_vport
*vport
,
1819 struct lpfc_nodelist
*ndlp
,
1820 void *arg
, uint32_t evt
)
1822 LPFC_MBOXQ_t
*pmb
= (LPFC_MBOXQ_t
*) arg
;
1823 MAILBOX_t
*mb
= &pmb
->mb
;
1826 ndlp
->nlp_rpi
= mb
->un
.varWords
[0];
1828 if (ndlp
->nlp_flag
& NLP_NODEV_REMOVE
) {
1829 lpfc_drop_node(vport
, ndlp
);
1830 return NLP_STE_FREED_NODE
;
1833 return ndlp
->nlp_state
;
1837 lpfc_device_rm_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1838 void *arg
, uint32_t evt
)
1840 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1842 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1843 spin_lock_irq(shost
->host_lock
);
1844 ndlp
->nlp_flag
|= NLP_NODEV_REMOVE
;
1845 spin_unlock_irq(shost
->host_lock
);
1846 return ndlp
->nlp_state
;
1848 lpfc_drop_node(vport
, ndlp
);
1849 return NLP_STE_FREED_NODE
;
1853 lpfc_device_recov_npr_node(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1854 void *arg
, uint32_t evt
)
1856 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1858 /* Don't do anything that will mess up processing of the
1861 if (vport
->fc_flag
& FC_RSCN_DEFERRED
)
1862 return ndlp
->nlp_state
;
1864 spin_lock_irq(shost
->host_lock
);
1865 ndlp
->nlp_flag
&= ~(NLP_NODEV_REMOVE
| NLP_NPR_2B_DISC
);
1866 spin_unlock_irq(shost
->host_lock
);
1867 if (ndlp
->nlp_flag
& NLP_DELAY_TMO
) {
1868 lpfc_cancel_retry_delay_tmo(vport
, ndlp
);
1870 return ndlp
->nlp_state
;
1874 /* This next section defines the NPort Discovery State Machine */
1876 /* There are 4 different double linked lists nodelist entries can reside on.
1877 * The plogi list and adisc list are used when Link Up discovery or RSCN
1878 * processing is needed. Each list holds the nodes that we will send PLOGI
1879 * or ADISC on. These lists will keep track of what nodes will be effected
1880 * by an RSCN, or a Link Up (Typically, all nodes are effected on Link Up).
1881 * The unmapped_list will contain all nodes that we have successfully logged
1882 * into at the Fibre Channel level. The mapped_list will contain all nodes
1883 * that are mapped FCP targets.
1886 * The bind list is a list of undiscovered (potentially non-existent) nodes
1887 * that we have saved binding information on. This information is used when
1888 * nodes transition from the unmapped to the mapped list.
1890 /* For UNUSED_NODE state, the node has just been allocated .
1891 * For PLOGI_ISSUE and REG_LOGIN_ISSUE, the node is on
1892 * the PLOGI list. For REG_LOGIN_COMPL, the node is taken off the PLOGI list
1893 * and put on the unmapped list. For ADISC processing, the node is taken off
1894 * the ADISC list and placed on either the mapped or unmapped list (depending
1895 * on its previous state). Once on the unmapped list, a PRLI is issued and the
1896 * state changed to PRLI_ISSUE. When the PRLI completion occurs, the state is
1897 * changed to UNMAPPED_NODE. If the completion indicates a mapped
1898 * node, the node is taken off the unmapped list. The binding list is checked
1899 * for a valid binding, or a binding is automatically assigned. If binding
1900 * assignment is unsuccessful, the node is left on the unmapped list. If
1901 * binding assignment is successful, the associated binding list entry (if
1902 * any) is removed, and the node is placed on the mapped list.
1905 * For a Link Down, all nodes on the ADISC, PLOGI, unmapped or mapped
1906 * lists will receive a DEVICE_RECOVERY event. If the linkdown or devloss timers
1907 * expire, all effected nodes will receive a DEVICE_RM event.
1910 * For a Link Up or RSCN, all nodes will move from the mapped / unmapped lists
1911 * to either the ADISC or PLOGI list. After a Nameserver query or ALPA loopmap
1912 * check, additional nodes may be added or removed (via DEVICE_RM) to / from
1913 * the PLOGI or ADISC lists. Once the PLOGI and ADISC lists are populated,
1914 * we will first process the ADISC list. 32 entries are processed initially and
1915 * ADISC is initited for each one. Completions / Events for each node are
1916 * funnelled thru the state machine. As each node finishes ADISC processing, it
1917 * starts ADISC for any nodes waiting for ADISC processing. If no nodes are
1918 * waiting, and the ADISC list count is identically 0, then we are done. For
1919 * Link Up discovery, since all nodes on the PLOGI list are UNREG_LOGIN'ed, we
1920 * can issue a CLEAR_LA and reenable Link Events. Next we will process the PLOGI
1921 * list. 32 entries are processed initially and PLOGI is initited for each one.
1922 * Completions / Events for each node are funnelled thru the state machine. As
1923 * each node finishes PLOGI processing, it starts PLOGI for any nodes waiting
1924 * for PLOGI processing. If no nodes are waiting, and the PLOGI list count is
1925 * indentically 0, then we are done. We have now completed discovery / RSCN
1926 * handling. Upon completion, ALL nodes should be on either the mapped or
1930 static uint32_t (*lpfc_disc_action
[NLP_STE_MAX_STATE
* NLP_EVT_MAX_EVENT
])
1931 (struct lpfc_vport
*, struct lpfc_nodelist
*, void *, uint32_t) = {
1932 /* Action routine Event Current State */
1933 lpfc_rcv_plogi_unused_node
, /* RCV_PLOGI UNUSED_NODE */
1934 lpfc_rcv_els_unused_node
, /* RCV_PRLI */
1935 lpfc_rcv_logo_unused_node
, /* RCV_LOGO */
1936 lpfc_rcv_els_unused_node
, /* RCV_ADISC */
1937 lpfc_rcv_els_unused_node
, /* RCV_PDISC */
1938 lpfc_rcv_els_unused_node
, /* RCV_PRLO */
1939 lpfc_disc_illegal
, /* CMPL_PLOGI */
1940 lpfc_disc_illegal
, /* CMPL_PRLI */
1941 lpfc_cmpl_logo_unused_node
, /* CMPL_LOGO */
1942 lpfc_disc_illegal
, /* CMPL_ADISC */
1943 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
1944 lpfc_device_rm_unused_node
, /* DEVICE_RM */
1945 lpfc_disc_illegal
, /* DEVICE_RECOVERY */
1947 lpfc_rcv_plogi_plogi_issue
, /* RCV_PLOGI PLOGI_ISSUE */
1948 lpfc_rcv_prli_plogi_issue
, /* RCV_PRLI */
1949 lpfc_rcv_logo_plogi_issue
, /* RCV_LOGO */
1950 lpfc_rcv_els_plogi_issue
, /* RCV_ADISC */
1951 lpfc_rcv_els_plogi_issue
, /* RCV_PDISC */
1952 lpfc_rcv_els_plogi_issue
, /* RCV_PRLO */
1953 lpfc_cmpl_plogi_plogi_issue
, /* CMPL_PLOGI */
1954 lpfc_disc_illegal
, /* CMPL_PRLI */
1955 lpfc_disc_illegal
, /* CMPL_LOGO */
1956 lpfc_disc_illegal
, /* CMPL_ADISC */
1957 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
1958 lpfc_device_rm_plogi_issue
, /* DEVICE_RM */
1959 lpfc_device_recov_plogi_issue
, /* DEVICE_RECOVERY */
1961 lpfc_rcv_plogi_adisc_issue
, /* RCV_PLOGI ADISC_ISSUE */
1962 lpfc_rcv_prli_adisc_issue
, /* RCV_PRLI */
1963 lpfc_rcv_logo_adisc_issue
, /* RCV_LOGO */
1964 lpfc_rcv_padisc_adisc_issue
, /* RCV_ADISC */
1965 lpfc_rcv_padisc_adisc_issue
, /* RCV_PDISC */
1966 lpfc_rcv_prlo_adisc_issue
, /* RCV_PRLO */
1967 lpfc_disc_illegal
, /* CMPL_PLOGI */
1968 lpfc_disc_illegal
, /* CMPL_PRLI */
1969 lpfc_disc_illegal
, /* CMPL_LOGO */
1970 lpfc_cmpl_adisc_adisc_issue
, /* CMPL_ADISC */
1971 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
1972 lpfc_device_rm_adisc_issue
, /* DEVICE_RM */
1973 lpfc_device_recov_adisc_issue
, /* DEVICE_RECOVERY */
1975 lpfc_rcv_plogi_reglogin_issue
, /* RCV_PLOGI REG_LOGIN_ISSUE */
1976 lpfc_rcv_prli_reglogin_issue
, /* RCV_PLOGI */
1977 lpfc_rcv_logo_reglogin_issue
, /* RCV_LOGO */
1978 lpfc_rcv_padisc_reglogin_issue
, /* RCV_ADISC */
1979 lpfc_rcv_padisc_reglogin_issue
, /* RCV_PDISC */
1980 lpfc_rcv_prlo_reglogin_issue
, /* RCV_PRLO */
1981 lpfc_disc_illegal
, /* CMPL_PLOGI */
1982 lpfc_disc_illegal
, /* CMPL_PRLI */
1983 lpfc_disc_illegal
, /* CMPL_LOGO */
1984 lpfc_disc_illegal
, /* CMPL_ADISC */
1985 lpfc_cmpl_reglogin_reglogin_issue
,/* CMPL_REG_LOGIN */
1986 lpfc_device_rm_reglogin_issue
, /* DEVICE_RM */
1987 lpfc_device_recov_reglogin_issue
,/* DEVICE_RECOVERY */
1989 lpfc_rcv_plogi_prli_issue
, /* RCV_PLOGI PRLI_ISSUE */
1990 lpfc_rcv_prli_prli_issue
, /* RCV_PRLI */
1991 lpfc_rcv_logo_prli_issue
, /* RCV_LOGO */
1992 lpfc_rcv_padisc_prli_issue
, /* RCV_ADISC */
1993 lpfc_rcv_padisc_prli_issue
, /* RCV_PDISC */
1994 lpfc_rcv_prlo_prli_issue
, /* RCV_PRLO */
1995 lpfc_disc_illegal
, /* CMPL_PLOGI */
1996 lpfc_cmpl_prli_prli_issue
, /* CMPL_PRLI */
1997 lpfc_disc_illegal
, /* CMPL_LOGO */
1998 lpfc_disc_illegal
, /* CMPL_ADISC */
1999 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
2000 lpfc_device_rm_prli_issue
, /* DEVICE_RM */
2001 lpfc_device_recov_prli_issue
, /* DEVICE_RECOVERY */
2003 lpfc_rcv_plogi_unmap_node
, /* RCV_PLOGI UNMAPPED_NODE */
2004 lpfc_rcv_prli_unmap_node
, /* RCV_PRLI */
2005 lpfc_rcv_logo_unmap_node
, /* RCV_LOGO */
2006 lpfc_rcv_padisc_unmap_node
, /* RCV_ADISC */
2007 lpfc_rcv_padisc_unmap_node
, /* RCV_PDISC */
2008 lpfc_rcv_prlo_unmap_node
, /* RCV_PRLO */
2009 lpfc_disc_illegal
, /* CMPL_PLOGI */
2010 lpfc_disc_illegal
, /* CMPL_PRLI */
2011 lpfc_disc_illegal
, /* CMPL_LOGO */
2012 lpfc_disc_illegal
, /* CMPL_ADISC */
2013 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
2014 lpfc_disc_illegal
, /* DEVICE_RM */
2015 lpfc_device_recov_unmap_node
, /* DEVICE_RECOVERY */
2017 lpfc_rcv_plogi_mapped_node
, /* RCV_PLOGI MAPPED_NODE */
2018 lpfc_rcv_prli_mapped_node
, /* RCV_PRLI */
2019 lpfc_rcv_logo_mapped_node
, /* RCV_LOGO */
2020 lpfc_rcv_padisc_mapped_node
, /* RCV_ADISC */
2021 lpfc_rcv_padisc_mapped_node
, /* RCV_PDISC */
2022 lpfc_rcv_prlo_mapped_node
, /* RCV_PRLO */
2023 lpfc_disc_illegal
, /* CMPL_PLOGI */
2024 lpfc_disc_illegal
, /* CMPL_PRLI */
2025 lpfc_disc_illegal
, /* CMPL_LOGO */
2026 lpfc_disc_illegal
, /* CMPL_ADISC */
2027 lpfc_disc_illegal
, /* CMPL_REG_LOGIN */
2028 lpfc_disc_illegal
, /* DEVICE_RM */
2029 lpfc_device_recov_mapped_node
, /* DEVICE_RECOVERY */
2031 lpfc_rcv_plogi_npr_node
, /* RCV_PLOGI NPR_NODE */
2032 lpfc_rcv_prli_npr_node
, /* RCV_PRLI */
2033 lpfc_rcv_logo_npr_node
, /* RCV_LOGO */
2034 lpfc_rcv_padisc_npr_node
, /* RCV_ADISC */
2035 lpfc_rcv_padisc_npr_node
, /* RCV_PDISC */
2036 lpfc_rcv_prlo_npr_node
, /* RCV_PRLO */
2037 lpfc_cmpl_plogi_npr_node
, /* CMPL_PLOGI */
2038 lpfc_cmpl_prli_npr_node
, /* CMPL_PRLI */
2039 lpfc_cmpl_logo_npr_node
, /* CMPL_LOGO */
2040 lpfc_cmpl_adisc_npr_node
, /* CMPL_ADISC */
2041 lpfc_cmpl_reglogin_npr_node
, /* CMPL_REG_LOGIN */
2042 lpfc_device_rm_npr_node
, /* DEVICE_RM */
2043 lpfc_device_recov_npr_node
, /* DEVICE_RECOVERY */
2047 lpfc_disc_state_machine(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
2048 void *arg
, uint32_t evt
)
2050 struct lpfc_hba
*phba
= vport
->phba
;
2051 uint32_t cur_state
, rc
;
2052 uint32_t(*func
) (struct lpfc_vport
*, struct lpfc_nodelist
*, void *,
2056 cur_state
= ndlp
->nlp_state
;
2058 /* DSM in event <evt> on NPort <nlp_DID> in state <cur_state> */
2059 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
2060 "%d (%d):0211 DSM in event x%x on NPort x%x in "
2061 "state %d Data: x%x\n",
2062 phba
->brd_no
, vport
->vpi
,
2063 evt
, ndlp
->nlp_DID
, cur_state
, ndlp
->nlp_flag
);
2065 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_DSM
,
2066 "DSM in: evt:%d ste:%d did:x%x",
2067 evt
, cur_state
, ndlp
->nlp_DID
);
2069 func
= lpfc_disc_action
[(cur_state
* NLP_EVT_MAX_EVENT
) + evt
];
2070 rc
= (func
) (vport
, ndlp
, arg
, evt
);
2072 /* DSM out state <rc> on NPort <nlp_DID> */
2073 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
2074 "%d (%d):0212 DSM out state %d on NPort x%x "
2076 phba
->brd_no
, vport
->vpi
,
2077 rc
, ndlp
->nlp_DID
, ndlp
->nlp_flag
);
2079 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_DSM
,
2080 "DSM out: ste:%d did:x%x flg:x%x",
2081 rc
, ndlp
->nlp_DID
, ndlp
->nlp_flag
);