1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2009 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
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 *******************************************************************/
21 /* See Fibre Channel protocol T11 FC-LS for details */
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/slab.h>
25 #include <linux/interrupt.h>
27 #include <scsi/scsi.h>
28 #include <scsi/scsi_device.h>
29 #include <scsi/scsi_host.h>
30 #include <scsi/scsi_transport_fc.h>
35 #include "lpfc_sli4.h"
37 #include "lpfc_disc.h"
38 #include "lpfc_scsi.h"
40 #include "lpfc_logmsg.h"
41 #include "lpfc_crtn.h"
42 #include "lpfc_vport.h"
43 #include "lpfc_debugfs.h"
45 static int lpfc_els_retry(struct lpfc_hba
*, struct lpfc_iocbq
*,
47 static void lpfc_cmpl_fabric_iocb(struct lpfc_hba
*, struct lpfc_iocbq
*,
49 static void lpfc_fabric_abort_vport(struct lpfc_vport
*vport
);
50 static int lpfc_issue_els_fdisc(struct lpfc_vport
*vport
,
51 struct lpfc_nodelist
*ndlp
, uint8_t retry
);
52 static int lpfc_issue_fabric_iocb(struct lpfc_hba
*phba
,
53 struct lpfc_iocbq
*iocb
);
55 static int lpfc_max_els_tries
= 3;
58 * lpfc_els_chk_latt - Check host link attention event for a vport
59 * @vport: pointer to a host virtual N_Port data structure.
61 * This routine checks whether there is an outstanding host link
62 * attention event during the discovery process with the @vport. It is done
63 * by reading the HBA's Host Attention (HA) register. If there is any host
64 * link attention events during this @vport's discovery process, the @vport
65 * shall be marked as FC_ABORT_DISCOVERY, a host link attention clear shall
66 * be issued if the link state is not already in host link cleared state,
67 * and a return code shall indicate whether the host link attention event
70 * Note that, if either the host link is in state LPFC_LINK_DOWN or @vport
71 * state in LPFC_VPORT_READY, the request for checking host link attention
72 * event will be ignored and a return code shall indicate no host link
73 * attention event had happened.
76 * 0 - no host link attention event happened
77 * 1 - host link attention event happened
80 lpfc_els_chk_latt(struct lpfc_vport
*vport
)
82 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
83 struct lpfc_hba
*phba
= vport
->phba
;
86 if (vport
->port_state
>= LPFC_VPORT_READY
||
87 phba
->link_state
== LPFC_LINK_DOWN
||
88 phba
->sli_rev
> LPFC_SLI_REV3
)
91 /* Read the HBA Host Attention Register */
92 ha_copy
= readl(phba
->HAregaddr
);
94 if (!(ha_copy
& HA_LATT
))
97 /* Pending Link Event during Discovery */
98 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_DISCOVERY
,
99 "0237 Pending Link Event during "
100 "Discovery: State x%x\n",
101 phba
->pport
->port_state
);
103 /* CLEAR_LA should re-enable link attention events and
104 * we should then imediately take a LATT event. The
105 * LATT processing should call lpfc_linkdown() which
106 * will cleanup any left over in-progress discovery
109 spin_lock_irq(shost
->host_lock
);
110 vport
->fc_flag
|= FC_ABORT_DISCOVERY
;
111 spin_unlock_irq(shost
->host_lock
);
113 if (phba
->link_state
!= LPFC_CLEAR_LA
)
114 lpfc_issue_clear_la(phba
, vport
);
120 * lpfc_prep_els_iocb - Allocate and prepare a lpfc iocb data structure
121 * @vport: pointer to a host virtual N_Port data structure.
122 * @expectRsp: flag indicating whether response is expected.
123 * @cmdSize: size of the ELS command.
124 * @retry: number of retries to the command IOCB when it fails.
125 * @ndlp: pointer to a node-list data structure.
126 * @did: destination identifier.
127 * @elscmd: the ELS command code.
129 * This routine is used for allocating a lpfc-IOCB data structure from
130 * the driver lpfc-IOCB free-list and prepare the IOCB with the parameters
131 * passed into the routine for discovery state machine to issue an Extended
132 * Link Service (ELS) commands. It is a generic lpfc-IOCB allocation
133 * and preparation routine that is used by all the discovery state machine
134 * routines and the ELS command-specific fields will be later set up by
135 * the individual discovery machine routines after calling this routine
136 * allocating and preparing a generic IOCB data structure. It fills in the
137 * Buffer Descriptor Entries (BDEs), allocates buffers for both command
138 * payload and response payload (if expected). The reference count on the
139 * ndlp is incremented by 1 and the reference to the ndlp is put into
140 * context1 of the IOCB data structure for this IOCB to hold the ndlp
141 * reference for the command's callback function to access later.
144 * Pointer to the newly allocated/prepared els iocb data structure
145 * NULL - when els iocb data structure allocation/preparation failed
148 lpfc_prep_els_iocb(struct lpfc_vport
*vport
, uint8_t expectRsp
,
149 uint16_t cmdSize
, uint8_t retry
,
150 struct lpfc_nodelist
*ndlp
, uint32_t did
,
153 struct lpfc_hba
*phba
= vport
->phba
;
154 struct lpfc_iocbq
*elsiocb
;
155 struct lpfc_dmabuf
*pcmd
, *prsp
, *pbuflist
;
156 struct ulp_bde64
*bpl
;
160 if (!lpfc_is_link_up(phba
))
163 /* Allocate buffer for command iocb */
164 elsiocb
= lpfc_sli_get_iocbq(phba
);
170 * If this command is for fabric controller and HBA running
171 * in FIP mode send FLOGI, FDISC and LOGO as FIP frames.
173 if ((did
== Fabric_DID
) &&
174 (phba
->hba_flag
& HBA_FIP_SUPPORT
) &&
175 ((elscmd
== ELS_CMD_FLOGI
) ||
176 (elscmd
== ELS_CMD_FDISC
) ||
177 (elscmd
== ELS_CMD_LOGO
)))
180 elsiocb
->iocb_flag
|= ((ELS_ID_FLOGI
<< LPFC_FIP_ELS_ID_SHIFT
)
181 & LPFC_FIP_ELS_ID_MASK
);
184 elsiocb
->iocb_flag
|= ((ELS_ID_FDISC
<< LPFC_FIP_ELS_ID_SHIFT
)
185 & LPFC_FIP_ELS_ID_MASK
);
188 elsiocb
->iocb_flag
|= ((ELS_ID_LOGO
<< LPFC_FIP_ELS_ID_SHIFT
)
189 & LPFC_FIP_ELS_ID_MASK
);
193 elsiocb
->iocb_flag
&= ~LPFC_FIP_ELS_ID_MASK
;
195 icmd
= &elsiocb
->iocb
;
197 /* fill in BDEs for command */
198 /* Allocate buffer for command payload */
199 pcmd
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
201 pcmd
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
, &pcmd
->phys
);
202 if (!pcmd
|| !pcmd
->virt
)
203 goto els_iocb_free_pcmb_exit
;
205 INIT_LIST_HEAD(&pcmd
->list
);
207 /* Allocate buffer for response payload */
209 prsp
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
211 prsp
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
,
213 if (!prsp
|| !prsp
->virt
)
214 goto els_iocb_free_prsp_exit
;
215 INIT_LIST_HEAD(&prsp
->list
);
219 /* Allocate buffer for Buffer ptr list */
220 pbuflist
= kmalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
222 pbuflist
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
,
224 if (!pbuflist
|| !pbuflist
->virt
)
225 goto els_iocb_free_pbuf_exit
;
227 INIT_LIST_HEAD(&pbuflist
->list
);
229 icmd
->un
.elsreq64
.bdl
.addrHigh
= putPaddrHigh(pbuflist
->phys
);
230 icmd
->un
.elsreq64
.bdl
.addrLow
= putPaddrLow(pbuflist
->phys
);
231 icmd
->un
.elsreq64
.bdl
.bdeFlags
= BUFF_TYPE_BLP_64
;
232 icmd
->un
.elsreq64
.remoteID
= did
; /* DID */
234 icmd
->un
.elsreq64
.bdl
.bdeSize
= (2 * sizeof(struct ulp_bde64
));
235 icmd
->ulpCommand
= CMD_ELS_REQUEST64_CR
;
236 icmd
->ulpTimeout
= phba
->fc_ratov
* 2;
238 icmd
->un
.elsreq64
.bdl
.bdeSize
= sizeof(struct ulp_bde64
);
239 icmd
->ulpCommand
= CMD_XMIT_ELS_RSP64_CX
;
241 icmd
->ulpBdeCount
= 1;
243 icmd
->ulpClass
= CLASS3
;
245 if (phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
) {
246 icmd
->un
.elsreq64
.myID
= vport
->fc_myDID
;
248 /* For ELS_REQUEST64_CR, use the VPI by default */
249 icmd
->ulpContext
= vport
->vpi
+ phba
->vpi_base
;
251 /* The CT field must be 0=INVALID_RPI for the ECHO cmd */
252 if (elscmd
== ELS_CMD_ECHO
)
253 icmd
->ulpCt_l
= 0; /* context = invalid RPI */
255 icmd
->ulpCt_l
= 1; /* context = VPI */
258 bpl
= (struct ulp_bde64
*) pbuflist
->virt
;
259 bpl
->addrLow
= le32_to_cpu(putPaddrLow(pcmd
->phys
));
260 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(pcmd
->phys
));
261 bpl
->tus
.f
.bdeSize
= cmdSize
;
262 bpl
->tus
.f
.bdeFlags
= 0;
263 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
267 bpl
->addrLow
= le32_to_cpu(putPaddrLow(prsp
->phys
));
268 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(prsp
->phys
));
269 bpl
->tus
.f
.bdeSize
= FCELSSIZE
;
270 bpl
->tus
.f
.bdeFlags
= BUFF_TYPE_BDE_64
;
271 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
274 /* prevent preparing iocb with NULL ndlp reference */
275 elsiocb
->context1
= lpfc_nlp_get(ndlp
);
276 if (!elsiocb
->context1
)
277 goto els_iocb_free_pbuf_exit
;
278 elsiocb
->context2
= pcmd
;
279 elsiocb
->context3
= pbuflist
;
280 elsiocb
->retry
= retry
;
281 elsiocb
->vport
= vport
;
282 elsiocb
->drvrTimeout
= (phba
->fc_ratov
<< 1) + LPFC_DRVR_TIMEOUT
;
285 list_add(&prsp
->list
, &pcmd
->list
);
288 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
289 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
290 "0116 Xmit ELS command x%x to remote "
291 "NPORT x%x I/O tag: x%x, port state: x%x\n",
292 elscmd
, did
, elsiocb
->iotag
,
295 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
296 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
297 "0117 Xmit ELS response x%x to remote "
298 "NPORT x%x I/O tag: x%x, size: x%x\n",
299 elscmd
, ndlp
->nlp_DID
, elsiocb
->iotag
,
304 els_iocb_free_pbuf_exit
:
306 lpfc_mbuf_free(phba
, prsp
->virt
, prsp
->phys
);
309 els_iocb_free_prsp_exit
:
310 lpfc_mbuf_free(phba
, pcmd
->virt
, pcmd
->phys
);
313 els_iocb_free_pcmb_exit
:
315 lpfc_sli_release_iocbq(phba
, elsiocb
);
320 * lpfc_issue_fabric_reglogin - Issue fabric registration login for a vport
321 * @vport: pointer to a host virtual N_Port data structure.
323 * This routine issues a fabric registration login for a @vport. An
324 * active ndlp node with Fabric_DID must already exist for this @vport.
325 * The routine invokes two mailbox commands to carry out fabric registration
326 * login through the HBA firmware: the first mailbox command requests the
327 * HBA to perform link configuration for the @vport; and the second mailbox
328 * command requests the HBA to perform the actual fabric registration login
332 * 0 - successfully issued fabric registration login for @vport
333 * -ENXIO -- failed to issue fabric registration login for @vport
336 lpfc_issue_fabric_reglogin(struct lpfc_vport
*vport
)
338 struct lpfc_hba
*phba
= vport
->phba
;
340 struct lpfc_dmabuf
*mp
;
341 struct lpfc_nodelist
*ndlp
;
342 struct serv_parm
*sp
;
346 sp
= &phba
->fc_fabparam
;
347 ndlp
= lpfc_findnode_did(vport
, Fabric_DID
);
348 if (!ndlp
|| !NLP_CHK_NODE_ACT(ndlp
)) {
353 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
359 vport
->port_state
= LPFC_FABRIC_CFG_LINK
;
360 lpfc_config_link(phba
, mbox
);
361 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
364 rc
= lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
);
365 if (rc
== MBX_NOT_FINISHED
) {
370 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
375 rc
= lpfc_reg_rpi(phba
, vport
->vpi
, Fabric_DID
, (uint8_t *)sp
, mbox
, 0);
381 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_fabric_reg_login
;
383 /* increment the reference count on ndlp to hold reference
384 * for the callback routine.
386 mbox
->context2
= lpfc_nlp_get(ndlp
);
388 rc
= lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
);
389 if (rc
== MBX_NOT_FINISHED
) {
391 goto fail_issue_reg_login
;
396 fail_issue_reg_login
:
397 /* decrement the reference count on ndlp just incremented
398 * for the failed mbox command.
401 mp
= (struct lpfc_dmabuf
*) mbox
->context1
;
402 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
405 mempool_free(mbox
, phba
->mbox_mem_pool
);
408 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
409 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
410 "0249 Cannot issue Register Fabric login: Err %d\n", err
);
415 * lpfc_issue_reg_vfi - Register VFI for this vport's fabric login
416 * @vport: pointer to a host virtual N_Port data structure.
418 * This routine issues a REG_VFI mailbox for the vfi, vpi, fcfi triplet for
419 * the @vport. This mailbox command is necessary for FCoE only.
422 * 0 - successfully issued REG_VFI for @vport
423 * A failure code otherwise.
426 lpfc_issue_reg_vfi(struct lpfc_vport
*vport
)
428 struct lpfc_hba
*phba
= vport
->phba
;
430 struct lpfc_nodelist
*ndlp
;
431 struct serv_parm
*sp
;
432 struct lpfc_dmabuf
*dmabuf
;
435 sp
= &phba
->fc_fabparam
;
436 ndlp
= lpfc_findnode_did(vport
, Fabric_DID
);
437 if (!ndlp
|| !NLP_CHK_NODE_ACT(ndlp
)) {
442 dmabuf
= kzalloc(sizeof(struct lpfc_dmabuf
), GFP_KERNEL
);
447 dmabuf
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
, &dmabuf
->phys
);
450 goto fail_free_dmabuf
;
452 mboxq
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
455 goto fail_free_coherent
;
457 vport
->port_state
= LPFC_FABRIC_CFG_LINK
;
458 memcpy(dmabuf
->virt
, &phba
->fc_fabparam
, sizeof(vport
->fc_sparam
));
459 lpfc_reg_vfi(mboxq
, vport
, dmabuf
->phys
);
460 mboxq
->mbox_cmpl
= lpfc_mbx_cmpl_reg_vfi
;
461 mboxq
->vport
= vport
;
462 mboxq
->context1
= dmabuf
;
463 rc
= lpfc_sli_issue_mbox(phba
, mboxq
, MBX_NOWAIT
);
464 if (rc
== MBX_NOT_FINISHED
) {
471 mempool_free(mboxq
, phba
->mbox_mem_pool
);
473 lpfc_mbuf_free(phba
, dmabuf
->virt
, dmabuf
->phys
);
477 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
478 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
479 "0289 Issue Register VFI failed: Err %d\n", rc
);
484 * lpfc_cmpl_els_flogi_fabric - Completion function for flogi to a fabric port
485 * @vport: pointer to a host virtual N_Port data structure.
486 * @ndlp: pointer to a node-list data structure.
487 * @sp: pointer to service parameter data structure.
488 * @irsp: pointer to the IOCB within the lpfc response IOCB.
490 * This routine is invoked by the lpfc_cmpl_els_flogi() completion callback
491 * function to handle the completion of a Fabric Login (FLOGI) into a fabric
492 * port in a fabric topology. It properly sets up the parameters to the @ndlp
493 * from the IOCB response. It also check the newly assigned N_Port ID to the
494 * @vport against the previously assigned N_Port ID. If it is different from
495 * the previously assigned Destination ID (DID), the lpfc_unreg_rpi() routine
496 * is invoked on all the remaining nodes with the @vport to unregister the
497 * Remote Port Indicators (RPIs). Finally, the lpfc_issue_fabric_reglogin()
498 * is invoked to register login to the fabric.
501 * 0 - Success (currently, always return 0)
504 lpfc_cmpl_els_flogi_fabric(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
505 struct serv_parm
*sp
, IOCB_t
*irsp
)
507 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
508 struct lpfc_hba
*phba
= vport
->phba
;
509 struct lpfc_nodelist
*np
;
510 struct lpfc_nodelist
*next_np
;
512 spin_lock_irq(shost
->host_lock
);
513 vport
->fc_flag
|= FC_FABRIC
;
514 spin_unlock_irq(shost
->host_lock
);
516 phba
->fc_edtov
= be32_to_cpu(sp
->cmn
.e_d_tov
);
517 if (sp
->cmn
.edtovResolution
) /* E_D_TOV ticks are in nanoseconds */
518 phba
->fc_edtov
= (phba
->fc_edtov
+ 999999) / 1000000;
520 phba
->fc_ratov
= (be32_to_cpu(sp
->cmn
.w2
.r_a_tov
) + 999) / 1000;
522 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
523 spin_lock_irq(shost
->host_lock
);
524 vport
->fc_flag
|= FC_PUBLIC_LOOP
;
525 spin_unlock_irq(shost
->host_lock
);
528 * If we are a N-port connected to a Fabric, fixup sparam's so
529 * logins to devices on remote loops work.
531 vport
->fc_sparam
.cmn
.altBbCredit
= 1;
534 vport
->fc_myDID
= irsp
->un
.ulpWord
[4] & Mask_DID
;
535 memcpy(&ndlp
->nlp_portname
, &sp
->portName
, sizeof(struct lpfc_name
));
536 memcpy(&ndlp
->nlp_nodename
, &sp
->nodeName
, sizeof(struct lpfc_name
));
537 ndlp
->nlp_class_sup
= 0;
538 if (sp
->cls1
.classValid
)
539 ndlp
->nlp_class_sup
|= FC_COS_CLASS1
;
540 if (sp
->cls2
.classValid
)
541 ndlp
->nlp_class_sup
|= FC_COS_CLASS2
;
542 if (sp
->cls3
.classValid
)
543 ndlp
->nlp_class_sup
|= FC_COS_CLASS3
;
544 if (sp
->cls4
.classValid
)
545 ndlp
->nlp_class_sup
|= FC_COS_CLASS4
;
546 ndlp
->nlp_maxframe
= ((sp
->cmn
.bbRcvSizeMsb
& 0x0F) << 8) |
547 sp
->cmn
.bbRcvSizeLsb
;
548 memcpy(&phba
->fc_fabparam
, sp
, sizeof(struct serv_parm
));
550 if (phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
) {
551 if (sp
->cmn
.response_multiple_NPort
) {
552 lpfc_printf_vlog(vport
, KERN_WARNING
,
554 "1816 FLOGI NPIV supported, "
555 "response data 0x%x\n",
556 sp
->cmn
.response_multiple_NPort
);
557 phba
->link_flag
|= LS_NPIV_FAB_SUPPORTED
;
559 /* Because we asked f/w for NPIV it still expects us
560 to call reg_vnpid atleast for the physcial host */
561 lpfc_printf_vlog(vport
, KERN_WARNING
,
563 "1817 Fabric does not support NPIV "
564 "- configuring single port mode.\n");
565 phba
->link_flag
&= ~LS_NPIV_FAB_SUPPORTED
;
569 if ((vport
->fc_prevDID
!= vport
->fc_myDID
) &&
570 !(vport
->fc_flag
& FC_VPORT_NEEDS_REG_VPI
)) {
572 /* If our NportID changed, we need to ensure all
573 * remaining NPORTs get unreg_login'ed.
575 list_for_each_entry_safe(np
, next_np
,
576 &vport
->fc_nodes
, nlp_listp
) {
577 if (!NLP_CHK_NODE_ACT(np
))
579 if ((np
->nlp_state
!= NLP_STE_NPR_NODE
) ||
580 !(np
->nlp_flag
& NLP_NPR_ADISC
))
582 spin_lock_irq(shost
->host_lock
);
583 np
->nlp_flag
&= ~NLP_NPR_ADISC
;
584 spin_unlock_irq(shost
->host_lock
);
585 lpfc_unreg_rpi(vport
, np
);
587 lpfc_cleanup_pending_mbox(vport
);
588 if (phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
) {
589 lpfc_mbx_unreg_vpi(vport
);
590 spin_lock_irq(shost
->host_lock
);
591 vport
->fc_flag
|= FC_VPORT_NEEDS_REG_VPI
;
592 spin_unlock_irq(shost
->host_lock
);
595 * If VPI is unreged, driver need to do INIT_VPI
596 * before re-registering
598 if (phba
->sli_rev
== LPFC_SLI_REV4
) {
599 spin_lock_irq(shost
->host_lock
);
600 vport
->fc_flag
|= FC_VPORT_NEEDS_INIT_VPI
;
601 spin_unlock_irq(shost
->host_lock
);
603 } else if ((phba
->sli_rev
== LPFC_SLI_REV4
) &&
604 !(vport
->fc_flag
& FC_VPORT_NEEDS_REG_VPI
)) {
606 * Driver needs to re-reg VPI in order for f/w
607 * to update the MAC address.
609 lpfc_register_new_vport(phba
, vport
, ndlp
);
613 if (phba
->sli_rev
< LPFC_SLI_REV4
) {
614 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_REG_LOGIN_ISSUE
);
615 if (phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
&&
616 vport
->fc_flag
& FC_VPORT_NEEDS_REG_VPI
)
617 lpfc_register_new_vport(phba
, vport
, ndlp
);
619 lpfc_issue_fabric_reglogin(vport
);
621 ndlp
->nlp_type
|= NLP_FABRIC
;
622 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_UNMAPPED_NODE
);
623 if ((!(vport
->fc_flag
& FC_VPORT_NEEDS_REG_VPI
)) &&
624 (vport
->vpi_state
& LPFC_VPI_REGISTERED
)) {
625 lpfc_start_fdiscs(phba
);
626 lpfc_do_scr_ns_plogi(phba
, vport
);
627 } else if (vport
->fc_flag
& FC_VFI_REGISTERED
)
628 lpfc_issue_init_vpi(vport
);
630 lpfc_issue_reg_vfi(vport
);
635 * lpfc_cmpl_els_flogi_nport - Completion function for flogi to an N_Port
636 * @vport: pointer to a host virtual N_Port data structure.
637 * @ndlp: pointer to a node-list data structure.
638 * @sp: pointer to service parameter data structure.
640 * This routine is invoked by the lpfc_cmpl_els_flogi() completion callback
641 * function to handle the completion of a Fabric Login (FLOGI) into an N_Port
642 * in a point-to-point topology. First, the @vport's N_Port Name is compared
643 * with the received N_Port Name: if the @vport's N_Port Name is greater than
644 * the received N_Port Name lexicographically, this node shall assign local
645 * N_Port ID (PT2PT_LocalID: 1) and remote N_Port ID (PT2PT_RemoteID: 2) and
646 * will send out Port Login (PLOGI) with the N_Port IDs assigned. Otherwise,
647 * this node shall just wait for the remote node to issue PLOGI and assign
655 lpfc_cmpl_els_flogi_nport(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
656 struct serv_parm
*sp
)
658 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
659 struct lpfc_hba
*phba
= vport
->phba
;
663 spin_lock_irq(shost
->host_lock
);
664 vport
->fc_flag
&= ~(FC_FABRIC
| FC_PUBLIC_LOOP
);
665 spin_unlock_irq(shost
->host_lock
);
667 phba
->fc_edtov
= FF_DEF_EDTOV
;
668 phba
->fc_ratov
= FF_DEF_RATOV
;
669 rc
= memcmp(&vport
->fc_portname
, &sp
->portName
,
670 sizeof(vport
->fc_portname
));
672 /* This side will initiate the PLOGI */
673 spin_lock_irq(shost
->host_lock
);
674 vport
->fc_flag
|= FC_PT2PT_PLOGI
;
675 spin_unlock_irq(shost
->host_lock
);
678 * N_Port ID cannot be 0, set our to LocalID the other
679 * side will be RemoteID.
684 vport
->fc_myDID
= PT2PT_LocalID
;
686 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
690 lpfc_config_link(phba
, mbox
);
692 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
694 rc
= lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
);
695 if (rc
== MBX_NOT_FINISHED
) {
696 mempool_free(mbox
, phba
->mbox_mem_pool
);
699 /* Decrement ndlp reference count indicating that ndlp can be
700 * safely released when other references to it are done.
704 ndlp
= lpfc_findnode_did(vport
, PT2PT_RemoteID
);
707 * Cannot find existing Fabric ndlp, so allocate a
710 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
713 lpfc_nlp_init(vport
, ndlp
, PT2PT_RemoteID
);
714 } else if (!NLP_CHK_NODE_ACT(ndlp
)) {
715 ndlp
= lpfc_enable_node(vport
, ndlp
,
716 NLP_STE_UNUSED_NODE
);
721 memcpy(&ndlp
->nlp_portname
, &sp
->portName
,
722 sizeof(struct lpfc_name
));
723 memcpy(&ndlp
->nlp_nodename
, &sp
->nodeName
,
724 sizeof(struct lpfc_name
));
725 /* Set state will put ndlp onto node list if not already done */
726 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
727 spin_lock_irq(shost
->host_lock
);
728 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
729 spin_unlock_irq(shost
->host_lock
);
731 /* This side will wait for the PLOGI, decrement ndlp reference
732 * count indicating that ndlp can be released when other
733 * references to it are done.
737 /* If we are pt2pt with another NPort, force NPIV off! */
738 phba
->sli3_options
&= ~LPFC_SLI3_NPIV_ENABLED
;
740 spin_lock_irq(shost
->host_lock
);
741 vport
->fc_flag
|= FC_PT2PT
;
742 spin_unlock_irq(shost
->host_lock
);
744 /* Start discovery - this should just do CLEAR_LA */
745 lpfc_disc_start(vport
);
752 * lpfc_cmpl_els_flogi - Completion callback function for flogi
753 * @phba: pointer to lpfc hba data structure.
754 * @cmdiocb: pointer to lpfc command iocb data structure.
755 * @rspiocb: pointer to lpfc response iocb data structure.
757 * This routine is the top-level completion callback function for issuing
758 * a Fabric Login (FLOGI) command. If the response IOCB reported error,
759 * the lpfc_els_retry() routine shall be invoked to retry the FLOGI. If
760 * retry has been made (either immediately or delayed with lpfc_els_retry()
761 * returning 1), the command IOCB will be released and function returned.
762 * If the retry attempt has been given up (possibly reach the maximum
763 * number of retries), one additional decrement of ndlp reference shall be
764 * invoked before going out after releasing the command IOCB. This will
765 * actually release the remote node (Note, lpfc_els_free_iocb() will also
766 * invoke one decrement of ndlp reference count). If no error reported in
767 * the IOCB status, the command Port ID field is used to determine whether
768 * this is a point-to-point topology or a fabric topology: if the Port ID
769 * field is assigned, it is a fabric topology; otherwise, it is a
770 * point-to-point topology. The routine lpfc_cmpl_els_flogi_fabric() or
771 * lpfc_cmpl_els_flogi_nport() shall be invoked accordingly to handle the
772 * specific topology completion conditions.
775 lpfc_cmpl_els_flogi(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
776 struct lpfc_iocbq
*rspiocb
)
778 struct lpfc_vport
*vport
= cmdiocb
->vport
;
779 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
780 IOCB_t
*irsp
= &rspiocb
->iocb
;
781 struct lpfc_nodelist
*ndlp
= cmdiocb
->context1
;
782 struct lpfc_dmabuf
*pcmd
= cmdiocb
->context2
, *prsp
;
783 struct serv_parm
*sp
;
787 /* Check to see if link went down during discovery */
788 if (lpfc_els_chk_latt(vport
)) {
789 /* One additional decrement on node reference count to
790 * trigger the release of the node
796 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
797 "FLOGI cmpl: status:x%x/x%x state:x%x",
798 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
801 if (irsp
->ulpStatus
) {
803 * In case of FIP mode, perform round robin FCF failover
804 * due to new FCF discovery
806 if ((phba
->hba_flag
& HBA_FIP_SUPPORT
) &&
807 (phba
->fcf
.fcf_flag
& FCF_DISCOVERY
) &&
808 (irsp
->ulpStatus
!= IOSTAT_LOCAL_REJECT
) &&
809 (irsp
->un
.ulpWord
[4] != IOERR_SLI_ABORTED
)) {
810 lpfc_printf_log(phba
, KERN_WARNING
, LOG_FIP
| LOG_ELS
,
811 "2611 FLOGI failed on registered "
812 "FCF record fcf_index(%d), status: "
813 "x%x/x%x, tmo:x%x, trying to perform "
814 "round robin failover\n",
815 phba
->fcf
.current_rec
.fcf_indx
,
816 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
818 fcf_index
= lpfc_sli4_fcf_rr_next_index_get(phba
);
819 if (fcf_index
== LPFC_FCOE_FCF_NEXT_NONE
) {
821 * Exhausted the eligible FCF record list,
822 * fail through to retry FLOGI on current
825 lpfc_printf_log(phba
, KERN_WARNING
,
827 "2760 Completed one round "
828 "of FLOGI FCF round robin "
829 "failover list, retry FLOGI "
830 "on currently registered "
832 phba
->fcf
.current_rec
.fcf_indx
);
834 lpfc_printf_log(phba
, KERN_INFO
,
836 "2794 FLOGI FCF round robin "
837 "failover to FCF index x%x\n",
839 rc
= lpfc_sli4_fcf_rr_read_fcf_rec(phba
,
842 lpfc_printf_log(phba
, KERN_WARNING
,
845 "robin FCF failover "
849 phba
->fcf
.current_rec
.fcf_indx
);
856 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
857 "2858 FLOGI failure Status:x%x/x%x TMO:x%x\n",
858 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
861 /* Check for retry */
862 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
))
865 /* FLOGI failed, so there is no fabric */
866 spin_lock_irq(shost
->host_lock
);
867 vport
->fc_flag
&= ~(FC_FABRIC
| FC_PUBLIC_LOOP
);
868 spin_unlock_irq(shost
->host_lock
);
870 /* If private loop, then allow max outstanding els to be
871 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
872 * alpa map would take too long otherwise.
874 if (phba
->alpa_map
[0] == 0) {
875 vport
->cfg_discovery_threads
= LPFC_MAX_DISC_THREADS
;
879 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
880 "0100 FLOGI failure Status:x%x/x%x TMO:x%x\n",
881 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
885 spin_lock_irq(shost
->host_lock
);
886 vport
->fc_flag
&= ~FC_VPORT_CVL_RCVD
;
887 vport
->fc_flag
&= ~FC_VPORT_LOGO_RCVD
;
888 spin_unlock_irq(shost
->host_lock
);
891 * The FLogI succeeded. Sync the data for the CPU before
894 prsp
= list_get_first(&pcmd
->list
, struct lpfc_dmabuf
, list
);
896 sp
= prsp
->virt
+ sizeof(uint32_t);
898 /* FLOGI completes successfully */
899 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
900 "0101 FLOGI completes successfully "
901 "Data: x%x x%x x%x x%x\n",
902 irsp
->un
.ulpWord
[4], sp
->cmn
.e_d_tov
,
903 sp
->cmn
.w2
.r_a_tov
, sp
->cmn
.edtovResolution
);
905 if (vport
->port_state
== LPFC_FLOGI
) {
907 * If Common Service Parameters indicate Nport
908 * we are point to point, if Fport we are Fabric.
911 rc
= lpfc_cmpl_els_flogi_fabric(vport
, ndlp
, sp
, irsp
);
912 else if (!(phba
->hba_flag
& HBA_FCOE_SUPPORT
))
913 rc
= lpfc_cmpl_els_flogi_nport(vport
, ndlp
, sp
);
915 lpfc_printf_vlog(vport
, KERN_ERR
,
917 "2831 FLOGI response with cleared Fabric "
918 "bit fcf_index 0x%x "
919 "Switch Name %02x%02x%02x%02x%02x%02x%02x%02x "
921 "%02x%02x%02x%02x%02x%02x%02x%02x\n",
922 phba
->fcf
.current_rec
.fcf_indx
,
923 phba
->fcf
.current_rec
.switch_name
[0],
924 phba
->fcf
.current_rec
.switch_name
[1],
925 phba
->fcf
.current_rec
.switch_name
[2],
926 phba
->fcf
.current_rec
.switch_name
[3],
927 phba
->fcf
.current_rec
.switch_name
[4],
928 phba
->fcf
.current_rec
.switch_name
[5],
929 phba
->fcf
.current_rec
.switch_name
[6],
930 phba
->fcf
.current_rec
.switch_name
[7],
931 phba
->fcf
.current_rec
.fabric_name
[0],
932 phba
->fcf
.current_rec
.fabric_name
[1],
933 phba
->fcf
.current_rec
.fabric_name
[2],
934 phba
->fcf
.current_rec
.fabric_name
[3],
935 phba
->fcf
.current_rec
.fabric_name
[4],
936 phba
->fcf
.current_rec
.fabric_name
[5],
937 phba
->fcf
.current_rec
.fabric_name
[6],
938 phba
->fcf
.current_rec
.fabric_name
[7]);
940 spin_lock_irq(&phba
->hbalock
);
941 phba
->fcf
.fcf_flag
&= ~FCF_DISCOVERY
;
942 spin_unlock_irq(&phba
->hbalock
);
946 /* Mark the FCF discovery process done */
947 if (phba
->hba_flag
& HBA_FIP_SUPPORT
)
948 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_FIP
|
950 "2769 FLOGI successful on FCF "
951 "record: current_fcf_index:"
952 "x%x, terminate FCF round "
953 "robin failover process\n",
954 phba
->fcf
.current_rec
.fcf_indx
);
955 spin_lock_irq(&phba
->hbalock
);
956 phba
->fcf
.fcf_flag
&= ~FCF_DISCOVERY
;
957 spin_unlock_irq(&phba
->hbalock
);
965 if (!lpfc_error_lost_link(irsp
)) {
966 /* FLOGI failed, so just use loop map to make discovery list */
967 lpfc_disc_list_loopmap(vport
);
969 /* Start discovery */
970 lpfc_disc_start(vport
);
971 } else if (((irsp
->ulpStatus
!= IOSTAT_LOCAL_REJECT
) ||
972 ((irsp
->un
.ulpWord
[4] != IOERR_SLI_ABORTED
) &&
973 (irsp
->un
.ulpWord
[4] != IOERR_SLI_DOWN
))) &&
974 (phba
->link_state
!= LPFC_CLEAR_LA
)) {
975 /* If FLOGI failed enable link interrupt. */
976 lpfc_issue_clear_la(phba
, vport
);
979 lpfc_els_free_iocb(phba
, cmdiocb
);
983 * lpfc_issue_els_flogi - Issue an flogi iocb command for a vport
984 * @vport: pointer to a host virtual N_Port data structure.
985 * @ndlp: pointer to a node-list data structure.
986 * @retry: number of retries to the command IOCB.
988 * This routine issues a Fabric Login (FLOGI) Request ELS command
989 * for a @vport. The initiator service parameters are put into the payload
990 * of the FLOGI Request IOCB and the top-level callback function pointer
991 * to lpfc_cmpl_els_flogi() routine is put to the IOCB completion callback
992 * function field. The lpfc_issue_fabric_iocb routine is invoked to send
993 * out FLOGI ELS command with one outstanding fabric IOCB at a time.
995 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
996 * will be incremented by 1 for holding the ndlp and the reference to ndlp
997 * will be stored into the context1 field of the IOCB for the completion
998 * callback function to the FLOGI ELS command.
1001 * 0 - successfully issued flogi iocb for @vport
1002 * 1 - failed to issue flogi iocb for @vport
1005 lpfc_issue_els_flogi(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1008 struct lpfc_hba
*phba
= vport
->phba
;
1009 struct serv_parm
*sp
;
1011 struct lpfc_iocbq
*elsiocb
;
1012 struct lpfc_sli_ring
*pring
;
1018 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
1020 cmdsize
= (sizeof(uint32_t) + sizeof(struct serv_parm
));
1021 elsiocb
= lpfc_prep_els_iocb(vport
, 1, cmdsize
, retry
, ndlp
,
1022 ndlp
->nlp_DID
, ELS_CMD_FLOGI
);
1027 icmd
= &elsiocb
->iocb
;
1028 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1030 /* For FLOGI request, remainder of payload is service parameters */
1031 *((uint32_t *) (pcmd
)) = ELS_CMD_FLOGI
;
1032 pcmd
+= sizeof(uint32_t);
1033 memcpy(pcmd
, &vport
->fc_sparam
, sizeof(struct serv_parm
));
1034 sp
= (struct serv_parm
*) pcmd
;
1036 /* Setup CSPs accordingly for Fabric */
1037 sp
->cmn
.e_d_tov
= 0;
1038 sp
->cmn
.w2
.r_a_tov
= 0;
1039 sp
->cls1
.classValid
= 0;
1040 sp
->cls2
.seqDelivery
= 1;
1041 sp
->cls3
.seqDelivery
= 1;
1042 if (sp
->cmn
.fcphLow
< FC_PH3
)
1043 sp
->cmn
.fcphLow
= FC_PH3
;
1044 if (sp
->cmn
.fcphHigh
< FC_PH3
)
1045 sp
->cmn
.fcphHigh
= FC_PH3
;
1047 if (phba
->sli_rev
== LPFC_SLI_REV4
) {
1048 elsiocb
->iocb
.ulpCt_h
= ((SLI4_CT_FCFI
>> 1) & 1);
1049 elsiocb
->iocb
.ulpCt_l
= (SLI4_CT_FCFI
& 1);
1050 /* FLOGI needs to be 3 for WQE FCFI */
1051 /* Set the fcfi to the fcfi we registered with */
1052 elsiocb
->iocb
.ulpContext
= phba
->fcf
.fcfi
;
1053 } else if (phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
) {
1054 sp
->cmn
.request_multiple_Nport
= 1;
1055 /* For FLOGI, Let FLOGI rsp set the NPortID for VPI 0 */
1060 if (phba
->fc_topology
!= TOPOLOGY_LOOP
) {
1061 icmd
->un
.elsreq64
.myID
= 0;
1062 icmd
->un
.elsreq64
.fl
= 1;
1065 tmo
= phba
->fc_ratov
;
1066 phba
->fc_ratov
= LPFC_DISC_FLOGI_TMO
;
1067 lpfc_set_disctmo(vport
);
1068 phba
->fc_ratov
= tmo
;
1070 phba
->fc_stat
.elsXmitFLOGI
++;
1071 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_flogi
;
1073 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
1074 "Issue FLOGI: opt:x%x",
1075 phba
->sli3_options
, 0, 0);
1077 rc
= lpfc_issue_fabric_iocb(phba
, elsiocb
);
1078 if (rc
== IOCB_ERROR
) {
1079 lpfc_els_free_iocb(phba
, elsiocb
);
1086 * lpfc_els_abort_flogi - Abort all outstanding flogi iocbs
1087 * @phba: pointer to lpfc hba data structure.
1089 * This routine aborts all the outstanding Fabric Login (FLOGI) IOCBs
1090 * with a @phba. This routine walks all the outstanding IOCBs on the txcmplq
1091 * list and issues an abort IOCB commond on each outstanding IOCB that
1092 * contains a active Fabric_DID ndlp. Note that this function is to issue
1093 * the abort IOCB command on all the outstanding IOCBs, thus when this
1094 * function returns, it does not guarantee all the IOCBs are actually aborted.
1097 * 0 - Successfully issued abort iocb on all outstanding flogis (Always 0)
1100 lpfc_els_abort_flogi(struct lpfc_hba
*phba
)
1102 struct lpfc_sli_ring
*pring
;
1103 struct lpfc_iocbq
*iocb
, *next_iocb
;
1104 struct lpfc_nodelist
*ndlp
;
1107 /* Abort outstanding I/O on NPort <nlp_DID> */
1108 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
1109 "0201 Abort outstanding I/O on NPort x%x\n",
1112 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
1115 * Check the txcmplq for an iocb that matches the nport the driver is
1118 spin_lock_irq(&phba
->hbalock
);
1119 list_for_each_entry_safe(iocb
, next_iocb
, &pring
->txcmplq
, list
) {
1121 if (icmd
->ulpCommand
== CMD_ELS_REQUEST64_CR
&&
1122 icmd
->un
.elsreq64
.bdl
.ulpIoTag32
) {
1123 ndlp
= (struct lpfc_nodelist
*)(iocb
->context1
);
1124 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
) &&
1125 (ndlp
->nlp_DID
== Fabric_DID
))
1126 lpfc_sli_issue_abort_iotag(phba
, pring
, iocb
);
1129 spin_unlock_irq(&phba
->hbalock
);
1135 * lpfc_initial_flogi - Issue an initial fabric login for a vport
1136 * @vport: pointer to a host virtual N_Port data structure.
1138 * This routine issues an initial Fabric Login (FLOGI) for the @vport
1139 * specified. It first searches the ndlp with the Fabric_DID (0xfffffe) from
1140 * the @vport's ndlp list. If no such ndlp found, it will create an ndlp and
1141 * put it into the @vport's ndlp list. If an inactive ndlp found on the list,
1142 * it will just be enabled and made active. The lpfc_issue_els_flogi() routine
1143 * is then invoked with the @vport and the ndlp to perform the FLOGI for the
1147 * 0 - failed to issue initial flogi for @vport
1148 * 1 - successfully issued initial flogi for @vport
1151 lpfc_initial_flogi(struct lpfc_vport
*vport
)
1153 struct lpfc_hba
*phba
= vport
->phba
;
1154 struct lpfc_nodelist
*ndlp
;
1156 vport
->port_state
= LPFC_FLOGI
;
1157 lpfc_set_disctmo(vport
);
1159 /* First look for the Fabric ndlp */
1160 ndlp
= lpfc_findnode_did(vport
, Fabric_DID
);
1162 /* Cannot find existing Fabric ndlp, so allocate a new one */
1163 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
1166 lpfc_nlp_init(vport
, ndlp
, Fabric_DID
);
1167 /* Set the node type */
1168 ndlp
->nlp_type
|= NLP_FABRIC
;
1169 /* Put ndlp onto node list */
1170 lpfc_enqueue_node(vport
, ndlp
);
1171 } else if (!NLP_CHK_NODE_ACT(ndlp
)) {
1172 /* re-setup ndlp without removing from node list */
1173 ndlp
= lpfc_enable_node(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
1178 if (lpfc_issue_els_flogi(vport
, ndlp
, 0))
1179 /* This decrement of reference count to node shall kick off
1180 * the release of the node.
1188 * lpfc_initial_fdisc - Issue an initial fabric discovery for a vport
1189 * @vport: pointer to a host virtual N_Port data structure.
1191 * This routine issues an initial Fabric Discover (FDISC) for the @vport
1192 * specified. It first searches the ndlp with the Fabric_DID (0xfffffe) from
1193 * the @vport's ndlp list. If no such ndlp found, it will create an ndlp and
1194 * put it into the @vport's ndlp list. If an inactive ndlp found on the list,
1195 * it will just be enabled and made active. The lpfc_issue_els_fdisc() routine
1196 * is then invoked with the @vport and the ndlp to perform the FDISC for the
1200 * 0 - failed to issue initial fdisc for @vport
1201 * 1 - successfully issued initial fdisc for @vport
1204 lpfc_initial_fdisc(struct lpfc_vport
*vport
)
1206 struct lpfc_hba
*phba
= vport
->phba
;
1207 struct lpfc_nodelist
*ndlp
;
1209 /* First look for the Fabric ndlp */
1210 ndlp
= lpfc_findnode_did(vport
, Fabric_DID
);
1212 /* Cannot find existing Fabric ndlp, so allocate a new one */
1213 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
1216 lpfc_nlp_init(vport
, ndlp
, Fabric_DID
);
1217 /* Put ndlp onto node list */
1218 lpfc_enqueue_node(vport
, ndlp
);
1219 } else if (!NLP_CHK_NODE_ACT(ndlp
)) {
1220 /* re-setup ndlp without removing from node list */
1221 ndlp
= lpfc_enable_node(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
1226 if (lpfc_issue_els_fdisc(vport
, ndlp
, 0)) {
1227 /* decrement node reference count to trigger the release of
1237 * lpfc_more_plogi - Check and issue remaining plogis for a vport
1238 * @vport: pointer to a host virtual N_Port data structure.
1240 * This routine checks whether there are more remaining Port Logins
1241 * (PLOGI) to be issued for the @vport. If so, it will invoke the routine
1242 * lpfc_els_disc_plogi() to go through the Node Port Recovery (NPR) nodes
1243 * to issue ELS PLOGIs up to the configured discover threads with the
1244 * @vport (@vport->cfg_discovery_threads). The function also decrement
1245 * the @vport's num_disc_node by 1 if it is not already 0.
1248 lpfc_more_plogi(struct lpfc_vport
*vport
)
1252 if (vport
->num_disc_nodes
)
1253 vport
->num_disc_nodes
--;
1255 /* Continue discovery with <num_disc_nodes> PLOGIs to go */
1256 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_DISCOVERY
,
1257 "0232 Continue discovery with %d PLOGIs to go "
1258 "Data: x%x x%x x%x\n",
1259 vport
->num_disc_nodes
, vport
->fc_plogi_cnt
,
1260 vport
->fc_flag
, vport
->port_state
);
1261 /* Check to see if there are more PLOGIs to be sent */
1262 if (vport
->fc_flag
& FC_NLP_MORE
)
1263 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
1264 sentplogi
= lpfc_els_disc_plogi(vport
);
1270 * lpfc_plogi_confirm_nport - Confirm pologi wwpn matches stored ndlp
1271 * @phba: pointer to lpfc hba data structure.
1272 * @prsp: pointer to response IOCB payload.
1273 * @ndlp: pointer to a node-list data structure.
1275 * This routine checks and indicates whether the WWPN of an N_Port, retrieved
1276 * from a PLOGI, matches the WWPN that is stored in the @ndlp for that N_POrt.
1277 * The following cases are considered N_Port confirmed:
1278 * 1) The N_Port is a Fabric ndlp; 2) The @ndlp is on vport list and matches
1279 * the WWPN of the N_Port logged into; 3) The @ndlp is not on vport list but
1280 * it does not have WWPN assigned either. If the WWPN is confirmed, the
1281 * pointer to the @ndlp will be returned. If the WWPN is not confirmed:
1282 * 1) if there is a node on vport list other than the @ndlp with the same
1283 * WWPN of the N_Port PLOGI logged into, the lpfc_unreg_rpi() will be invoked
1284 * on that node to release the RPI associated with the node; 2) if there is
1285 * no node found on vport list with the same WWPN of the N_Port PLOGI logged
1286 * into, a new node shall be allocated (or activated). In either case, the
1287 * parameters of the @ndlp shall be copied to the new_ndlp, the @ndlp shall
1288 * be released and the new_ndlp shall be put on to the vport node list and
1289 * its pointer returned as the confirmed node.
1291 * Note that before the @ndlp got "released", the keepDID from not-matching
1292 * or inactive "new_ndlp" on the vport node list is assigned to the nlp_DID
1293 * of the @ndlp. This is because the release of @ndlp is actually to put it
1294 * into an inactive state on the vport node list and the vport node list
1295 * management algorithm does not allow two node with a same DID.
1298 * pointer to the PLOGI N_Port @ndlp
1300 static struct lpfc_nodelist
*
1301 lpfc_plogi_confirm_nport(struct lpfc_hba
*phba
, uint32_t *prsp
,
1302 struct lpfc_nodelist
*ndlp
)
1304 struct lpfc_vport
*vport
= ndlp
->vport
;
1305 struct lpfc_nodelist
*new_ndlp
;
1306 struct lpfc_rport_data
*rdata
;
1307 struct fc_rport
*rport
;
1308 struct serv_parm
*sp
;
1309 uint8_t name
[sizeof(struct lpfc_name
)];
1310 uint32_t rc
, keepDID
= 0;
1314 /* Fabric nodes can have the same WWPN so we don't bother searching
1315 * by WWPN. Just return the ndlp that was given to us.
1317 if (ndlp
->nlp_type
& NLP_FABRIC
)
1320 sp
= (struct serv_parm
*) ((uint8_t *) prsp
+ sizeof(uint32_t));
1321 memset(name
, 0, sizeof(struct lpfc_name
));
1323 /* Now we find out if the NPort we are logging into, matches the WWPN
1324 * we have for that ndlp. If not, we have some work to do.
1326 new_ndlp
= lpfc_findnode_wwpn(vport
, &sp
->portName
);
1328 if (new_ndlp
== ndlp
&& NLP_CHK_NODE_ACT(new_ndlp
))
1332 rc
= memcmp(&ndlp
->nlp_portname
, name
,
1333 sizeof(struct lpfc_name
));
1336 new_ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_ATOMIC
);
1339 lpfc_nlp_init(vport
, new_ndlp
, ndlp
->nlp_DID
);
1340 } else if (!NLP_CHK_NODE_ACT(new_ndlp
)) {
1341 rc
= memcmp(&ndlp
->nlp_portname
, name
,
1342 sizeof(struct lpfc_name
));
1345 new_ndlp
= lpfc_enable_node(vport
, new_ndlp
,
1346 NLP_STE_UNUSED_NODE
);
1349 keepDID
= new_ndlp
->nlp_DID
;
1351 keepDID
= new_ndlp
->nlp_DID
;
1353 lpfc_unreg_rpi(vport
, new_ndlp
);
1354 new_ndlp
->nlp_DID
= ndlp
->nlp_DID
;
1355 new_ndlp
->nlp_prev_state
= ndlp
->nlp_prev_state
;
1357 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
)
1358 new_ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
1359 ndlp
->nlp_flag
&= ~NLP_NPR_2B_DISC
;
1361 /* Set state will put new_ndlp on to node list if not already done */
1362 lpfc_nlp_set_state(vport
, new_ndlp
, ndlp
->nlp_state
);
1364 /* Move this back to NPR state */
1365 if (memcmp(&ndlp
->nlp_portname
, name
, sizeof(struct lpfc_name
)) == 0) {
1366 /* The new_ndlp is replacing ndlp totally, so we need
1367 * to put ndlp on UNUSED list and try to free it.
1370 /* Fix up the rport accordingly */
1371 rport
= ndlp
->rport
;
1373 rdata
= rport
->dd_data
;
1374 if (rdata
->pnode
== ndlp
) {
1377 rdata
->pnode
= lpfc_nlp_get(new_ndlp
);
1378 new_ndlp
->rport
= rport
;
1380 new_ndlp
->nlp_type
= ndlp
->nlp_type
;
1382 /* We shall actually free the ndlp with both nlp_DID and
1383 * nlp_portname fields equals 0 to avoid any ndlp on the
1384 * nodelist never to be used.
1386 if (ndlp
->nlp_DID
== 0) {
1387 spin_lock_irq(&phba
->ndlp_lock
);
1388 NLP_SET_FREE_REQ(ndlp
);
1389 spin_unlock_irq(&phba
->ndlp_lock
);
1392 /* Two ndlps cannot have the same did on the nodelist */
1393 ndlp
->nlp_DID
= keepDID
;
1394 lpfc_drop_node(vport
, ndlp
);
1397 lpfc_unreg_rpi(vport
, ndlp
);
1398 /* Two ndlps cannot have the same did */
1399 ndlp
->nlp_DID
= keepDID
;
1400 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
1401 /* Since we are swapping the ndlp passed in with the new one
1402 * and the did has already been swapped, copy over the
1405 memcpy(&new_ndlp
->nlp_portname
, &ndlp
->nlp_portname
,
1406 sizeof(struct lpfc_name
));
1407 memcpy(&new_ndlp
->nlp_nodename
, &ndlp
->nlp_nodename
,
1408 sizeof(struct lpfc_name
));
1409 new_ndlp
->nlp_state
= ndlp
->nlp_state
;
1410 /* Fix up the rport accordingly */
1411 rport
= ndlp
->rport
;
1413 rdata
= rport
->dd_data
;
1414 put_node
= rdata
->pnode
!= NULL
;
1415 put_rport
= ndlp
->rport
!= NULL
;
1416 rdata
->pnode
= NULL
;
1421 put_device(&rport
->dev
);
1428 * lpfc_end_rscn - Check and handle more rscn for a vport
1429 * @vport: pointer to a host virtual N_Port data structure.
1431 * This routine checks whether more Registration State Change
1432 * Notifications (RSCNs) came in while the discovery state machine was in
1433 * the FC_RSCN_MODE. If so, the lpfc_els_handle_rscn() routine will be
1434 * invoked to handle the additional RSCNs for the @vport. Otherwise, the
1435 * FC_RSCN_MODE bit will be cleared with the @vport to mark as the end of
1436 * handling the RSCNs.
1439 lpfc_end_rscn(struct lpfc_vport
*vport
)
1441 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1443 if (vport
->fc_flag
& FC_RSCN_MODE
) {
1445 * Check to see if more RSCNs came in while we were
1446 * processing this one.
1448 if (vport
->fc_rscn_id_cnt
||
1449 (vport
->fc_flag
& FC_RSCN_DISCOVERY
) != 0)
1450 lpfc_els_handle_rscn(vport
);
1452 spin_lock_irq(shost
->host_lock
);
1453 vport
->fc_flag
&= ~FC_RSCN_MODE
;
1454 spin_unlock_irq(shost
->host_lock
);
1460 * lpfc_cmpl_els_plogi - Completion callback function for plogi
1461 * @phba: pointer to lpfc hba data structure.
1462 * @cmdiocb: pointer to lpfc command iocb data structure.
1463 * @rspiocb: pointer to lpfc response iocb data structure.
1465 * This routine is the completion callback function for issuing the Port
1466 * Login (PLOGI) command. For PLOGI completion, there must be an active
1467 * ndlp on the vport node list that matches the remote node ID from the
1468 * PLOGI reponse IOCB. If such ndlp does not exist, the PLOGI is simply
1469 * ignored and command IOCB released. The PLOGI response IOCB status is
1470 * checked for error conditons. If there is error status reported, PLOGI
1471 * retry shall be attempted by invoking the lpfc_els_retry() routine.
1472 * Otherwise, the lpfc_plogi_confirm_nport() routine shall be invoked on
1473 * the ndlp and the NLP_EVT_CMPL_PLOGI state to the Discover State Machine
1474 * (DSM) is set for this PLOGI completion. Finally, it checks whether
1475 * there are additional N_Port nodes with the vport that need to perform
1476 * PLOGI. If so, the lpfc_more_plogi() routine is invoked to issue addition
1480 lpfc_cmpl_els_plogi(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
1481 struct lpfc_iocbq
*rspiocb
)
1483 struct lpfc_vport
*vport
= cmdiocb
->vport
;
1484 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1486 struct lpfc_nodelist
*ndlp
;
1487 struct lpfc_dmabuf
*prsp
;
1488 int disc
, rc
, did
, type
;
1490 /* we pass cmdiocb to state machine which needs rspiocb as well */
1491 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
1493 irsp
= &rspiocb
->iocb
;
1494 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
1495 "PLOGI cmpl: status:x%x/x%x did:x%x",
1496 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
1497 irsp
->un
.elsreq64
.remoteID
);
1499 ndlp
= lpfc_findnode_did(vport
, irsp
->un
.elsreq64
.remoteID
);
1500 if (!ndlp
|| !NLP_CHK_NODE_ACT(ndlp
)) {
1501 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
1502 "0136 PLOGI completes to NPort x%x "
1503 "with no ndlp. Data: x%x x%x x%x\n",
1504 irsp
->un
.elsreq64
.remoteID
,
1505 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
1510 /* Since ndlp can be freed in the disc state machine, note if this node
1511 * is being used during discovery.
1513 spin_lock_irq(shost
->host_lock
);
1514 disc
= (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
);
1515 ndlp
->nlp_flag
&= ~NLP_NPR_2B_DISC
;
1516 spin_unlock_irq(shost
->host_lock
);
1519 /* PLOGI completes to NPort <nlp_DID> */
1520 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
1521 "0102 PLOGI completes to NPort x%x "
1522 "Data: x%x x%x x%x x%x x%x\n",
1523 ndlp
->nlp_DID
, irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
1524 irsp
->ulpTimeout
, disc
, vport
->num_disc_nodes
);
1525 /* Check to see if link went down during discovery */
1526 if (lpfc_els_chk_latt(vport
)) {
1527 spin_lock_irq(shost
->host_lock
);
1528 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
1529 spin_unlock_irq(shost
->host_lock
);
1533 /* ndlp could be freed in DSM, save these values now */
1534 type
= ndlp
->nlp_type
;
1535 did
= ndlp
->nlp_DID
;
1537 if (irsp
->ulpStatus
) {
1538 /* Check for retry */
1539 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
1540 /* ELS command is being retried */
1542 spin_lock_irq(shost
->host_lock
);
1543 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
1544 spin_unlock_irq(shost
->host_lock
);
1548 /* PLOGI failed Don't print the vport to vport rjts */
1549 if (irsp
->ulpStatus
!= IOSTAT_LS_RJT
||
1550 (((irsp
->un
.ulpWord
[4]) >> 16 != LSRJT_INVALID_CMD
) &&
1551 ((irsp
->un
.ulpWord
[4]) >> 16 != LSRJT_UNABLE_TPC
)) ||
1552 (phba
)->pport
->cfg_log_verbose
& LOG_ELS
)
1553 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
1554 "2753 PLOGI failure DID:%06X Status:x%x/x%x\n",
1555 ndlp
->nlp_DID
, irsp
->ulpStatus
,
1556 irsp
->un
.ulpWord
[4]);
1557 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1558 if (lpfc_error_lost_link(irsp
))
1559 rc
= NLP_STE_FREED_NODE
;
1561 rc
= lpfc_disc_state_machine(vport
, ndlp
, cmdiocb
,
1562 NLP_EVT_CMPL_PLOGI
);
1564 /* Good status, call state machine */
1565 prsp
= list_entry(((struct lpfc_dmabuf
*)
1566 cmdiocb
->context2
)->list
.next
,
1567 struct lpfc_dmabuf
, list
);
1568 ndlp
= lpfc_plogi_confirm_nport(phba
, prsp
->virt
, ndlp
);
1569 rc
= lpfc_disc_state_machine(vport
, ndlp
, cmdiocb
,
1570 NLP_EVT_CMPL_PLOGI
);
1573 if (disc
&& vport
->num_disc_nodes
) {
1574 /* Check to see if there are more PLOGIs to be sent */
1575 lpfc_more_plogi(vport
);
1577 if (vport
->num_disc_nodes
== 0) {
1578 spin_lock_irq(shost
->host_lock
);
1579 vport
->fc_flag
&= ~FC_NDISC_ACTIVE
;
1580 spin_unlock_irq(shost
->host_lock
);
1582 lpfc_can_disctmo(vport
);
1583 lpfc_end_rscn(vport
);
1588 lpfc_els_free_iocb(phba
, cmdiocb
);
1593 * lpfc_issue_els_plogi - Issue an plogi iocb command for a vport
1594 * @vport: pointer to a host virtual N_Port data structure.
1595 * @did: destination port identifier.
1596 * @retry: number of retries to the command IOCB.
1598 * This routine issues a Port Login (PLOGI) command to a remote N_Port
1599 * (with the @did) for a @vport. Before issuing a PLOGI to a remote N_Port,
1600 * the ndlp with the remote N_Port DID must exist on the @vport's ndlp list.
1601 * This routine constructs the proper feilds of the PLOGI IOCB and invokes
1602 * the lpfc_sli_issue_iocb() routine to send out PLOGI ELS command.
1604 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
1605 * will be incremented by 1 for holding the ndlp and the reference to ndlp
1606 * will be stored into the context1 field of the IOCB for the completion
1607 * callback function to the PLOGI ELS command.
1610 * 0 - Successfully issued a plogi for @vport
1611 * 1 - failed to issue a plogi for @vport
1614 lpfc_issue_els_plogi(struct lpfc_vport
*vport
, uint32_t did
, uint8_t retry
)
1616 struct lpfc_hba
*phba
= vport
->phba
;
1617 struct serv_parm
*sp
;
1619 struct lpfc_nodelist
*ndlp
;
1620 struct lpfc_iocbq
*elsiocb
;
1621 struct lpfc_sli
*psli
;
1628 ndlp
= lpfc_findnode_did(vport
, did
);
1629 if (ndlp
&& !NLP_CHK_NODE_ACT(ndlp
))
1632 /* If ndlp is not NULL, we will bump the reference count on it */
1633 cmdsize
= (sizeof(uint32_t) + sizeof(struct serv_parm
));
1634 elsiocb
= lpfc_prep_els_iocb(vport
, 1, cmdsize
, retry
, ndlp
, did
,
1639 icmd
= &elsiocb
->iocb
;
1640 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1642 /* For PLOGI request, remainder of payload is service parameters */
1643 *((uint32_t *) (pcmd
)) = ELS_CMD_PLOGI
;
1644 pcmd
+= sizeof(uint32_t);
1645 memcpy(pcmd
, &vport
->fc_sparam
, sizeof(struct serv_parm
));
1646 sp
= (struct serv_parm
*) pcmd
;
1648 if (sp
->cmn
.fcphLow
< FC_PH_4_3
)
1649 sp
->cmn
.fcphLow
= FC_PH_4_3
;
1651 if (sp
->cmn
.fcphHigh
< FC_PH3
)
1652 sp
->cmn
.fcphHigh
= FC_PH3
;
1654 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
1655 "Issue PLOGI: did:x%x",
1658 phba
->fc_stat
.elsXmitPLOGI
++;
1659 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_plogi
;
1660 ret
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0);
1662 if (ret
== IOCB_ERROR
) {
1663 lpfc_els_free_iocb(phba
, elsiocb
);
1670 * lpfc_cmpl_els_prli - Completion callback function for prli
1671 * @phba: pointer to lpfc hba data structure.
1672 * @cmdiocb: pointer to lpfc command iocb data structure.
1673 * @rspiocb: pointer to lpfc response iocb data structure.
1675 * This routine is the completion callback function for a Process Login
1676 * (PRLI) ELS command. The PRLI response IOCB status is checked for error
1677 * status. If there is error status reported, PRLI retry shall be attempted
1678 * by invoking the lpfc_els_retry() routine. Otherwise, the state
1679 * NLP_EVT_CMPL_PRLI is sent to the Discover State Machine (DSM) for this
1680 * ndlp to mark the PRLI completion.
1683 lpfc_cmpl_els_prli(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
1684 struct lpfc_iocbq
*rspiocb
)
1686 struct lpfc_vport
*vport
= cmdiocb
->vport
;
1687 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1689 struct lpfc_sli
*psli
;
1690 struct lpfc_nodelist
*ndlp
;
1693 /* we pass cmdiocb to state machine which needs rspiocb as well */
1694 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
1696 irsp
= &(rspiocb
->iocb
);
1697 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1698 spin_lock_irq(shost
->host_lock
);
1699 ndlp
->nlp_flag
&= ~NLP_PRLI_SND
;
1700 spin_unlock_irq(shost
->host_lock
);
1702 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
1703 "PRLI cmpl: status:x%x/x%x did:x%x",
1704 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
1706 /* PRLI completes to NPort <nlp_DID> */
1707 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
1708 "0103 PRLI completes to NPort x%x "
1709 "Data: x%x x%x x%x x%x\n",
1710 ndlp
->nlp_DID
, irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
1711 irsp
->ulpTimeout
, vport
->num_disc_nodes
);
1713 vport
->fc_prli_sent
--;
1714 /* Check to see if link went down during discovery */
1715 if (lpfc_els_chk_latt(vport
))
1718 if (irsp
->ulpStatus
) {
1719 /* Check for retry */
1720 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
1721 /* ELS command is being retried */
1725 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
1726 "2754 PRLI failure DID:%06X Status:x%x/x%x\n",
1727 ndlp
->nlp_DID
, irsp
->ulpStatus
,
1728 irsp
->un
.ulpWord
[4]);
1729 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1730 if (lpfc_error_lost_link(irsp
))
1733 lpfc_disc_state_machine(vport
, ndlp
, cmdiocb
,
1736 /* Good status, call state machine */
1737 lpfc_disc_state_machine(vport
, ndlp
, cmdiocb
,
1740 lpfc_els_free_iocb(phba
, cmdiocb
);
1745 * lpfc_issue_els_prli - Issue a prli iocb command for a vport
1746 * @vport: pointer to a host virtual N_Port data structure.
1747 * @ndlp: pointer to a node-list data structure.
1748 * @retry: number of retries to the command IOCB.
1750 * This routine issues a Process Login (PRLI) ELS command for the
1751 * @vport. The PRLI service parameters are set up in the payload of the
1752 * PRLI Request command and the pointer to lpfc_cmpl_els_prli() routine
1753 * is put to the IOCB completion callback func field before invoking the
1754 * routine lpfc_sli_issue_iocb() to send out PRLI command.
1756 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
1757 * will be incremented by 1 for holding the ndlp and the reference to ndlp
1758 * will be stored into the context1 field of the IOCB for the completion
1759 * callback function to the PRLI ELS command.
1762 * 0 - successfully issued prli iocb command for @vport
1763 * 1 - failed to issue prli iocb command for @vport
1766 lpfc_issue_els_prli(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
1769 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1770 struct lpfc_hba
*phba
= vport
->phba
;
1773 struct lpfc_iocbq
*elsiocb
;
1777 cmdsize
= (sizeof(uint32_t) + sizeof(PRLI
));
1778 elsiocb
= lpfc_prep_els_iocb(vport
, 1, cmdsize
, retry
, ndlp
,
1779 ndlp
->nlp_DID
, ELS_CMD_PRLI
);
1783 icmd
= &elsiocb
->iocb
;
1784 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1786 /* For PRLI request, remainder of payload is service parameters */
1787 memset(pcmd
, 0, (sizeof(PRLI
) + sizeof(uint32_t)));
1788 *((uint32_t *) (pcmd
)) = ELS_CMD_PRLI
;
1789 pcmd
+= sizeof(uint32_t);
1791 /* For PRLI, remainder of payload is PRLI parameter page */
1792 npr
= (PRLI
*) pcmd
;
1794 * If our firmware version is 3.20 or later,
1795 * set the following bits for FC-TAPE support.
1797 if (phba
->vpd
.rev
.feaLevelHigh
>= 0x02) {
1798 npr
->ConfmComplAllowed
= 1;
1800 npr
->TaskRetryIdReq
= 1;
1802 npr
->estabImagePair
= 1;
1803 npr
->readXferRdyDis
= 1;
1805 /* For FCP support */
1806 npr
->prliType
= PRLI_FCP_TYPE
;
1807 npr
->initiatorFunc
= 1;
1809 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
1810 "Issue PRLI: did:x%x",
1811 ndlp
->nlp_DID
, 0, 0);
1813 phba
->fc_stat
.elsXmitPRLI
++;
1814 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_prli
;
1815 spin_lock_irq(shost
->host_lock
);
1816 ndlp
->nlp_flag
|= NLP_PRLI_SND
;
1817 spin_unlock_irq(shost
->host_lock
);
1818 if (lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0) ==
1820 spin_lock_irq(shost
->host_lock
);
1821 ndlp
->nlp_flag
&= ~NLP_PRLI_SND
;
1822 spin_unlock_irq(shost
->host_lock
);
1823 lpfc_els_free_iocb(phba
, elsiocb
);
1826 vport
->fc_prli_sent
++;
1831 * lpfc_rscn_disc - Perform rscn discovery for a vport
1832 * @vport: pointer to a host virtual N_Port data structure.
1834 * This routine performs Registration State Change Notification (RSCN)
1835 * discovery for a @vport. If the @vport's node port recovery count is not
1836 * zero, it will invoke the lpfc_els_disc_plogi() to perform PLOGI for all
1837 * the nodes that need recovery. If none of the PLOGI were needed through
1838 * the lpfc_els_disc_plogi() routine, the lpfc_end_rscn() routine shall be
1839 * invoked to check and handle possible more RSCN came in during the period
1840 * of processing the current ones.
1843 lpfc_rscn_disc(struct lpfc_vport
*vport
)
1845 lpfc_can_disctmo(vport
);
1847 /* RSCN discovery */
1848 /* go thru NPR nodes and issue ELS PLOGIs */
1849 if (vport
->fc_npr_cnt
)
1850 if (lpfc_els_disc_plogi(vport
))
1853 lpfc_end_rscn(vport
);
1857 * lpfc_adisc_done - Complete the adisc phase of discovery
1858 * @vport: pointer to lpfc_vport hba data structure that finished all ADISCs.
1860 * This function is called when the final ADISC is completed during discovery.
1861 * This function handles clearing link attention or issuing reg_vpi depending
1862 * on whether npiv is enabled. This function also kicks off the PLOGI phase of
1864 * This function is called with no locks held.
1867 lpfc_adisc_done(struct lpfc_vport
*vport
)
1869 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1870 struct lpfc_hba
*phba
= vport
->phba
;
1873 * For NPIV, cmpl_reg_vpi will set port_state to READY,
1874 * and continue discovery.
1876 if ((phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
) &&
1877 !(vport
->fc_flag
& FC_RSCN_MODE
) &&
1878 (phba
->sli_rev
< LPFC_SLI_REV4
)) {
1879 lpfc_issue_reg_vpi(phba
, vport
);
1883 * For SLI2, we need to set port_state to READY
1884 * and continue discovery.
1886 if (vport
->port_state
< LPFC_VPORT_READY
) {
1887 /* If we get here, there is nothing to ADISC */
1888 if (vport
->port_type
== LPFC_PHYSICAL_PORT
)
1889 lpfc_issue_clear_la(phba
, vport
);
1890 if (!(vport
->fc_flag
& FC_ABORT_DISCOVERY
)) {
1891 vport
->num_disc_nodes
= 0;
1892 /* go thru NPR list, issue ELS PLOGIs */
1893 if (vport
->fc_npr_cnt
)
1894 lpfc_els_disc_plogi(vport
);
1895 if (!vport
->num_disc_nodes
) {
1896 spin_lock_irq(shost
->host_lock
);
1897 vport
->fc_flag
&= ~FC_NDISC_ACTIVE
;
1898 spin_unlock_irq(shost
->host_lock
);
1899 lpfc_can_disctmo(vport
);
1900 lpfc_end_rscn(vport
);
1903 vport
->port_state
= LPFC_VPORT_READY
;
1905 lpfc_rscn_disc(vport
);
1909 * lpfc_more_adisc - Issue more adisc as needed
1910 * @vport: pointer to a host virtual N_Port data structure.
1912 * This routine determines whether there are more ndlps on a @vport
1913 * node list need to have Address Discover (ADISC) issued. If so, it will
1914 * invoke the lpfc_els_disc_adisc() routine to issue ADISC on the @vport's
1915 * remaining nodes which need to have ADISC sent.
1918 lpfc_more_adisc(struct lpfc_vport
*vport
)
1922 if (vport
->num_disc_nodes
)
1923 vport
->num_disc_nodes
--;
1924 /* Continue discovery with <num_disc_nodes> ADISCs to go */
1925 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_DISCOVERY
,
1926 "0210 Continue discovery with %d ADISCs to go "
1927 "Data: x%x x%x x%x\n",
1928 vport
->num_disc_nodes
, vport
->fc_adisc_cnt
,
1929 vport
->fc_flag
, vport
->port_state
);
1930 /* Check to see if there are more ADISCs to be sent */
1931 if (vport
->fc_flag
& FC_NLP_MORE
) {
1932 lpfc_set_disctmo(vport
);
1933 /* go thru NPR nodes and issue any remaining ELS ADISCs */
1934 sentadisc
= lpfc_els_disc_adisc(vport
);
1936 if (!vport
->num_disc_nodes
)
1937 lpfc_adisc_done(vport
);
1942 * lpfc_cmpl_els_adisc - Completion callback function for adisc
1943 * @phba: pointer to lpfc hba data structure.
1944 * @cmdiocb: pointer to lpfc command iocb data structure.
1945 * @rspiocb: pointer to lpfc response iocb data structure.
1947 * This routine is the completion function for issuing the Address Discover
1948 * (ADISC) command. It first checks to see whether link went down during
1949 * the discovery process. If so, the node will be marked as node port
1950 * recovery for issuing discover IOCB by the link attention handler and
1951 * exit. Otherwise, the response status is checked. If error was reported
1952 * in the response status, the ADISC command shall be retried by invoking
1953 * the lpfc_els_retry() routine. Otherwise, if no error was reported in
1954 * the response status, the state machine is invoked to set transition
1955 * with respect to NLP_EVT_CMPL_ADISC event.
1958 lpfc_cmpl_els_adisc(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
1959 struct lpfc_iocbq
*rspiocb
)
1961 struct lpfc_vport
*vport
= cmdiocb
->vport
;
1962 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1964 struct lpfc_nodelist
*ndlp
;
1967 /* we pass cmdiocb to state machine which needs rspiocb as well */
1968 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
1970 irsp
= &(rspiocb
->iocb
);
1971 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1973 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
1974 "ADISC cmpl: status:x%x/x%x did:x%x",
1975 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
1978 /* Since ndlp can be freed in the disc state machine, note if this node
1979 * is being used during discovery.
1981 spin_lock_irq(shost
->host_lock
);
1982 disc
= (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
);
1983 ndlp
->nlp_flag
&= ~(NLP_ADISC_SND
| NLP_NPR_2B_DISC
);
1984 spin_unlock_irq(shost
->host_lock
);
1985 /* ADISC completes to NPort <nlp_DID> */
1986 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
1987 "0104 ADISC completes to NPort x%x "
1988 "Data: x%x x%x x%x x%x x%x\n",
1989 ndlp
->nlp_DID
, irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
1990 irsp
->ulpTimeout
, disc
, vport
->num_disc_nodes
);
1991 /* Check to see if link went down during discovery */
1992 if (lpfc_els_chk_latt(vport
)) {
1993 spin_lock_irq(shost
->host_lock
);
1994 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
1995 spin_unlock_irq(shost
->host_lock
);
1999 if (irsp
->ulpStatus
) {
2000 /* Check for retry */
2001 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
2002 /* ELS command is being retried */
2004 spin_lock_irq(shost
->host_lock
);
2005 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
2006 spin_unlock_irq(shost
->host_lock
);
2007 lpfc_set_disctmo(vport
);
2012 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
2013 "2755 ADISC failure DID:%06X Status:x%x/x%x\n",
2014 ndlp
->nlp_DID
, irsp
->ulpStatus
,
2015 irsp
->un
.ulpWord
[4]);
2016 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
2017 if (!lpfc_error_lost_link(irsp
))
2018 lpfc_disc_state_machine(vport
, ndlp
, cmdiocb
,
2019 NLP_EVT_CMPL_ADISC
);
2021 /* Good status, call state machine */
2022 lpfc_disc_state_machine(vport
, ndlp
, cmdiocb
,
2023 NLP_EVT_CMPL_ADISC
);
2025 /* Check to see if there are more ADISCs to be sent */
2026 if (disc
&& vport
->num_disc_nodes
)
2027 lpfc_more_adisc(vport
);
2029 lpfc_els_free_iocb(phba
, cmdiocb
);
2034 * lpfc_issue_els_adisc - Issue an address discover iocb to an node on a vport
2035 * @vport: pointer to a virtual N_Port data structure.
2036 * @ndlp: pointer to a node-list data structure.
2037 * @retry: number of retries to the command IOCB.
2039 * This routine issues an Address Discover (ADISC) for an @ndlp on a
2040 * @vport. It prepares the payload of the ADISC ELS command, updates the
2041 * and states of the ndlp, and invokes the lpfc_sli_issue_iocb() routine
2042 * to issue the ADISC ELS command.
2044 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
2045 * will be incremented by 1 for holding the ndlp and the reference to ndlp
2046 * will be stored into the context1 field of the IOCB for the completion
2047 * callback function to the ADISC ELS command.
2050 * 0 - successfully issued adisc
2051 * 1 - failed to issue adisc
2054 lpfc_issue_els_adisc(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
2057 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
2058 struct lpfc_hba
*phba
= vport
->phba
;
2061 struct lpfc_iocbq
*elsiocb
;
2065 cmdsize
= (sizeof(uint32_t) + sizeof(ADISC
));
2066 elsiocb
= lpfc_prep_els_iocb(vport
, 1, cmdsize
, retry
, ndlp
,
2067 ndlp
->nlp_DID
, ELS_CMD_ADISC
);
2071 icmd
= &elsiocb
->iocb
;
2072 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2074 /* For ADISC request, remainder of payload is service parameters */
2075 *((uint32_t *) (pcmd
)) = ELS_CMD_ADISC
;
2076 pcmd
+= sizeof(uint32_t);
2078 /* Fill in ADISC payload */
2079 ap
= (ADISC
*) pcmd
;
2080 ap
->hardAL_PA
= phba
->fc_pref_ALPA
;
2081 memcpy(&ap
->portName
, &vport
->fc_portname
, sizeof(struct lpfc_name
));
2082 memcpy(&ap
->nodeName
, &vport
->fc_nodename
, sizeof(struct lpfc_name
));
2083 ap
->DID
= be32_to_cpu(vport
->fc_myDID
);
2085 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
2086 "Issue ADISC: did:x%x",
2087 ndlp
->nlp_DID
, 0, 0);
2089 phba
->fc_stat
.elsXmitADISC
++;
2090 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_adisc
;
2091 spin_lock_irq(shost
->host_lock
);
2092 ndlp
->nlp_flag
|= NLP_ADISC_SND
;
2093 spin_unlock_irq(shost
->host_lock
);
2094 if (lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0) ==
2096 spin_lock_irq(shost
->host_lock
);
2097 ndlp
->nlp_flag
&= ~NLP_ADISC_SND
;
2098 spin_unlock_irq(shost
->host_lock
);
2099 lpfc_els_free_iocb(phba
, elsiocb
);
2106 * lpfc_cmpl_els_logo - Completion callback function for logo
2107 * @phba: pointer to lpfc hba data structure.
2108 * @cmdiocb: pointer to lpfc command iocb data structure.
2109 * @rspiocb: pointer to lpfc response iocb data structure.
2111 * This routine is the completion function for issuing the ELS Logout (LOGO)
2112 * command. If no error status was reported from the LOGO response, the
2113 * state machine of the associated ndlp shall be invoked for transition with
2114 * respect to NLP_EVT_CMPL_LOGO event. Otherwise, if error status was reported,
2115 * the lpfc_els_retry() routine will be invoked to retry the LOGO command.
2118 lpfc_cmpl_els_logo(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
2119 struct lpfc_iocbq
*rspiocb
)
2121 struct lpfc_nodelist
*ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
2122 struct lpfc_vport
*vport
= ndlp
->vport
;
2123 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
2125 struct lpfc_sli
*psli
;
2128 /* we pass cmdiocb to state machine which needs rspiocb as well */
2129 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
2131 irsp
= &(rspiocb
->iocb
);
2132 spin_lock_irq(shost
->host_lock
);
2133 ndlp
->nlp_flag
&= ~NLP_LOGO_SND
;
2134 spin_unlock_irq(shost
->host_lock
);
2136 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
2137 "LOGO cmpl: status:x%x/x%x did:x%x",
2138 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
2140 /* LOGO completes to NPort <nlp_DID> */
2141 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
2142 "0105 LOGO completes to NPort x%x "
2143 "Data: x%x x%x x%x x%x\n",
2144 ndlp
->nlp_DID
, irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
2145 irsp
->ulpTimeout
, vport
->num_disc_nodes
);
2146 /* Check to see if link went down during discovery */
2147 if (lpfc_els_chk_latt(vport
))
2150 if (ndlp
->nlp_flag
& NLP_TARGET_REMOVE
) {
2151 /* NLP_EVT_DEVICE_RM should unregister the RPI
2152 * which should abort all outstanding IOs.
2154 lpfc_disc_state_machine(vport
, ndlp
, cmdiocb
,
2159 if (irsp
->ulpStatus
) {
2160 /* Check for retry */
2161 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
))
2162 /* ELS command is being retried */
2165 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
2166 "2756 LOGO failure DID:%06X Status:x%x/x%x\n",
2167 ndlp
->nlp_DID
, irsp
->ulpStatus
,
2168 irsp
->un
.ulpWord
[4]);
2169 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
2170 if (lpfc_error_lost_link(irsp
))
2173 lpfc_disc_state_machine(vport
, ndlp
, cmdiocb
,
2176 /* Good status, call state machine.
2177 * This will unregister the rpi if needed.
2179 lpfc_disc_state_machine(vport
, ndlp
, cmdiocb
,
2182 lpfc_els_free_iocb(phba
, cmdiocb
);
2187 * lpfc_issue_els_logo - Issue a logo to an node on a vport
2188 * @vport: pointer to a virtual N_Port data structure.
2189 * @ndlp: pointer to a node-list data structure.
2190 * @retry: number of retries to the command IOCB.
2192 * This routine constructs and issues an ELS Logout (LOGO) iocb command
2193 * to a remote node, referred by an @ndlp on a @vport. It constructs the
2194 * payload of the IOCB, properly sets up the @ndlp state, and invokes the
2195 * lpfc_sli_issue_iocb() routine to send out the LOGO ELS command.
2197 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
2198 * will be incremented by 1 for holding the ndlp and the reference to ndlp
2199 * will be stored into the context1 field of the IOCB for the completion
2200 * callback function to the LOGO ELS command.
2203 * 0 - successfully issued logo
2204 * 1 - failed to issue logo
2207 lpfc_issue_els_logo(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
2210 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
2211 struct lpfc_hba
*phba
= vport
->phba
;
2213 struct lpfc_iocbq
*elsiocb
;
2218 spin_lock_irq(shost
->host_lock
);
2219 if (ndlp
->nlp_flag
& NLP_LOGO_SND
) {
2220 spin_unlock_irq(shost
->host_lock
);
2223 spin_unlock_irq(shost
->host_lock
);
2225 cmdsize
= (2 * sizeof(uint32_t)) + sizeof(struct lpfc_name
);
2226 elsiocb
= lpfc_prep_els_iocb(vport
, 1, cmdsize
, retry
, ndlp
,
2227 ndlp
->nlp_DID
, ELS_CMD_LOGO
);
2231 icmd
= &elsiocb
->iocb
;
2232 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2233 *((uint32_t *) (pcmd
)) = ELS_CMD_LOGO
;
2234 pcmd
+= sizeof(uint32_t);
2236 /* Fill in LOGO payload */
2237 *((uint32_t *) (pcmd
)) = be32_to_cpu(vport
->fc_myDID
);
2238 pcmd
+= sizeof(uint32_t);
2239 memcpy(pcmd
, &vport
->fc_portname
, sizeof(struct lpfc_name
));
2241 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
2242 "Issue LOGO: did:x%x",
2243 ndlp
->nlp_DID
, 0, 0);
2245 phba
->fc_stat
.elsXmitLOGO
++;
2246 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_logo
;
2247 spin_lock_irq(shost
->host_lock
);
2248 ndlp
->nlp_flag
|= NLP_LOGO_SND
;
2249 spin_unlock_irq(shost
->host_lock
);
2250 rc
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0);
2252 if (rc
== IOCB_ERROR
) {
2253 spin_lock_irq(shost
->host_lock
);
2254 ndlp
->nlp_flag
&= ~NLP_LOGO_SND
;
2255 spin_unlock_irq(shost
->host_lock
);
2256 lpfc_els_free_iocb(phba
, elsiocb
);
2263 * lpfc_cmpl_els_cmd - Completion callback function for generic els command
2264 * @phba: pointer to lpfc hba data structure.
2265 * @cmdiocb: pointer to lpfc command iocb data structure.
2266 * @rspiocb: pointer to lpfc response iocb data structure.
2268 * This routine is a generic completion callback function for ELS commands.
2269 * Specifically, it is the callback function which does not need to perform
2270 * any command specific operations. It is currently used by the ELS command
2271 * issuing routines for the ELS State Change Request (SCR),
2272 * lpfc_issue_els_scr(), and the ELS Fibre Channel Address Resolution
2273 * Protocol Response (FARPR) routine, lpfc_issue_els_farpr(). Other than
2274 * certain debug loggings, this callback function simply invokes the
2275 * lpfc_els_chk_latt() routine to check whether link went down during the
2276 * discovery process.
2279 lpfc_cmpl_els_cmd(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
2280 struct lpfc_iocbq
*rspiocb
)
2282 struct lpfc_vport
*vport
= cmdiocb
->vport
;
2285 irsp
= &rspiocb
->iocb
;
2287 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
2288 "ELS cmd cmpl: status:x%x/x%x did:x%x",
2289 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
2290 irsp
->un
.elsreq64
.remoteID
);
2291 /* ELS cmd tag <ulpIoTag> completes */
2292 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
2293 "0106 ELS cmd tag x%x completes Data: x%x x%x x%x\n",
2294 irsp
->ulpIoTag
, irsp
->ulpStatus
,
2295 irsp
->un
.ulpWord
[4], irsp
->ulpTimeout
);
2296 /* Check to see if link went down during discovery */
2297 lpfc_els_chk_latt(vport
);
2298 lpfc_els_free_iocb(phba
, cmdiocb
);
2303 * lpfc_issue_els_scr - Issue a scr to an node on a vport
2304 * @vport: pointer to a host virtual N_Port data structure.
2305 * @nportid: N_Port identifier to the remote node.
2306 * @retry: number of retries to the command IOCB.
2308 * This routine issues a State Change Request (SCR) to a fabric node
2309 * on a @vport. The remote node @nportid is passed into the function. It
2310 * first search the @vport node list to find the matching ndlp. If no such
2311 * ndlp is found, a new ndlp shall be created for this (SCR) purpose. An
2312 * IOCB is allocated, payload prepared, and the lpfc_sli_issue_iocb()
2313 * routine is invoked to send the SCR IOCB.
2315 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
2316 * will be incremented by 1 for holding the ndlp and the reference to ndlp
2317 * will be stored into the context1 field of the IOCB for the completion
2318 * callback function to the SCR ELS command.
2321 * 0 - Successfully issued scr command
2322 * 1 - Failed to issue scr command
2325 lpfc_issue_els_scr(struct lpfc_vport
*vport
, uint32_t nportid
, uint8_t retry
)
2327 struct lpfc_hba
*phba
= vport
->phba
;
2329 struct lpfc_iocbq
*elsiocb
;
2330 struct lpfc_sli
*psli
;
2333 struct lpfc_nodelist
*ndlp
;
2336 cmdsize
= (sizeof(uint32_t) + sizeof(SCR
));
2338 ndlp
= lpfc_findnode_did(vport
, nportid
);
2340 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
2343 lpfc_nlp_init(vport
, ndlp
, nportid
);
2344 lpfc_enqueue_node(vport
, ndlp
);
2345 } else if (!NLP_CHK_NODE_ACT(ndlp
)) {
2346 ndlp
= lpfc_enable_node(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
2351 elsiocb
= lpfc_prep_els_iocb(vport
, 1, cmdsize
, retry
, ndlp
,
2352 ndlp
->nlp_DID
, ELS_CMD_SCR
);
2355 /* This will trigger the release of the node just
2362 icmd
= &elsiocb
->iocb
;
2363 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2365 *((uint32_t *) (pcmd
)) = ELS_CMD_SCR
;
2366 pcmd
+= sizeof(uint32_t);
2368 /* For SCR, remainder of payload is SCR parameter page */
2369 memset(pcmd
, 0, sizeof(SCR
));
2370 ((SCR
*) pcmd
)->Function
= SCR_FUNC_FULL
;
2372 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
2373 "Issue SCR: did:x%x",
2374 ndlp
->nlp_DID
, 0, 0);
2376 phba
->fc_stat
.elsXmitSCR
++;
2377 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_cmd
;
2378 if (lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0) ==
2380 /* The additional lpfc_nlp_put will cause the following
2381 * lpfc_els_free_iocb routine to trigger the rlease of
2385 lpfc_els_free_iocb(phba
, elsiocb
);
2388 /* This will cause the callback-function lpfc_cmpl_els_cmd to
2389 * trigger the release of node.
2396 * lpfc_issue_els_farpr - Issue a farp to an node on a vport
2397 * @vport: pointer to a host virtual N_Port data structure.
2398 * @nportid: N_Port identifier to the remote node.
2399 * @retry: number of retries to the command IOCB.
2401 * This routine issues a Fibre Channel Address Resolution Response
2402 * (FARPR) to a node on a vport. The remote node N_Port identifier (@nportid)
2403 * is passed into the function. It first search the @vport node list to find
2404 * the matching ndlp. If no such ndlp is found, a new ndlp shall be created
2405 * for this (FARPR) purpose. An IOCB is allocated, payload prepared, and the
2406 * lpfc_sli_issue_iocb() routine is invoked to send the FARPR ELS command.
2408 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
2409 * will be incremented by 1 for holding the ndlp and the reference to ndlp
2410 * will be stored into the context1 field of the IOCB for the completion
2411 * callback function to the PARPR ELS command.
2414 * 0 - Successfully issued farpr command
2415 * 1 - Failed to issue farpr command
2418 lpfc_issue_els_farpr(struct lpfc_vport
*vport
, uint32_t nportid
, uint8_t retry
)
2420 struct lpfc_hba
*phba
= vport
->phba
;
2422 struct lpfc_iocbq
*elsiocb
;
2423 struct lpfc_sli
*psli
;
2428 struct lpfc_nodelist
*ondlp
;
2429 struct lpfc_nodelist
*ndlp
;
2432 cmdsize
= (sizeof(uint32_t) + sizeof(FARP
));
2434 ndlp
= lpfc_findnode_did(vport
, nportid
);
2436 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
2439 lpfc_nlp_init(vport
, ndlp
, nportid
);
2440 lpfc_enqueue_node(vport
, ndlp
);
2441 } else if (!NLP_CHK_NODE_ACT(ndlp
)) {
2442 ndlp
= lpfc_enable_node(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
2447 elsiocb
= lpfc_prep_els_iocb(vport
, 1, cmdsize
, retry
, ndlp
,
2448 ndlp
->nlp_DID
, ELS_CMD_RNID
);
2450 /* This will trigger the release of the node just
2457 icmd
= &elsiocb
->iocb
;
2458 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2460 *((uint32_t *) (pcmd
)) = ELS_CMD_FARPR
;
2461 pcmd
+= sizeof(uint32_t);
2463 /* Fill in FARPR payload */
2464 fp
= (FARP
*) (pcmd
);
2465 memset(fp
, 0, sizeof(FARP
));
2466 lp
= (uint32_t *) pcmd
;
2467 *lp
++ = be32_to_cpu(nportid
);
2468 *lp
++ = be32_to_cpu(vport
->fc_myDID
);
2470 fp
->Mflags
= (FARP_MATCH_PORT
| FARP_MATCH_NODE
);
2472 memcpy(&fp
->RportName
, &vport
->fc_portname
, sizeof(struct lpfc_name
));
2473 memcpy(&fp
->RnodeName
, &vport
->fc_nodename
, sizeof(struct lpfc_name
));
2474 ondlp
= lpfc_findnode_did(vport
, nportid
);
2475 if (ondlp
&& NLP_CHK_NODE_ACT(ondlp
)) {
2476 memcpy(&fp
->OportName
, &ondlp
->nlp_portname
,
2477 sizeof(struct lpfc_name
));
2478 memcpy(&fp
->OnodeName
, &ondlp
->nlp_nodename
,
2479 sizeof(struct lpfc_name
));
2482 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
2483 "Issue FARPR: did:x%x",
2484 ndlp
->nlp_DID
, 0, 0);
2486 phba
->fc_stat
.elsXmitFARPR
++;
2487 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_cmd
;
2488 if (lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0) ==
2490 /* The additional lpfc_nlp_put will cause the following
2491 * lpfc_els_free_iocb routine to trigger the release of
2495 lpfc_els_free_iocb(phba
, elsiocb
);
2498 /* This will cause the callback-function lpfc_cmpl_els_cmd to
2499 * trigger the release of the node.
2506 * lpfc_cancel_retry_delay_tmo - Cancel the timer with delayed iocb-cmd retry
2507 * @vport: pointer to a host virtual N_Port data structure.
2508 * @nlp: pointer to a node-list data structure.
2510 * This routine cancels the timer with a delayed IOCB-command retry for
2511 * a @vport's @ndlp. It stops the timer for the delayed function retrial and
2512 * removes the ELS retry event if it presents. In addition, if the
2513 * NLP_NPR_2B_DISC bit is set in the @nlp's nlp_flag bitmap, ADISC IOCB
2514 * commands are sent for the @vport's nodes that require issuing discovery
2518 lpfc_cancel_retry_delay_tmo(struct lpfc_vport
*vport
, struct lpfc_nodelist
*nlp
)
2520 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
2521 struct lpfc_work_evt
*evtp
;
2523 if (!(nlp
->nlp_flag
& NLP_DELAY_TMO
))
2525 spin_lock_irq(shost
->host_lock
);
2526 nlp
->nlp_flag
&= ~NLP_DELAY_TMO
;
2527 spin_unlock_irq(shost
->host_lock
);
2528 del_timer_sync(&nlp
->nlp_delayfunc
);
2529 nlp
->nlp_last_elscmd
= 0;
2530 if (!list_empty(&nlp
->els_retry_evt
.evt_listp
)) {
2531 list_del_init(&nlp
->els_retry_evt
.evt_listp
);
2532 /* Decrement nlp reference count held for the delayed retry */
2533 evtp
= &nlp
->els_retry_evt
;
2534 lpfc_nlp_put((struct lpfc_nodelist
*)evtp
->evt_arg1
);
2536 if (nlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
2537 spin_lock_irq(shost
->host_lock
);
2538 nlp
->nlp_flag
&= ~NLP_NPR_2B_DISC
;
2539 spin_unlock_irq(shost
->host_lock
);
2540 if (vport
->num_disc_nodes
) {
2541 if (vport
->port_state
< LPFC_VPORT_READY
) {
2542 /* Check if there are more ADISCs to be sent */
2543 lpfc_more_adisc(vport
);
2545 /* Check if there are more PLOGIs to be sent */
2546 lpfc_more_plogi(vport
);
2547 if (vport
->num_disc_nodes
== 0) {
2548 spin_lock_irq(shost
->host_lock
);
2549 vport
->fc_flag
&= ~FC_NDISC_ACTIVE
;
2550 spin_unlock_irq(shost
->host_lock
);
2551 lpfc_can_disctmo(vport
);
2552 lpfc_end_rscn(vport
);
2561 * lpfc_els_retry_delay - Timer function with a ndlp delayed function timer
2562 * @ptr: holder for the pointer to the timer function associated data (ndlp).
2564 * This routine is invoked by the ndlp delayed-function timer to check
2565 * whether there is any pending ELS retry event(s) with the node. If not, it
2566 * simply returns. Otherwise, if there is at least one ELS delayed event, it
2567 * adds the delayed events to the HBA work list and invokes the
2568 * lpfc_worker_wake_up() routine to wake up worker thread to process the
2569 * event. Note that lpfc_nlp_get() is called before posting the event to
2570 * the work list to hold reference count of ndlp so that it guarantees the
2571 * reference to ndlp will still be available when the worker thread gets
2572 * to the event associated with the ndlp.
2575 lpfc_els_retry_delay(unsigned long ptr
)
2577 struct lpfc_nodelist
*ndlp
= (struct lpfc_nodelist
*) ptr
;
2578 struct lpfc_vport
*vport
= ndlp
->vport
;
2579 struct lpfc_hba
*phba
= vport
->phba
;
2580 unsigned long flags
;
2581 struct lpfc_work_evt
*evtp
= &ndlp
->els_retry_evt
;
2583 spin_lock_irqsave(&phba
->hbalock
, flags
);
2584 if (!list_empty(&evtp
->evt_listp
)) {
2585 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
2589 /* We need to hold the node by incrementing the reference
2590 * count until the queued work is done
2592 evtp
->evt_arg1
= lpfc_nlp_get(ndlp
);
2593 if (evtp
->evt_arg1
) {
2594 evtp
->evt
= LPFC_EVT_ELS_RETRY
;
2595 list_add_tail(&evtp
->evt_listp
, &phba
->work_list
);
2596 lpfc_worker_wake_up(phba
);
2598 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
2603 * lpfc_els_retry_delay_handler - Work thread handler for ndlp delayed function
2604 * @ndlp: pointer to a node-list data structure.
2606 * This routine is the worker-thread handler for processing the @ndlp delayed
2607 * event(s), posted by the lpfc_els_retry_delay() routine. It simply retrieves
2608 * the last ELS command from the associated ndlp and invokes the proper ELS
2609 * function according to the delayed ELS command to retry the command.
2612 lpfc_els_retry_delay_handler(struct lpfc_nodelist
*ndlp
)
2614 struct lpfc_vport
*vport
= ndlp
->vport
;
2615 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
2616 uint32_t cmd
, did
, retry
;
2618 spin_lock_irq(shost
->host_lock
);
2619 did
= ndlp
->nlp_DID
;
2620 cmd
= ndlp
->nlp_last_elscmd
;
2621 ndlp
->nlp_last_elscmd
= 0;
2623 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
)) {
2624 spin_unlock_irq(shost
->host_lock
);
2628 ndlp
->nlp_flag
&= ~NLP_DELAY_TMO
;
2629 spin_unlock_irq(shost
->host_lock
);
2631 * If a discovery event readded nlp_delayfunc after timer
2632 * firing and before processing the timer, cancel the
2635 del_timer_sync(&ndlp
->nlp_delayfunc
);
2636 retry
= ndlp
->nlp_retry
;
2637 ndlp
->nlp_retry
= 0;
2641 lpfc_issue_els_flogi(vport
, ndlp
, retry
);
2644 if (!lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, retry
)) {
2645 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2646 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
2650 if (!lpfc_issue_els_adisc(vport
, ndlp
, retry
)) {
2651 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2652 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_ADISC_ISSUE
);
2656 if (!lpfc_issue_els_prli(vport
, ndlp
, retry
)) {
2657 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2658 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PRLI_ISSUE
);
2662 if (!lpfc_issue_els_logo(vport
, ndlp
, retry
)) {
2663 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2664 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
2668 lpfc_issue_els_fdisc(vport
, ndlp
, retry
);
2675 * lpfc_els_retry - Make retry decision on an els command iocb
2676 * @phba: pointer to lpfc hba data structure.
2677 * @cmdiocb: pointer to lpfc command iocb data structure.
2678 * @rspiocb: pointer to lpfc response iocb data structure.
2680 * This routine makes a retry decision on an ELS command IOCB, which has
2681 * failed. The following ELS IOCBs use this function for retrying the command
2682 * when previously issued command responsed with error status: FLOGI, PLOGI,
2683 * PRLI, ADISC, LOGO, and FDISC. Based on the ELS command type and the
2684 * returned error status, it makes the decision whether a retry shall be
2685 * issued for the command, and whether a retry shall be made immediately or
2686 * delayed. In the former case, the corresponding ELS command issuing-function
2687 * is called to retry the command. In the later case, the ELS command shall
2688 * be posted to the ndlp delayed event and delayed function timer set to the
2689 * ndlp for the delayed command issusing.
2692 * 0 - No retry of els command is made
2693 * 1 - Immediate or delayed retry of els command is made
2696 lpfc_els_retry(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
2697 struct lpfc_iocbq
*rspiocb
)
2699 struct lpfc_vport
*vport
= cmdiocb
->vport
;
2700 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
2701 IOCB_t
*irsp
= &rspiocb
->iocb
;
2702 struct lpfc_nodelist
*ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
2703 struct lpfc_dmabuf
*pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2706 int retry
= 0, maxretry
= lpfc_max_els_tries
, delay
= 0;
2712 /* Note: context2 may be 0 for internal driver abort
2713 * of delays ELS command.
2716 if (pcmd
&& pcmd
->virt
) {
2717 elscmd
= (uint32_t *) (pcmd
->virt
);
2721 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
))
2722 did
= ndlp
->nlp_DID
;
2724 /* We should only hit this case for retrying PLOGI */
2725 did
= irsp
->un
.elsreq64
.remoteID
;
2726 ndlp
= lpfc_findnode_did(vport
, did
);
2727 if ((!ndlp
|| !NLP_CHK_NODE_ACT(ndlp
))
2728 && (cmd
!= ELS_CMD_PLOGI
))
2732 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
2733 "Retry ELS: wd7:x%x wd4:x%x did:x%x",
2734 *(((uint32_t *) irsp
) + 7), irsp
->un
.ulpWord
[4], ndlp
->nlp_DID
);
2736 switch (irsp
->ulpStatus
) {
2737 case IOSTAT_FCP_RSP_ERROR
:
2738 case IOSTAT_REMOTE_STOP
:
2741 case IOSTAT_LOCAL_REJECT
:
2742 switch ((irsp
->un
.ulpWord
[4] & 0xff)) {
2743 case IOERR_LOOP_OPEN_FAILURE
:
2744 if (cmd
== ELS_CMD_FLOGI
) {
2745 if (PCI_DEVICE_ID_HORNET
==
2746 phba
->pcidev
->device
) {
2747 phba
->fc_topology
= TOPOLOGY_LOOP
;
2748 phba
->pport
->fc_myDID
= 0;
2749 phba
->alpa_map
[0] = 0;
2750 phba
->alpa_map
[1] = 0;
2753 if (cmd
== ELS_CMD_PLOGI
&& cmdiocb
->retry
== 0)
2758 case IOERR_ILLEGAL_COMMAND
:
2759 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
2760 "0124 Retry illegal cmd x%x "
2761 "retry:x%x delay:x%x\n",
2762 cmd
, cmdiocb
->retry
, delay
);
2764 /* All command's retry policy */
2766 if (cmdiocb
->retry
> 2)
2770 case IOERR_NO_RESOURCES
:
2771 logerr
= 1; /* HBA out of resources */
2773 if (cmdiocb
->retry
> 100)
2778 case IOERR_ILLEGAL_FRAME
:
2783 case IOERR_SEQUENCE_TIMEOUT
:
2784 case IOERR_INVALID_RPI
:
2790 case IOSTAT_NPORT_RJT
:
2791 case IOSTAT_FABRIC_RJT
:
2792 if (irsp
->un
.ulpWord
[4] & RJT_UNAVAIL_TEMP
) {
2798 case IOSTAT_NPORT_BSY
:
2799 case IOSTAT_FABRIC_BSY
:
2800 logerr
= 1; /* Fabric / Remote NPort out of resources */
2805 stat
.un
.lsRjtError
= be32_to_cpu(irsp
->un
.ulpWord
[4]);
2806 /* Added for Vendor specifc support
2807 * Just keep retrying for these Rsn / Exp codes
2809 switch (stat
.un
.b
.lsRjtRsnCode
) {
2810 case LSRJT_UNABLE_TPC
:
2811 if (stat
.un
.b
.lsRjtRsnCodeExp
==
2812 LSEXP_CMD_IN_PROGRESS
) {
2813 if (cmd
== ELS_CMD_PLOGI
) {
2820 if (stat
.un
.b
.lsRjtRsnCodeExp
==
2821 LSEXP_CANT_GIVE_DATA
) {
2822 if (cmd
== ELS_CMD_PLOGI
) {
2829 if (cmd
== ELS_CMD_PLOGI
) {
2831 maxretry
= lpfc_max_els_tries
+ 1;
2835 if ((phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
) &&
2836 (cmd
== ELS_CMD_FDISC
) &&
2837 (stat
.un
.b
.lsRjtRsnCodeExp
== LSEXP_OUT_OF_RESOURCE
)){
2838 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
2839 "0125 FDISC Failed (x%x). "
2840 "Fabric out of resources\n",
2841 stat
.un
.lsRjtError
);
2842 lpfc_vport_set_state(vport
,
2843 FC_VPORT_NO_FABRIC_RSCS
);
2847 case LSRJT_LOGICAL_BSY
:
2848 if ((cmd
== ELS_CMD_PLOGI
) ||
2849 (cmd
== ELS_CMD_PRLI
)) {
2852 } else if (cmd
== ELS_CMD_FDISC
) {
2853 /* FDISC retry policy */
2855 if (cmdiocb
->retry
>= 32)
2861 case LSRJT_LOGICAL_ERR
:
2862 /* There are some cases where switches return this
2863 * error when they are not ready and should be returning
2864 * Logical Busy. We should delay every time.
2866 if (cmd
== ELS_CMD_FDISC
&&
2867 stat
.un
.b
.lsRjtRsnCodeExp
== LSEXP_PORT_LOGIN_REQ
) {
2873 case LSRJT_PROTOCOL_ERR
:
2874 if ((phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
) &&
2875 (cmd
== ELS_CMD_FDISC
) &&
2876 ((stat
.un
.b
.lsRjtRsnCodeExp
== LSEXP_INVALID_PNAME
) ||
2877 (stat
.un
.b
.lsRjtRsnCodeExp
== LSEXP_INVALID_NPORT_ID
))
2879 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
2880 "0122 FDISC Failed (x%x). "
2881 "Fabric Detected Bad WWN\n",
2882 stat
.un
.lsRjtError
);
2883 lpfc_vport_set_state(vport
,
2884 FC_VPORT_FABRIC_REJ_WWN
);
2890 case IOSTAT_INTERMED_RSP
:
2898 if (did
== FDMI_DID
)
2901 if (((cmd
== ELS_CMD_FLOGI
) || (cmd
== ELS_CMD_FDISC
)) &&
2902 (phba
->fc_topology
!= TOPOLOGY_LOOP
) &&
2903 !lpfc_error_lost_link(irsp
)) {
2904 /* FLOGI retry policy */
2908 if (cmdiocb
->retry
>= 100)
2910 else if (cmdiocb
->retry
>= 32)
2915 if (maxretry
&& (cmdiocb
->retry
>= maxretry
)) {
2916 phba
->fc_stat
.elsRetryExceeded
++;
2920 if ((vport
->load_flag
& FC_UNLOADING
) != 0)
2924 if ((cmd
== ELS_CMD_PLOGI
) || (cmd
== ELS_CMD_FDISC
)) {
2925 /* Stop retrying PLOGI and FDISC if in FCF discovery */
2926 if (phba
->fcf
.fcf_flag
& FCF_DISCOVERY
) {
2927 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
2928 "2849 Stop retry ELS command "
2929 "x%x to remote NPORT x%x, "
2930 "Data: x%x x%x\n", cmd
, did
,
2931 cmdiocb
->retry
, delay
);
2936 /* Retry ELS command <elsCmd> to remote NPORT <did> */
2937 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
2938 "0107 Retry ELS command x%x to remote "
2939 "NPORT x%x Data: x%x x%x\n",
2940 cmd
, did
, cmdiocb
->retry
, delay
);
2942 if (((cmd
== ELS_CMD_PLOGI
) || (cmd
== ELS_CMD_ADISC
)) &&
2943 ((irsp
->ulpStatus
!= IOSTAT_LOCAL_REJECT
) ||
2944 ((irsp
->un
.ulpWord
[4] & 0xff) != IOERR_NO_RESOURCES
))) {
2945 /* Don't reset timer for no resources */
2947 /* If discovery / RSCN timer is running, reset it */
2948 if (timer_pending(&vport
->fc_disctmo
) ||
2949 (vport
->fc_flag
& FC_RSCN_MODE
))
2950 lpfc_set_disctmo(vport
);
2953 phba
->fc_stat
.elsXmitRetry
++;
2954 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
) && delay
) {
2955 phba
->fc_stat
.elsDelayRetry
++;
2956 ndlp
->nlp_retry
= cmdiocb
->retry
;
2958 /* delay is specified in milliseconds */
2959 mod_timer(&ndlp
->nlp_delayfunc
,
2960 jiffies
+ msecs_to_jiffies(delay
));
2961 spin_lock_irq(shost
->host_lock
);
2962 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
2963 spin_unlock_irq(shost
->host_lock
);
2965 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2966 if (cmd
== ELS_CMD_PRLI
)
2967 lpfc_nlp_set_state(vport
, ndlp
,
2968 NLP_STE_REG_LOGIN_ISSUE
);
2970 lpfc_nlp_set_state(vport
, ndlp
,
2972 ndlp
->nlp_last_elscmd
= cmd
;
2978 lpfc_issue_els_flogi(vport
, ndlp
, cmdiocb
->retry
);
2981 lpfc_issue_els_fdisc(vport
, ndlp
, cmdiocb
->retry
);
2984 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
)) {
2985 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2986 lpfc_nlp_set_state(vport
, ndlp
,
2987 NLP_STE_PLOGI_ISSUE
);
2989 lpfc_issue_els_plogi(vport
, did
, cmdiocb
->retry
);
2992 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2993 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_ADISC_ISSUE
);
2994 lpfc_issue_els_adisc(vport
, ndlp
, cmdiocb
->retry
);
2997 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2998 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PRLI_ISSUE
);
2999 lpfc_issue_els_prli(vport
, ndlp
, cmdiocb
->retry
);
3002 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
3003 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
3004 lpfc_issue_els_logo(vport
, ndlp
, cmdiocb
->retry
);
3008 /* No retry ELS command <elsCmd> to remote NPORT <did> */
3010 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
3011 "0137 No retry ELS command x%x to remote "
3012 "NPORT x%x: Out of Resources: Error:x%x/%x\n",
3013 cmd
, did
, irsp
->ulpStatus
,
3014 irsp
->un
.ulpWord
[4]);
3017 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
3018 "0108 No retry ELS command x%x to remote "
3019 "NPORT x%x Retried:%d Error:x%x/%x\n",
3020 cmd
, did
, cmdiocb
->retry
, irsp
->ulpStatus
,
3021 irsp
->un
.ulpWord
[4]);
3027 * lpfc_els_free_data - Free lpfc dma buffer and data structure with an iocb
3028 * @phba: pointer to lpfc hba data structure.
3029 * @buf_ptr1: pointer to the lpfc DMA buffer data structure.
3031 * This routine releases the lpfc DMA (Direct Memory Access) buffer(s)
3032 * associated with a command IOCB back to the lpfc DMA buffer pool. It first
3033 * checks to see whether there is a lpfc DMA buffer associated with the
3034 * response of the command IOCB. If so, it will be released before releasing
3035 * the lpfc DMA buffer associated with the IOCB itself.
3038 * 0 - Successfully released lpfc DMA buffer (currently, always return 0)
3041 lpfc_els_free_data(struct lpfc_hba
*phba
, struct lpfc_dmabuf
*buf_ptr1
)
3043 struct lpfc_dmabuf
*buf_ptr
;
3045 /* Free the response before processing the command. */
3046 if (!list_empty(&buf_ptr1
->list
)) {
3047 list_remove_head(&buf_ptr1
->list
, buf_ptr
,
3050 lpfc_mbuf_free(phba
, buf_ptr
->virt
, buf_ptr
->phys
);
3053 lpfc_mbuf_free(phba
, buf_ptr1
->virt
, buf_ptr1
->phys
);
3059 * lpfc_els_free_bpl - Free lpfc dma buffer and data structure with bpl
3060 * @phba: pointer to lpfc hba data structure.
3061 * @buf_ptr: pointer to the lpfc dma buffer data structure.
3063 * This routine releases the lpfc Direct Memory Access (DMA) buffer
3064 * associated with a Buffer Pointer List (BPL) back to the lpfc DMA buffer
3068 * 0 - Successfully released lpfc DMA buffer (currently, always return 0)
3071 lpfc_els_free_bpl(struct lpfc_hba
*phba
, struct lpfc_dmabuf
*buf_ptr
)
3073 lpfc_mbuf_free(phba
, buf_ptr
->virt
, buf_ptr
->phys
);
3079 * lpfc_els_free_iocb - Free a command iocb and its associated resources
3080 * @phba: pointer to lpfc hba data structure.
3081 * @elsiocb: pointer to lpfc els command iocb data structure.
3083 * This routine frees a command IOCB and its associated resources. The
3084 * command IOCB data structure contains the reference to various associated
3085 * resources, these fields must be set to NULL if the associated reference
3087 * context1 - reference to ndlp
3088 * context2 - reference to cmd
3089 * context2->next - reference to rsp
3090 * context3 - reference to bpl
3092 * It first properly decrements the reference count held on ndlp for the
3093 * IOCB completion callback function. If LPFC_DELAY_MEM_FREE flag is not
3094 * set, it invokes the lpfc_els_free_data() routine to release the Direct
3095 * Memory Access (DMA) buffers associated with the IOCB. Otherwise, it
3096 * adds the DMA buffer the @phba data structure for the delayed release.
3097 * If reference to the Buffer Pointer List (BPL) is present, the
3098 * lpfc_els_free_bpl() routine is invoked to release the DMA memory
3099 * associated with BPL. Finally, the lpfc_sli_release_iocbq() routine is
3100 * invoked to release the IOCB data structure back to @phba IOCBQ list.
3103 * 0 - Success (currently, always return 0)
3106 lpfc_els_free_iocb(struct lpfc_hba
*phba
, struct lpfc_iocbq
*elsiocb
)
3108 struct lpfc_dmabuf
*buf_ptr
, *buf_ptr1
;
3109 struct lpfc_nodelist
*ndlp
;
3111 ndlp
= (struct lpfc_nodelist
*)elsiocb
->context1
;
3113 if (ndlp
->nlp_flag
& NLP_DEFER_RM
) {
3116 /* If the ndlp is not being used by another discovery
3119 if (!lpfc_nlp_not_used(ndlp
)) {
3120 /* If ndlp is being used by another discovery
3121 * thread, just clear NLP_DEFER_RM
3123 ndlp
->nlp_flag
&= ~NLP_DEFER_RM
;
3128 elsiocb
->context1
= NULL
;
3130 /* context2 = cmd, context2->next = rsp, context3 = bpl */
3131 if (elsiocb
->context2
) {
3132 if (elsiocb
->iocb_flag
& LPFC_DELAY_MEM_FREE
) {
3133 /* Firmware could still be in progress of DMAing
3134 * payload, so don't free data buffer till after
3137 elsiocb
->iocb_flag
&= ~LPFC_DELAY_MEM_FREE
;
3138 buf_ptr
= elsiocb
->context2
;
3139 elsiocb
->context2
= NULL
;
3142 spin_lock_irq(&phba
->hbalock
);
3143 if (!list_empty(&buf_ptr
->list
)) {
3144 list_remove_head(&buf_ptr
->list
,
3145 buf_ptr1
, struct lpfc_dmabuf
,
3147 INIT_LIST_HEAD(&buf_ptr1
->list
);
3148 list_add_tail(&buf_ptr1
->list
,
3152 INIT_LIST_HEAD(&buf_ptr
->list
);
3153 list_add_tail(&buf_ptr
->list
, &phba
->elsbuf
);
3155 spin_unlock_irq(&phba
->hbalock
);
3158 buf_ptr1
= (struct lpfc_dmabuf
*) elsiocb
->context2
;
3159 lpfc_els_free_data(phba
, buf_ptr1
);
3163 if (elsiocb
->context3
) {
3164 buf_ptr
= (struct lpfc_dmabuf
*) elsiocb
->context3
;
3165 lpfc_els_free_bpl(phba
, buf_ptr
);
3167 lpfc_sli_release_iocbq(phba
, elsiocb
);
3172 * lpfc_cmpl_els_logo_acc - Completion callback function to logo acc response
3173 * @phba: pointer to lpfc hba data structure.
3174 * @cmdiocb: pointer to lpfc command iocb data structure.
3175 * @rspiocb: pointer to lpfc response iocb data structure.
3177 * This routine is the completion callback function to the Logout (LOGO)
3178 * Accept (ACC) Response ELS command. This routine is invoked to indicate
3179 * the completion of the LOGO process. It invokes the lpfc_nlp_not_used() to
3180 * release the ndlp if it has the last reference remaining (reference count
3181 * is 1). If succeeded (meaning ndlp released), it sets the IOCB context1
3182 * field to NULL to inform the following lpfc_els_free_iocb() routine no
3183 * ndlp reference count needs to be decremented. Otherwise, the ndlp
3184 * reference use-count shall be decremented by the lpfc_els_free_iocb()
3185 * routine. Finally, the lpfc_els_free_iocb() is invoked to release the
3186 * IOCB data structure.
3189 lpfc_cmpl_els_logo_acc(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
3190 struct lpfc_iocbq
*rspiocb
)
3192 struct lpfc_nodelist
*ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
3193 struct lpfc_vport
*vport
= cmdiocb
->vport
;
3196 irsp
= &rspiocb
->iocb
;
3197 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_RSP
,
3198 "ACC LOGO cmpl: status:x%x/x%x did:x%x",
3199 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4], ndlp
->nlp_DID
);
3200 /* ACC to LOGO completes to NPort <nlp_DID> */
3201 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
3202 "0109 ACC to LOGO completes to NPort x%x "
3203 "Data: x%x x%x x%x\n",
3204 ndlp
->nlp_DID
, ndlp
->nlp_flag
, ndlp
->nlp_state
,
3207 if (ndlp
->nlp_state
== NLP_STE_NPR_NODE
) {
3208 /* NPort Recovery mode or node is just allocated */
3209 if (!lpfc_nlp_not_used(ndlp
)) {
3210 /* If the ndlp is being used by another discovery
3211 * thread, just unregister the RPI.
3213 lpfc_unreg_rpi(vport
, ndlp
);
3215 /* Indicate the node has already released, should
3216 * not reference to it from within lpfc_els_free_iocb.
3218 cmdiocb
->context1
= NULL
;
3221 lpfc_els_free_iocb(phba
, cmdiocb
);
3226 * lpfc_mbx_cmpl_dflt_rpi - Completion callbk func for unreg dflt rpi mbox cmd
3227 * @phba: pointer to lpfc hba data structure.
3228 * @pmb: pointer to the driver internal queue element for mailbox command.
3230 * This routine is the completion callback function for unregister default
3231 * RPI (Remote Port Index) mailbox command to the @phba. It simply releases
3232 * the associated lpfc Direct Memory Access (DMA) buffer back to the pool and
3233 * decrements the ndlp reference count held for this completion callback
3234 * function. After that, it invokes the lpfc_nlp_not_used() to check
3235 * whether there is only one reference left on the ndlp. If so, it will
3236 * perform one more decrement and trigger the release of the ndlp.
3239 lpfc_mbx_cmpl_dflt_rpi(struct lpfc_hba
*phba
, LPFC_MBOXQ_t
*pmb
)
3241 struct lpfc_dmabuf
*mp
= (struct lpfc_dmabuf
*) (pmb
->context1
);
3242 struct lpfc_nodelist
*ndlp
= (struct lpfc_nodelist
*) pmb
->context2
;
3245 * This routine is used to register and unregister in previous SLI
3248 if ((pmb
->u
.mb
.mbxCommand
== MBX_UNREG_LOGIN
) &&
3249 (phba
->sli_rev
== LPFC_SLI_REV4
))
3250 lpfc_sli4_free_rpi(phba
, pmb
->u
.mb
.un
.varUnregLogin
.rpi
);
3252 pmb
->context1
= NULL
;
3253 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3255 mempool_free(pmb
, phba
->mbox_mem_pool
);
3256 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
)) {
3258 /* This is the end of the default RPI cleanup logic for this
3259 * ndlp. If no other discovery threads are using this ndlp.
3260 * we should free all resources associated with it.
3262 lpfc_nlp_not_used(ndlp
);
3269 * lpfc_cmpl_els_rsp - Completion callback function for els response iocb cmd
3270 * @phba: pointer to lpfc hba data structure.
3271 * @cmdiocb: pointer to lpfc command iocb data structure.
3272 * @rspiocb: pointer to lpfc response iocb data structure.
3274 * This routine is the completion callback function for ELS Response IOCB
3275 * command. In normal case, this callback function just properly sets the
3276 * nlp_flag bitmap in the ndlp data structure, if the mbox command reference
3277 * field in the command IOCB is not NULL, the referred mailbox command will
3278 * be send out, and then invokes the lpfc_els_free_iocb() routine to release
3279 * the IOCB. Under error conditions, such as when a LS_RJT is returned or a
3280 * link down event occurred during the discovery, the lpfc_nlp_not_used()
3281 * routine shall be invoked trying to release the ndlp if no other threads
3282 * are currently referring it.
3285 lpfc_cmpl_els_rsp(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
3286 struct lpfc_iocbq
*rspiocb
)
3288 struct lpfc_nodelist
*ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
3289 struct lpfc_vport
*vport
= ndlp
? ndlp
->vport
: NULL
;
3290 struct Scsi_Host
*shost
= vport
? lpfc_shost_from_vport(vport
) : NULL
;
3293 LPFC_MBOXQ_t
*mbox
= NULL
;
3294 struct lpfc_dmabuf
*mp
= NULL
;
3295 uint32_t ls_rjt
= 0;
3297 irsp
= &rspiocb
->iocb
;
3299 if (cmdiocb
->context_un
.mbox
)
3300 mbox
= cmdiocb
->context_un
.mbox
;
3302 /* First determine if this is a LS_RJT cmpl. Note, this callback
3303 * function can have cmdiocb->contest1 (ndlp) field set to NULL.
3305 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) cmdiocb
->context2
)->virt
);
3306 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
) &&
3307 (*((uint32_t *) (pcmd
)) == ELS_CMD_LS_RJT
)) {
3308 /* A LS_RJT associated with Default RPI cleanup has its own
3309 * separate code path.
3311 if (!(ndlp
->nlp_flag
& NLP_RM_DFLT_RPI
))
3315 /* Check to see if link went down during discovery */
3316 if (!ndlp
|| !NLP_CHK_NODE_ACT(ndlp
) || lpfc_els_chk_latt(vport
)) {
3318 mp
= (struct lpfc_dmabuf
*) mbox
->context1
;
3320 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3323 mempool_free(mbox
, phba
->mbox_mem_pool
);
3325 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
) &&
3326 (ndlp
->nlp_flag
& NLP_RM_DFLT_RPI
))
3327 if (lpfc_nlp_not_used(ndlp
)) {
3329 /* Indicate the node has already released,
3330 * should not reference to it from within
3331 * the routine lpfc_els_free_iocb.
3333 cmdiocb
->context1
= NULL
;
3338 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_RSP
,
3339 "ELS rsp cmpl: status:x%x/x%x did:x%x",
3340 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
3341 cmdiocb
->iocb
.un
.elsreq64
.remoteID
);
3342 /* ELS response tag <ulpIoTag> completes */
3343 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
3344 "0110 ELS response tag x%x completes "
3345 "Data: x%x x%x x%x x%x x%x x%x x%x\n",
3346 cmdiocb
->iocb
.ulpIoTag
, rspiocb
->iocb
.ulpStatus
,
3347 rspiocb
->iocb
.un
.ulpWord
[4], rspiocb
->iocb
.ulpTimeout
,
3348 ndlp
->nlp_DID
, ndlp
->nlp_flag
, ndlp
->nlp_state
,
3351 if ((rspiocb
->iocb
.ulpStatus
== 0)
3352 && (ndlp
->nlp_flag
& NLP_ACC_REGLOGIN
)) {
3353 lpfc_unreg_rpi(vport
, ndlp
);
3354 /* Increment reference count to ndlp to hold the
3355 * reference to ndlp for the callback function.
3357 mbox
->context2
= lpfc_nlp_get(ndlp
);
3358 mbox
->vport
= vport
;
3359 if (ndlp
->nlp_flag
& NLP_RM_DFLT_RPI
) {
3360 mbox
->mbox_flag
|= LPFC_MBX_IMED_UNREG
;
3361 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_dflt_rpi
;
3364 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_reg_login
;
3365 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
3366 lpfc_nlp_set_state(vport
, ndlp
,
3367 NLP_STE_REG_LOGIN_ISSUE
);
3369 if (lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
)
3370 != MBX_NOT_FINISHED
)
3373 /* Decrement the ndlp reference count we
3374 * set for this failed mailbox command.
3378 /* ELS rsp: Cannot issue reg_login for <NPortid> */
3379 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
3380 "0138 ELS rsp: Cannot issue reg_login for x%x "
3381 "Data: x%x x%x x%x\n",
3382 ndlp
->nlp_DID
, ndlp
->nlp_flag
, ndlp
->nlp_state
,
3385 if (lpfc_nlp_not_used(ndlp
)) {
3387 /* Indicate node has already been released,
3388 * should not reference to it from within
3389 * the routine lpfc_els_free_iocb.
3391 cmdiocb
->context1
= NULL
;
3394 /* Do not drop node for lpfc_els_abort'ed ELS cmds */
3395 if (!lpfc_error_lost_link(irsp
) &&
3396 ndlp
->nlp_flag
& NLP_ACC_REGLOGIN
) {
3397 if (lpfc_nlp_not_used(ndlp
)) {
3399 /* Indicate node has already been
3400 * released, should not reference
3401 * to it from within the routine
3402 * lpfc_els_free_iocb.
3404 cmdiocb
->context1
= NULL
;
3408 mp
= (struct lpfc_dmabuf
*) mbox
->context1
;
3410 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3413 mempool_free(mbox
, phba
->mbox_mem_pool
);
3416 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
)) {
3417 spin_lock_irq(shost
->host_lock
);
3418 ndlp
->nlp_flag
&= ~(NLP_ACC_REGLOGIN
| NLP_RM_DFLT_RPI
);
3419 spin_unlock_irq(shost
->host_lock
);
3421 /* If the node is not being used by another discovery thread,
3422 * and we are sending a reject, we are done with it.
3423 * Release driver reference count here and free associated
3427 if (lpfc_nlp_not_used(ndlp
))
3428 /* Indicate node has already been released,
3429 * should not reference to it from within
3430 * the routine lpfc_els_free_iocb.
3432 cmdiocb
->context1
= NULL
;
3435 lpfc_els_free_iocb(phba
, cmdiocb
);
3440 * lpfc_els_rsp_acc - Prepare and issue an acc response iocb command
3441 * @vport: pointer to a host virtual N_Port data structure.
3442 * @flag: the els command code to be accepted.
3443 * @oldiocb: pointer to the original lpfc command iocb data structure.
3444 * @ndlp: pointer to a node-list data structure.
3445 * @mbox: pointer to the driver internal queue element for mailbox command.
3447 * This routine prepares and issues an Accept (ACC) response IOCB
3448 * command. It uses the @flag to properly set up the IOCB field for the
3449 * specific ACC response command to be issued and invokes the
3450 * lpfc_sli_issue_iocb() routine to send out ACC response IOCB. If a
3451 * @mbox pointer is passed in, it will be put into the context_un.mbox
3452 * field of the IOCB for the completion callback function to issue the
3453 * mailbox command to the HBA later when callback is invoked.
3455 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
3456 * will be incremented by 1 for holding the ndlp and the reference to ndlp
3457 * will be stored into the context1 field of the IOCB for the completion
3458 * callback function to the corresponding response ELS IOCB command.
3461 * 0 - Successfully issued acc response
3462 * 1 - Failed to issue acc response
3465 lpfc_els_rsp_acc(struct lpfc_vport
*vport
, uint32_t flag
,
3466 struct lpfc_iocbq
*oldiocb
, struct lpfc_nodelist
*ndlp
,
3469 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
3470 struct lpfc_hba
*phba
= vport
->phba
;
3473 struct lpfc_iocbq
*elsiocb
;
3474 struct lpfc_sli
*psli
;
3478 ELS_PKT
*els_pkt_ptr
;
3481 oldcmd
= &oldiocb
->iocb
;
3485 cmdsize
= sizeof(uint32_t);
3486 elsiocb
= lpfc_prep_els_iocb(vport
, 0, cmdsize
, oldiocb
->retry
,
3487 ndlp
, ndlp
->nlp_DID
, ELS_CMD_ACC
);
3489 spin_lock_irq(shost
->host_lock
);
3490 ndlp
->nlp_flag
&= ~NLP_LOGO_ACC
;
3491 spin_unlock_irq(shost
->host_lock
);
3495 icmd
= &elsiocb
->iocb
;
3496 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
3497 pcmd
= (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
3498 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
3499 pcmd
+= sizeof(uint32_t);
3501 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_RSP
,
3502 "Issue ACC: did:x%x flg:x%x",
3503 ndlp
->nlp_DID
, ndlp
->nlp_flag
, 0);
3506 cmdsize
= (sizeof(struct serv_parm
) + sizeof(uint32_t));
3507 elsiocb
= lpfc_prep_els_iocb(vport
, 0, cmdsize
, oldiocb
->retry
,
3508 ndlp
, ndlp
->nlp_DID
, ELS_CMD_ACC
);
3512 icmd
= &elsiocb
->iocb
;
3513 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
3514 pcmd
= (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
3517 elsiocb
->context_un
.mbox
= mbox
;
3519 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
3520 pcmd
+= sizeof(uint32_t);
3521 memcpy(pcmd
, &vport
->fc_sparam
, sizeof(struct serv_parm
));
3523 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_RSP
,
3524 "Issue ACC PLOGI: did:x%x flg:x%x",
3525 ndlp
->nlp_DID
, ndlp
->nlp_flag
, 0);
3528 cmdsize
= sizeof(uint32_t) + sizeof(PRLO
);
3529 elsiocb
= lpfc_prep_els_iocb(vport
, 0, cmdsize
, oldiocb
->retry
,
3530 ndlp
, ndlp
->nlp_DID
, ELS_CMD_PRLO
);
3534 icmd
= &elsiocb
->iocb
;
3535 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
3536 pcmd
= (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
3538 memcpy(pcmd
, ((struct lpfc_dmabuf
*) oldiocb
->context2
)->virt
,
3539 sizeof(uint32_t) + sizeof(PRLO
));
3540 *((uint32_t *) (pcmd
)) = ELS_CMD_PRLO_ACC
;
3541 els_pkt_ptr
= (ELS_PKT
*) pcmd
;
3542 els_pkt_ptr
->un
.prlo
.acceptRspCode
= PRLO_REQ_EXECUTED
;
3544 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_RSP
,
3545 "Issue ACC PRLO: did:x%x flg:x%x",
3546 ndlp
->nlp_DID
, ndlp
->nlp_flag
, 0);
3551 /* Xmit ELS ACC response tag <ulpIoTag> */
3552 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
3553 "0128 Xmit ELS ACC response tag x%x, XRI: x%x, "
3554 "DID: x%x, nlp_flag: x%x nlp_state: x%x RPI: x%x\n",
3555 elsiocb
->iotag
, elsiocb
->iocb
.ulpContext
,
3556 ndlp
->nlp_DID
, ndlp
->nlp_flag
, ndlp
->nlp_state
,
3558 if (ndlp
->nlp_flag
& NLP_LOGO_ACC
) {
3559 spin_lock_irq(shost
->host_lock
);
3560 ndlp
->nlp_flag
&= ~NLP_LOGO_ACC
;
3561 spin_unlock_irq(shost
->host_lock
);
3562 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_logo_acc
;
3564 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_rsp
;
3567 phba
->fc_stat
.elsXmitACC
++;
3568 rc
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0);
3569 if (rc
== IOCB_ERROR
) {
3570 lpfc_els_free_iocb(phba
, elsiocb
);
3577 * lpfc_els_rsp_reject - Propare and issue a rjt response iocb command
3578 * @vport: pointer to a virtual N_Port data structure.
3580 * @oldiocb: pointer to the original lpfc command iocb data structure.
3581 * @ndlp: pointer to a node-list data structure.
3582 * @mbox: pointer to the driver internal queue element for mailbox command.
3584 * This routine prepares and issue an Reject (RJT) response IOCB
3585 * command. If a @mbox pointer is passed in, it will be put into the
3586 * context_un.mbox field of the IOCB for the completion callback function
3587 * to issue to the HBA later.
3589 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
3590 * will be incremented by 1 for holding the ndlp and the reference to ndlp
3591 * will be stored into the context1 field of the IOCB for the completion
3592 * callback function to the reject response ELS IOCB command.
3595 * 0 - Successfully issued reject response
3596 * 1 - Failed to issue reject response
3599 lpfc_els_rsp_reject(struct lpfc_vport
*vport
, uint32_t rejectError
,
3600 struct lpfc_iocbq
*oldiocb
, struct lpfc_nodelist
*ndlp
,
3603 struct lpfc_hba
*phba
= vport
->phba
;
3606 struct lpfc_iocbq
*elsiocb
;
3607 struct lpfc_sli
*psli
;
3613 cmdsize
= 2 * sizeof(uint32_t);
3614 elsiocb
= lpfc_prep_els_iocb(vport
, 0, cmdsize
, oldiocb
->retry
, ndlp
,
3615 ndlp
->nlp_DID
, ELS_CMD_LS_RJT
);
3619 icmd
= &elsiocb
->iocb
;
3620 oldcmd
= &oldiocb
->iocb
;
3621 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
3622 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
3624 *((uint32_t *) (pcmd
)) = ELS_CMD_LS_RJT
;
3625 pcmd
+= sizeof(uint32_t);
3626 *((uint32_t *) (pcmd
)) = rejectError
;
3629 elsiocb
->context_un
.mbox
= mbox
;
3631 /* Xmit ELS RJT <err> response tag <ulpIoTag> */
3632 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
3633 "0129 Xmit ELS RJT x%x response tag x%x "
3634 "xri x%x, did x%x, nlp_flag x%x, nlp_state x%x, "
3636 rejectError
, elsiocb
->iotag
,
3637 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
3638 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
3639 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_RSP
,
3640 "Issue LS_RJT: did:x%x flg:x%x err:x%x",
3641 ndlp
->nlp_DID
, ndlp
->nlp_flag
, rejectError
);
3643 phba
->fc_stat
.elsXmitLSRJT
++;
3644 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_rsp
;
3645 rc
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0);
3647 if (rc
== IOCB_ERROR
) {
3648 lpfc_els_free_iocb(phba
, elsiocb
);
3655 * lpfc_els_rsp_adisc_acc - Prepare and issue acc response to adisc iocb cmd
3656 * @vport: pointer to a virtual N_Port data structure.
3657 * @oldiocb: pointer to the original lpfc command iocb data structure.
3658 * @ndlp: pointer to a node-list data structure.
3660 * This routine prepares and issues an Accept (ACC) response to Address
3661 * Discover (ADISC) ELS command. It simply prepares the payload of the IOCB
3662 * and invokes the lpfc_sli_issue_iocb() routine to send out the command.
3664 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
3665 * will be incremented by 1 for holding the ndlp and the reference to ndlp
3666 * will be stored into the context1 field of the IOCB for the completion
3667 * callback function to the ADISC Accept response ELS IOCB command.
3670 * 0 - Successfully issued acc adisc response
3671 * 1 - Failed to issue adisc acc response
3674 lpfc_els_rsp_adisc_acc(struct lpfc_vport
*vport
, struct lpfc_iocbq
*oldiocb
,
3675 struct lpfc_nodelist
*ndlp
)
3677 struct lpfc_hba
*phba
= vport
->phba
;
3679 IOCB_t
*icmd
, *oldcmd
;
3680 struct lpfc_iocbq
*elsiocb
;
3685 cmdsize
= sizeof(uint32_t) + sizeof(ADISC
);
3686 elsiocb
= lpfc_prep_els_iocb(vport
, 0, cmdsize
, oldiocb
->retry
, ndlp
,
3687 ndlp
->nlp_DID
, ELS_CMD_ACC
);
3691 icmd
= &elsiocb
->iocb
;
3692 oldcmd
= &oldiocb
->iocb
;
3693 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
3695 /* Xmit ADISC ACC response tag <ulpIoTag> */
3696 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
3697 "0130 Xmit ADISC ACC response iotag x%x xri: "
3698 "x%x, did x%x, nlp_flag x%x, nlp_state x%x rpi x%x\n",
3699 elsiocb
->iotag
, elsiocb
->iocb
.ulpContext
,
3700 ndlp
->nlp_DID
, ndlp
->nlp_flag
, ndlp
->nlp_state
,
3702 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
3704 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
3705 pcmd
+= sizeof(uint32_t);
3707 ap
= (ADISC
*) (pcmd
);
3708 ap
->hardAL_PA
= phba
->fc_pref_ALPA
;
3709 memcpy(&ap
->portName
, &vport
->fc_portname
, sizeof(struct lpfc_name
));
3710 memcpy(&ap
->nodeName
, &vport
->fc_nodename
, sizeof(struct lpfc_name
));
3711 ap
->DID
= be32_to_cpu(vport
->fc_myDID
);
3713 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_RSP
,
3714 "Issue ACC ADISC: did:x%x flg:x%x",
3715 ndlp
->nlp_DID
, ndlp
->nlp_flag
, 0);
3717 phba
->fc_stat
.elsXmitACC
++;
3718 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_rsp
;
3719 rc
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0);
3720 if (rc
== IOCB_ERROR
) {
3721 lpfc_els_free_iocb(phba
, elsiocb
);
3728 * lpfc_els_rsp_prli_acc - Prepare and issue acc response to prli iocb cmd
3729 * @vport: pointer to a virtual N_Port data structure.
3730 * @oldiocb: pointer to the original lpfc command iocb data structure.
3731 * @ndlp: pointer to a node-list data structure.
3733 * This routine prepares and issues an Accept (ACC) response to Process
3734 * Login (PRLI) ELS command. It simply prepares the payload of the IOCB
3735 * and invokes the lpfc_sli_issue_iocb() routine to send out the command.
3737 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
3738 * will be incremented by 1 for holding the ndlp and the reference to ndlp
3739 * will be stored into the context1 field of the IOCB for the completion
3740 * callback function to the PRLI Accept response ELS IOCB command.
3743 * 0 - Successfully issued acc prli response
3744 * 1 - Failed to issue acc prli response
3747 lpfc_els_rsp_prli_acc(struct lpfc_vport
*vport
, struct lpfc_iocbq
*oldiocb
,
3748 struct lpfc_nodelist
*ndlp
)
3750 struct lpfc_hba
*phba
= vport
->phba
;
3755 struct lpfc_iocbq
*elsiocb
;
3756 struct lpfc_sli
*psli
;
3763 cmdsize
= sizeof(uint32_t) + sizeof(PRLI
);
3764 elsiocb
= lpfc_prep_els_iocb(vport
, 0, cmdsize
, oldiocb
->retry
, ndlp
,
3765 ndlp
->nlp_DID
, (ELS_CMD_ACC
| (ELS_CMD_PRLI
& ~ELS_RSP_MASK
)));
3769 icmd
= &elsiocb
->iocb
;
3770 oldcmd
= &oldiocb
->iocb
;
3771 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
3772 /* Xmit PRLI ACC response tag <ulpIoTag> */
3773 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
3774 "0131 Xmit PRLI ACC response tag x%x xri x%x, "
3775 "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
3776 elsiocb
->iotag
, elsiocb
->iocb
.ulpContext
,
3777 ndlp
->nlp_DID
, ndlp
->nlp_flag
, ndlp
->nlp_state
,
3779 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
3781 *((uint32_t *) (pcmd
)) = (ELS_CMD_ACC
| (ELS_CMD_PRLI
& ~ELS_RSP_MASK
));
3782 pcmd
+= sizeof(uint32_t);
3784 /* For PRLI, remainder of payload is PRLI parameter page */
3785 memset(pcmd
, 0, sizeof(PRLI
));
3787 npr
= (PRLI
*) pcmd
;
3790 * If the remote port is a target and our firmware version is 3.20 or
3791 * later, set the following bits for FC-TAPE support.
3793 if ((ndlp
->nlp_type
& NLP_FCP_TARGET
) &&
3794 (vpd
->rev
.feaLevelHigh
>= 0x02)) {
3795 npr
->ConfmComplAllowed
= 1;
3797 npr
->TaskRetryIdReq
= 1;
3800 npr
->acceptRspCode
= PRLI_REQ_EXECUTED
;
3801 npr
->estabImagePair
= 1;
3802 npr
->readXferRdyDis
= 1;
3803 npr
->ConfmComplAllowed
= 1;
3805 npr
->prliType
= PRLI_FCP_TYPE
;
3806 npr
->initiatorFunc
= 1;
3808 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_RSP
,
3809 "Issue ACC PRLI: did:x%x flg:x%x",
3810 ndlp
->nlp_DID
, ndlp
->nlp_flag
, 0);
3812 phba
->fc_stat
.elsXmitACC
++;
3813 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_rsp
;
3815 rc
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0);
3816 if (rc
== IOCB_ERROR
) {
3817 lpfc_els_free_iocb(phba
, elsiocb
);
3824 * lpfc_els_rsp_rnid_acc - Issue rnid acc response iocb command
3825 * @vport: pointer to a virtual N_Port data structure.
3826 * @format: rnid command format.
3827 * @oldiocb: pointer to the original lpfc command iocb data structure.
3828 * @ndlp: pointer to a node-list data structure.
3830 * This routine issues a Request Node Identification Data (RNID) Accept
3831 * (ACC) response. It constructs the RNID ACC response command according to
3832 * the proper @format and then calls the lpfc_sli_issue_iocb() routine to
3833 * issue the response. Note that this command does not need to hold the ndlp
3834 * reference count for the callback. So, the ndlp reference count taken by
3835 * the lpfc_prep_els_iocb() routine is put back and the context1 field of
3836 * IOCB is set to NULL to indicate to the lpfc_els_free_iocb() routine that
3837 * there is no ndlp reference available.
3839 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
3840 * will be incremented by 1 for holding the ndlp and the reference to ndlp
3841 * will be stored into the context1 field of the IOCB for the completion
3842 * callback function. However, for the RNID Accept Response ELS command,
3843 * this is undone later by this routine after the IOCB is allocated.
3846 * 0 - Successfully issued acc rnid response
3847 * 1 - Failed to issue acc rnid response
3850 lpfc_els_rsp_rnid_acc(struct lpfc_vport
*vport
, uint8_t format
,
3851 struct lpfc_iocbq
*oldiocb
, struct lpfc_nodelist
*ndlp
)
3853 struct lpfc_hba
*phba
= vport
->phba
;
3855 IOCB_t
*icmd
, *oldcmd
;
3856 struct lpfc_iocbq
*elsiocb
;
3857 struct lpfc_sli
*psli
;
3863 cmdsize
= sizeof(uint32_t) + sizeof(uint32_t)
3864 + (2 * sizeof(struct lpfc_name
));
3866 cmdsize
+= sizeof(RNID_TOP_DISC
);
3868 elsiocb
= lpfc_prep_els_iocb(vport
, 0, cmdsize
, oldiocb
->retry
, ndlp
,
3869 ndlp
->nlp_DID
, ELS_CMD_ACC
);
3873 icmd
= &elsiocb
->iocb
;
3874 oldcmd
= &oldiocb
->iocb
;
3875 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
3876 /* Xmit RNID ACC response tag <ulpIoTag> */
3877 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
3878 "0132 Xmit RNID ACC response tag x%x xri x%x\n",
3879 elsiocb
->iotag
, elsiocb
->iocb
.ulpContext
);
3880 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
3881 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
3882 pcmd
+= sizeof(uint32_t);
3884 memset(pcmd
, 0, sizeof(RNID
));
3885 rn
= (RNID
*) (pcmd
);
3886 rn
->Format
= format
;
3887 rn
->CommonLen
= (2 * sizeof(struct lpfc_name
));
3888 memcpy(&rn
->portName
, &vport
->fc_portname
, sizeof(struct lpfc_name
));
3889 memcpy(&rn
->nodeName
, &vport
->fc_nodename
, sizeof(struct lpfc_name
));
3892 rn
->SpecificLen
= 0;
3894 case RNID_TOPOLOGY_DISC
:
3895 rn
->SpecificLen
= sizeof(RNID_TOP_DISC
);
3896 memcpy(&rn
->un
.topologyDisc
.portName
,
3897 &vport
->fc_portname
, sizeof(struct lpfc_name
));
3898 rn
->un
.topologyDisc
.unitType
= RNID_HBA
;
3899 rn
->un
.topologyDisc
.physPort
= 0;
3900 rn
->un
.topologyDisc
.attachedNodes
= 0;
3904 rn
->SpecificLen
= 0;
3908 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_RSP
,
3909 "Issue ACC RNID: did:x%x flg:x%x",
3910 ndlp
->nlp_DID
, ndlp
->nlp_flag
, 0);
3912 phba
->fc_stat
.elsXmitACC
++;
3913 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_rsp
;
3915 elsiocb
->context1
= NULL
; /* Don't need ndlp for cmpl,
3916 * it could be freed */
3918 rc
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0);
3919 if (rc
== IOCB_ERROR
) {
3920 lpfc_els_free_iocb(phba
, elsiocb
);
3927 * lpfc_els_disc_adisc - Issue remaining adisc iocbs to npr nodes of a vport
3928 * @vport: pointer to a host virtual N_Port data structure.
3930 * This routine issues Address Discover (ADISC) ELS commands to those
3931 * N_Ports which are in node port recovery state and ADISC has not been issued
3932 * for the @vport. Each time an ELS ADISC IOCB is issued by invoking the
3933 * lpfc_issue_els_adisc() routine, the per @vport number of discover count
3934 * (num_disc_nodes) shall be incremented. If the num_disc_nodes reaches a
3935 * pre-configured threshold (cfg_discovery_threads), the @vport fc_flag will
3936 * be marked with FC_NLP_MORE bit and the process of issuing remaining ADISC
3937 * IOCBs quit for later pick up. On the other hand, after walking through
3938 * all the ndlps with the @vport and there is none ADISC IOCB issued, the
3939 * @vport fc_flag shall be cleared with FC_NLP_MORE bit indicating there is
3940 * no more ADISC need to be sent.
3943 * The number of N_Ports with adisc issued.
3946 lpfc_els_disc_adisc(struct lpfc_vport
*vport
)
3948 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
3949 struct lpfc_nodelist
*ndlp
, *next_ndlp
;
3952 /* go thru NPR nodes and issue any remaining ELS ADISCs */
3953 list_for_each_entry_safe(ndlp
, next_ndlp
, &vport
->fc_nodes
, nlp_listp
) {
3954 if (!NLP_CHK_NODE_ACT(ndlp
))
3956 if (ndlp
->nlp_state
== NLP_STE_NPR_NODE
&&
3957 (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) != 0 &&
3958 (ndlp
->nlp_flag
& NLP_NPR_ADISC
) != 0) {
3959 spin_lock_irq(shost
->host_lock
);
3960 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
3961 spin_unlock_irq(shost
->host_lock
);
3962 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
3963 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_ADISC_ISSUE
);
3964 lpfc_issue_els_adisc(vport
, ndlp
, 0);
3966 vport
->num_disc_nodes
++;
3967 if (vport
->num_disc_nodes
>=
3968 vport
->cfg_discovery_threads
) {
3969 spin_lock_irq(shost
->host_lock
);
3970 vport
->fc_flag
|= FC_NLP_MORE
;
3971 spin_unlock_irq(shost
->host_lock
);
3976 if (sentadisc
== 0) {
3977 spin_lock_irq(shost
->host_lock
);
3978 vport
->fc_flag
&= ~FC_NLP_MORE
;
3979 spin_unlock_irq(shost
->host_lock
);
3985 * lpfc_els_disc_plogi - Issue plogi for all npr nodes of a vport before adisc
3986 * @vport: pointer to a host virtual N_Port data structure.
3988 * This routine issues Port Login (PLOGI) ELS commands to all the N_Ports
3989 * which are in node port recovery state, with a @vport. Each time an ELS
3990 * ADISC PLOGI IOCB is issued by invoking the lpfc_issue_els_plogi() routine,
3991 * the per @vport number of discover count (num_disc_nodes) shall be
3992 * incremented. If the num_disc_nodes reaches a pre-configured threshold
3993 * (cfg_discovery_threads), the @vport fc_flag will be marked with FC_NLP_MORE
3994 * bit set and quit the process of issuing remaining ADISC PLOGIN IOCBs for
3995 * later pick up. On the other hand, after walking through all the ndlps with
3996 * the @vport and there is none ADISC PLOGI IOCB issued, the @vport fc_flag
3997 * shall be cleared with the FC_NLP_MORE bit indicating there is no more ADISC
3998 * PLOGI need to be sent.
4001 * The number of N_Ports with plogi issued.
4004 lpfc_els_disc_plogi(struct lpfc_vport
*vport
)
4006 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
4007 struct lpfc_nodelist
*ndlp
, *next_ndlp
;
4010 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
4011 list_for_each_entry_safe(ndlp
, next_ndlp
, &vport
->fc_nodes
, nlp_listp
) {
4012 if (!NLP_CHK_NODE_ACT(ndlp
))
4014 if (ndlp
->nlp_state
== NLP_STE_NPR_NODE
&&
4015 (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) != 0 &&
4016 (ndlp
->nlp_flag
& NLP_DELAY_TMO
) == 0 &&
4017 (ndlp
->nlp_flag
& NLP_NPR_ADISC
) == 0) {
4018 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
4019 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
4020 lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0);
4022 vport
->num_disc_nodes
++;
4023 if (vport
->num_disc_nodes
>=
4024 vport
->cfg_discovery_threads
) {
4025 spin_lock_irq(shost
->host_lock
);
4026 vport
->fc_flag
|= FC_NLP_MORE
;
4027 spin_unlock_irq(shost
->host_lock
);
4033 lpfc_set_disctmo(vport
);
4036 spin_lock_irq(shost
->host_lock
);
4037 vport
->fc_flag
&= ~FC_NLP_MORE
;
4038 spin_unlock_irq(shost
->host_lock
);
4044 * lpfc_els_flush_rscn - Clean up any rscn activities with a vport
4045 * @vport: pointer to a host virtual N_Port data structure.
4047 * This routine cleans up any Registration State Change Notification
4048 * (RSCN) activity with a @vport. Note that the fc_rscn_flush flag of the
4049 * @vport together with the host_lock is used to prevent multiple thread
4050 * trying to access the RSCN array on a same @vport at the same time.
4053 lpfc_els_flush_rscn(struct lpfc_vport
*vport
)
4055 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
4056 struct lpfc_hba
*phba
= vport
->phba
;
4059 spin_lock_irq(shost
->host_lock
);
4060 if (vport
->fc_rscn_flush
) {
4061 /* Another thread is walking fc_rscn_id_list on this vport */
4062 spin_unlock_irq(shost
->host_lock
);
4065 /* Indicate we are walking lpfc_els_flush_rscn on this vport */
4066 vport
->fc_rscn_flush
= 1;
4067 spin_unlock_irq(shost
->host_lock
);
4069 for (i
= 0; i
< vport
->fc_rscn_id_cnt
; i
++) {
4070 lpfc_in_buf_free(phba
, vport
->fc_rscn_id_list
[i
]);
4071 vport
->fc_rscn_id_list
[i
] = NULL
;
4073 spin_lock_irq(shost
->host_lock
);
4074 vport
->fc_rscn_id_cnt
= 0;
4075 vport
->fc_flag
&= ~(FC_RSCN_MODE
| FC_RSCN_DISCOVERY
);
4076 spin_unlock_irq(shost
->host_lock
);
4077 lpfc_can_disctmo(vport
);
4078 /* Indicate we are done walking this fc_rscn_id_list */
4079 vport
->fc_rscn_flush
= 0;
4083 * lpfc_rscn_payload_check - Check whether there is a pending rscn to a did
4084 * @vport: pointer to a host virtual N_Port data structure.
4085 * @did: remote destination port identifier.
4087 * This routine checks whether there is any pending Registration State
4088 * Configuration Notification (RSCN) to a @did on @vport.
4091 * None zero - The @did matched with a pending rscn
4092 * 0 - not able to match @did with a pending rscn
4095 lpfc_rscn_payload_check(struct lpfc_vport
*vport
, uint32_t did
)
4100 uint32_t payload_len
, i
;
4101 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
4103 ns_did
.un
.word
= did
;
4105 /* Never match fabric nodes for RSCNs */
4106 if ((did
& Fabric_DID_MASK
) == Fabric_DID_MASK
)
4109 /* If we are doing a FULL RSCN rediscovery, match everything */
4110 if (vport
->fc_flag
& FC_RSCN_DISCOVERY
)
4113 spin_lock_irq(shost
->host_lock
);
4114 if (vport
->fc_rscn_flush
) {
4115 /* Another thread is walking fc_rscn_id_list on this vport */
4116 spin_unlock_irq(shost
->host_lock
);
4119 /* Indicate we are walking fc_rscn_id_list on this vport */
4120 vport
->fc_rscn_flush
= 1;
4121 spin_unlock_irq(shost
->host_lock
);
4122 for (i
= 0; i
< vport
->fc_rscn_id_cnt
; i
++) {
4123 lp
= vport
->fc_rscn_id_list
[i
]->virt
;
4124 payload_len
= be32_to_cpu(*lp
++ & ~ELS_CMD_MASK
);
4125 payload_len
-= sizeof(uint32_t); /* take off word 0 */
4126 while (payload_len
) {
4127 rscn_did
.un
.word
= be32_to_cpu(*lp
++);
4128 payload_len
-= sizeof(uint32_t);
4129 switch (rscn_did
.un
.b
.resv
& RSCN_ADDRESS_FORMAT_MASK
) {
4130 case RSCN_ADDRESS_FORMAT_PORT
:
4131 if ((ns_did
.un
.b
.domain
== rscn_did
.un
.b
.domain
)
4132 && (ns_did
.un
.b
.area
== rscn_did
.un
.b
.area
)
4133 && (ns_did
.un
.b
.id
== rscn_did
.un
.b
.id
))
4134 goto return_did_out
;
4136 case RSCN_ADDRESS_FORMAT_AREA
:
4137 if ((ns_did
.un
.b
.domain
== rscn_did
.un
.b
.domain
)
4138 && (ns_did
.un
.b
.area
== rscn_did
.un
.b
.area
))
4139 goto return_did_out
;
4141 case RSCN_ADDRESS_FORMAT_DOMAIN
:
4142 if (ns_did
.un
.b
.domain
== rscn_did
.un
.b
.domain
)
4143 goto return_did_out
;
4145 case RSCN_ADDRESS_FORMAT_FABRIC
:
4146 goto return_did_out
;
4150 /* Indicate we are done with walking fc_rscn_id_list on this vport */
4151 vport
->fc_rscn_flush
= 0;
4154 /* Indicate we are done with walking fc_rscn_id_list on this vport */
4155 vport
->fc_rscn_flush
= 0;
4160 * lpfc_rscn_recovery_check - Send recovery event to vport nodes matching rscn
4161 * @vport: pointer to a host virtual N_Port data structure.
4163 * This routine sends recovery (NLP_EVT_DEVICE_RECOVERY) event to the
4164 * state machine for a @vport's nodes that are with pending RSCN (Registration
4165 * State Change Notification).
4168 * 0 - Successful (currently alway return 0)
4171 lpfc_rscn_recovery_check(struct lpfc_vport
*vport
)
4173 struct lpfc_nodelist
*ndlp
= NULL
;
4175 /* Move all affected nodes by pending RSCNs to NPR state. */
4176 list_for_each_entry(ndlp
, &vport
->fc_nodes
, nlp_listp
) {
4177 if (!NLP_CHK_NODE_ACT(ndlp
) ||
4178 (ndlp
->nlp_state
== NLP_STE_UNUSED_NODE
) ||
4179 !lpfc_rscn_payload_check(vport
, ndlp
->nlp_DID
))
4181 lpfc_disc_state_machine(vport
, ndlp
, NULL
,
4182 NLP_EVT_DEVICE_RECOVERY
);
4183 lpfc_cancel_retry_delay_tmo(vport
, ndlp
);
4189 * lpfc_send_rscn_event - Send an RSCN event to management application
4190 * @vport: pointer to a host virtual N_Port data structure.
4191 * @cmdiocb: pointer to lpfc command iocb data structure.
4193 * lpfc_send_rscn_event sends an RSCN netlink event to management
4197 lpfc_send_rscn_event(struct lpfc_vport
*vport
,
4198 struct lpfc_iocbq
*cmdiocb
)
4200 struct lpfc_dmabuf
*pcmd
;
4201 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
4202 uint32_t *payload_ptr
;
4203 uint32_t payload_len
;
4204 struct lpfc_rscn_event_header
*rscn_event_data
;
4206 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
4207 payload_ptr
= (uint32_t *) pcmd
->virt
;
4208 payload_len
= be32_to_cpu(*payload_ptr
& ~ELS_CMD_MASK
);
4210 rscn_event_data
= kmalloc(sizeof(struct lpfc_rscn_event_header
) +
4211 payload_len
, GFP_KERNEL
);
4212 if (!rscn_event_data
) {
4213 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
4214 "0147 Failed to allocate memory for RSCN event\n");
4217 rscn_event_data
->event_type
= FC_REG_RSCN_EVENT
;
4218 rscn_event_data
->payload_length
= payload_len
;
4219 memcpy(rscn_event_data
->rscn_payload
, payload_ptr
,
4222 fc_host_post_vendor_event(shost
,
4223 fc_get_event_number(),
4224 sizeof(struct lpfc_els_event_header
) + payload_len
,
4225 (char *)rscn_event_data
,
4228 kfree(rscn_event_data
);
4232 * lpfc_els_rcv_rscn - Process an unsolicited rscn iocb
4233 * @vport: pointer to a host virtual N_Port data structure.
4234 * @cmdiocb: pointer to lpfc command iocb data structure.
4235 * @ndlp: pointer to a node-list data structure.
4237 * This routine processes an unsolicited RSCN (Registration State Change
4238 * Notification) IOCB. First, the payload of the unsolicited RSCN is walked
4239 * to invoke fc_host_post_event() routine to the FC transport layer. If the
4240 * discover state machine is about to begin discovery, it just accepts the
4241 * RSCN and the discovery process will satisfy the RSCN. If this RSCN only
4242 * contains N_Port IDs for other vports on this HBA, it just accepts the
4243 * RSCN and ignore processing it. If the state machine is in the recovery
4244 * state, the fc_rscn_id_list of this @vport is walked and the
4245 * lpfc_rscn_recovery_check() routine is invoked to send recovery event for
4246 * all nodes that match RSCN payload. Otherwise, the lpfc_els_handle_rscn()
4247 * routine is invoked to handle the RSCN event.
4250 * 0 - Just sent the acc response
4251 * 1 - Sent the acc response and waited for name server completion
4254 lpfc_els_rcv_rscn(struct lpfc_vport
*vport
, struct lpfc_iocbq
*cmdiocb
,
4255 struct lpfc_nodelist
*ndlp
)
4257 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
4258 struct lpfc_hba
*phba
= vport
->phba
;
4259 struct lpfc_dmabuf
*pcmd
;
4260 uint32_t *lp
, *datap
;
4262 uint32_t payload_len
, length
, nportid
, *cmd
;
4264 int rscn_id
= 0, hba_id
= 0;
4267 icmd
= &cmdiocb
->iocb
;
4268 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
4269 lp
= (uint32_t *) pcmd
->virt
;
4271 payload_len
= be32_to_cpu(*lp
++ & ~ELS_CMD_MASK
);
4272 payload_len
-= sizeof(uint32_t); /* take off word 0 */
4274 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_DISCOVERY
,
4275 "0214 RSCN received Data: x%x x%x x%x x%x\n",
4276 vport
->fc_flag
, payload_len
, *lp
,
4277 vport
->fc_rscn_id_cnt
);
4279 /* Send an RSCN event to the management application */
4280 lpfc_send_rscn_event(vport
, cmdiocb
);
4282 for (i
= 0; i
< payload_len
/sizeof(uint32_t); i
++)
4283 fc_host_post_event(shost
, fc_get_event_number(),
4284 FCH_EVT_RSCN
, lp
[i
]);
4286 /* If we are about to begin discovery, just ACC the RSCN.
4287 * Discovery processing will satisfy it.
4289 if (vport
->port_state
<= LPFC_NS_QRY
) {
4290 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
4291 "RCV RSCN ignore: did:x%x/ste:x%x flg:x%x",
4292 ndlp
->nlp_DID
, vport
->port_state
, ndlp
->nlp_flag
);
4294 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
);
4298 /* If this RSCN just contains NPortIDs for other vports on this HBA,
4299 * just ACC and ignore it.
4301 if ((phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
) &&
4302 !(vport
->cfg_peer_port_login
)) {
4307 nportid
= ((be32_to_cpu(nportid
)) & Mask_DID
);
4308 i
-= sizeof(uint32_t);
4310 if (lpfc_find_vport_by_did(phba
, nportid
))
4313 if (rscn_id
== hba_id
) {
4314 /* ALL NPortIDs in RSCN are on HBA */
4315 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_DISCOVERY
,
4317 "Data: x%x x%x x%x x%x\n",
4318 vport
->fc_flag
, payload_len
,
4319 *lp
, vport
->fc_rscn_id_cnt
);
4320 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
4321 "RCV RSCN vport: did:x%x/ste:x%x flg:x%x",
4322 ndlp
->nlp_DID
, vport
->port_state
,
4325 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
,
4331 spin_lock_irq(shost
->host_lock
);
4332 if (vport
->fc_rscn_flush
) {
4333 /* Another thread is walking fc_rscn_id_list on this vport */
4334 vport
->fc_flag
|= FC_RSCN_DISCOVERY
;
4335 spin_unlock_irq(shost
->host_lock
);
4337 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
);
4340 /* Indicate we are walking fc_rscn_id_list on this vport */
4341 vport
->fc_rscn_flush
= 1;
4342 spin_unlock_irq(shost
->host_lock
);
4343 /* Get the array count after successfully have the token */
4344 rscn_cnt
= vport
->fc_rscn_id_cnt
;
4345 /* If we are already processing an RSCN, save the received
4346 * RSCN payload buffer, cmdiocb->context2 to process later.
4348 if (vport
->fc_flag
& (FC_RSCN_MODE
| FC_NDISC_ACTIVE
)) {
4349 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
4350 "RCV RSCN defer: did:x%x/ste:x%x flg:x%x",
4351 ndlp
->nlp_DID
, vport
->port_state
, ndlp
->nlp_flag
);
4353 spin_lock_irq(shost
->host_lock
);
4354 vport
->fc_flag
|= FC_RSCN_DEFERRED
;
4355 if ((rscn_cnt
< FC_MAX_HOLD_RSCN
) &&
4356 !(vport
->fc_flag
& FC_RSCN_DISCOVERY
)) {
4357 vport
->fc_flag
|= FC_RSCN_MODE
;
4358 spin_unlock_irq(shost
->host_lock
);
4360 cmd
= vport
->fc_rscn_id_list
[rscn_cnt
-1]->virt
;
4361 length
= be32_to_cpu(*cmd
& ~ELS_CMD_MASK
);
4364 (payload_len
+ length
<= LPFC_BPL_SIZE
)) {
4365 *cmd
&= ELS_CMD_MASK
;
4366 *cmd
|= cpu_to_be32(payload_len
+ length
);
4367 memcpy(((uint8_t *)cmd
) + length
, lp
,
4370 vport
->fc_rscn_id_list
[rscn_cnt
] = pcmd
;
4371 vport
->fc_rscn_id_cnt
++;
4372 /* If we zero, cmdiocb->context2, the calling
4373 * routine will not try to free it.
4375 cmdiocb
->context2
= NULL
;
4378 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_DISCOVERY
,
4379 "0235 Deferred RSCN "
4380 "Data: x%x x%x x%x\n",
4381 vport
->fc_rscn_id_cnt
, vport
->fc_flag
,
4384 vport
->fc_flag
|= FC_RSCN_DISCOVERY
;
4385 spin_unlock_irq(shost
->host_lock
);
4386 /* ReDiscovery RSCN */
4387 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_DISCOVERY
,
4388 "0234 ReDiscovery RSCN "
4389 "Data: x%x x%x x%x\n",
4390 vport
->fc_rscn_id_cnt
, vport
->fc_flag
,
4393 /* Indicate we are done walking fc_rscn_id_list on this vport */
4394 vport
->fc_rscn_flush
= 0;
4396 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
);
4397 /* send RECOVERY event for ALL nodes that match RSCN payload */
4398 lpfc_rscn_recovery_check(vport
);
4399 spin_lock_irq(shost
->host_lock
);
4400 vport
->fc_flag
&= ~FC_RSCN_DEFERRED
;
4401 spin_unlock_irq(shost
->host_lock
);
4404 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
4405 "RCV RSCN: did:x%x/ste:x%x flg:x%x",
4406 ndlp
->nlp_DID
, vport
->port_state
, ndlp
->nlp_flag
);
4408 spin_lock_irq(shost
->host_lock
);
4409 vport
->fc_flag
|= FC_RSCN_MODE
;
4410 spin_unlock_irq(shost
->host_lock
);
4411 vport
->fc_rscn_id_list
[vport
->fc_rscn_id_cnt
++] = pcmd
;
4412 /* Indicate we are done walking fc_rscn_id_list on this vport */
4413 vport
->fc_rscn_flush
= 0;
4415 * If we zero, cmdiocb->context2, the calling routine will
4416 * not try to free it.
4418 cmdiocb
->context2
= NULL
;
4419 lpfc_set_disctmo(vport
);
4421 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
);
4422 /* send RECOVERY event for ALL nodes that match RSCN payload */
4423 lpfc_rscn_recovery_check(vport
);
4424 return lpfc_els_handle_rscn(vport
);
4428 * lpfc_els_handle_rscn - Handle rscn for a vport
4429 * @vport: pointer to a host virtual N_Port data structure.
4431 * This routine handles the Registration State Configuration Notification
4432 * (RSCN) for a @vport. If login to NameServer does not exist, a new ndlp shall
4433 * be created and a Port Login (PLOGI) to the NameServer is issued. Otherwise,
4434 * if the ndlp to NameServer exists, a Common Transport (CT) command to the
4435 * NameServer shall be issued. If CT command to the NameServer fails to be
4436 * issued, the lpfc_els_flush_rscn() routine shall be invoked to clean up any
4437 * RSCN activities with the @vport.
4440 * 0 - Cleaned up rscn on the @vport
4441 * 1 - Wait for plogi to name server before proceed
4444 lpfc_els_handle_rscn(struct lpfc_vport
*vport
)
4446 struct lpfc_nodelist
*ndlp
;
4447 struct lpfc_hba
*phba
= vport
->phba
;
4449 /* Ignore RSCN if the port is being torn down. */
4450 if (vport
->load_flag
& FC_UNLOADING
) {
4451 lpfc_els_flush_rscn(vport
);
4455 /* Start timer for RSCN processing */
4456 lpfc_set_disctmo(vport
);
4458 /* RSCN processed */
4459 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_DISCOVERY
,
4460 "0215 RSCN processed Data: x%x x%x x%x x%x\n",
4461 vport
->fc_flag
, 0, vport
->fc_rscn_id_cnt
,
4464 /* To process RSCN, first compare RSCN data with NameServer */
4465 vport
->fc_ns_retry
= 0;
4466 vport
->num_disc_nodes
= 0;
4468 ndlp
= lpfc_findnode_did(vport
, NameServer_DID
);
4469 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
)
4470 && ndlp
->nlp_state
== NLP_STE_UNMAPPED_NODE
) {
4471 /* Good ndlp, issue CT Request to NameServer */
4472 if (lpfc_ns_cmd(vport
, SLI_CTNS_GID_FT
, 0, 0) == 0)
4473 /* Wait for NameServer query cmpl before we can
4477 /* If login to NameServer does not exist, issue one */
4478 /* Good status, issue PLOGI to NameServer */
4479 ndlp
= lpfc_findnode_did(vport
, NameServer_DID
);
4480 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
))
4481 /* Wait for NameServer login cmpl before we can
4486 ndlp
= lpfc_enable_node(vport
, ndlp
,
4487 NLP_STE_PLOGI_ISSUE
);
4489 lpfc_els_flush_rscn(vport
);
4492 ndlp
->nlp_prev_state
= NLP_STE_UNUSED_NODE
;
4494 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
4496 lpfc_els_flush_rscn(vport
);
4499 lpfc_nlp_init(vport
, ndlp
, NameServer_DID
);
4500 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
4501 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
4503 ndlp
->nlp_type
|= NLP_FABRIC
;
4504 lpfc_issue_els_plogi(vport
, NameServer_DID
, 0);
4505 /* Wait for NameServer login cmpl before we can
4511 lpfc_els_flush_rscn(vport
);
4516 * lpfc_els_rcv_flogi - Process an unsolicited flogi iocb
4517 * @vport: pointer to a host virtual N_Port data structure.
4518 * @cmdiocb: pointer to lpfc command iocb data structure.
4519 * @ndlp: pointer to a node-list data structure.
4521 * This routine processes Fabric Login (FLOGI) IOCB received as an ELS
4522 * unsolicited event. An unsolicited FLOGI can be received in a point-to-
4523 * point topology. As an unsolicited FLOGI should not be received in a loop
4524 * mode, any unsolicited FLOGI received in loop mode shall be ignored. The
4525 * lpfc_check_sparm() routine is invoked to check the parameters in the
4526 * unsolicited FLOGI. If parameters validation failed, the routine
4527 * lpfc_els_rsp_reject() shall be called with reject reason code set to
4528 * LSEXP_SPARM_OPTIONS to reject the FLOGI. Otherwise, the Port WWN in the
4529 * FLOGI shall be compared with the Port WWN of the @vport to determine who
4530 * will initiate PLOGI. The higher lexicographical value party shall has
4531 * higher priority (as the winning port) and will initiate PLOGI and
4532 * communicate Port_IDs (Addresses) for both nodes in PLOGI. The result
4533 * of this will be marked in the @vport fc_flag field with FC_PT2PT_PLOGI
4534 * and then the lpfc_els_rsp_acc() routine is invoked to accept the FLOGI.
4537 * 0 - Successfully processed the unsolicited flogi
4538 * 1 - Failed to process the unsolicited flogi
4541 lpfc_els_rcv_flogi(struct lpfc_vport
*vport
, struct lpfc_iocbq
*cmdiocb
,
4542 struct lpfc_nodelist
*ndlp
)
4544 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
4545 struct lpfc_hba
*phba
= vport
->phba
;
4546 struct lpfc_dmabuf
*pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
4547 uint32_t *lp
= (uint32_t *) pcmd
->virt
;
4548 IOCB_t
*icmd
= &cmdiocb
->iocb
;
4549 struct serv_parm
*sp
;
4556 sp
= (struct serv_parm
*) lp
;
4558 /* FLOGI received */
4560 lpfc_set_disctmo(vport
);
4562 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
4563 /* We should never receive a FLOGI in loop mode, ignore it */
4564 did
= icmd
->un
.elsreq64
.remoteID
;
4566 /* An FLOGI ELS command <elsCmd> was received from DID <did> in
4568 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
4569 "0113 An FLOGI ELS command x%x was "
4570 "received from DID x%x in Loop Mode\n",
4577 if ((lpfc_check_sparm(vport
, ndlp
, sp
, CLASS3
, 1))) {
4578 /* For a FLOGI we accept, then if our portname is greater
4579 * then the remote portname we initiate Nport login.
4582 rc
= memcmp(&vport
->fc_portname
, &sp
->portName
,
4583 sizeof(struct lpfc_name
));
4586 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
4590 lpfc_linkdown(phba
);
4591 lpfc_init_link(phba
, mbox
,
4593 phba
->cfg_link_speed
);
4594 mbox
->u
.mb
.un
.varInitLnk
.lipsr_AL_PA
= 0;
4595 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
4596 mbox
->vport
= vport
;
4597 rc
= lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
);
4598 lpfc_set_loopback_flag(phba
);
4599 if (rc
== MBX_NOT_FINISHED
) {
4600 mempool_free(mbox
, phba
->mbox_mem_pool
);
4603 } else if (rc
> 0) { /* greater than */
4604 spin_lock_irq(shost
->host_lock
);
4605 vport
->fc_flag
|= FC_PT2PT_PLOGI
;
4606 spin_unlock_irq(shost
->host_lock
);
4608 spin_lock_irq(shost
->host_lock
);
4609 vport
->fc_flag
|= FC_PT2PT
;
4610 vport
->fc_flag
&= ~(FC_FABRIC
| FC_PUBLIC_LOOP
);
4611 spin_unlock_irq(shost
->host_lock
);
4613 /* Reject this request because invalid parameters */
4614 stat
.un
.b
.lsRjtRsvd0
= 0;
4615 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
4616 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_SPARM_OPTIONS
;
4617 stat
.un
.b
.vendorUnique
= 0;
4618 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
,
4624 lpfc_els_rsp_acc(vport
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
, NULL
);
4630 * lpfc_els_rcv_rnid - Process an unsolicited rnid iocb
4631 * @vport: pointer to a host virtual N_Port data structure.
4632 * @cmdiocb: pointer to lpfc command iocb data structure.
4633 * @ndlp: pointer to a node-list data structure.
4635 * This routine processes Request Node Identification Data (RNID) IOCB
4636 * received as an ELS unsolicited event. Only when the RNID specified format
4637 * 0x0 or 0xDF (Topology Discovery Specific Node Identification Data)
4638 * present, this routine will invoke the lpfc_els_rsp_rnid_acc() routine to
4639 * Accept (ACC) the RNID ELS command. All the other RNID formats are
4640 * rejected by invoking the lpfc_els_rsp_reject() routine.
4643 * 0 - Successfully processed rnid iocb (currently always return 0)
4646 lpfc_els_rcv_rnid(struct lpfc_vport
*vport
, struct lpfc_iocbq
*cmdiocb
,
4647 struct lpfc_nodelist
*ndlp
)
4649 struct lpfc_dmabuf
*pcmd
;
4656 icmd
= &cmdiocb
->iocb
;
4657 did
= icmd
->un
.elsreq64
.remoteID
;
4658 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
4659 lp
= (uint32_t *) pcmd
->virt
;
4666 switch (rn
->Format
) {
4668 case RNID_TOPOLOGY_DISC
:
4670 lpfc_els_rsp_rnid_acc(vport
, rn
->Format
, cmdiocb
, ndlp
);
4673 /* Reject this request because format not supported */
4674 stat
.un
.b
.lsRjtRsvd0
= 0;
4675 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
4676 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CANT_GIVE_DATA
;
4677 stat
.un
.b
.vendorUnique
= 0;
4678 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
,
4685 * lpfc_els_rcv_lirr - Process an unsolicited lirr iocb
4686 * @vport: pointer to a host virtual N_Port data structure.
4687 * @cmdiocb: pointer to lpfc command iocb data structure.
4688 * @ndlp: pointer to a node-list data structure.
4690 * This routine processes a Link Incident Report Registration(LIRR) IOCB
4691 * received as an ELS unsolicited event. Currently, this function just invokes
4692 * the lpfc_els_rsp_reject() routine to reject the LIRR IOCB unconditionally.
4695 * 0 - Successfully processed lirr iocb (currently always return 0)
4698 lpfc_els_rcv_lirr(struct lpfc_vport
*vport
, struct lpfc_iocbq
*cmdiocb
,
4699 struct lpfc_nodelist
*ndlp
)
4703 /* For now, unconditionally reject this command */
4704 stat
.un
.b
.lsRjtRsvd0
= 0;
4705 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
4706 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CANT_GIVE_DATA
;
4707 stat
.un
.b
.vendorUnique
= 0;
4708 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
, NULL
);
4713 * lpfc_els_rcv_rrq - Process an unsolicited rrq iocb
4714 * @vport: pointer to a host virtual N_Port data structure.
4715 * @cmdiocb: pointer to lpfc command iocb data structure.
4716 * @ndlp: pointer to a node-list data structure.
4718 * This routine processes a Reinstate Recovery Qualifier (RRQ) IOCB
4719 * received as an ELS unsolicited event. A request to RRQ shall only
4720 * be accepted if the Originator Nx_Port N_Port_ID or the Responder
4721 * Nx_Port N_Port_ID of the target Exchange is the same as the
4722 * N_Port_ID of the Nx_Port that makes the request. If the RRQ is
4723 * not accepted, an LS_RJT with reason code "Unable to perform
4724 * command request" and reason code explanation "Invalid Originator
4725 * S_ID" shall be returned. For now, we just unconditionally accept
4726 * RRQ from the target.
4729 lpfc_els_rcv_rrq(struct lpfc_vport
*vport
, struct lpfc_iocbq
*cmdiocb
,
4730 struct lpfc_nodelist
*ndlp
)
4732 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
);
4736 * lpfc_els_rsp_rps_acc - Completion callbk func for MBX_READ_LNK_STAT mbox cmd
4737 * @phba: pointer to lpfc hba data structure.
4738 * @pmb: pointer to the driver internal queue element for mailbox command.
4740 * This routine is the completion callback function for the MBX_READ_LNK_STAT
4741 * mailbox command. This callback function is to actually send the Accept
4742 * (ACC) response to a Read Port Status (RPS) unsolicited IOCB event. It
4743 * collects the link statistics from the completion of the MBX_READ_LNK_STAT
4744 * mailbox command, constructs the RPS response with the link statistics
4745 * collected, and then invokes the lpfc_sli_issue_iocb() routine to send ACC
4746 * response to the RPS.
4748 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
4749 * will be incremented by 1 for holding the ndlp and the reference to ndlp
4750 * will be stored into the context1 field of the IOCB for the completion
4751 * callback function to the RPS Accept Response ELS IOCB command.
4755 lpfc_els_rsp_rps_acc(struct lpfc_hba
*phba
, LPFC_MBOXQ_t
*pmb
)
4761 struct lpfc_iocbq
*elsiocb
;
4762 struct lpfc_nodelist
*ndlp
;
4763 uint16_t xri
, status
;
4768 ndlp
= (struct lpfc_nodelist
*) pmb
->context2
;
4769 xri
= (uint16_t) ((unsigned long)(pmb
->context1
));
4770 pmb
->context1
= NULL
;
4771 pmb
->context2
= NULL
;
4773 if (mb
->mbxStatus
) {
4774 mempool_free(pmb
, phba
->mbox_mem_pool
);
4778 cmdsize
= sizeof(RPS_RSP
) + sizeof(uint32_t);
4779 mempool_free(pmb
, phba
->mbox_mem_pool
);
4780 elsiocb
= lpfc_prep_els_iocb(phba
->pport
, 0, cmdsize
,
4781 lpfc_max_els_tries
, ndlp
,
4782 ndlp
->nlp_DID
, ELS_CMD_ACC
);
4784 /* Decrement the ndlp reference count from previous mbox command */
4790 icmd
= &elsiocb
->iocb
;
4791 icmd
->ulpContext
= xri
;
4793 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
4794 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
4795 pcmd
+= sizeof(uint32_t); /* Skip past command */
4796 rps_rsp
= (RPS_RSP
*)pcmd
;
4798 if (phba
->fc_topology
!= TOPOLOGY_LOOP
)
4802 if (phba
->pport
->fc_flag
& FC_FABRIC
)
4806 rps_rsp
->portStatus
= cpu_to_be16(status
);
4807 rps_rsp
->linkFailureCnt
= cpu_to_be32(mb
->un
.varRdLnk
.linkFailureCnt
);
4808 rps_rsp
->lossSyncCnt
= cpu_to_be32(mb
->un
.varRdLnk
.lossSyncCnt
);
4809 rps_rsp
->lossSignalCnt
= cpu_to_be32(mb
->un
.varRdLnk
.lossSignalCnt
);
4810 rps_rsp
->primSeqErrCnt
= cpu_to_be32(mb
->un
.varRdLnk
.primSeqErrCnt
);
4811 rps_rsp
->invalidXmitWord
= cpu_to_be32(mb
->un
.varRdLnk
.invalidXmitWord
);
4812 rps_rsp
->crcCnt
= cpu_to_be32(mb
->un
.varRdLnk
.crcCnt
);
4813 /* Xmit ELS RPS ACC response tag <ulpIoTag> */
4814 lpfc_printf_vlog(ndlp
->vport
, KERN_INFO
, LOG_ELS
,
4815 "0118 Xmit ELS RPS ACC response tag x%x xri x%x, "
4816 "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
4817 elsiocb
->iotag
, elsiocb
->iocb
.ulpContext
,
4818 ndlp
->nlp_DID
, ndlp
->nlp_flag
, ndlp
->nlp_state
,
4820 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_rsp
;
4821 phba
->fc_stat
.elsXmitACC
++;
4822 if (lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0) == IOCB_ERROR
)
4823 lpfc_els_free_iocb(phba
, elsiocb
);
4828 * lpfc_els_rcv_rps - Process an unsolicited rps iocb
4829 * @vport: pointer to a host virtual N_Port data structure.
4830 * @cmdiocb: pointer to lpfc command iocb data structure.
4831 * @ndlp: pointer to a node-list data structure.
4833 * This routine processes Read Port Status (RPS) IOCB received as an
4834 * ELS unsolicited event. It first checks the remote port state. If the
4835 * remote port is not in NLP_STE_UNMAPPED_NODE state or NLP_STE_MAPPED_NODE
4836 * state, it invokes the lpfc_els_rsp_reject() routine to send the reject
4837 * response. Otherwise, it issue the MBX_READ_LNK_STAT mailbox command
4838 * for reading the HBA link statistics. It is for the callback function,
4839 * lpfc_els_rsp_rps_acc(), set to the MBX_READ_LNK_STAT mailbox command
4840 * to actually sending out RPS Accept (ACC) response.
4843 * 0 - Successfully processed rps iocb (currently always return 0)
4846 lpfc_els_rcv_rps(struct lpfc_vport
*vport
, struct lpfc_iocbq
*cmdiocb
,
4847 struct lpfc_nodelist
*ndlp
)
4849 struct lpfc_hba
*phba
= vport
->phba
;
4853 struct lpfc_dmabuf
*pcmd
;
4857 if ((ndlp
->nlp_state
!= NLP_STE_UNMAPPED_NODE
) &&
4858 (ndlp
->nlp_state
!= NLP_STE_MAPPED_NODE
))
4859 /* reject the unsolicited RPS request and done with it */
4862 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
4863 lp
= (uint32_t *) pcmd
->virt
;
4864 flag
= (be32_to_cpu(*lp
++) & 0xf);
4868 ((flag
== 1) && (be32_to_cpu(rps
->un
.portNum
) == 0)) ||
4869 ((flag
== 2) && (memcmp(&rps
->un
.portName
, &vport
->fc_portname
,
4870 sizeof(struct lpfc_name
)) == 0))) {
4872 printk("Fix me....\n");
4874 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_ATOMIC
);
4876 lpfc_read_lnk_stat(phba
, mbox
);
4878 (void *)((unsigned long) cmdiocb
->iocb
.ulpContext
);
4879 mbox
->context2
= lpfc_nlp_get(ndlp
);
4880 mbox
->vport
= vport
;
4881 mbox
->mbox_cmpl
= lpfc_els_rsp_rps_acc
;
4882 if (lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
)
4883 != MBX_NOT_FINISHED
)
4884 /* Mbox completion will send ELS Response */
4886 /* Decrement reference count used for the failed mbox
4890 mempool_free(mbox
, phba
->mbox_mem_pool
);
4895 /* issue rejection response */
4896 stat
.un
.b
.lsRjtRsvd0
= 0;
4897 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
4898 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CANT_GIVE_DATA
;
4899 stat
.un
.b
.vendorUnique
= 0;
4900 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
, NULL
);
4905 * lpfc_els_rsp_rpl_acc - Issue an accept rpl els command
4906 * @vport: pointer to a host virtual N_Port data structure.
4907 * @cmdsize: size of the ELS command.
4908 * @oldiocb: pointer to the original lpfc command iocb data structure.
4909 * @ndlp: pointer to a node-list data structure.
4911 * This routine issuees an Accept (ACC) Read Port List (RPL) ELS command.
4912 * It is to be called by the lpfc_els_rcv_rpl() routine to accept the RPL.
4914 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
4915 * will be incremented by 1 for holding the ndlp and the reference to ndlp
4916 * will be stored into the context1 field of the IOCB for the completion
4917 * callback function to the RPL Accept Response ELS command.
4920 * 0 - Successfully issued ACC RPL ELS command
4921 * 1 - Failed to issue ACC RPL ELS command
4924 lpfc_els_rsp_rpl_acc(struct lpfc_vport
*vport
, uint16_t cmdsize
,
4925 struct lpfc_iocbq
*oldiocb
, struct lpfc_nodelist
*ndlp
)
4927 struct lpfc_hba
*phba
= vport
->phba
;
4928 IOCB_t
*icmd
, *oldcmd
;
4930 struct lpfc_iocbq
*elsiocb
;
4933 elsiocb
= lpfc_prep_els_iocb(vport
, 0, cmdsize
, oldiocb
->retry
, ndlp
,
4934 ndlp
->nlp_DID
, ELS_CMD_ACC
);
4939 icmd
= &elsiocb
->iocb
;
4940 oldcmd
= &oldiocb
->iocb
;
4941 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
4943 pcmd
= (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
4944 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
4945 pcmd
+= sizeof(uint16_t);
4946 *((uint16_t *)(pcmd
)) = be16_to_cpu(cmdsize
);
4947 pcmd
+= sizeof(uint16_t);
4949 /* Setup the RPL ACC payload */
4950 rpl_rsp
.listLen
= be32_to_cpu(1);
4952 rpl_rsp
.port_num_blk
.portNum
= 0;
4953 rpl_rsp
.port_num_blk
.portID
= be32_to_cpu(vport
->fc_myDID
);
4954 memcpy(&rpl_rsp
.port_num_blk
.portName
, &vport
->fc_portname
,
4955 sizeof(struct lpfc_name
));
4956 memcpy(pcmd
, &rpl_rsp
, cmdsize
- sizeof(uint32_t));
4957 /* Xmit ELS RPL ACC response tag <ulpIoTag> */
4958 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
4959 "0120 Xmit ELS RPL ACC response tag x%x "
4960 "xri x%x, did x%x, nlp_flag x%x, nlp_state x%x, "
4962 elsiocb
->iotag
, elsiocb
->iocb
.ulpContext
,
4963 ndlp
->nlp_DID
, ndlp
->nlp_flag
, ndlp
->nlp_state
,
4965 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_rsp
;
4966 phba
->fc_stat
.elsXmitACC
++;
4967 if (lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0) ==
4969 lpfc_els_free_iocb(phba
, elsiocb
);
4976 * lpfc_els_rcv_rpl - Process an unsolicited rpl iocb
4977 * @vport: pointer to a host virtual N_Port data structure.
4978 * @cmdiocb: pointer to lpfc command iocb data structure.
4979 * @ndlp: pointer to a node-list data structure.
4981 * This routine processes Read Port List (RPL) IOCB received as an ELS
4982 * unsolicited event. It first checks the remote port state. If the remote
4983 * port is not in NLP_STE_UNMAPPED_NODE and NLP_STE_MAPPED_NODE states, it
4984 * invokes the lpfc_els_rsp_reject() routine to send reject response.
4985 * Otherwise, this routine then invokes the lpfc_els_rsp_rpl_acc() routine
4986 * to accept the RPL.
4989 * 0 - Successfully processed rpl iocb (currently always return 0)
4992 lpfc_els_rcv_rpl(struct lpfc_vport
*vport
, struct lpfc_iocbq
*cmdiocb
,
4993 struct lpfc_nodelist
*ndlp
)
4995 struct lpfc_dmabuf
*pcmd
;
5002 if ((ndlp
->nlp_state
!= NLP_STE_UNMAPPED_NODE
) &&
5003 (ndlp
->nlp_state
!= NLP_STE_MAPPED_NODE
)) {
5004 /* issue rejection response */
5005 stat
.un
.b
.lsRjtRsvd0
= 0;
5006 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
5007 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CANT_GIVE_DATA
;
5008 stat
.un
.b
.vendorUnique
= 0;
5009 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
,
5011 /* rejected the unsolicited RPL request and done with it */
5015 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
5016 lp
= (uint32_t *) pcmd
->virt
;
5017 rpl
= (RPL
*) (lp
+ 1);
5019 maxsize
= be32_to_cpu(rpl
->maxsize
);
5021 /* We support only one port */
5022 if ((rpl
->index
== 0) &&
5024 ((maxsize
* sizeof(uint32_t)) >= sizeof(RPL_RSP
)))) {
5025 cmdsize
= sizeof(uint32_t) + sizeof(RPL_RSP
);
5027 cmdsize
= sizeof(uint32_t) + maxsize
* sizeof(uint32_t);
5029 lpfc_els_rsp_rpl_acc(vport
, cmdsize
, cmdiocb
, ndlp
);
5035 * lpfc_els_rcv_farp - Process an unsolicited farp request els command
5036 * @vport: pointer to a virtual N_Port data structure.
5037 * @cmdiocb: pointer to lpfc command iocb data structure.
5038 * @ndlp: pointer to a node-list data structure.
5040 * This routine processes Fibre Channel Address Resolution Protocol
5041 * (FARP) Request IOCB received as an ELS unsolicited event. Currently,
5042 * the lpfc driver only supports matching on WWPN or WWNN for FARP. As such,
5043 * FARP_MATCH_PORT flag and FARP_MATCH_NODE flag are checked against the
5044 * Match Flag in the FARP request IOCB: if FARP_MATCH_PORT flag is set, the
5045 * remote PortName is compared against the FC PortName stored in the @vport
5046 * data structure; if FARP_MATCH_NODE flag is set, the remote NodeName is
5047 * compared against the FC NodeName stored in the @vport data structure.
5048 * If any of these matches and the FARP_REQUEST_FARPR flag is set in the
5049 * FARP request IOCB Response Flag, the lpfc_issue_els_farpr() routine is
5050 * invoked to send out FARP Response to the remote node. Before sending the
5051 * FARP Response, however, the FARP_REQUEST_PLOGI flag is check in the FARP
5052 * request IOCB Response Flag and, if it is set, the lpfc_issue_els_plogi()
5053 * routine is invoked to log into the remote port first.
5056 * 0 - Either the FARP Match Mode not supported or successfully processed
5059 lpfc_els_rcv_farp(struct lpfc_vport
*vport
, struct lpfc_iocbq
*cmdiocb
,
5060 struct lpfc_nodelist
*ndlp
)
5062 struct lpfc_dmabuf
*pcmd
;
5066 uint32_t cmd
, cnt
, did
;
5068 icmd
= &cmdiocb
->iocb
;
5069 did
= icmd
->un
.elsreq64
.remoteID
;
5070 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
5071 lp
= (uint32_t *) pcmd
->virt
;
5075 /* FARP-REQ received from DID <did> */
5076 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
5077 "0601 FARP-REQ received from DID x%x\n", did
);
5078 /* We will only support match on WWPN or WWNN */
5079 if (fp
->Mflags
& ~(FARP_MATCH_NODE
| FARP_MATCH_PORT
)) {
5084 /* If this FARP command is searching for my portname */
5085 if (fp
->Mflags
& FARP_MATCH_PORT
) {
5086 if (memcmp(&fp
->RportName
, &vport
->fc_portname
,
5087 sizeof(struct lpfc_name
)) == 0)
5091 /* If this FARP command is searching for my nodename */
5092 if (fp
->Mflags
& FARP_MATCH_NODE
) {
5093 if (memcmp(&fp
->RnodeName
, &vport
->fc_nodename
,
5094 sizeof(struct lpfc_name
)) == 0)
5099 if ((ndlp
->nlp_state
== NLP_STE_UNMAPPED_NODE
) ||
5100 (ndlp
->nlp_state
== NLP_STE_MAPPED_NODE
)) {
5101 /* Log back into the node before sending the FARP. */
5102 if (fp
->Rflags
& FARP_REQUEST_PLOGI
) {
5103 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
5104 lpfc_nlp_set_state(vport
, ndlp
,
5105 NLP_STE_PLOGI_ISSUE
);
5106 lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0);
5109 /* Send a FARP response to that node */
5110 if (fp
->Rflags
& FARP_REQUEST_FARPR
)
5111 lpfc_issue_els_farpr(vport
, did
, 0);
5118 * lpfc_els_rcv_farpr - Process an unsolicited farp response iocb
5119 * @vport: pointer to a host virtual N_Port data structure.
5120 * @cmdiocb: pointer to lpfc command iocb data structure.
5121 * @ndlp: pointer to a node-list data structure.
5123 * This routine processes Fibre Channel Address Resolution Protocol
5124 * Response (FARPR) IOCB received as an ELS unsolicited event. It simply
5125 * invokes the lpfc_els_rsp_acc() routine to the remote node to accept
5126 * the FARP response request.
5129 * 0 - Successfully processed FARPR IOCB (currently always return 0)
5132 lpfc_els_rcv_farpr(struct lpfc_vport
*vport
, struct lpfc_iocbq
*cmdiocb
,
5133 struct lpfc_nodelist
*ndlp
)
5135 struct lpfc_dmabuf
*pcmd
;
5140 icmd
= &cmdiocb
->iocb
;
5141 did
= icmd
->un
.elsreq64
.remoteID
;
5142 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
5143 lp
= (uint32_t *) pcmd
->virt
;
5146 /* FARP-RSP received from DID <did> */
5147 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
5148 "0600 FARP-RSP received from DID x%x\n", did
);
5149 /* ACCEPT the Farp resp request */
5150 lpfc_els_rsp_acc(vport
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
);
5156 * lpfc_els_rcv_fan - Process an unsolicited fan iocb command
5157 * @vport: pointer to a host virtual N_Port data structure.
5158 * @cmdiocb: pointer to lpfc command iocb data structure.
5159 * @fan_ndlp: pointer to a node-list data structure.
5161 * This routine processes a Fabric Address Notification (FAN) IOCB
5162 * command received as an ELS unsolicited event. The FAN ELS command will
5163 * only be processed on a physical port (i.e., the @vport represents the
5164 * physical port). The fabric NodeName and PortName from the FAN IOCB are
5165 * compared against those in the phba data structure. If any of those is
5166 * different, the lpfc_initial_flogi() routine is invoked to initialize
5167 * Fabric Login (FLOGI) to the fabric to start the discover over. Otherwise,
5168 * if both of those are identical, the lpfc_issue_fabric_reglogin() routine
5169 * is invoked to register login to the fabric.
5172 * 0 - Successfully processed fan iocb (currently always return 0).
5175 lpfc_els_rcv_fan(struct lpfc_vport
*vport
, struct lpfc_iocbq
*cmdiocb
,
5176 struct lpfc_nodelist
*fan_ndlp
)
5178 struct lpfc_hba
*phba
= vport
->phba
;
5182 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
, "0265 FAN received\n");
5183 lp
= (uint32_t *)((struct lpfc_dmabuf
*)cmdiocb
->context2
)->virt
;
5185 /* FAN received; Fan does not have a reply sequence */
5186 if ((vport
== phba
->pport
) &&
5187 (vport
->port_state
== LPFC_LOCAL_CFG_LINK
)) {
5188 if ((memcmp(&phba
->fc_fabparam
.nodeName
, &fp
->FnodeName
,
5189 sizeof(struct lpfc_name
))) ||
5190 (memcmp(&phba
->fc_fabparam
.portName
, &fp
->FportName
,
5191 sizeof(struct lpfc_name
)))) {
5192 /* This port has switched fabrics. FLOGI is required */
5193 lpfc_initial_flogi(vport
);
5195 /* FAN verified - skip FLOGI */
5196 vport
->fc_myDID
= vport
->fc_prevDID
;
5197 if (phba
->sli_rev
< LPFC_SLI_REV4
)
5198 lpfc_issue_fabric_reglogin(vport
);
5200 lpfc_issue_reg_vfi(vport
);
5207 * lpfc_els_timeout - Handler funciton to the els timer
5208 * @ptr: holder for the timer function associated data.
5210 * This routine is invoked by the ELS timer after timeout. It posts the ELS
5211 * timer timeout event by setting the WORKER_ELS_TMO bit to the work port
5212 * event bitmap and then invokes the lpfc_worker_wake_up() routine to wake
5213 * up the worker thread. It is for the worker thread to invoke the routine
5214 * lpfc_els_timeout_handler() to work on the posted event WORKER_ELS_TMO.
5217 lpfc_els_timeout(unsigned long ptr
)
5219 struct lpfc_vport
*vport
= (struct lpfc_vport
*) ptr
;
5220 struct lpfc_hba
*phba
= vport
->phba
;
5221 uint32_t tmo_posted
;
5222 unsigned long iflag
;
5224 spin_lock_irqsave(&vport
->work_port_lock
, iflag
);
5225 tmo_posted
= vport
->work_port_events
& WORKER_ELS_TMO
;
5227 vport
->work_port_events
|= WORKER_ELS_TMO
;
5228 spin_unlock_irqrestore(&vport
->work_port_lock
, iflag
);
5231 lpfc_worker_wake_up(phba
);
5237 * lpfc_els_timeout_handler - Process an els timeout event
5238 * @vport: pointer to a virtual N_Port data structure.
5240 * This routine is the actual handler function that processes an ELS timeout
5241 * event. It walks the ELS ring to get and abort all the IOCBs (except the
5242 * ABORT/CLOSE/FARP/FARPR/FDISC), which are associated with the @vport by
5243 * invoking the lpfc_sli_issue_abort_iotag() routine.
5246 lpfc_els_timeout_handler(struct lpfc_vport
*vport
)
5248 struct lpfc_hba
*phba
= vport
->phba
;
5249 struct lpfc_sli_ring
*pring
;
5250 struct lpfc_iocbq
*tmp_iocb
, *piocb
;
5252 struct lpfc_dmabuf
*pcmd
;
5253 uint32_t els_command
= 0;
5255 uint32_t remote_ID
= 0xffffffff;
5256 LIST_HEAD(txcmplq_completions
);
5257 LIST_HEAD(abort_list
);
5260 timeout
= (uint32_t)(phba
->fc_ratov
<< 1);
5262 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
5264 spin_lock_irq(&phba
->hbalock
);
5265 list_splice_init(&pring
->txcmplq
, &txcmplq_completions
);
5266 spin_unlock_irq(&phba
->hbalock
);
5268 list_for_each_entry_safe(piocb
, tmp_iocb
, &txcmplq_completions
, list
) {
5271 if ((piocb
->iocb_flag
& LPFC_IO_LIBDFC
) != 0 ||
5272 piocb
->iocb
.ulpCommand
== CMD_ABORT_XRI_CN
||
5273 piocb
->iocb
.ulpCommand
== CMD_CLOSE_XRI_CN
)
5276 if (piocb
->vport
!= vport
)
5279 pcmd
= (struct lpfc_dmabuf
*) piocb
->context2
;
5281 els_command
= *(uint32_t *) (pcmd
->virt
);
5283 if (els_command
== ELS_CMD_FARP
||
5284 els_command
== ELS_CMD_FARPR
||
5285 els_command
== ELS_CMD_FDISC
)
5288 if (piocb
->drvrTimeout
> 0) {
5289 if (piocb
->drvrTimeout
>= timeout
)
5290 piocb
->drvrTimeout
-= timeout
;
5292 piocb
->drvrTimeout
= 0;
5296 remote_ID
= 0xffffffff;
5297 if (cmd
->ulpCommand
!= CMD_GEN_REQUEST64_CR
)
5298 remote_ID
= cmd
->un
.elsreq64
.remoteID
;
5300 struct lpfc_nodelist
*ndlp
;
5301 ndlp
= __lpfc_findnode_rpi(vport
, cmd
->ulpContext
);
5302 if (ndlp
&& NLP_CHK_NODE_ACT(ndlp
))
5303 remote_ID
= ndlp
->nlp_DID
;
5305 list_add_tail(&piocb
->dlist
, &abort_list
);
5307 spin_lock_irq(&phba
->hbalock
);
5308 list_splice(&txcmplq_completions
, &pring
->txcmplq
);
5309 spin_unlock_irq(&phba
->hbalock
);
5311 list_for_each_entry_safe(piocb
, tmp_iocb
, &abort_list
, dlist
) {
5312 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
5313 "0127 ELS timeout Data: x%x x%x x%x "
5314 "x%x\n", els_command
,
5315 remote_ID
, cmd
->ulpCommand
, cmd
->ulpIoTag
);
5316 spin_lock_irq(&phba
->hbalock
);
5317 list_del_init(&piocb
->dlist
);
5318 lpfc_sli_issue_abort_iotag(phba
, pring
, piocb
);
5319 spin_unlock_irq(&phba
->hbalock
);
5322 if (phba
->sli
.ring
[LPFC_ELS_RING
].txcmplq_cnt
)
5323 mod_timer(&vport
->els_tmofunc
, jiffies
+ HZ
* timeout
);
5327 * lpfc_els_flush_cmd - Clean up the outstanding els commands to a vport
5328 * @vport: pointer to a host virtual N_Port data structure.
5330 * This routine is used to clean up all the outstanding ELS commands on a
5331 * @vport. It first aborts the @vport by invoking lpfc_fabric_abort_vport()
5332 * routine. After that, it walks the ELS transmit queue to remove all the
5333 * IOCBs with the @vport other than the QUE_RING and ABORT/CLOSE IOCBs. For
5334 * the IOCBs with a non-NULL completion callback function, the callback
5335 * function will be invoked with the status set to IOSTAT_LOCAL_REJECT and
5336 * un.ulpWord[4] set to IOERR_SLI_ABORTED. For IOCBs with a NULL completion
5337 * callback function, the IOCB will simply be released. Finally, it walks
5338 * the ELS transmit completion queue to issue an abort IOCB to any transmit
5339 * completion queue IOCB that is associated with the @vport and is not
5340 * an IOCB from libdfc (i.e., the management plane IOCBs that are not
5341 * part of the discovery state machine) out to HBA by invoking the
5342 * lpfc_sli_issue_abort_iotag() routine. Note that this function issues the
5343 * abort IOCB to any transmit completion queueed IOCB, it does not guarantee
5344 * the IOCBs are aborted when this function returns.
5347 lpfc_els_flush_cmd(struct lpfc_vport
*vport
)
5349 LIST_HEAD(completions
);
5350 struct lpfc_hba
*phba
= vport
->phba
;
5351 struct lpfc_sli_ring
*pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
5352 struct lpfc_iocbq
*tmp_iocb
, *piocb
;
5355 lpfc_fabric_abort_vport(vport
);
5357 spin_lock_irq(&phba
->hbalock
);
5358 list_for_each_entry_safe(piocb
, tmp_iocb
, &pring
->txq
, list
) {
5361 if (piocb
->iocb_flag
& LPFC_IO_LIBDFC
) {
5365 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
5366 if (cmd
->ulpCommand
== CMD_QUE_RING_BUF_CN
||
5367 cmd
->ulpCommand
== CMD_QUE_RING_BUF64_CN
||
5368 cmd
->ulpCommand
== CMD_CLOSE_XRI_CN
||
5369 cmd
->ulpCommand
== CMD_ABORT_XRI_CN
)
5372 if (piocb
->vport
!= vport
)
5375 list_move_tail(&piocb
->list
, &completions
);
5379 list_for_each_entry_safe(piocb
, tmp_iocb
, &pring
->txcmplq
, list
) {
5380 if (piocb
->iocb_flag
& LPFC_IO_LIBDFC
) {
5384 if (piocb
->vport
!= vport
)
5387 lpfc_sli_issue_abort_iotag(phba
, pring
, piocb
);
5389 spin_unlock_irq(&phba
->hbalock
);
5391 /* Cancell all the IOCBs from the completions list */
5392 lpfc_sli_cancel_iocbs(phba
, &completions
, IOSTAT_LOCAL_REJECT
,
5399 * lpfc_els_flush_all_cmd - Clean up all the outstanding els commands to a HBA
5400 * @phba: pointer to lpfc hba data structure.
5402 * This routine is used to clean up all the outstanding ELS commands on a
5403 * @phba. It first aborts the @phba by invoking the lpfc_fabric_abort_hba()
5404 * routine. After that, it walks the ELS transmit queue to remove all the
5405 * IOCBs to the @phba other than the QUE_RING and ABORT/CLOSE IOCBs. For
5406 * the IOCBs with the completion callback function associated, the callback
5407 * function will be invoked with the status set to IOSTAT_LOCAL_REJECT and
5408 * un.ulpWord[4] set to IOERR_SLI_ABORTED. For IOCBs without the completion
5409 * callback function associated, the IOCB will simply be released. Finally,
5410 * it walks the ELS transmit completion queue to issue an abort IOCB to any
5411 * transmit completion queue IOCB that is not an IOCB from libdfc (i.e., the
5412 * management plane IOCBs that are not part of the discovery state machine)
5413 * out to HBA by invoking the lpfc_sli_issue_abort_iotag() routine.
5416 lpfc_els_flush_all_cmd(struct lpfc_hba
*phba
)
5418 LIST_HEAD(completions
);
5419 struct lpfc_sli_ring
*pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
5420 struct lpfc_iocbq
*tmp_iocb
, *piocb
;
5423 lpfc_fabric_abort_hba(phba
);
5424 spin_lock_irq(&phba
->hbalock
);
5425 list_for_each_entry_safe(piocb
, tmp_iocb
, &pring
->txq
, list
) {
5427 if (piocb
->iocb_flag
& LPFC_IO_LIBDFC
)
5429 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
5430 if (cmd
->ulpCommand
== CMD_QUE_RING_BUF_CN
||
5431 cmd
->ulpCommand
== CMD_QUE_RING_BUF64_CN
||
5432 cmd
->ulpCommand
== CMD_CLOSE_XRI_CN
||
5433 cmd
->ulpCommand
== CMD_ABORT_XRI_CN
)
5435 list_move_tail(&piocb
->list
, &completions
);
5438 list_for_each_entry_safe(piocb
, tmp_iocb
, &pring
->txcmplq
, list
) {
5439 if (piocb
->iocb_flag
& LPFC_IO_LIBDFC
)
5441 lpfc_sli_issue_abort_iotag(phba
, pring
, piocb
);
5443 spin_unlock_irq(&phba
->hbalock
);
5445 /* Cancel all the IOCBs from the completions list */
5446 lpfc_sli_cancel_iocbs(phba
, &completions
, IOSTAT_LOCAL_REJECT
,
5453 * lpfc_send_els_failure_event - Posts an ELS command failure event
5454 * @phba: Pointer to hba context object.
5455 * @cmdiocbp: Pointer to command iocb which reported error.
5456 * @rspiocbp: Pointer to response iocb which reported error.
5458 * This function sends an event when there is an ELS command
5462 lpfc_send_els_failure_event(struct lpfc_hba
*phba
,
5463 struct lpfc_iocbq
*cmdiocbp
,
5464 struct lpfc_iocbq
*rspiocbp
)
5466 struct lpfc_vport
*vport
= cmdiocbp
->vport
;
5467 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
5468 struct lpfc_lsrjt_event lsrjt_event
;
5469 struct lpfc_fabric_event_header fabric_event
;
5471 struct lpfc_nodelist
*ndlp
;
5474 ndlp
= cmdiocbp
->context1
;
5475 if (!ndlp
|| !NLP_CHK_NODE_ACT(ndlp
))
5478 if (rspiocbp
->iocb
.ulpStatus
== IOSTAT_LS_RJT
) {
5479 lsrjt_event
.header
.event_type
= FC_REG_ELS_EVENT
;
5480 lsrjt_event
.header
.subcategory
= LPFC_EVENT_LSRJT_RCV
;
5481 memcpy(lsrjt_event
.header
.wwpn
, &ndlp
->nlp_portname
,
5482 sizeof(struct lpfc_name
));
5483 memcpy(lsrjt_event
.header
.wwnn
, &ndlp
->nlp_nodename
,
5484 sizeof(struct lpfc_name
));
5485 pcmd
= (uint32_t *) (((struct lpfc_dmabuf
*)
5486 cmdiocbp
->context2
)->virt
);
5487 lsrjt_event
.command
= (pcmd
!= NULL
) ? *pcmd
: 0;
5488 stat
.un
.lsRjtError
= be32_to_cpu(rspiocbp
->iocb
.un
.ulpWord
[4]);
5489 lsrjt_event
.reason_code
= stat
.un
.b
.lsRjtRsnCode
;
5490 lsrjt_event
.explanation
= stat
.un
.b
.lsRjtRsnCodeExp
;
5491 fc_host_post_vendor_event(shost
,
5492 fc_get_event_number(),
5493 sizeof(lsrjt_event
),
5494 (char *)&lsrjt_event
,
5498 if ((rspiocbp
->iocb
.ulpStatus
== IOSTAT_NPORT_BSY
) ||
5499 (rspiocbp
->iocb
.ulpStatus
== IOSTAT_FABRIC_BSY
)) {
5500 fabric_event
.event_type
= FC_REG_FABRIC_EVENT
;
5501 if (rspiocbp
->iocb
.ulpStatus
== IOSTAT_NPORT_BSY
)
5502 fabric_event
.subcategory
= LPFC_EVENT_PORT_BUSY
;
5504 fabric_event
.subcategory
= LPFC_EVENT_FABRIC_BUSY
;
5505 memcpy(fabric_event
.wwpn
, &ndlp
->nlp_portname
,
5506 sizeof(struct lpfc_name
));
5507 memcpy(fabric_event
.wwnn
, &ndlp
->nlp_nodename
,
5508 sizeof(struct lpfc_name
));
5509 fc_host_post_vendor_event(shost
,
5510 fc_get_event_number(),
5511 sizeof(fabric_event
),
5512 (char *)&fabric_event
,
5520 * lpfc_send_els_event - Posts unsolicited els event
5521 * @vport: Pointer to vport object.
5522 * @ndlp: Pointer FC node object.
5523 * @cmd: ELS command code.
5525 * This function posts an event when there is an incoming
5526 * unsolicited ELS command.
5529 lpfc_send_els_event(struct lpfc_vport
*vport
,
5530 struct lpfc_nodelist
*ndlp
,
5533 struct lpfc_els_event_header
*els_data
= NULL
;
5534 struct lpfc_logo_event
*logo_data
= NULL
;
5535 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
5537 if (*payload
== ELS_CMD_LOGO
) {
5538 logo_data
= kmalloc(sizeof(struct lpfc_logo_event
), GFP_KERNEL
);
5540 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
5541 "0148 Failed to allocate memory "
5542 "for LOGO event\n");
5545 els_data
= &logo_data
->header
;
5547 els_data
= kmalloc(sizeof(struct lpfc_els_event_header
),
5550 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
5551 "0149 Failed to allocate memory "
5556 els_data
->event_type
= FC_REG_ELS_EVENT
;
5559 els_data
->subcategory
= LPFC_EVENT_PLOGI_RCV
;
5562 els_data
->subcategory
= LPFC_EVENT_PRLO_RCV
;
5565 els_data
->subcategory
= LPFC_EVENT_ADISC_RCV
;
5568 els_data
->subcategory
= LPFC_EVENT_LOGO_RCV
;
5569 /* Copy the WWPN in the LOGO payload */
5570 memcpy(logo_data
->logo_wwpn
, &payload
[2],
5571 sizeof(struct lpfc_name
));
5577 memcpy(els_data
->wwpn
, &ndlp
->nlp_portname
, sizeof(struct lpfc_name
));
5578 memcpy(els_data
->wwnn
, &ndlp
->nlp_nodename
, sizeof(struct lpfc_name
));
5579 if (*payload
== ELS_CMD_LOGO
) {
5580 fc_host_post_vendor_event(shost
,
5581 fc_get_event_number(),
5582 sizeof(struct lpfc_logo_event
),
5587 fc_host_post_vendor_event(shost
,
5588 fc_get_event_number(),
5589 sizeof(struct lpfc_els_event_header
),
5600 * lpfc_els_unsol_buffer - Process an unsolicited event data buffer
5601 * @phba: pointer to lpfc hba data structure.
5602 * @pring: pointer to a SLI ring.
5603 * @vport: pointer to a host virtual N_Port data structure.
5604 * @elsiocb: pointer to lpfc els command iocb data structure.
5606 * This routine is used for processing the IOCB associated with a unsolicited
5607 * event. It first determines whether there is an existing ndlp that matches
5608 * the DID from the unsolicited IOCB. If not, it will create a new one with
5609 * the DID from the unsolicited IOCB. The ELS command from the unsolicited
5610 * IOCB is then used to invoke the proper routine and to set up proper state
5611 * of the discovery state machine.
5614 lpfc_els_unsol_buffer(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
5615 struct lpfc_vport
*vport
, struct lpfc_iocbq
*elsiocb
)
5617 struct Scsi_Host
*shost
;
5618 struct lpfc_nodelist
*ndlp
;
5621 uint32_t cmd
, did
, newnode
, rjt_err
= 0;
5622 IOCB_t
*icmd
= &elsiocb
->iocb
;
5624 if (!vport
|| !(elsiocb
->context2
))
5628 payload
= ((struct lpfc_dmabuf
*)elsiocb
->context2
)->virt
;
5630 if ((phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
) == 0)
5631 lpfc_post_buffer(phba
, pring
, 1);
5633 did
= icmd
->un
.rcvels
.remoteID
;
5634 if (icmd
->ulpStatus
) {
5635 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5636 "RCV Unsol ELS: status:x%x/x%x did:x%x",
5637 icmd
->ulpStatus
, icmd
->un
.ulpWord
[4], did
);
5641 /* Check to see if link went down during discovery */
5642 if (lpfc_els_chk_latt(vport
))
5645 /* Ignore traffic received during vport shutdown. */
5646 if (vport
->load_flag
& FC_UNLOADING
)
5649 ndlp
= lpfc_findnode_did(vport
, did
);
5651 /* Cannot find existing Fabric ndlp, so allocate a new one */
5652 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
5656 lpfc_nlp_init(vport
, ndlp
, did
);
5657 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
5659 if ((did
& Fabric_DID_MASK
) == Fabric_DID_MASK
)
5660 ndlp
->nlp_type
|= NLP_FABRIC
;
5661 } else if (!NLP_CHK_NODE_ACT(ndlp
)) {
5662 ndlp
= lpfc_enable_node(vport
, ndlp
,
5663 NLP_STE_UNUSED_NODE
);
5666 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
5668 if ((did
& Fabric_DID_MASK
) == Fabric_DID_MASK
)
5669 ndlp
->nlp_type
|= NLP_FABRIC
;
5670 } else if (ndlp
->nlp_state
== NLP_STE_UNUSED_NODE
) {
5671 /* This is similar to the new node path */
5672 ndlp
= lpfc_nlp_get(ndlp
);
5675 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_NPR_NODE
);
5679 phba
->fc_stat
.elsRcvFrame
++;
5681 elsiocb
->context1
= lpfc_nlp_get(ndlp
);
5682 elsiocb
->vport
= vport
;
5684 if ((cmd
& ELS_CMD_MASK
) == ELS_CMD_RSCN
) {
5685 cmd
&= ELS_CMD_MASK
;
5687 /* ELS command <elsCmd> received from NPORT <did> */
5688 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
5689 "0112 ELS command x%x received from NPORT x%x "
5690 "Data: x%x\n", cmd
, did
, vport
->port_state
);
5693 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5694 "RCV PLOGI: did:x%x/ste:x%x flg:x%x",
5695 did
, vport
->port_state
, ndlp
->nlp_flag
);
5697 phba
->fc_stat
.elsRcvPLOGI
++;
5698 ndlp
= lpfc_plogi_confirm_nport(phba
, payload
, ndlp
);
5700 lpfc_send_els_event(vport
, ndlp
, payload
);
5701 if (vport
->port_state
< LPFC_DISC_AUTH
) {
5702 if (!(phba
->pport
->fc_flag
& FC_PT2PT
) ||
5703 (phba
->pport
->fc_flag
& FC_PT2PT_PLOGI
)) {
5704 rjt_err
= LSRJT_UNABLE_TPC
;
5707 /* We get here, and drop thru, if we are PT2PT with
5708 * another NPort and the other side has initiated
5709 * the PLOGI before responding to our FLOGI.
5713 shost
= lpfc_shost_from_vport(vport
);
5714 spin_lock_irq(shost
->host_lock
);
5715 ndlp
->nlp_flag
&= ~NLP_TARGET_REMOVE
;
5716 spin_unlock_irq(shost
->host_lock
);
5718 lpfc_disc_state_machine(vport
, ndlp
, elsiocb
,
5723 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5724 "RCV FLOGI: did:x%x/ste:x%x flg:x%x",
5725 did
, vport
->port_state
, ndlp
->nlp_flag
);
5727 phba
->fc_stat
.elsRcvFLOGI
++;
5728 lpfc_els_rcv_flogi(vport
, elsiocb
, ndlp
);
5733 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5734 "RCV LOGO: did:x%x/ste:x%x flg:x%x",
5735 did
, vport
->port_state
, ndlp
->nlp_flag
);
5737 phba
->fc_stat
.elsRcvLOGO
++;
5738 lpfc_send_els_event(vport
, ndlp
, payload
);
5739 if (vport
->port_state
< LPFC_DISC_AUTH
) {
5740 rjt_err
= LSRJT_UNABLE_TPC
;
5743 lpfc_disc_state_machine(vport
, ndlp
, elsiocb
, NLP_EVT_RCV_LOGO
);
5746 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5747 "RCV PRLO: did:x%x/ste:x%x flg:x%x",
5748 did
, vport
->port_state
, ndlp
->nlp_flag
);
5750 phba
->fc_stat
.elsRcvPRLO
++;
5751 lpfc_send_els_event(vport
, ndlp
, payload
);
5752 if (vport
->port_state
< LPFC_DISC_AUTH
) {
5753 rjt_err
= LSRJT_UNABLE_TPC
;
5756 lpfc_disc_state_machine(vport
, ndlp
, elsiocb
, NLP_EVT_RCV_PRLO
);
5759 phba
->fc_stat
.elsRcvRSCN
++;
5760 lpfc_els_rcv_rscn(vport
, elsiocb
, ndlp
);
5765 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5766 "RCV ADISC: did:x%x/ste:x%x flg:x%x",
5767 did
, vport
->port_state
, ndlp
->nlp_flag
);
5769 lpfc_send_els_event(vport
, ndlp
, payload
);
5770 phba
->fc_stat
.elsRcvADISC
++;
5771 if (vport
->port_state
< LPFC_DISC_AUTH
) {
5772 rjt_err
= LSRJT_UNABLE_TPC
;
5775 lpfc_disc_state_machine(vport
, ndlp
, elsiocb
,
5779 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5780 "RCV PDISC: did:x%x/ste:x%x flg:x%x",
5781 did
, vport
->port_state
, ndlp
->nlp_flag
);
5783 phba
->fc_stat
.elsRcvPDISC
++;
5784 if (vport
->port_state
< LPFC_DISC_AUTH
) {
5785 rjt_err
= LSRJT_UNABLE_TPC
;
5788 lpfc_disc_state_machine(vport
, ndlp
, elsiocb
,
5792 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5793 "RCV FARPR: did:x%x/ste:x%x flg:x%x",
5794 did
, vport
->port_state
, ndlp
->nlp_flag
);
5796 phba
->fc_stat
.elsRcvFARPR
++;
5797 lpfc_els_rcv_farpr(vport
, elsiocb
, ndlp
);
5800 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5801 "RCV FARP: did:x%x/ste:x%x flg:x%x",
5802 did
, vport
->port_state
, ndlp
->nlp_flag
);
5804 phba
->fc_stat
.elsRcvFARP
++;
5805 lpfc_els_rcv_farp(vport
, elsiocb
, ndlp
);
5808 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5809 "RCV FAN: did:x%x/ste:x%x flg:x%x",
5810 did
, vport
->port_state
, ndlp
->nlp_flag
);
5812 phba
->fc_stat
.elsRcvFAN
++;
5813 lpfc_els_rcv_fan(vport
, elsiocb
, ndlp
);
5816 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5817 "RCV PRLI: did:x%x/ste:x%x flg:x%x",
5818 did
, vport
->port_state
, ndlp
->nlp_flag
);
5820 phba
->fc_stat
.elsRcvPRLI
++;
5821 if (vport
->port_state
< LPFC_DISC_AUTH
) {
5822 rjt_err
= LSRJT_UNABLE_TPC
;
5825 lpfc_disc_state_machine(vport
, ndlp
, elsiocb
, NLP_EVT_RCV_PRLI
);
5828 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5829 "RCV LIRR: did:x%x/ste:x%x flg:x%x",
5830 did
, vport
->port_state
, ndlp
->nlp_flag
);
5832 phba
->fc_stat
.elsRcvLIRR
++;
5833 lpfc_els_rcv_lirr(vport
, elsiocb
, ndlp
);
5838 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5839 "RCV RPS: did:x%x/ste:x%x flg:x%x",
5840 did
, vport
->port_state
, ndlp
->nlp_flag
);
5842 phba
->fc_stat
.elsRcvRPS
++;
5843 lpfc_els_rcv_rps(vport
, elsiocb
, ndlp
);
5848 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5849 "RCV RPL: did:x%x/ste:x%x flg:x%x",
5850 did
, vport
->port_state
, ndlp
->nlp_flag
);
5852 phba
->fc_stat
.elsRcvRPL
++;
5853 lpfc_els_rcv_rpl(vport
, elsiocb
, ndlp
);
5858 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5859 "RCV RNID: did:x%x/ste:x%x flg:x%x",
5860 did
, vport
->port_state
, ndlp
->nlp_flag
);
5862 phba
->fc_stat
.elsRcvRNID
++;
5863 lpfc_els_rcv_rnid(vport
, elsiocb
, ndlp
);
5868 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5869 "RCV RRQ: did:x%x/ste:x%x flg:x%x",
5870 did
, vport
->port_state
, ndlp
->nlp_flag
);
5872 phba
->fc_stat
.elsRcvRRQ
++;
5873 lpfc_els_rcv_rrq(vport
, elsiocb
, ndlp
);
5878 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_UNSOL
,
5879 "RCV ELS cmd: cmd:x%x did:x%x/ste:x%x",
5880 cmd
, did
, vport
->port_state
);
5882 /* Unsupported ELS command, reject */
5883 rjt_err
= LSRJT_INVALID_CMD
;
5885 /* Unknown ELS command <elsCmd> received from NPORT <did> */
5886 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
5887 "0115 Unknown ELS command x%x "
5888 "received from NPORT x%x\n", cmd
, did
);
5894 /* check if need to LS_RJT received ELS cmd */
5896 memset(&stat
, 0, sizeof(stat
));
5897 stat
.un
.b
.lsRjtRsnCode
= rjt_err
;
5898 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
5899 lpfc_els_rsp_reject(vport
, stat
.un
.lsRjtError
, elsiocb
, ndlp
,
5903 lpfc_nlp_put(elsiocb
->context1
);
5904 elsiocb
->context1
= NULL
;
5908 if (vport
&& !(vport
->load_flag
& FC_UNLOADING
))
5909 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
5910 "0111 Dropping received ELS cmd "
5911 "Data: x%x x%x x%x\n",
5912 icmd
->ulpStatus
, icmd
->un
.ulpWord
[4], icmd
->ulpTimeout
);
5913 phba
->fc_stat
.elsRcvDrop
++;
5917 * lpfc_find_vport_by_vpid - Find a vport on a HBA through vport identifier
5918 * @phba: pointer to lpfc hba data structure.
5919 * @vpi: host virtual N_Port identifier.
5921 * This routine finds a vport on a HBA (referred by @phba) through a
5922 * @vpi. The function walks the HBA's vport list and returns the address
5923 * of the vport with the matching @vpi.
5926 * NULL - No vport with the matching @vpi found
5927 * Otherwise - Address to the vport with the matching @vpi.
5930 lpfc_find_vport_by_vpid(struct lpfc_hba
*phba
, uint16_t vpi
)
5932 struct lpfc_vport
*vport
;
5933 unsigned long flags
;
5935 spin_lock_irqsave(&phba
->hbalock
, flags
);
5936 list_for_each_entry(vport
, &phba
->port_list
, listentry
) {
5937 if (vport
->vpi
== vpi
) {
5938 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
5942 spin_unlock_irqrestore(&phba
->hbalock
, flags
);
5947 * lpfc_els_unsol_event - Process an unsolicited event from an els sli ring
5948 * @phba: pointer to lpfc hba data structure.
5949 * @pring: pointer to a SLI ring.
5950 * @elsiocb: pointer to lpfc els iocb data structure.
5952 * This routine is used to process an unsolicited event received from a SLI
5953 * (Service Level Interface) ring. The actual processing of the data buffer
5954 * associated with the unsolicited event is done by invoking the routine
5955 * lpfc_els_unsol_buffer() after properly set up the iocb buffer from the
5956 * SLI ring on which the unsolicited event was received.
5959 lpfc_els_unsol_event(struct lpfc_hba
*phba
, struct lpfc_sli_ring
*pring
,
5960 struct lpfc_iocbq
*elsiocb
)
5962 struct lpfc_vport
*vport
= phba
->pport
;
5963 IOCB_t
*icmd
= &elsiocb
->iocb
;
5965 struct lpfc_dmabuf
*bdeBuf1
= elsiocb
->context2
;
5966 struct lpfc_dmabuf
*bdeBuf2
= elsiocb
->context3
;
5968 elsiocb
->context1
= NULL
;
5969 elsiocb
->context2
= NULL
;
5970 elsiocb
->context3
= NULL
;
5972 if (icmd
->ulpStatus
== IOSTAT_NEED_BUFFER
) {
5973 lpfc_sli_hbqbuf_add_hbqs(phba
, LPFC_ELS_HBQ
);
5974 } else if (icmd
->ulpStatus
== IOSTAT_LOCAL_REJECT
&&
5975 (icmd
->un
.ulpWord
[4] & 0xff) == IOERR_RCV_BUFFER_WAITING
) {
5976 phba
->fc_stat
.NoRcvBuf
++;
5977 /* Not enough posted buffers; Try posting more buffers */
5978 if (!(phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
))
5979 lpfc_post_buffer(phba
, pring
, 0);
5983 if ((phba
->sli3_options
& LPFC_SLI3_NPIV_ENABLED
) &&
5984 (icmd
->ulpCommand
== CMD_IOCB_RCV_ELS64_CX
||
5985 icmd
->ulpCommand
== CMD_IOCB_RCV_SEQ64_CX
)) {
5986 if (icmd
->unsli3
.rcvsli3
.vpi
== 0xffff)
5987 vport
= phba
->pport
;
5989 vport
= lpfc_find_vport_by_vpid(phba
,
5990 icmd
->unsli3
.rcvsli3
.vpi
- phba
->vpi_base
);
5992 /* If there are no BDEs associated
5993 * with this IOCB, there is nothing to do.
5995 if (icmd
->ulpBdeCount
== 0)
5998 /* type of ELS cmd is first 32bit word
6001 if (phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
) {
6002 elsiocb
->context2
= bdeBuf1
;
6004 paddr
= getPaddr(icmd
->un
.cont64
[0].addrHigh
,
6005 icmd
->un
.cont64
[0].addrLow
);
6006 elsiocb
->context2
= lpfc_sli_ringpostbuf_get(phba
, pring
,
6010 lpfc_els_unsol_buffer(phba
, pring
, vport
, elsiocb
);
6012 * The different unsolicited event handlers would tell us
6013 * if they are done with "mp" by setting context2 to NULL.
6015 if (elsiocb
->context2
) {
6016 lpfc_in_buf_free(phba
, (struct lpfc_dmabuf
*)elsiocb
->context2
);
6017 elsiocb
->context2
= NULL
;
6020 /* RCV_ELS64_CX provide for 2 BDEs - process 2nd if included */
6021 if ((phba
->sli3_options
& LPFC_SLI3_HBQ_ENABLED
) &&
6022 icmd
->ulpBdeCount
== 2) {
6023 elsiocb
->context2
= bdeBuf2
;
6024 lpfc_els_unsol_buffer(phba
, pring
, vport
, elsiocb
);
6025 /* free mp if we are done with it */
6026 if (elsiocb
->context2
) {
6027 lpfc_in_buf_free(phba
, elsiocb
->context2
);
6028 elsiocb
->context2
= NULL
;
6034 * lpfc_do_scr_ns_plogi - Issue a plogi to the name server for scr
6035 * @phba: pointer to lpfc hba data structure.
6036 * @vport: pointer to a virtual N_Port data structure.
6038 * This routine issues a Port Login (PLOGI) to the Name Server with
6039 * State Change Request (SCR) for a @vport. This routine will create an
6040 * ndlp for the Name Server associated to the @vport if such node does
6041 * not already exist. The PLOGI to Name Server is issued by invoking the
6042 * lpfc_issue_els_plogi() routine. If Fabric-Device Management Interface
6043 * (FDMI) is configured to the @vport, a FDMI node will be created and
6044 * the PLOGI to FDMI is issued by invoking lpfc_issue_els_plogi() routine.
6047 lpfc_do_scr_ns_plogi(struct lpfc_hba
*phba
, struct lpfc_vport
*vport
)
6049 struct lpfc_nodelist
*ndlp
, *ndlp_fdmi
;
6051 ndlp
= lpfc_findnode_did(vport
, NameServer_DID
);
6053 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
6055 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
6056 lpfc_disc_start(vport
);
6059 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
6060 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
6061 "0251 NameServer login: no memory\n");
6064 lpfc_nlp_init(vport
, ndlp
, NameServer_DID
);
6065 } else if (!NLP_CHK_NODE_ACT(ndlp
)) {
6066 ndlp
= lpfc_enable_node(vport
, ndlp
, NLP_STE_UNUSED_NODE
);
6068 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
6069 lpfc_disc_start(vport
);
6072 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
6073 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
6074 "0348 NameServer login: node freed\n");
6078 ndlp
->nlp_type
|= NLP_FABRIC
;
6080 lpfc_nlp_set_state(vport
, ndlp
, NLP_STE_PLOGI_ISSUE
);
6082 if (lpfc_issue_els_plogi(vport
, ndlp
->nlp_DID
, 0)) {
6083 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
6084 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
6085 "0252 Cannot issue NameServer login\n");
6089 if (vport
->cfg_fdmi_on
) {
6090 ndlp_fdmi
= mempool_alloc(phba
->nlp_mem_pool
,
6093 lpfc_nlp_init(vport
, ndlp_fdmi
, FDMI_DID
);
6094 ndlp_fdmi
->nlp_type
|= NLP_FABRIC
;
6095 lpfc_nlp_set_state(vport
, ndlp_fdmi
,
6096 NLP_STE_PLOGI_ISSUE
);
6097 lpfc_issue_els_plogi(vport
, ndlp_fdmi
->nlp_DID
,
6105 * lpfc_cmpl_reg_new_vport - Completion callback function to register new vport
6106 * @phba: pointer to lpfc hba data structure.
6107 * @pmb: pointer to the driver internal queue element for mailbox command.
6109 * This routine is the completion callback function to register new vport
6110 * mailbox command. If the new vport mailbox command completes successfully,
6111 * the fabric registration login shall be performed on physical port (the
6112 * new vport created is actually a physical port, with VPI 0) or the port
6113 * login to Name Server for State Change Request (SCR) will be performed
6114 * on virtual port (real virtual port, with VPI greater than 0).
6117 lpfc_cmpl_reg_new_vport(struct lpfc_hba
*phba
, LPFC_MBOXQ_t
*pmb
)
6119 struct lpfc_vport
*vport
= pmb
->vport
;
6120 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
6121 struct lpfc_nodelist
*ndlp
= (struct lpfc_nodelist
*) pmb
->context2
;
6122 MAILBOX_t
*mb
= &pmb
->u
.mb
;
6125 spin_lock_irq(shost
->host_lock
);
6126 vport
->fc_flag
&= ~FC_VPORT_NEEDS_REG_VPI
;
6127 spin_unlock_irq(shost
->host_lock
);
6129 if (mb
->mbxStatus
) {
6130 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_MBOX
,
6131 "0915 Register VPI failed : Status: x%x"
6132 " upd bit: x%x \n", mb
->mbxStatus
,
6133 mb
->un
.varRegVpi
.upd
);
6134 if (phba
->sli_rev
== LPFC_SLI_REV4
&&
6135 mb
->un
.varRegVpi
.upd
)
6136 goto mbox_err_exit
;
6138 switch (mb
->mbxStatus
) {
6139 case 0x11: /* unsupported feature */
6140 case 0x9603: /* max_vpi exceeded */
6141 case 0x9602: /* Link event since CLEAR_LA */
6142 /* giving up on vport registration */
6143 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
6144 spin_lock_irq(shost
->host_lock
);
6145 vport
->fc_flag
&= ~(FC_FABRIC
| FC_PUBLIC_LOOP
);
6146 spin_unlock_irq(shost
->host_lock
);
6147 lpfc_can_disctmo(vport
);
6149 /* If reg_vpi fail with invalid VPI status, re-init VPI */
6151 spin_lock_irq(shost
->host_lock
);
6152 vport
->fc_flag
|= FC_VPORT_NEEDS_REG_VPI
;
6153 spin_unlock_irq(shost
->host_lock
);
6154 lpfc_init_vpi(phba
, pmb
, vport
->vpi
);
6156 pmb
->mbox_cmpl
= lpfc_init_vpi_cmpl
;
6157 rc
= lpfc_sli_issue_mbox(phba
, pmb
,
6159 if (rc
== MBX_NOT_FINISHED
) {
6160 lpfc_printf_vlog(vport
,
6162 "2732 Failed to issue INIT_VPI"
6163 " mailbox command\n");
6170 /* Try to recover from this error */
6171 lpfc_mbx_unreg_vpi(vport
);
6172 spin_lock_irq(shost
->host_lock
);
6173 vport
->fc_flag
|= FC_VPORT_NEEDS_REG_VPI
;
6174 spin_unlock_irq(shost
->host_lock
);
6175 if (vport
->port_type
== LPFC_PHYSICAL_PORT
6176 && !(vport
->fc_flag
& FC_LOGO_RCVD_DID_CHNG
))
6177 lpfc_initial_flogi(vport
);
6179 lpfc_initial_fdisc(vport
);
6183 spin_lock_irq(shost
->host_lock
);
6184 vport
->vpi_state
|= LPFC_VPI_REGISTERED
;
6185 spin_unlock_irq(shost
->host_lock
);
6186 if (vport
== phba
->pport
) {
6187 if (phba
->sli_rev
< LPFC_SLI_REV4
)
6188 lpfc_issue_fabric_reglogin(vport
);
6191 * If the physical port is instantiated using
6192 * FDISC, do not start vport discovery.
6194 if (vport
->port_state
!= LPFC_FDISC
)
6195 lpfc_start_fdiscs(phba
);
6196 lpfc_do_scr_ns_plogi(phba
, vport
);
6199 lpfc_do_scr_ns_plogi(phba
, vport
);
6202 /* Now, we decrement the ndlp reference count held for this
6207 mempool_free(pmb
, phba
->mbox_mem_pool
);
6212 * lpfc_register_new_vport - Register a new vport with a HBA
6213 * @phba: pointer to lpfc hba data structure.
6214 * @vport: pointer to a host virtual N_Port data structure.
6215 * @ndlp: pointer to a node-list data structure.
6217 * This routine registers the @vport as a new virtual port with a HBA.
6218 * It is done through a registering vpi mailbox command.
6221 lpfc_register_new_vport(struct lpfc_hba
*phba
, struct lpfc_vport
*vport
,
6222 struct lpfc_nodelist
*ndlp
)
6224 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
6227 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
6229 lpfc_reg_vpi(vport
, mbox
);
6230 mbox
->vport
= vport
;
6231 mbox
->context2
= lpfc_nlp_get(ndlp
);
6232 mbox
->mbox_cmpl
= lpfc_cmpl_reg_new_vport
;
6233 if (lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
)
6234 == MBX_NOT_FINISHED
) {
6235 /* mailbox command not success, decrement ndlp
6236 * reference count for this command
6239 mempool_free(mbox
, phba
->mbox_mem_pool
);
6241 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_MBOX
,
6242 "0253 Register VPI: Can't send mbox\n");
6246 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_MBOX
,
6247 "0254 Register VPI: no memory\n");
6253 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
6254 spin_lock_irq(shost
->host_lock
);
6255 vport
->fc_flag
&= ~FC_VPORT_NEEDS_REG_VPI
;
6256 spin_unlock_irq(shost
->host_lock
);
6261 * lpfc_cancel_all_vport_retry_delay_timer - Cancel all vport retry delay timer
6262 * @phba: pointer to lpfc hba data structure.
6264 * This routine cancels the retry delay timers to all the vports.
6267 lpfc_cancel_all_vport_retry_delay_timer(struct lpfc_hba
*phba
)
6269 struct lpfc_vport
**vports
;
6270 struct lpfc_nodelist
*ndlp
;
6271 uint32_t link_state
;
6274 /* Treat this failure as linkdown for all vports */
6275 link_state
= phba
->link_state
;
6276 lpfc_linkdown(phba
);
6277 phba
->link_state
= link_state
;
6279 vports
= lpfc_create_vport_work_array(phba
);
6282 for (i
= 0; i
<= phba
->max_vports
&& vports
[i
] != NULL
; i
++) {
6283 ndlp
= lpfc_findnode_did(vports
[i
], Fabric_DID
);
6285 lpfc_cancel_retry_delay_tmo(vports
[i
], ndlp
);
6286 lpfc_els_flush_cmd(vports
[i
]);
6288 lpfc_destroy_vport_work_array(phba
, vports
);
6293 * lpfc_retry_pport_discovery - Start timer to retry FLOGI.
6294 * @phba: pointer to lpfc hba data structure.
6296 * This routine abort all pending discovery commands and
6297 * start a timer to retry FLOGI for the physical port
6301 lpfc_retry_pport_discovery(struct lpfc_hba
*phba
)
6303 struct lpfc_nodelist
*ndlp
;
6304 struct Scsi_Host
*shost
;
6306 /* Cancel the all vports retry delay retry timers */
6307 lpfc_cancel_all_vport_retry_delay_timer(phba
);
6309 /* If fabric require FLOGI, then re-instantiate physical login */
6310 ndlp
= lpfc_findnode_did(phba
->pport
, Fabric_DID
);
6314 shost
= lpfc_shost_from_vport(phba
->pport
);
6315 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
);
6316 spin_lock_irq(shost
->host_lock
);
6317 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
6318 spin_unlock_irq(shost
->host_lock
);
6319 ndlp
->nlp_last_elscmd
= ELS_CMD_FLOGI
;
6320 phba
->pport
->port_state
= LPFC_FLOGI
;
6325 * lpfc_fabric_login_reqd - Check if FLOGI required.
6326 * @phba: pointer to lpfc hba data structure.
6327 * @cmdiocb: pointer to FDISC command iocb.
6328 * @rspiocb: pointer to FDISC response iocb.
6330 * This routine checks if a FLOGI is reguired for FDISC
6334 lpfc_fabric_login_reqd(struct lpfc_hba
*phba
,
6335 struct lpfc_iocbq
*cmdiocb
,
6336 struct lpfc_iocbq
*rspiocb
)
6339 if ((rspiocb
->iocb
.ulpStatus
!= IOSTAT_FABRIC_RJT
) ||
6340 (rspiocb
->iocb
.un
.ulpWord
[4] != RJT_LOGIN_REQUIRED
))
6347 * lpfc_cmpl_els_fdisc - Completion function for fdisc iocb command
6348 * @phba: pointer to lpfc hba data structure.
6349 * @cmdiocb: pointer to lpfc command iocb data structure.
6350 * @rspiocb: pointer to lpfc response iocb data structure.
6352 * This routine is the completion callback function to a Fabric Discover
6353 * (FDISC) ELS command. Since all the FDISC ELS commands are issued
6354 * single threaded, each FDISC completion callback function will reset
6355 * the discovery timer for all vports such that the timers will not get
6356 * unnecessary timeout. The function checks the FDISC IOCB status. If error
6357 * detected, the vport will be set to FC_VPORT_FAILED state. Otherwise,the
6358 * vport will set to FC_VPORT_ACTIVE state. It then checks whether the DID
6359 * assigned to the vport has been changed with the completion of the FDISC
6360 * command. If so, both RPI (Remote Port Index) and VPI (Virtual Port Index)
6361 * are unregistered from the HBA, and then the lpfc_register_new_vport()
6362 * routine is invoked to register new vport with the HBA. Otherwise, the
6363 * lpfc_do_scr_ns_plogi() routine is invoked to issue a PLOGI to the Name
6364 * Server for State Change Request (SCR).
6367 lpfc_cmpl_els_fdisc(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
6368 struct lpfc_iocbq
*rspiocb
)
6370 struct lpfc_vport
*vport
= cmdiocb
->vport
;
6371 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
6372 struct lpfc_nodelist
*ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
6373 struct lpfc_nodelist
*np
;
6374 struct lpfc_nodelist
*next_np
;
6375 IOCB_t
*irsp
= &rspiocb
->iocb
;
6376 struct lpfc_iocbq
*piocb
;
6378 lpfc_printf_vlog(vport
, KERN_INFO
, LOG_ELS
,
6379 "0123 FDISC completes. x%x/x%x prevDID: x%x\n",
6380 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
6382 /* Since all FDISCs are being single threaded, we
6383 * must reset the discovery timer for ALL vports
6384 * waiting to send FDISC when one completes.
6386 list_for_each_entry(piocb
, &phba
->fabric_iocb_list
, list
) {
6387 lpfc_set_disctmo(piocb
->vport
);
6390 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
6391 "FDISC cmpl: status:x%x/x%x prevdid:x%x",
6392 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4], vport
->fc_prevDID
);
6394 if (irsp
->ulpStatus
) {
6396 if (lpfc_fabric_login_reqd(phba
, cmdiocb
, rspiocb
)) {
6397 lpfc_retry_pport_discovery(phba
);
6401 /* Check for retry */
6402 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
))
6405 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
6406 "0126 FDISC failed. (%d/%d)\n",
6407 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4]);
6410 spin_lock_irq(shost
->host_lock
);
6411 vport
->fc_flag
&= ~FC_VPORT_CVL_RCVD
;
6412 vport
->fc_flag
&= ~FC_VPORT_LOGO_RCVD
;
6413 vport
->fc_flag
|= FC_FABRIC
;
6414 if (vport
->phba
->fc_topology
== TOPOLOGY_LOOP
)
6415 vport
->fc_flag
|= FC_PUBLIC_LOOP
;
6416 spin_unlock_irq(shost
->host_lock
);
6418 vport
->fc_myDID
= irsp
->un
.ulpWord
[4] & Mask_DID
;
6419 lpfc_vport_set_state(vport
, FC_VPORT_ACTIVE
);
6420 if ((vport
->fc_prevDID
!= vport
->fc_myDID
) &&
6421 !(vport
->fc_flag
& FC_VPORT_NEEDS_REG_VPI
)) {
6422 /* If our NportID changed, we need to ensure all
6423 * remaining NPORTs get unreg_login'ed so we can
6426 list_for_each_entry_safe(np
, next_np
,
6427 &vport
->fc_nodes
, nlp_listp
) {
6428 if (!NLP_CHK_NODE_ACT(ndlp
) ||
6429 (np
->nlp_state
!= NLP_STE_NPR_NODE
) ||
6430 !(np
->nlp_flag
& NLP_NPR_ADISC
))
6432 spin_lock_irq(shost
->host_lock
);
6433 np
->nlp_flag
&= ~NLP_NPR_ADISC
;
6434 spin_unlock_irq(shost
->host_lock
);
6435 lpfc_unreg_rpi(vport
, np
);
6437 lpfc_cleanup_pending_mbox(vport
);
6438 lpfc_mbx_unreg_vpi(vport
);
6439 spin_lock_irq(shost
->host_lock
);
6440 vport
->fc_flag
|= FC_VPORT_NEEDS_REG_VPI
;
6441 if (phba
->sli_rev
== LPFC_SLI_REV4
)
6442 vport
->fc_flag
|= FC_VPORT_NEEDS_INIT_VPI
;
6444 vport
->fc_flag
|= FC_LOGO_RCVD_DID_CHNG
;
6445 spin_unlock_irq(shost
->host_lock
);
6446 } else if ((phba
->sli_rev
== LPFC_SLI_REV4
) &&
6447 !(vport
->fc_flag
& FC_VPORT_NEEDS_REG_VPI
)) {
6449 * Driver needs to re-reg VPI in order for f/w
6450 * to update the MAC address.
6452 lpfc_register_new_vport(phba
, vport
, ndlp
);
6456 if (vport
->fc_flag
& FC_VPORT_NEEDS_INIT_VPI
)
6457 lpfc_issue_init_vpi(vport
);
6458 else if (vport
->fc_flag
& FC_VPORT_NEEDS_REG_VPI
)
6459 lpfc_register_new_vport(phba
, vport
, ndlp
);
6461 lpfc_do_scr_ns_plogi(phba
, vport
);
6464 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
6465 /* Cancel discovery timer */
6466 lpfc_can_disctmo(vport
);
6469 lpfc_els_free_iocb(phba
, cmdiocb
);
6473 * lpfc_issue_els_fdisc - Issue a fdisc iocb command
6474 * @vport: pointer to a virtual N_Port data structure.
6475 * @ndlp: pointer to a node-list data structure.
6476 * @retry: number of retries to the command IOCB.
6478 * This routine prepares and issues a Fabric Discover (FDISC) IOCB to
6479 * a remote node (@ndlp) off a @vport. It uses the lpfc_issue_fabric_iocb()
6480 * routine to issue the IOCB, which makes sure only one outstanding fabric
6481 * IOCB will be sent off HBA at any given time.
6483 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
6484 * will be incremented by 1 for holding the ndlp and the reference to ndlp
6485 * will be stored into the context1 field of the IOCB for the completion
6486 * callback function to the FDISC ELS command.
6489 * 0 - Successfully issued fdisc iocb command
6490 * 1 - Failed to issue fdisc iocb command
6493 lpfc_issue_els_fdisc(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
,
6496 struct lpfc_hba
*phba
= vport
->phba
;
6498 struct lpfc_iocbq
*elsiocb
;
6499 struct serv_parm
*sp
;
6502 int did
= ndlp
->nlp_DID
;
6505 vport
->port_state
= LPFC_FDISC
;
6506 cmdsize
= (sizeof(uint32_t) + sizeof(struct serv_parm
));
6507 elsiocb
= lpfc_prep_els_iocb(vport
, 1, cmdsize
, retry
, ndlp
, did
,
6510 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
6511 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
6512 "0255 Issue FDISC: no IOCB\n");
6516 icmd
= &elsiocb
->iocb
;
6517 icmd
->un
.elsreq64
.myID
= 0;
6518 icmd
->un
.elsreq64
.fl
= 1;
6520 if (phba
->sli_rev
== LPFC_SLI_REV4
) {
6521 /* FDISC needs to be 1 for WQE VPI */
6522 elsiocb
->iocb
.ulpCt_h
= (SLI4_CT_VPI
>> 1) & 1;
6523 elsiocb
->iocb
.ulpCt_l
= SLI4_CT_VPI
& 1 ;
6524 /* Set the ulpContext to the vpi */
6525 elsiocb
->iocb
.ulpContext
= vport
->vpi
+ phba
->vpi_base
;
6527 /* For FDISC, Let FDISC rsp set the NPortID for this VPI */
6532 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
6533 *((uint32_t *) (pcmd
)) = ELS_CMD_FDISC
;
6534 pcmd
+= sizeof(uint32_t); /* CSP Word 1 */
6535 memcpy(pcmd
, &vport
->phba
->pport
->fc_sparam
, sizeof(struct serv_parm
));
6536 sp
= (struct serv_parm
*) pcmd
;
6537 /* Setup CSPs accordingly for Fabric */
6538 sp
->cmn
.e_d_tov
= 0;
6539 sp
->cmn
.w2
.r_a_tov
= 0;
6540 sp
->cls1
.classValid
= 0;
6541 sp
->cls2
.seqDelivery
= 1;
6542 sp
->cls3
.seqDelivery
= 1;
6544 pcmd
+= sizeof(uint32_t); /* CSP Word 2 */
6545 pcmd
+= sizeof(uint32_t); /* CSP Word 3 */
6546 pcmd
+= sizeof(uint32_t); /* CSP Word 4 */
6547 pcmd
+= sizeof(uint32_t); /* Port Name */
6548 memcpy(pcmd
, &vport
->fc_portname
, 8);
6549 pcmd
+= sizeof(uint32_t); /* Node Name */
6550 pcmd
+= sizeof(uint32_t); /* Node Name */
6551 memcpy(pcmd
, &vport
->fc_nodename
, 8);
6553 lpfc_set_disctmo(vport
);
6555 phba
->fc_stat
.elsXmitFDISC
++;
6556 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_fdisc
;
6558 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
6559 "Issue FDISC: did:x%x",
6562 rc
= lpfc_issue_fabric_iocb(phba
, elsiocb
);
6563 if (rc
== IOCB_ERROR
) {
6564 lpfc_els_free_iocb(phba
, elsiocb
);
6565 lpfc_vport_set_state(vport
, FC_VPORT_FAILED
);
6566 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_ELS
,
6567 "0256 Issue FDISC: Cannot send IOCB\n");
6570 lpfc_vport_set_state(vport
, FC_VPORT_INITIALIZING
);
6575 * lpfc_cmpl_els_npiv_logo - Completion function with vport logo
6576 * @phba: pointer to lpfc hba data structure.
6577 * @cmdiocb: pointer to lpfc command iocb data structure.
6578 * @rspiocb: pointer to lpfc response iocb data structure.
6580 * This routine is the completion callback function to the issuing of a LOGO
6581 * ELS command off a vport. It frees the command IOCB and then decrement the
6582 * reference count held on ndlp for this completion function, indicating that
6583 * the reference to the ndlp is no long needed. Note that the
6584 * lpfc_els_free_iocb() routine decrements the ndlp reference held for this
6585 * callback function and an additional explicit ndlp reference decrementation
6586 * will trigger the actual release of the ndlp.
6589 lpfc_cmpl_els_npiv_logo(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
6590 struct lpfc_iocbq
*rspiocb
)
6592 struct lpfc_vport
*vport
= cmdiocb
->vport
;
6594 struct lpfc_nodelist
*ndlp
;
6595 ndlp
= (struct lpfc_nodelist
*)cmdiocb
->context1
;
6597 irsp
= &rspiocb
->iocb
;
6598 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
6599 "LOGO npiv cmpl: status:x%x/x%x did:x%x",
6600 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4], irsp
->un
.rcvels
.remoteID
);
6602 lpfc_els_free_iocb(phba
, cmdiocb
);
6603 vport
->unreg_vpi_cmpl
= VPORT_ERROR
;
6605 /* Trigger the release of the ndlp after logo */
6610 * lpfc_issue_els_npiv_logo - Issue a logo off a vport
6611 * @vport: pointer to a virtual N_Port data structure.
6612 * @ndlp: pointer to a node-list data structure.
6614 * This routine issues a LOGO ELS command to an @ndlp off a @vport.
6616 * Note that, in lpfc_prep_els_iocb() routine, the reference count of ndlp
6617 * will be incremented by 1 for holding the ndlp and the reference to ndlp
6618 * will be stored into the context1 field of the IOCB for the completion
6619 * callback function to the LOGO ELS command.
6622 * 0 - Successfully issued logo off the @vport
6623 * 1 - Failed to issue logo off the @vport
6626 lpfc_issue_els_npiv_logo(struct lpfc_vport
*vport
, struct lpfc_nodelist
*ndlp
)
6628 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
6629 struct lpfc_hba
*phba
= vport
->phba
;
6631 struct lpfc_iocbq
*elsiocb
;
6635 cmdsize
= 2 * sizeof(uint32_t) + sizeof(struct lpfc_name
);
6636 elsiocb
= lpfc_prep_els_iocb(vport
, 1, cmdsize
, 0, ndlp
, ndlp
->nlp_DID
,
6641 icmd
= &elsiocb
->iocb
;
6642 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
6643 *((uint32_t *) (pcmd
)) = ELS_CMD_LOGO
;
6644 pcmd
+= sizeof(uint32_t);
6646 /* Fill in LOGO payload */
6647 *((uint32_t *) (pcmd
)) = be32_to_cpu(vport
->fc_myDID
);
6648 pcmd
+= sizeof(uint32_t);
6649 memcpy(pcmd
, &vport
->fc_portname
, sizeof(struct lpfc_name
));
6651 lpfc_debugfs_disc_trc(vport
, LPFC_DISC_TRC_ELS_CMD
,
6652 "Issue LOGO npiv did:x%x flg:x%x",
6653 ndlp
->nlp_DID
, ndlp
->nlp_flag
, 0);
6655 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_npiv_logo
;
6656 spin_lock_irq(shost
->host_lock
);
6657 ndlp
->nlp_flag
|= NLP_LOGO_SND
;
6658 spin_unlock_irq(shost
->host_lock
);
6659 if (lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, elsiocb
, 0) ==
6661 spin_lock_irq(shost
->host_lock
);
6662 ndlp
->nlp_flag
&= ~NLP_LOGO_SND
;
6663 spin_unlock_irq(shost
->host_lock
);
6664 lpfc_els_free_iocb(phba
, elsiocb
);
6671 * lpfc_fabric_block_timeout - Handler function to the fabric block timer
6672 * @ptr: holder for the timer function associated data.
6674 * This routine is invoked by the fabric iocb block timer after
6675 * timeout. It posts the fabric iocb block timeout event by setting the
6676 * WORKER_FABRIC_BLOCK_TMO bit to work port event bitmap and then invokes
6677 * lpfc_worker_wake_up() routine to wake up the worker thread. It is for
6678 * the worker thread to invoke the lpfc_unblock_fabric_iocbs() on the
6679 * posted event WORKER_FABRIC_BLOCK_TMO.
6682 lpfc_fabric_block_timeout(unsigned long ptr
)
6684 struct lpfc_hba
*phba
= (struct lpfc_hba
*) ptr
;
6685 unsigned long iflags
;
6686 uint32_t tmo_posted
;
6688 spin_lock_irqsave(&phba
->pport
->work_port_lock
, iflags
);
6689 tmo_posted
= phba
->pport
->work_port_events
& WORKER_FABRIC_BLOCK_TMO
;
6691 phba
->pport
->work_port_events
|= WORKER_FABRIC_BLOCK_TMO
;
6692 spin_unlock_irqrestore(&phba
->pport
->work_port_lock
, iflags
);
6695 lpfc_worker_wake_up(phba
);
6700 * lpfc_resume_fabric_iocbs - Issue a fabric iocb from driver internal list
6701 * @phba: pointer to lpfc hba data structure.
6703 * This routine issues one fabric iocb from the driver internal list to
6704 * the HBA. It first checks whether it's ready to issue one fabric iocb to
6705 * the HBA (whether there is no outstanding fabric iocb). If so, it shall
6706 * remove one pending fabric iocb from the driver internal list and invokes
6707 * lpfc_sli_issue_iocb() routine to send the fabric iocb to the HBA.
6710 lpfc_resume_fabric_iocbs(struct lpfc_hba
*phba
)
6712 struct lpfc_iocbq
*iocb
;
6713 unsigned long iflags
;
6719 spin_lock_irqsave(&phba
->hbalock
, iflags
);
6720 /* Post any pending iocb to the SLI layer */
6721 if (atomic_read(&phba
->fabric_iocb_count
) == 0) {
6722 list_remove_head(&phba
->fabric_iocb_list
, iocb
, typeof(*iocb
),
6725 /* Increment fabric iocb count to hold the position */
6726 atomic_inc(&phba
->fabric_iocb_count
);
6728 spin_unlock_irqrestore(&phba
->hbalock
, iflags
);
6730 iocb
->fabric_iocb_cmpl
= iocb
->iocb_cmpl
;
6731 iocb
->iocb_cmpl
= lpfc_cmpl_fabric_iocb
;
6732 iocb
->iocb_flag
|= LPFC_IO_FABRIC
;
6734 lpfc_debugfs_disc_trc(iocb
->vport
, LPFC_DISC_TRC_ELS_CMD
,
6735 "Fabric sched1: ste:x%x",
6736 iocb
->vport
->port_state
, 0, 0);
6738 ret
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, iocb
, 0);
6740 if (ret
== IOCB_ERROR
) {
6741 iocb
->iocb_cmpl
= iocb
->fabric_iocb_cmpl
;
6742 iocb
->fabric_iocb_cmpl
= NULL
;
6743 iocb
->iocb_flag
&= ~LPFC_IO_FABRIC
;
6745 cmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
6746 cmd
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
6747 iocb
->iocb_cmpl(phba
, iocb
, iocb
);
6749 atomic_dec(&phba
->fabric_iocb_count
);
6758 * lpfc_unblock_fabric_iocbs - Unblock issuing fabric iocb command
6759 * @phba: pointer to lpfc hba data structure.
6761 * This routine unblocks the issuing fabric iocb command. The function
6762 * will clear the fabric iocb block bit and then invoke the routine
6763 * lpfc_resume_fabric_iocbs() to issue one of the pending fabric iocb
6764 * from the driver internal fabric iocb list.
6767 lpfc_unblock_fabric_iocbs(struct lpfc_hba
*phba
)
6769 clear_bit(FABRIC_COMANDS_BLOCKED
, &phba
->bit_flags
);
6771 lpfc_resume_fabric_iocbs(phba
);
6776 * lpfc_block_fabric_iocbs - Block issuing fabric iocb command
6777 * @phba: pointer to lpfc hba data structure.
6779 * This routine blocks the issuing fabric iocb for a specified amount of
6780 * time (currently 100 ms). This is done by set the fabric iocb block bit
6781 * and set up a timeout timer for 100ms. When the block bit is set, no more
6782 * fabric iocb will be issued out of the HBA.
6785 lpfc_block_fabric_iocbs(struct lpfc_hba
*phba
)
6789 blocked
= test_and_set_bit(FABRIC_COMANDS_BLOCKED
, &phba
->bit_flags
);
6790 /* Start a timer to unblock fabric iocbs after 100ms */
6792 mod_timer(&phba
->fabric_block_timer
, jiffies
+ HZ
/10 );
6798 * lpfc_cmpl_fabric_iocb - Completion callback function for fabric iocb
6799 * @phba: pointer to lpfc hba data structure.
6800 * @cmdiocb: pointer to lpfc command iocb data structure.
6801 * @rspiocb: pointer to lpfc response iocb data structure.
6803 * This routine is the callback function that is put to the fabric iocb's
6804 * callback function pointer (iocb->iocb_cmpl). The original iocb's callback
6805 * function pointer has been stored in iocb->fabric_iocb_cmpl. This callback
6806 * function first restores and invokes the original iocb's callback function
6807 * and then invokes the lpfc_resume_fabric_iocbs() routine to issue the next
6808 * fabric bound iocb from the driver internal fabric iocb list onto the wire.
6811 lpfc_cmpl_fabric_iocb(struct lpfc_hba
*phba
, struct lpfc_iocbq
*cmdiocb
,
6812 struct lpfc_iocbq
*rspiocb
)
6816 if ((cmdiocb
->iocb_flag
& LPFC_IO_FABRIC
) != LPFC_IO_FABRIC
)
6819 switch (rspiocb
->iocb
.ulpStatus
) {
6820 case IOSTAT_NPORT_RJT
:
6821 case IOSTAT_FABRIC_RJT
:
6822 if (rspiocb
->iocb
.un
.ulpWord
[4] & RJT_UNAVAIL_TEMP
) {
6823 lpfc_block_fabric_iocbs(phba
);
6827 case IOSTAT_NPORT_BSY
:
6828 case IOSTAT_FABRIC_BSY
:
6829 lpfc_block_fabric_iocbs(phba
);
6833 stat
.un
.lsRjtError
=
6834 be32_to_cpu(rspiocb
->iocb
.un
.ulpWord
[4]);
6835 if ((stat
.un
.b
.lsRjtRsnCode
== LSRJT_UNABLE_TPC
) ||
6836 (stat
.un
.b
.lsRjtRsnCode
== LSRJT_LOGICAL_BSY
))
6837 lpfc_block_fabric_iocbs(phba
);
6841 if (atomic_read(&phba
->fabric_iocb_count
) == 0)
6844 cmdiocb
->iocb_cmpl
= cmdiocb
->fabric_iocb_cmpl
;
6845 cmdiocb
->fabric_iocb_cmpl
= NULL
;
6846 cmdiocb
->iocb_flag
&= ~LPFC_IO_FABRIC
;
6847 cmdiocb
->iocb_cmpl(phba
, cmdiocb
, rspiocb
);
6849 atomic_dec(&phba
->fabric_iocb_count
);
6850 if (!test_bit(FABRIC_COMANDS_BLOCKED
, &phba
->bit_flags
)) {
6851 /* Post any pending iocbs to HBA */
6852 lpfc_resume_fabric_iocbs(phba
);
6857 * lpfc_issue_fabric_iocb - Issue a fabric iocb command
6858 * @phba: pointer to lpfc hba data structure.
6859 * @iocb: pointer to lpfc command iocb data structure.
6861 * This routine is used as the top-level API for issuing a fabric iocb command
6862 * such as FLOGI and FDISC. To accommodate certain switch fabric, this driver
6863 * function makes sure that only one fabric bound iocb will be outstanding at
6864 * any given time. As such, this function will first check to see whether there
6865 * is already an outstanding fabric iocb on the wire. If so, it will put the
6866 * newly issued iocb onto the driver internal fabric iocb list, waiting to be
6867 * issued later. Otherwise, it will issue the iocb on the wire and update the
6868 * fabric iocb count it indicate that there is one fabric iocb on the wire.
6870 * Note, this implementation has a potential sending out fabric IOCBs out of
6871 * order. The problem is caused by the construction of the "ready" boolen does
6872 * not include the condition that the internal fabric IOCB list is empty. As
6873 * such, it is possible a fabric IOCB issued by this routine might be "jump"
6874 * ahead of the fabric IOCBs in the internal list.
6877 * IOCB_SUCCESS - either fabric iocb put on the list or issued successfully
6878 * IOCB_ERROR - failed to issue fabric iocb
6881 lpfc_issue_fabric_iocb(struct lpfc_hba
*phba
, struct lpfc_iocbq
*iocb
)
6883 unsigned long iflags
;
6887 if (atomic_read(&phba
->fabric_iocb_count
) > 1)
6890 spin_lock_irqsave(&phba
->hbalock
, iflags
);
6891 ready
= atomic_read(&phba
->fabric_iocb_count
) == 0 &&
6892 !test_bit(FABRIC_COMANDS_BLOCKED
, &phba
->bit_flags
);
6895 /* Increment fabric iocb count to hold the position */
6896 atomic_inc(&phba
->fabric_iocb_count
);
6897 spin_unlock_irqrestore(&phba
->hbalock
, iflags
);
6899 iocb
->fabric_iocb_cmpl
= iocb
->iocb_cmpl
;
6900 iocb
->iocb_cmpl
= lpfc_cmpl_fabric_iocb
;
6901 iocb
->iocb_flag
|= LPFC_IO_FABRIC
;
6903 lpfc_debugfs_disc_trc(iocb
->vport
, LPFC_DISC_TRC_ELS_CMD
,
6904 "Fabric sched2: ste:x%x",
6905 iocb
->vport
->port_state
, 0, 0);
6907 ret
= lpfc_sli_issue_iocb(phba
, LPFC_ELS_RING
, iocb
, 0);
6909 if (ret
== IOCB_ERROR
) {
6910 iocb
->iocb_cmpl
= iocb
->fabric_iocb_cmpl
;
6911 iocb
->fabric_iocb_cmpl
= NULL
;
6912 iocb
->iocb_flag
&= ~LPFC_IO_FABRIC
;
6913 atomic_dec(&phba
->fabric_iocb_count
);
6916 spin_lock_irqsave(&phba
->hbalock
, iflags
);
6917 list_add_tail(&iocb
->list
, &phba
->fabric_iocb_list
);
6918 spin_unlock_irqrestore(&phba
->hbalock
, iflags
);
6925 * lpfc_fabric_abort_vport - Abort a vport's iocbs from driver fabric iocb list
6926 * @vport: pointer to a virtual N_Port data structure.
6928 * This routine aborts all the IOCBs associated with a @vport from the
6929 * driver internal fabric IOCB list. The list contains fabric IOCBs to be
6930 * issued to the ELS IOCB ring. This abort function walks the fabric IOCB
6931 * list, removes each IOCB associated with the @vport off the list, set the
6932 * status feild to IOSTAT_LOCAL_REJECT, and invokes the callback function
6933 * associated with the IOCB.
6935 static void lpfc_fabric_abort_vport(struct lpfc_vport
*vport
)
6937 LIST_HEAD(completions
);
6938 struct lpfc_hba
*phba
= vport
->phba
;
6939 struct lpfc_iocbq
*tmp_iocb
, *piocb
;
6941 spin_lock_irq(&phba
->hbalock
);
6942 list_for_each_entry_safe(piocb
, tmp_iocb
, &phba
->fabric_iocb_list
,
6945 if (piocb
->vport
!= vport
)
6948 list_move_tail(&piocb
->list
, &completions
);
6950 spin_unlock_irq(&phba
->hbalock
);
6952 /* Cancel all the IOCBs from the completions list */
6953 lpfc_sli_cancel_iocbs(phba
, &completions
, IOSTAT_LOCAL_REJECT
,
6958 * lpfc_fabric_abort_nport - Abort a ndlp's iocbs from driver fabric iocb list
6959 * @ndlp: pointer to a node-list data structure.
6961 * This routine aborts all the IOCBs associated with an @ndlp from the
6962 * driver internal fabric IOCB list. The list contains fabric IOCBs to be
6963 * issued to the ELS IOCB ring. This abort function walks the fabric IOCB
6964 * list, removes each IOCB associated with the @ndlp off the list, set the
6965 * status feild to IOSTAT_LOCAL_REJECT, and invokes the callback function
6966 * associated with the IOCB.
6968 void lpfc_fabric_abort_nport(struct lpfc_nodelist
*ndlp
)
6970 LIST_HEAD(completions
);
6971 struct lpfc_hba
*phba
= ndlp
->phba
;
6972 struct lpfc_iocbq
*tmp_iocb
, *piocb
;
6973 struct lpfc_sli_ring
*pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
6975 spin_lock_irq(&phba
->hbalock
);
6976 list_for_each_entry_safe(piocb
, tmp_iocb
, &phba
->fabric_iocb_list
,
6978 if ((lpfc_check_sli_ndlp(phba
, pring
, piocb
, ndlp
))) {
6980 list_move_tail(&piocb
->list
, &completions
);
6983 spin_unlock_irq(&phba
->hbalock
);
6985 /* Cancel all the IOCBs from the completions list */
6986 lpfc_sli_cancel_iocbs(phba
, &completions
, IOSTAT_LOCAL_REJECT
,
6991 * lpfc_fabric_abort_hba - Abort all iocbs on driver fabric iocb list
6992 * @phba: pointer to lpfc hba data structure.
6994 * This routine aborts all the IOCBs currently on the driver internal
6995 * fabric IOCB list. The list contains fabric IOCBs to be issued to the ELS
6996 * IOCB ring. This function takes the entire IOCB list off the fabric IOCB
6997 * list, removes IOCBs off the list, set the status feild to
6998 * IOSTAT_LOCAL_REJECT, and invokes the callback function associated with
7001 void lpfc_fabric_abort_hba(struct lpfc_hba
*phba
)
7003 LIST_HEAD(completions
);
7005 spin_lock_irq(&phba
->hbalock
);
7006 list_splice_init(&phba
->fabric_iocb_list
, &completions
);
7007 spin_unlock_irq(&phba
->hbalock
);
7009 /* Cancel all the IOCBs from the completions list */
7010 lpfc_sli_cancel_iocbs(phba
, &completions
, IOSTAT_LOCAL_REJECT
,
7015 * lpfc_sli4_els_xri_aborted - Slow-path process of els xri abort
7016 * @phba: pointer to lpfc hba data structure.
7017 * @axri: pointer to the els xri abort wcqe structure.
7019 * This routine is invoked by the worker thread to process a SLI4 slow-path
7023 lpfc_sli4_els_xri_aborted(struct lpfc_hba
*phba
,
7024 struct sli4_wcqe_xri_aborted
*axri
)
7026 uint16_t xri
= bf_get(lpfc_wcqe_xa_xri
, axri
);
7027 struct lpfc_sglq
*sglq_entry
= NULL
, *sglq_next
= NULL
;
7028 unsigned long iflag
= 0;
7029 struct lpfc_sli_ring
*pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
7031 spin_lock_irqsave(&phba
->hbalock
, iflag
);
7032 spin_lock(&phba
->sli4_hba
.abts_sgl_list_lock
);
7033 list_for_each_entry_safe(sglq_entry
, sglq_next
,
7034 &phba
->sli4_hba
.lpfc_abts_els_sgl_list
, list
) {
7035 if (sglq_entry
->sli4_xritag
== xri
) {
7036 list_del(&sglq_entry
->list
);
7037 list_add_tail(&sglq_entry
->list
,
7038 &phba
->sli4_hba
.lpfc_sgl_list
);
7039 sglq_entry
->state
= SGL_FREED
;
7040 spin_unlock(&phba
->sli4_hba
.abts_sgl_list_lock
);
7041 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
7043 /* Check if TXQ queue needs to be serviced */
7045 lpfc_worker_wake_up(phba
);
7049 spin_unlock(&phba
->sli4_hba
.abts_sgl_list_lock
);
7050 sglq_entry
= __lpfc_get_active_sglq(phba
, xri
);
7051 if (!sglq_entry
|| (sglq_entry
->sli4_xritag
!= xri
)) {
7052 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);
7055 sglq_entry
->state
= SGL_XRI_ABORTED
;
7056 spin_unlock_irqrestore(&phba
->hbalock
, iflag
);