1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2005 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
26 #include <scsi/scsi.h>
27 #include <scsi/scsi_device.h>
28 #include <scsi/scsi_host.h>
29 #include <scsi/scsi_transport_fc.h>
33 #include "lpfc_disc.h"
34 #include "lpfc_scsi.h"
36 #include "lpfc_logmsg.h"
37 #include "lpfc_crtn.h"
39 static int lpfc_els_retry(struct lpfc_hba
*, struct lpfc_iocbq
*,
41 static int lpfc_max_els_tries
= 3;
44 lpfc_els_chk_latt(struct lpfc_hba
* phba
)
46 struct lpfc_sli
*psli
;
53 if ((phba
->hba_state
>= LPFC_HBA_READY
) ||
54 (phba
->hba_state
== LPFC_LINK_DOWN
))
57 /* Read the HBA Host Attention Register */
58 spin_lock_irq(phba
->host
->host_lock
);
59 ha_copy
= readl(phba
->HAregaddr
);
60 spin_unlock_irq(phba
->host
->host_lock
);
62 if (!(ha_copy
& HA_LATT
))
65 /* Pending Link Event during Discovery */
66 lpfc_printf_log(phba
, KERN_WARNING
, LOG_DISCOVERY
,
67 "%d:0237 Pending Link Event during "
68 "Discovery: State x%x\n",
69 phba
->brd_no
, phba
->hba_state
);
71 /* CLEAR_LA should re-enable link attention events and
72 * we should then imediately take a LATT event. The
73 * LATT processing should call lpfc_linkdown() which
74 * will cleanup any left over in-progress discovery
77 spin_lock_irq(phba
->host
->host_lock
);
78 phba
->fc_flag
|= FC_ABORT_DISCOVERY
;
79 spin_unlock_irq(phba
->host
->host_lock
);
81 if (phba
->hba_state
!= LPFC_CLEAR_LA
) {
82 if ((mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
))) {
83 phba
->hba_state
= LPFC_CLEAR_LA
;
84 lpfc_clear_la(phba
, mbox
);
85 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_clear_la
;
86 rc
= lpfc_sli_issue_mbox (phba
, mbox
,
87 (MBX_NOWAIT
| MBX_STOP_IOCB
));
88 if (rc
== MBX_NOT_FINISHED
) {
89 mempool_free(mbox
, phba
->mbox_mem_pool
);
90 phba
->hba_state
= LPFC_HBA_ERROR
;
99 static struct lpfc_iocbq
*
100 lpfc_prep_els_iocb(struct lpfc_hba
* phba
,
103 uint8_t retry
, struct lpfc_nodelist
* ndlp
, uint32_t elscmd
)
105 struct lpfc_sli_ring
*pring
;
106 struct lpfc_iocbq
*elsiocb
;
107 struct lpfc_dmabuf
*pcmd
, *prsp
, *pbuflist
;
108 struct ulp_bde64
*bpl
;
111 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
113 if (phba
->hba_state
< LPFC_LINK_UP
)
116 /* Allocate buffer for command iocb */
117 spin_lock_irq(phba
->host
->host_lock
);
118 elsiocb
= lpfc_sli_get_iocbq(phba
);
119 spin_unlock_irq(phba
->host
->host_lock
);
123 icmd
= &elsiocb
->iocb
;
125 /* fill in BDEs for command */
126 /* Allocate buffer for command payload */
127 if (((pcmd
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
)) == 0) ||
128 ((pcmd
->virt
= lpfc_mbuf_alloc(phba
,
129 MEM_PRI
, &(pcmd
->phys
))) == 0)) {
132 spin_lock_irq(phba
->host
->host_lock
);
133 lpfc_sli_release_iocbq(phba
, elsiocb
);
134 spin_unlock_irq(phba
->host
->host_lock
);
138 INIT_LIST_HEAD(&pcmd
->list
);
140 /* Allocate buffer for response payload */
142 prsp
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
);
144 prsp
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
,
146 if (prsp
== 0 || prsp
->virt
== 0) {
148 lpfc_mbuf_free(phba
, pcmd
->virt
, pcmd
->phys
);
150 spin_lock_irq(phba
->host
->host_lock
);
151 lpfc_sli_release_iocbq(phba
, elsiocb
);
152 spin_unlock_irq(phba
->host
->host_lock
);
155 INIT_LIST_HEAD(&prsp
->list
);
160 /* Allocate buffer for Buffer ptr list */
161 pbuflist
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
);
163 pbuflist
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
,
165 if (pbuflist
== 0 || pbuflist
->virt
== 0) {
166 spin_lock_irq(phba
->host
->host_lock
);
167 lpfc_sli_release_iocbq(phba
, elsiocb
);
168 spin_unlock_irq(phba
->host
->host_lock
);
169 lpfc_mbuf_free(phba
, pcmd
->virt
, pcmd
->phys
);
170 lpfc_mbuf_free(phba
, prsp
->virt
, prsp
->phys
);
177 INIT_LIST_HEAD(&pbuflist
->list
);
179 icmd
->un
.elsreq64
.bdl
.addrHigh
= putPaddrHigh(pbuflist
->phys
);
180 icmd
->un
.elsreq64
.bdl
.addrLow
= putPaddrLow(pbuflist
->phys
);
181 icmd
->un
.elsreq64
.bdl
.bdeFlags
= BUFF_TYPE_BDL
;
183 icmd
->un
.elsreq64
.bdl
.bdeSize
= (2 * sizeof (struct ulp_bde64
));
184 icmd
->un
.elsreq64
.remoteID
= ndlp
->nlp_DID
; /* DID */
185 icmd
->ulpCommand
= CMD_ELS_REQUEST64_CR
;
187 icmd
->un
.elsreq64
.bdl
.bdeSize
= sizeof (struct ulp_bde64
);
188 icmd
->ulpCommand
= CMD_XMIT_ELS_RSP64_CX
;
191 icmd
->ulpBdeCount
= 1;
193 icmd
->ulpClass
= CLASS3
;
195 bpl
= (struct ulp_bde64
*) pbuflist
->virt
;
196 bpl
->addrLow
= le32_to_cpu(putPaddrLow(pcmd
->phys
));
197 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(pcmd
->phys
));
198 bpl
->tus
.f
.bdeSize
= cmdSize
;
199 bpl
->tus
.f
.bdeFlags
= 0;
200 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
204 bpl
->addrLow
= le32_to_cpu(putPaddrLow(prsp
->phys
));
205 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(prsp
->phys
));
206 bpl
->tus
.f
.bdeSize
= FCELSSIZE
;
207 bpl
->tus
.f
.bdeFlags
= BUFF_USE_RCV
;
208 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
211 /* Save for completion so we can release these resources */
212 elsiocb
->context1
= (uint8_t *) ndlp
;
213 elsiocb
->context2
= (uint8_t *) pcmd
;
214 elsiocb
->context3
= (uint8_t *) pbuflist
;
215 elsiocb
->retry
= retry
;
216 elsiocb
->drvrTimeout
= (phba
->fc_ratov
<< 1) + LPFC_DRVR_TIMEOUT
;
219 list_add(&prsp
->list
, &pcmd
->list
);
223 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
224 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
225 "%d:0116 Xmit ELS command x%x to remote "
226 "NPORT x%x Data: x%x x%x\n",
227 phba
->brd_no
, elscmd
,
228 ndlp
->nlp_DID
, icmd
->ulpIoTag
, phba
->hba_state
);
230 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
231 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
232 "%d:0117 Xmit ELS response x%x to remote "
233 "NPORT x%x Data: x%x x%x\n",
234 phba
->brd_no
, elscmd
,
235 ndlp
->nlp_DID
, icmd
->ulpIoTag
, cmdSize
);
243 lpfc_cmpl_els_flogi_fabric(struct lpfc_hba
*phba
, struct lpfc_nodelist
*ndlp
,
244 struct serv_parm
*sp
, IOCB_t
*irsp
)
249 spin_lock_irq(phba
->host
->host_lock
);
250 phba
->fc_flag
|= FC_FABRIC
;
251 spin_unlock_irq(phba
->host
->host_lock
);
253 phba
->fc_edtov
= be32_to_cpu(sp
->cmn
.e_d_tov
);
254 if (sp
->cmn
.edtovResolution
) /* E_D_TOV ticks are in nanoseconds */
255 phba
->fc_edtov
= (phba
->fc_edtov
+ 999999) / 1000000;
257 phba
->fc_ratov
= (be32_to_cpu(sp
->cmn
.w2
.r_a_tov
) + 999) / 1000;
259 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
260 spin_lock_irq(phba
->host
->host_lock
);
261 phba
->fc_flag
|= FC_PUBLIC_LOOP
;
262 spin_unlock_irq(phba
->host
->host_lock
);
265 * If we are a N-port connected to a Fabric, fixup sparam's so
266 * logins to devices on remote loops work.
268 phba
->fc_sparam
.cmn
.altBbCredit
= 1;
271 phba
->fc_myDID
= irsp
->un
.ulpWord
[4] & Mask_DID
;
272 memcpy(&ndlp
->nlp_portname
, &sp
->portName
, sizeof(struct lpfc_name
));
273 memcpy(&ndlp
->nlp_nodename
, &sp
->nodeName
, sizeof (struct lpfc_name
));
274 ndlp
->nlp_class_sup
= 0;
275 if (sp
->cls1
.classValid
)
276 ndlp
->nlp_class_sup
|= FC_COS_CLASS1
;
277 if (sp
->cls2
.classValid
)
278 ndlp
->nlp_class_sup
|= FC_COS_CLASS2
;
279 if (sp
->cls3
.classValid
)
280 ndlp
->nlp_class_sup
|= FC_COS_CLASS3
;
281 if (sp
->cls4
.classValid
)
282 ndlp
->nlp_class_sup
|= FC_COS_CLASS4
;
283 ndlp
->nlp_maxframe
= ((sp
->cmn
.bbRcvSizeMsb
& 0x0F) << 8) |
284 sp
->cmn
.bbRcvSizeLsb
;
285 memcpy(&phba
->fc_fabparam
, sp
, sizeof(struct serv_parm
));
287 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
291 phba
->hba_state
= LPFC_FABRIC_CFG_LINK
;
292 lpfc_config_link(phba
, mbox
);
293 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
295 rc
= lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
| MBX_STOP_IOCB
);
296 if (rc
== MBX_NOT_FINISHED
)
299 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
303 if (lpfc_reg_login(phba
, Fabric_DID
, (uint8_t *) sp
, mbox
, 0))
307 * set_slim mailbox command needs to execute first,
308 * queue this command to be processed later.
310 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_fabric_reg_login
;
311 mbox
->context2
= ndlp
;
313 rc
= lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
| MBX_STOP_IOCB
);
314 if (rc
== MBX_NOT_FINISHED
)
320 mempool_free(mbox
, phba
->mbox_mem_pool
);
326 * We FLOGIed into an NPort, initiate pt2pt protocol
329 lpfc_cmpl_els_flogi_nport(struct lpfc_hba
*phba
, struct lpfc_nodelist
*ndlp
,
330 struct serv_parm
*sp
)
335 spin_lock_irq(phba
->host
->host_lock
);
336 phba
->fc_flag
&= ~(FC_FABRIC
| FC_PUBLIC_LOOP
);
337 spin_unlock_irq(phba
->host
->host_lock
);
339 phba
->fc_edtov
= FF_DEF_EDTOV
;
340 phba
->fc_ratov
= FF_DEF_RATOV
;
341 rc
= memcmp(&phba
->fc_portname
, &sp
->portName
,
342 sizeof(struct lpfc_name
));
344 /* This side will initiate the PLOGI */
345 spin_lock_irq(phba
->host
->host_lock
);
346 phba
->fc_flag
|= FC_PT2PT_PLOGI
;
347 spin_unlock_irq(phba
->host
->host_lock
);
350 * N_Port ID cannot be 0, set our to LocalID the other
351 * side will be RemoteID.
356 phba
->fc_myDID
= PT2PT_LocalID
;
358 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
362 lpfc_config_link(phba
, mbox
);
364 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
365 rc
= lpfc_sli_issue_mbox(phba
, mbox
,
366 MBX_NOWAIT
| MBX_STOP_IOCB
);
367 if (rc
== MBX_NOT_FINISHED
) {
368 mempool_free(mbox
, phba
->mbox_mem_pool
);
371 mempool_free(ndlp
, phba
->nlp_mem_pool
);
373 ndlp
= lpfc_findnode_did(phba
, NLP_SEARCH_ALL
, PT2PT_RemoteID
);
376 * Cannot find existing Fabric ndlp, so allocate a
379 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
383 lpfc_nlp_init(phba
, ndlp
, PT2PT_RemoteID
);
386 memcpy(&ndlp
->nlp_portname
, &sp
->portName
,
387 sizeof(struct lpfc_name
));
388 memcpy(&ndlp
->nlp_nodename
, &sp
->nodeName
,
389 sizeof(struct lpfc_name
));
390 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
391 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
392 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
394 /* This side will wait for the PLOGI */
395 mempool_free( ndlp
, phba
->nlp_mem_pool
);
398 spin_lock_irq(phba
->host
->host_lock
);
399 phba
->fc_flag
|= FC_PT2PT
;
400 spin_unlock_irq(phba
->host
->host_lock
);
402 /* Start discovery - this should just do CLEAR_LA */
403 lpfc_disc_start(phba
);
410 lpfc_cmpl_els_flogi(struct lpfc_hba
* phba
,
411 struct lpfc_iocbq
* cmdiocb
, struct lpfc_iocbq
* rspiocb
)
413 IOCB_t
*irsp
= &rspiocb
->iocb
;
414 struct lpfc_nodelist
*ndlp
= cmdiocb
->context1
;
415 struct lpfc_dmabuf
*pcmd
= cmdiocb
->context2
, *prsp
;
416 struct serv_parm
*sp
;
419 /* Check to see if link went down during discovery */
420 if (lpfc_els_chk_latt(phba
)) {
421 lpfc_nlp_remove(phba
, ndlp
);
425 if (irsp
->ulpStatus
) {
426 /* Check for retry */
427 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
428 /* ELS command is being retried */
431 /* FLOGI failed, so there is no fabric */
432 spin_lock_irq(phba
->host
->host_lock
);
433 phba
->fc_flag
&= ~(FC_FABRIC
| FC_PUBLIC_LOOP
);
434 spin_unlock_irq(phba
->host
->host_lock
);
436 /* If private loop, then allow max outstandting els to be
437 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
438 * alpa map would take too long otherwise.
440 if (phba
->alpa_map
[0] == 0) {
441 phba
->cfg_discovery_threads
=
442 LPFC_MAX_DISC_THREADS
;
446 lpfc_printf_log(phba
,
449 "%d:0100 FLOGI failure Data: x%x x%x\n",
451 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4]);
456 * The FLogI succeeded. Sync the data for the CPU before
459 prsp
= list_get_first(&pcmd
->list
, struct lpfc_dmabuf
, list
);
461 sp
= prsp
->virt
+ sizeof(uint32_t);
463 /* FLOGI completes successfully */
464 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
465 "%d:0101 FLOGI completes sucessfully "
466 "Data: x%x x%x x%x x%x\n",
468 irsp
->un
.ulpWord
[4], sp
->cmn
.e_d_tov
,
469 sp
->cmn
.w2
.r_a_tov
, sp
->cmn
.edtovResolution
);
471 if (phba
->hba_state
== LPFC_FLOGI
) {
473 * If Common Service Parameters indicate Nport
474 * we are point to point, if Fport we are Fabric.
477 rc
= lpfc_cmpl_els_flogi_fabric(phba
, ndlp
, sp
, irsp
);
479 rc
= lpfc_cmpl_els_flogi_nport(phba
, ndlp
, sp
);
486 lpfc_nlp_remove(phba
, ndlp
);
488 if (irsp
->ulpStatus
!= IOSTAT_LOCAL_REJECT
||
489 (irsp
->un
.ulpWord
[4] != IOERR_SLI_ABORTED
&&
490 irsp
->un
.ulpWord
[4] != IOERR_SLI_DOWN
)) {
491 /* FLOGI failed, so just use loop map to make discovery list */
492 lpfc_disc_list_loopmap(phba
);
494 /* Start discovery */
495 lpfc_disc_start(phba
);
499 lpfc_els_free_iocb(phba
, cmdiocb
);
503 lpfc_issue_els_flogi(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
506 struct serv_parm
*sp
;
508 struct lpfc_iocbq
*elsiocb
;
509 struct lpfc_sli_ring
*pring
;
515 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
517 cmdsize
= (sizeof (uint32_t) + sizeof (struct serv_parm
));
518 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
,
519 ndlp
, ELS_CMD_FLOGI
)) == 0) {
523 icmd
= &elsiocb
->iocb
;
524 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
526 /* For FLOGI request, remainder of payload is service parameters */
527 *((uint32_t *) (pcmd
)) = ELS_CMD_FLOGI
;
528 pcmd
+= sizeof (uint32_t);
529 memcpy(pcmd
, &phba
->fc_sparam
, sizeof (struct serv_parm
));
530 sp
= (struct serv_parm
*) pcmd
;
532 /* Setup CSPs accordingly for Fabric */
534 sp
->cmn
.w2
.r_a_tov
= 0;
535 sp
->cls1
.classValid
= 0;
536 sp
->cls2
.seqDelivery
= 1;
537 sp
->cls3
.seqDelivery
= 1;
538 if (sp
->cmn
.fcphLow
< FC_PH3
)
539 sp
->cmn
.fcphLow
= FC_PH3
;
540 if (sp
->cmn
.fcphHigh
< FC_PH3
)
541 sp
->cmn
.fcphHigh
= FC_PH3
;
543 tmo
= phba
->fc_ratov
;
544 phba
->fc_ratov
= LPFC_DISC_FLOGI_TMO
;
545 lpfc_set_disctmo(phba
);
546 phba
->fc_ratov
= tmo
;
548 phba
->fc_stat
.elsXmitFLOGI
++;
549 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_flogi
;
550 spin_lock_irq(phba
->host
->host_lock
);
551 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
552 spin_unlock_irq(phba
->host
->host_lock
);
553 if (rc
== IOCB_ERROR
) {
554 lpfc_els_free_iocb(phba
, elsiocb
);
561 lpfc_els_abort_flogi(struct lpfc_hba
* phba
)
563 struct lpfc_sli_ring
*pring
;
564 struct lpfc_iocbq
*iocb
, *next_iocb
;
565 struct lpfc_nodelist
*ndlp
;
568 /* Abort outstanding I/O on NPort <nlp_DID> */
569 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
570 "%d:0201 Abort outstanding I/O on NPort x%x\n",
571 phba
->brd_no
, Fabric_DID
);
573 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
576 * Check the txcmplq for an iocb that matches the nport the driver is
579 spin_lock_irq(phba
->host
->host_lock
);
580 list_for_each_entry_safe(iocb
, next_iocb
, &pring
->txcmplq
, list
) {
582 if (icmd
->ulpCommand
== CMD_ELS_REQUEST64_CR
) {
583 ndlp
= (struct lpfc_nodelist
*)(iocb
->context1
);
584 if (ndlp
&& (ndlp
->nlp_DID
== Fabric_DID
)) {
585 list_del(&iocb
->list
);
586 pring
->txcmplq_cnt
--;
588 if ((icmd
->un
.elsreq64
.bdl
.ulpIoTag32
)) {
589 lpfc_sli_issue_abort_iotag32
592 if (iocb
->iocb_cmpl
) {
593 icmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
594 icmd
->un
.ulpWord
[4] =
596 spin_unlock_irq(phba
->host
->host_lock
);
597 (iocb
->iocb_cmpl
) (phba
, iocb
, iocb
);
598 spin_lock_irq(phba
->host
->host_lock
);
600 lpfc_sli_release_iocbq(phba
, iocb
);
604 spin_unlock_irq(phba
->host
->host_lock
);
610 lpfc_initial_flogi(struct lpfc_hba
* phba
)
612 struct lpfc_nodelist
*ndlp
;
614 /* First look for Fabric ndlp on the unmapped list */
617 lpfc_findnode_did(phba
, NLP_SEARCH_UNMAPPED
,
619 /* Cannot find existing Fabric ndlp, so allocate a new one */
620 if ((ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
))
624 lpfc_nlp_init(phba
, ndlp
, Fabric_DID
);
627 phba
->fc_unmap_cnt
--;
628 list_del(&ndlp
->nlp_listp
);
629 spin_lock_irq(phba
->host
->host_lock
);
630 ndlp
->nlp_flag
&= ~NLP_LIST_MASK
;
631 spin_unlock_irq(phba
->host
->host_lock
);
633 if (lpfc_issue_els_flogi(phba
, ndlp
, 0)) {
634 mempool_free( ndlp
, phba
->nlp_mem_pool
);
640 lpfc_more_plogi(struct lpfc_hba
* phba
)
644 if (phba
->num_disc_nodes
)
645 phba
->num_disc_nodes
--;
647 /* Continue discovery with <num_disc_nodes> PLOGIs to go */
648 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
649 "%d:0232 Continue discovery with %d PLOGIs to go "
650 "Data: x%x x%x x%x\n",
651 phba
->brd_no
, phba
->num_disc_nodes
, phba
->fc_plogi_cnt
,
652 phba
->fc_flag
, phba
->hba_state
);
654 /* Check to see if there are more PLOGIs to be sent */
655 if (phba
->fc_flag
& FC_NLP_MORE
) {
656 /* go thru NPR list and issue any remaining ELS PLOGIs */
657 sentplogi
= lpfc_els_disc_plogi(phba
);
663 lpfc_cmpl_els_plogi(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
664 struct lpfc_iocbq
* rspiocb
)
667 struct lpfc_sli
*psli
;
668 struct lpfc_nodelist
*ndlp
;
669 int disc
, rc
, did
, type
;
673 /* we pass cmdiocb to state machine which needs rspiocb as well */
674 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
676 irsp
= &rspiocb
->iocb
;
677 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
678 spin_lock_irq(phba
->host
->host_lock
);
679 ndlp
->nlp_flag
&= ~NLP_PLOGI_SND
;
680 spin_unlock_irq(phba
->host
->host_lock
);
682 /* Since ndlp can be freed in the disc state machine, note if this node
683 * is being used during discovery.
685 disc
= (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
);
688 /* PLOGI completes to NPort <nlp_DID> */
689 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
690 "%d:0102 PLOGI completes to NPort x%x "
691 "Data: x%x x%x x%x x%x\n",
692 phba
->brd_no
, ndlp
->nlp_DID
, irsp
->ulpStatus
,
693 irsp
->un
.ulpWord
[4], disc
, phba
->num_disc_nodes
);
695 /* Check to see if link went down during discovery */
696 if (lpfc_els_chk_latt(phba
)) {
697 spin_lock_irq(phba
->host
->host_lock
);
698 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
699 spin_unlock_irq(phba
->host
->host_lock
);
703 /* ndlp could be freed in DSM, save these values now */
704 type
= ndlp
->nlp_type
;
707 if (irsp
->ulpStatus
) {
708 /* Check for retry */
709 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
710 /* ELS command is being retried */
712 spin_lock_irq(phba
->host
->host_lock
);
713 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
714 spin_unlock_irq(phba
->host
->host_lock
);
720 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
721 if ((irsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
722 ((irsp
->un
.ulpWord
[4] == IOERR_SLI_ABORTED
) ||
723 (irsp
->un
.ulpWord
[4] == IOERR_LINK_DOWN
) ||
724 (irsp
->un
.ulpWord
[4] == IOERR_SLI_DOWN
))) {
725 disc
= (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
);
728 rc
= lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
732 /* Good status, call state machine */
733 rc
= lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
737 if (type
& NLP_FABRIC
) {
738 /* If we cannot login to Nameserver, kick off discovery now */
739 if ((did
== NameServer_DID
) && (rc
== NLP_STE_FREED_NODE
)) {
740 lpfc_disc_start(phba
);
745 if (disc
&& phba
->num_disc_nodes
) {
746 /* Check to see if there are more PLOGIs to be sent */
747 lpfc_more_plogi(phba
);
750 if (rc
!= NLP_STE_FREED_NODE
) {
751 spin_lock_irq(phba
->host
->host_lock
);
752 ndlp
->nlp_flag
&= ~NLP_NPR_2B_DISC
;
753 spin_unlock_irq(phba
->host
->host_lock
);
756 if (phba
->num_disc_nodes
== 0) {
758 spin_lock_irq(phba
->host
->host_lock
);
759 phba
->fc_flag
&= ~FC_NDISC_ACTIVE
;
760 spin_unlock_irq(phba
->host
->host_lock
);
762 lpfc_can_disctmo(phba
);
763 if (phba
->fc_flag
& FC_RSCN_MODE
) {
764 /* Check to see if more RSCNs came in while we were
765 * processing this one.
767 if ((phba
->fc_rscn_id_cnt
== 0) &&
768 (!(phba
->fc_flag
& FC_RSCN_DISCOVERY
))) {
769 spin_lock_irq(phba
->host
->host_lock
);
770 phba
->fc_flag
&= ~FC_RSCN_MODE
;
771 spin_unlock_irq(phba
->host
->host_lock
);
773 lpfc_els_handle_rscn(phba
);
779 lpfc_els_free_iocb(phba
, cmdiocb
);
784 lpfc_issue_els_plogi(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
787 struct serv_parm
*sp
;
789 struct lpfc_iocbq
*elsiocb
;
790 struct lpfc_sli_ring
*pring
;
791 struct lpfc_sli
*psli
;
796 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
798 cmdsize
= (sizeof (uint32_t) + sizeof (struct serv_parm
));
799 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
,
800 ndlp
, ELS_CMD_PLOGI
)) == 0) {
804 icmd
= &elsiocb
->iocb
;
805 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
807 /* For PLOGI request, remainder of payload is service parameters */
808 *((uint32_t *) (pcmd
)) = ELS_CMD_PLOGI
;
809 pcmd
+= sizeof (uint32_t);
810 memcpy(pcmd
, &phba
->fc_sparam
, sizeof (struct serv_parm
));
811 sp
= (struct serv_parm
*) pcmd
;
813 if (sp
->cmn
.fcphLow
< FC_PH_4_3
)
814 sp
->cmn
.fcphLow
= FC_PH_4_3
;
816 if (sp
->cmn
.fcphHigh
< FC_PH3
)
817 sp
->cmn
.fcphHigh
= FC_PH3
;
819 phba
->fc_stat
.elsXmitPLOGI
++;
820 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_plogi
;
821 spin_lock_irq(phba
->host
->host_lock
);
822 ndlp
->nlp_flag
|= NLP_PLOGI_SND
;
823 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
824 ndlp
->nlp_flag
&= ~NLP_PLOGI_SND
;
825 spin_unlock_irq(phba
->host
->host_lock
);
826 lpfc_els_free_iocb(phba
, elsiocb
);
829 spin_unlock_irq(phba
->host
->host_lock
);
834 lpfc_cmpl_els_prli(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
835 struct lpfc_iocbq
* rspiocb
)
838 struct lpfc_sli
*psli
;
839 struct lpfc_nodelist
*ndlp
;
842 /* we pass cmdiocb to state machine which needs rspiocb as well */
843 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
845 irsp
= &(rspiocb
->iocb
);
846 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
847 spin_lock_irq(phba
->host
->host_lock
);
848 ndlp
->nlp_flag
&= ~NLP_PRLI_SND
;
849 spin_unlock_irq(phba
->host
->host_lock
);
851 /* PRLI completes to NPort <nlp_DID> */
852 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
853 "%d:0103 PRLI completes to NPort x%x "
854 "Data: x%x x%x x%x\n",
855 phba
->brd_no
, ndlp
->nlp_DID
, irsp
->ulpStatus
,
856 irsp
->un
.ulpWord
[4], phba
->num_disc_nodes
);
858 phba
->fc_prli_sent
--;
859 /* Check to see if link went down during discovery */
860 if (lpfc_els_chk_latt(phba
))
863 if (irsp
->ulpStatus
) {
864 /* Check for retry */
865 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
866 /* ELS command is being retried */
870 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
871 if ((irsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
872 ((irsp
->un
.ulpWord
[4] == IOERR_SLI_ABORTED
) ||
873 (irsp
->un
.ulpWord
[4] == IOERR_LINK_DOWN
) ||
874 (irsp
->un
.ulpWord
[4] == IOERR_SLI_DOWN
))) {
878 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
882 /* Good status, call state machine */
883 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
, NLP_EVT_CMPL_PRLI
);
887 lpfc_els_free_iocb(phba
, cmdiocb
);
892 lpfc_issue_els_prli(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
897 struct lpfc_iocbq
*elsiocb
;
898 struct lpfc_sli_ring
*pring
;
899 struct lpfc_sli
*psli
;
904 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
906 cmdsize
= (sizeof (uint32_t) + sizeof (PRLI
));
907 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
,
908 ndlp
, ELS_CMD_PRLI
)) == 0) {
912 icmd
= &elsiocb
->iocb
;
913 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
915 /* For PRLI request, remainder of payload is service parameters */
916 memset(pcmd
, 0, (sizeof (PRLI
) + sizeof (uint32_t)));
917 *((uint32_t *) (pcmd
)) = ELS_CMD_PRLI
;
918 pcmd
+= sizeof (uint32_t);
920 /* For PRLI, remainder of payload is PRLI parameter page */
923 * If our firmware version is 3.20 or later,
924 * set the following bits for FC-TAPE support.
926 if (phba
->vpd
.rev
.feaLevelHigh
>= 0x02) {
927 npr
->ConfmComplAllowed
= 1;
929 npr
->TaskRetryIdReq
= 1;
931 npr
->estabImagePair
= 1;
932 npr
->readXferRdyDis
= 1;
934 /* For FCP support */
935 npr
->prliType
= PRLI_FCP_TYPE
;
936 npr
->initiatorFunc
= 1;
938 phba
->fc_stat
.elsXmitPRLI
++;
939 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_prli
;
940 spin_lock_irq(phba
->host
->host_lock
);
941 ndlp
->nlp_flag
|= NLP_PRLI_SND
;
942 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
943 ndlp
->nlp_flag
&= ~NLP_PRLI_SND
;
944 spin_unlock_irq(phba
->host
->host_lock
);
945 lpfc_els_free_iocb(phba
, elsiocb
);
948 spin_unlock_irq(phba
->host
->host_lock
);
949 phba
->fc_prli_sent
++;
954 lpfc_more_adisc(struct lpfc_hba
* phba
)
958 if (phba
->num_disc_nodes
)
959 phba
->num_disc_nodes
--;
961 /* Continue discovery with <num_disc_nodes> ADISCs to go */
962 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
963 "%d:0210 Continue discovery with %d ADISCs to go "
964 "Data: x%x x%x x%x\n",
965 phba
->brd_no
, phba
->num_disc_nodes
, phba
->fc_adisc_cnt
,
966 phba
->fc_flag
, phba
->hba_state
);
968 /* Check to see if there are more ADISCs to be sent */
969 if (phba
->fc_flag
& FC_NLP_MORE
) {
970 lpfc_set_disctmo(phba
);
972 /* go thru NPR list and issue any remaining ELS ADISCs */
973 sentadisc
= lpfc_els_disc_adisc(phba
);
979 lpfc_rscn_disc(struct lpfc_hba
* phba
)
982 /* go thru NPR list and issue ELS PLOGIs */
983 if (phba
->fc_npr_cnt
) {
984 if (lpfc_els_disc_plogi(phba
))
987 if (phba
->fc_flag
& FC_RSCN_MODE
) {
988 /* Check to see if more RSCNs came in while we were
989 * processing this one.
991 if ((phba
->fc_rscn_id_cnt
== 0) &&
992 (!(phba
->fc_flag
& FC_RSCN_DISCOVERY
))) {
993 spin_lock_irq(phba
->host
->host_lock
);
994 phba
->fc_flag
&= ~FC_RSCN_MODE
;
995 spin_unlock_irq(phba
->host
->host_lock
);
997 lpfc_els_handle_rscn(phba
);
1003 lpfc_cmpl_els_adisc(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1004 struct lpfc_iocbq
* rspiocb
)
1007 struct lpfc_sli
*psli
;
1008 struct lpfc_nodelist
*ndlp
;
1014 /* we pass cmdiocb to state machine which needs rspiocb as well */
1015 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
1017 irsp
= &(rspiocb
->iocb
);
1018 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1019 spin_lock_irq(phba
->host
->host_lock
);
1020 ndlp
->nlp_flag
&= ~NLP_ADISC_SND
;
1021 spin_unlock_irq(phba
->host
->host_lock
);
1023 /* Since ndlp can be freed in the disc state machine, note if this node
1024 * is being used during discovery.
1026 disc
= (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
);
1028 /* ADISC completes to NPort <nlp_DID> */
1029 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1030 "%d:0104 ADISC completes to NPort x%x "
1031 "Data: x%x x%x x%x x%x\n",
1032 phba
->brd_no
, ndlp
->nlp_DID
, irsp
->ulpStatus
,
1033 irsp
->un
.ulpWord
[4], disc
, phba
->num_disc_nodes
);
1035 /* Check to see if link went down during discovery */
1036 if (lpfc_els_chk_latt(phba
)) {
1037 spin_lock_irq(phba
->host
->host_lock
);
1038 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
1039 spin_unlock_irq(phba
->host
->host_lock
);
1043 if (irsp
->ulpStatus
) {
1044 /* Check for retry */
1045 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
1046 /* ELS command is being retried */
1048 spin_lock_irq(phba
->host
->host_lock
);
1049 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
1050 spin_unlock_irq(phba
->host
->host_lock
);
1051 lpfc_set_disctmo(phba
);
1056 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1057 if ((irsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
1058 ((irsp
->un
.ulpWord
[4] == IOERR_SLI_ABORTED
) ||
1059 (irsp
->un
.ulpWord
[4] == IOERR_LINK_DOWN
) ||
1060 (irsp
->un
.ulpWord
[4] == IOERR_SLI_DOWN
))) {
1061 disc
= (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
);
1064 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
1065 NLP_EVT_CMPL_ADISC
);
1068 /* Good status, call state machine */
1069 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
1070 NLP_EVT_CMPL_ADISC
);
1073 if (disc
&& phba
->num_disc_nodes
) {
1074 /* Check to see if there are more ADISCs to be sent */
1075 lpfc_more_adisc(phba
);
1077 /* Check to see if we are done with ADISC authentication */
1078 if (phba
->num_disc_nodes
== 0) {
1079 lpfc_can_disctmo(phba
);
1080 /* If we get here, there is nothing left to wait for */
1081 if ((phba
->hba_state
< LPFC_HBA_READY
) &&
1082 (phba
->hba_state
!= LPFC_CLEAR_LA
)) {
1083 /* Link up discovery */
1084 if ((mbox
= mempool_alloc(phba
->mbox_mem_pool
,
1086 phba
->hba_state
= LPFC_CLEAR_LA
;
1087 lpfc_clear_la(phba
, mbox
);
1089 lpfc_mbx_cmpl_clear_la
;
1090 rc
= lpfc_sli_issue_mbox
1092 (MBX_NOWAIT
| MBX_STOP_IOCB
));
1093 if (rc
== MBX_NOT_FINISHED
) {
1095 phba
->mbox_mem_pool
);
1096 lpfc_disc_flush_list(phba
);
1097 psli
->ring
[(psli
->ip_ring
)].
1099 ~LPFC_STOP_IOCB_EVENT
;
1100 psli
->ring
[(psli
->fcp_ring
)].
1102 ~LPFC_STOP_IOCB_EVENT
;
1103 psli
->ring
[(psli
->next_ring
)].
1105 ~LPFC_STOP_IOCB_EVENT
;
1111 lpfc_rscn_disc(phba
);
1115 spin_lock_irq(phba
->host
->host_lock
);
1116 ndlp
->nlp_flag
&= ~NLP_NPR_2B_DISC
;
1117 spin_unlock_irq(phba
->host
->host_lock
);
1119 lpfc_els_free_iocb(phba
, cmdiocb
);
1124 lpfc_issue_els_adisc(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
1129 struct lpfc_iocbq
*elsiocb
;
1130 struct lpfc_sli_ring
*pring
;
1131 struct lpfc_sli
*psli
;
1136 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
1138 cmdsize
= (sizeof (uint32_t) + sizeof (ADISC
));
1139 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
,
1140 ndlp
, ELS_CMD_ADISC
)) == 0) {
1144 icmd
= &elsiocb
->iocb
;
1145 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1147 /* For ADISC request, remainder of payload is service parameters */
1148 *((uint32_t *) (pcmd
)) = ELS_CMD_ADISC
;
1149 pcmd
+= sizeof (uint32_t);
1151 /* Fill in ADISC payload */
1152 ap
= (ADISC
*) pcmd
;
1153 ap
->hardAL_PA
= phba
->fc_pref_ALPA
;
1154 memcpy(&ap
->portName
, &phba
->fc_portname
, sizeof (struct lpfc_name
));
1155 memcpy(&ap
->nodeName
, &phba
->fc_nodename
, sizeof (struct lpfc_name
));
1156 ap
->DID
= be32_to_cpu(phba
->fc_myDID
);
1158 phba
->fc_stat
.elsXmitADISC
++;
1159 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_adisc
;
1160 spin_lock_irq(phba
->host
->host_lock
);
1161 ndlp
->nlp_flag
|= NLP_ADISC_SND
;
1162 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
1163 ndlp
->nlp_flag
&= ~NLP_ADISC_SND
;
1164 spin_unlock_irq(phba
->host
->host_lock
);
1165 lpfc_els_free_iocb(phba
, elsiocb
);
1168 spin_unlock_irq(phba
->host
->host_lock
);
1173 lpfc_cmpl_els_logo(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1174 struct lpfc_iocbq
* rspiocb
)
1177 struct lpfc_sli
*psli
;
1178 struct lpfc_nodelist
*ndlp
;
1181 /* we pass cmdiocb to state machine which needs rspiocb as well */
1182 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
1184 irsp
= &(rspiocb
->iocb
);
1185 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1186 spin_lock_irq(phba
->host
->host_lock
);
1187 ndlp
->nlp_flag
&= ~NLP_LOGO_SND
;
1188 spin_unlock_irq(phba
->host
->host_lock
);
1190 /* LOGO completes to NPort <nlp_DID> */
1191 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1192 "%d:0105 LOGO completes to NPort x%x "
1193 "Data: x%x x%x x%x\n",
1194 phba
->brd_no
, ndlp
->nlp_DID
, irsp
->ulpStatus
,
1195 irsp
->un
.ulpWord
[4], phba
->num_disc_nodes
);
1197 /* Check to see if link went down during discovery */
1198 if (lpfc_els_chk_latt(phba
))
1201 if (irsp
->ulpStatus
) {
1202 /* Check for retry */
1203 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
1204 /* ELS command is being retried */
1208 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1209 if ((irsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
1210 ((irsp
->un
.ulpWord
[4] == IOERR_SLI_ABORTED
) ||
1211 (irsp
->un
.ulpWord
[4] == IOERR_LINK_DOWN
) ||
1212 (irsp
->un
.ulpWord
[4] == IOERR_SLI_DOWN
))) {
1216 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
1220 /* Good status, call state machine */
1221 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
, NLP_EVT_CMPL_LOGO
);
1223 if (ndlp
->nlp_flag
& NLP_DELAY_TMO
) {
1224 lpfc_unreg_rpi(phba
, ndlp
);
1229 lpfc_els_free_iocb(phba
, cmdiocb
);
1234 lpfc_issue_els_logo(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
1238 struct lpfc_iocbq
*elsiocb
;
1239 struct lpfc_sli_ring
*pring
;
1240 struct lpfc_sli
*psli
;
1245 pring
= &psli
->ring
[LPFC_ELS_RING
];
1247 cmdsize
= 2 * (sizeof (uint32_t) + sizeof (struct lpfc_name
));
1248 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
,
1249 ndlp
, ELS_CMD_LOGO
)) == 0) {
1253 icmd
= &elsiocb
->iocb
;
1254 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1255 *((uint32_t *) (pcmd
)) = ELS_CMD_LOGO
;
1256 pcmd
+= sizeof (uint32_t);
1258 /* Fill in LOGO payload */
1259 *((uint32_t *) (pcmd
)) = be32_to_cpu(phba
->fc_myDID
);
1260 pcmd
+= sizeof (uint32_t);
1261 memcpy(pcmd
, &phba
->fc_portname
, sizeof (struct lpfc_name
));
1263 phba
->fc_stat
.elsXmitLOGO
++;
1264 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_logo
;
1265 spin_lock_irq(phba
->host
->host_lock
);
1266 ndlp
->nlp_flag
|= NLP_LOGO_SND
;
1267 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
1268 ndlp
->nlp_flag
&= ~NLP_LOGO_SND
;
1269 spin_unlock_irq(phba
->host
->host_lock
);
1270 lpfc_els_free_iocb(phba
, elsiocb
);
1273 spin_unlock_irq(phba
->host
->host_lock
);
1278 lpfc_cmpl_els_cmd(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1279 struct lpfc_iocbq
* rspiocb
)
1283 irsp
= &rspiocb
->iocb
;
1285 /* ELS cmd tag <ulpIoTag> completes */
1286 lpfc_printf_log(phba
,
1289 "%d:0106 ELS cmd tag x%x completes Data: x%x x%x\n",
1291 irsp
->ulpIoTag
, irsp
->ulpStatus
, irsp
->un
.ulpWord
[4]);
1293 /* Check to see if link went down during discovery */
1294 lpfc_els_chk_latt(phba
);
1295 lpfc_els_free_iocb(phba
, cmdiocb
);
1300 lpfc_issue_els_scr(struct lpfc_hba
* phba
, uint32_t nportid
, uint8_t retry
)
1303 struct lpfc_iocbq
*elsiocb
;
1304 struct lpfc_sli_ring
*pring
;
1305 struct lpfc_sli
*psli
;
1308 struct lpfc_nodelist
*ndlp
;
1311 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
1312 cmdsize
= (sizeof (uint32_t) + sizeof (SCR
));
1313 if ((ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
)) == 0) {
1317 lpfc_nlp_init(phba
, ndlp
, nportid
);
1319 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
,
1320 ndlp
, ELS_CMD_SCR
)) == 0) {
1321 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1325 icmd
= &elsiocb
->iocb
;
1326 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1328 *((uint32_t *) (pcmd
)) = ELS_CMD_SCR
;
1329 pcmd
+= sizeof (uint32_t);
1331 /* For SCR, remainder of payload is SCR parameter page */
1332 memset(pcmd
, 0, sizeof (SCR
));
1333 ((SCR
*) pcmd
)->Function
= SCR_FUNC_FULL
;
1335 phba
->fc_stat
.elsXmitSCR
++;
1336 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_cmd
;
1337 spin_lock_irq(phba
->host
->host_lock
);
1338 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
1339 spin_unlock_irq(phba
->host
->host_lock
);
1340 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1341 lpfc_els_free_iocb(phba
, elsiocb
);
1344 spin_unlock_irq(phba
->host
->host_lock
);
1345 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1350 lpfc_issue_els_farpr(struct lpfc_hba
* phba
, uint32_t nportid
, uint8_t retry
)
1353 struct lpfc_iocbq
*elsiocb
;
1354 struct lpfc_sli_ring
*pring
;
1355 struct lpfc_sli
*psli
;
1360 struct lpfc_nodelist
*ondlp
;
1361 struct lpfc_nodelist
*ndlp
;
1364 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
1365 cmdsize
= (sizeof (uint32_t) + sizeof (FARP
));
1366 if ((ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
)) == 0) {
1369 lpfc_nlp_init(phba
, ndlp
, nportid
);
1371 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
,
1372 ndlp
, ELS_CMD_RNID
)) == 0) {
1373 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1377 icmd
= &elsiocb
->iocb
;
1378 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1380 *((uint32_t *) (pcmd
)) = ELS_CMD_FARPR
;
1381 pcmd
+= sizeof (uint32_t);
1383 /* Fill in FARPR payload */
1384 fp
= (FARP
*) (pcmd
);
1385 memset(fp
, 0, sizeof (FARP
));
1386 lp
= (uint32_t *) pcmd
;
1387 *lp
++ = be32_to_cpu(nportid
);
1388 *lp
++ = be32_to_cpu(phba
->fc_myDID
);
1390 fp
->Mflags
= (FARP_MATCH_PORT
| FARP_MATCH_NODE
);
1392 memcpy(&fp
->RportName
, &phba
->fc_portname
, sizeof (struct lpfc_name
));
1393 memcpy(&fp
->RnodeName
, &phba
->fc_nodename
, sizeof (struct lpfc_name
));
1394 if ((ondlp
= lpfc_findnode_did(phba
, NLP_SEARCH_ALL
, nportid
))) {
1395 memcpy(&fp
->OportName
, &ondlp
->nlp_portname
,
1396 sizeof (struct lpfc_name
));
1397 memcpy(&fp
->OnodeName
, &ondlp
->nlp_nodename
,
1398 sizeof (struct lpfc_name
));
1401 phba
->fc_stat
.elsXmitFARPR
++;
1402 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_cmd
;
1403 spin_lock_irq(phba
->host
->host_lock
);
1404 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
1405 spin_unlock_irq(phba
->host
->host_lock
);
1406 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1407 lpfc_els_free_iocb(phba
, elsiocb
);
1410 spin_unlock_irq(phba
->host
->host_lock
);
1411 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1416 lpfc_els_retry_delay(unsigned long ptr
)
1418 struct lpfc_nodelist
*ndlp
;
1419 struct lpfc_hba
*phba
;
1420 unsigned long iflag
;
1421 struct lpfc_work_evt
*evtp
;
1423 ndlp
= (struct lpfc_nodelist
*)ptr
;
1424 phba
= ndlp
->nlp_phba
;
1425 evtp
= &ndlp
->els_retry_evt
;
1427 spin_lock_irqsave(phba
->host
->host_lock
, iflag
);
1428 if (!list_empty(&evtp
->evt_listp
)) {
1429 spin_unlock_irqrestore(phba
->host
->host_lock
, iflag
);
1433 evtp
->evt_arg1
= ndlp
;
1434 evtp
->evt
= LPFC_EVT_ELS_RETRY
;
1435 list_add_tail(&evtp
->evt_listp
, &phba
->work_list
);
1436 if (phba
->work_wait
)
1437 wake_up(phba
->work_wait
);
1439 spin_unlock_irqrestore(phba
->host
->host_lock
, iflag
);
1444 lpfc_els_retry_delay_handler(struct lpfc_nodelist
*ndlp
)
1446 struct lpfc_hba
*phba
;
1451 phba
= ndlp
->nlp_phba
;
1452 spin_lock_irq(phba
->host
->host_lock
);
1453 did
= (uint32_t) (ndlp
->nlp_DID
);
1454 cmd
= (uint32_t) (ndlp
->nlp_last_elscmd
);
1456 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
)) {
1457 spin_unlock_irq(phba
->host
->host_lock
);
1461 ndlp
->nlp_flag
&= ~NLP_DELAY_TMO
;
1462 spin_unlock_irq(phba
->host
->host_lock
);
1463 retry
= ndlp
->nlp_retry
;
1467 lpfc_issue_els_flogi(phba
, ndlp
, retry
);
1470 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
1471 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
1472 lpfc_issue_els_plogi(phba
, ndlp
, retry
);
1475 ndlp
->nlp_state
= NLP_STE_ADISC_ISSUE
;
1476 lpfc_nlp_list(phba
, ndlp
, NLP_ADISC_LIST
);
1477 lpfc_issue_els_adisc(phba
, ndlp
, retry
);
1480 ndlp
->nlp_state
= NLP_STE_PRLI_ISSUE
;
1481 lpfc_nlp_list(phba
, ndlp
, NLP_PRLI_LIST
);
1482 lpfc_issue_els_prli(phba
, ndlp
, retry
);
1485 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1486 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1487 lpfc_issue_els_logo(phba
, ndlp
, retry
);
1494 lpfc_els_retry(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1495 struct lpfc_iocbq
* rspiocb
)
1498 struct lpfc_dmabuf
*pcmd
;
1499 struct lpfc_nodelist
*ndlp
;
1502 int retry
, maxretry
;
1508 maxretry
= lpfc_max_els_tries
;
1509 irsp
= &rspiocb
->iocb
;
1510 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1511 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
1513 /* Note: context2 may be 0 for internal driver abort
1514 * of delays ELS command.
1517 if (pcmd
&& pcmd
->virt
) {
1518 elscmd
= (uint32_t *) (pcmd
->virt
);
1522 switch (irsp
->ulpStatus
) {
1523 case IOSTAT_FCP_RSP_ERROR
:
1524 case IOSTAT_REMOTE_STOP
:
1527 case IOSTAT_LOCAL_REJECT
:
1528 switch ((irsp
->un
.ulpWord
[4] & 0xff)) {
1529 case IOERR_LOOP_OPEN_FAILURE
:
1530 if (cmd
== ELS_CMD_PLOGI
) {
1531 if (cmdiocb
->retry
== 0) {
1538 case IOERR_SEQUENCE_TIMEOUT
:
1540 if ((cmd
== ELS_CMD_FLOGI
)
1541 && (phba
->fc_topology
!= TOPOLOGY_LOOP
)) {
1547 case IOERR_NO_RESOURCES
:
1548 if (cmd
== ELS_CMD_PLOGI
) {
1554 case IOERR_INVALID_RPI
:
1560 case IOSTAT_NPORT_RJT
:
1561 case IOSTAT_FABRIC_RJT
:
1562 if (irsp
->un
.ulpWord
[4] & RJT_UNAVAIL_TEMP
) {
1568 case IOSTAT_NPORT_BSY
:
1569 case IOSTAT_FABRIC_BSY
:
1574 stat
.un
.lsRjtError
= be32_to_cpu(irsp
->un
.ulpWord
[4]);
1575 /* Added for Vendor specifc support
1576 * Just keep retrying for these Rsn / Exp codes
1578 switch (stat
.un
.b
.lsRjtRsnCode
) {
1579 case LSRJT_UNABLE_TPC
:
1580 if (stat
.un
.b
.lsRjtRsnCodeExp
==
1581 LSEXP_CMD_IN_PROGRESS
) {
1582 if (cmd
== ELS_CMD_PLOGI
) {
1589 if (cmd
== ELS_CMD_PLOGI
) {
1591 maxretry
= lpfc_max_els_tries
+ 1;
1597 case LSRJT_LOGICAL_BSY
:
1598 if (cmd
== ELS_CMD_PLOGI
) {
1607 case IOSTAT_INTERMED_RSP
:
1615 if (ndlp
->nlp_DID
== FDMI_DID
) {
1619 if ((++cmdiocb
->retry
) >= maxretry
) {
1620 phba
->fc_stat
.elsRetryExceeded
++;
1626 /* Retry ELS command <elsCmd> to remote NPORT <did> */
1627 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1628 "%d:0107 Retry ELS command x%x to remote "
1629 "NPORT x%x Data: x%x x%x\n",
1631 cmd
, ndlp
->nlp_DID
, cmdiocb
->retry
, delay
);
1633 if ((cmd
== ELS_CMD_PLOGI
) || (cmd
== ELS_CMD_ADISC
)) {
1634 /* If discovery / RSCN timer is running, reset it */
1635 if (timer_pending(&phba
->fc_disctmo
) ||
1636 (phba
->fc_flag
& FC_RSCN_MODE
)) {
1637 lpfc_set_disctmo(phba
);
1641 phba
->fc_stat
.elsXmitRetry
++;
1643 phba
->fc_stat
.elsDelayRetry
++;
1644 ndlp
->nlp_retry
= cmdiocb
->retry
;
1646 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
);
1647 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
1649 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1650 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1651 ndlp
->nlp_last_elscmd
= cmd
;
1657 lpfc_issue_els_flogi(phba
, ndlp
, cmdiocb
->retry
);
1660 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
1661 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
1662 lpfc_issue_els_plogi(phba
, ndlp
, cmdiocb
->retry
);
1665 ndlp
->nlp_state
= NLP_STE_ADISC_ISSUE
;
1666 lpfc_nlp_list(phba
, ndlp
, NLP_ADISC_LIST
);
1667 lpfc_issue_els_adisc(phba
, ndlp
, cmdiocb
->retry
);
1670 ndlp
->nlp_state
= NLP_STE_PRLI_ISSUE
;
1671 lpfc_nlp_list(phba
, ndlp
, NLP_PRLI_LIST
);
1672 lpfc_issue_els_prli(phba
, ndlp
, cmdiocb
->retry
);
1675 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1676 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1677 lpfc_issue_els_logo(phba
, ndlp
, cmdiocb
->retry
);
1682 /* No retry ELS command <elsCmd> to remote NPORT <did> */
1683 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1684 "%d:0108 No retry ELS command x%x to remote NPORT x%x "
1687 cmd
, ndlp
->nlp_DID
, cmdiocb
->retry
, ndlp
->nlp_flag
);
1693 lpfc_els_free_iocb(struct lpfc_hba
* phba
, struct lpfc_iocbq
* elsiocb
)
1695 struct lpfc_dmabuf
*buf_ptr
, *buf_ptr1
;
1697 /* context2 = cmd, context2->next = rsp, context3 = bpl */
1698 if (elsiocb
->context2
) {
1699 buf_ptr1
= (struct lpfc_dmabuf
*) elsiocb
->context2
;
1700 /* Free the response before processing the command. */
1701 if (!list_empty(&buf_ptr1
->list
)) {
1702 list_remove_head(&buf_ptr1
->list
, buf_ptr
,
1705 lpfc_mbuf_free(phba
, buf_ptr
->virt
, buf_ptr
->phys
);
1708 lpfc_mbuf_free(phba
, buf_ptr1
->virt
, buf_ptr1
->phys
);
1712 if (elsiocb
->context3
) {
1713 buf_ptr
= (struct lpfc_dmabuf
*) elsiocb
->context3
;
1714 lpfc_mbuf_free(phba
, buf_ptr
->virt
, buf_ptr
->phys
);
1717 spin_lock_irq(phba
->host
->host_lock
);
1718 lpfc_sli_release_iocbq(phba
, elsiocb
);
1719 spin_unlock_irq(phba
->host
->host_lock
);
1724 lpfc_cmpl_els_logo_acc(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1725 struct lpfc_iocbq
* rspiocb
)
1727 struct lpfc_nodelist
*ndlp
;
1729 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1731 /* ACC to LOGO completes to NPort <nlp_DID> */
1732 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1733 "%d:0109 ACC to LOGO completes to NPort x%x "
1734 "Data: x%x x%x x%x\n",
1735 phba
->brd_no
, ndlp
->nlp_DID
, ndlp
->nlp_flag
,
1736 ndlp
->nlp_state
, ndlp
->nlp_rpi
);
1738 spin_lock_irq(phba
->host
->host_lock
);
1739 ndlp
->nlp_flag
&= ~NLP_LOGO_ACC
;
1740 spin_unlock_irq(phba
->host
->host_lock
);
1742 switch (ndlp
->nlp_state
) {
1743 case NLP_STE_UNUSED_NODE
: /* node is just allocated */
1744 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1746 case NLP_STE_NPR_NODE
: /* NPort Recovery mode */
1747 lpfc_unreg_rpi(phba
, ndlp
);
1752 lpfc_els_free_iocb(phba
, cmdiocb
);
1757 lpfc_cmpl_els_acc(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1758 struct lpfc_iocbq
* rspiocb
)
1760 struct lpfc_nodelist
*ndlp
;
1761 LPFC_MBOXQ_t
*mbox
= NULL
;
1763 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1764 if (cmdiocb
->context_un
.mbox
)
1765 mbox
= cmdiocb
->context_un
.mbox
;
1768 /* Check to see if link went down during discovery */
1769 if ((lpfc_els_chk_latt(phba
)) || !ndlp
) {
1771 mempool_free( mbox
, phba
->mbox_mem_pool
);
1776 /* ELS response tag <ulpIoTag> completes */
1777 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1778 "%d:0110 ELS response tag x%x completes "
1779 "Data: x%x x%x x%x x%x x%x x%x\n",
1781 cmdiocb
->iocb
.ulpIoTag
, rspiocb
->iocb
.ulpStatus
,
1782 rspiocb
->iocb
.un
.ulpWord
[4], ndlp
->nlp_DID
,
1783 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
1786 if ((rspiocb
->iocb
.ulpStatus
== 0)
1787 && (ndlp
->nlp_flag
& NLP_ACC_REGLOGIN
)) {
1788 /* set_slim mailbox command needs to execute first,
1789 * queue this command to be processed later.
1791 lpfc_unreg_rpi(phba
, ndlp
);
1792 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_reg_login
;
1793 mbox
->context2
= ndlp
;
1794 ndlp
->nlp_state
= NLP_STE_REG_LOGIN_ISSUE
;
1795 lpfc_nlp_list(phba
, ndlp
, NLP_REGLOGIN_LIST
);
1796 if (lpfc_sli_issue_mbox(phba
, mbox
,
1797 (MBX_NOWAIT
| MBX_STOP_IOCB
))
1798 != MBX_NOT_FINISHED
) {
1801 /* NOTE: we should have messages for unsuccessful
1803 mempool_free( mbox
, phba
->mbox_mem_pool
);
1805 mempool_free( mbox
, phba
->mbox_mem_pool
);
1806 if (ndlp
->nlp_flag
& NLP_ACC_REGLOGIN
) {
1807 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1813 spin_lock_irq(phba
->host
->host_lock
);
1814 ndlp
->nlp_flag
&= ~NLP_ACC_REGLOGIN
;
1815 spin_unlock_irq(phba
->host
->host_lock
);
1817 lpfc_els_free_iocb(phba
, cmdiocb
);
1822 lpfc_els_rsp_acc(struct lpfc_hba
* phba
, uint32_t flag
,
1823 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
,
1824 LPFC_MBOXQ_t
* mbox
, uint8_t newnode
)
1828 struct lpfc_iocbq
*elsiocb
;
1829 struct lpfc_sli_ring
*pring
;
1830 struct lpfc_sli
*psli
;
1836 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
1837 oldcmd
= &oldiocb
->iocb
;
1841 cmdsize
= sizeof (uint32_t);
1843 lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
1844 ndlp
, ELS_CMD_ACC
)) == 0) {
1847 icmd
= &elsiocb
->iocb
;
1848 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
1849 pcmd
= (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1850 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
1851 pcmd
+= sizeof (uint32_t);
1854 cmdsize
= (sizeof (struct serv_parm
) + sizeof (uint32_t));
1856 lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
1857 ndlp
, ELS_CMD_ACC
)) == 0) {
1860 icmd
= &elsiocb
->iocb
;
1861 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
1862 pcmd
= (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1865 elsiocb
->context_un
.mbox
= mbox
;
1867 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
1868 pcmd
+= sizeof (uint32_t);
1869 memcpy(pcmd
, &phba
->fc_sparam
, sizeof (struct serv_parm
));
1876 elsiocb
->context1
= NULL
;
1878 /* Xmit ELS ACC response tag <ulpIoTag> */
1879 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1880 "%d:0128 Xmit ELS ACC response tag x%x "
1881 "Data: x%x x%x x%x x%x x%x\n",
1883 elsiocb
->iocb
.ulpIoTag
,
1884 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
1885 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
1887 if (ndlp
->nlp_flag
& NLP_LOGO_ACC
) {
1888 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_logo_acc
;
1890 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
1893 phba
->fc_stat
.elsXmitACC
++;
1894 spin_lock_irq(phba
->host
->host_lock
);
1895 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
1896 spin_unlock_irq(phba
->host
->host_lock
);
1897 if (rc
== IOCB_ERROR
) {
1898 lpfc_els_free_iocb(phba
, elsiocb
);
1905 lpfc_els_rsp_reject(struct lpfc_hba
* phba
, uint32_t rejectError
,
1906 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
)
1910 struct lpfc_iocbq
*elsiocb
;
1911 struct lpfc_sli_ring
*pring
;
1912 struct lpfc_sli
*psli
;
1918 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
1920 cmdsize
= 2 * sizeof (uint32_t);
1921 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
1922 ndlp
, ELS_CMD_LS_RJT
)) == 0) {
1926 icmd
= &elsiocb
->iocb
;
1927 oldcmd
= &oldiocb
->iocb
;
1928 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
1929 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1931 *((uint32_t *) (pcmd
)) = ELS_CMD_LS_RJT
;
1932 pcmd
+= sizeof (uint32_t);
1933 *((uint32_t *) (pcmd
)) = rejectError
;
1935 /* Xmit ELS RJT <err> response tag <ulpIoTag> */
1936 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1937 "%d:0129 Xmit ELS RJT x%x response tag x%x "
1938 "Data: x%x x%x x%x x%x x%x\n",
1940 rejectError
, elsiocb
->iocb
.ulpIoTag
,
1941 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
1942 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
1944 phba
->fc_stat
.elsXmitLSRJT
++;
1945 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
1946 spin_lock_irq(phba
->host
->host_lock
);
1947 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
1948 spin_unlock_irq(phba
->host
->host_lock
);
1949 if (rc
== IOCB_ERROR
) {
1950 lpfc_els_free_iocb(phba
, elsiocb
);
1957 lpfc_els_rsp_adisc_acc(struct lpfc_hba
* phba
,
1958 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
)
1963 struct lpfc_iocbq
*elsiocb
;
1964 struct lpfc_sli_ring
*pring
;
1965 struct lpfc_sli
*psli
;
1971 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
1973 cmdsize
= sizeof (uint32_t) + sizeof (ADISC
);
1974 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
1975 ndlp
, ELS_CMD_ACC
)) == 0) {
1979 /* Xmit ADISC ACC response tag <ulpIoTag> */
1980 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1981 "%d:0130 Xmit ADISC ACC response tag x%x "
1982 "Data: x%x x%x x%x x%x x%x\n",
1984 elsiocb
->iocb
.ulpIoTag
,
1985 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
1986 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
1988 icmd
= &elsiocb
->iocb
;
1989 oldcmd
= &oldiocb
->iocb
;
1990 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
1991 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1993 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
1994 pcmd
+= sizeof (uint32_t);
1996 ap
= (ADISC
*) (pcmd
);
1997 ap
->hardAL_PA
= phba
->fc_pref_ALPA
;
1998 memcpy(&ap
->portName
, &phba
->fc_portname
, sizeof (struct lpfc_name
));
1999 memcpy(&ap
->nodeName
, &phba
->fc_nodename
, sizeof (struct lpfc_name
));
2000 ap
->DID
= be32_to_cpu(phba
->fc_myDID
);
2002 phba
->fc_stat
.elsXmitACC
++;
2003 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
2004 spin_lock_irq(phba
->host
->host_lock
);
2005 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
2006 spin_unlock_irq(phba
->host
->host_lock
);
2007 if (rc
== IOCB_ERROR
) {
2008 lpfc_els_free_iocb(phba
, elsiocb
);
2015 lpfc_els_rsp_prli_acc(struct lpfc_hba
* phba
,
2016 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
)
2022 struct lpfc_iocbq
*elsiocb
;
2023 struct lpfc_sli_ring
*pring
;
2024 struct lpfc_sli
*psli
;
2030 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
2032 cmdsize
= sizeof (uint32_t) + sizeof (PRLI
);
2033 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
2036 (ELS_CMD_PRLI
& ~ELS_RSP_MASK
)))) ==
2041 /* Xmit PRLI ACC response tag <ulpIoTag> */
2042 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
2043 "%d:0131 Xmit PRLI ACC response tag x%x "
2044 "Data: x%x x%x x%x x%x x%x\n",
2046 elsiocb
->iocb
.ulpIoTag
,
2047 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
2048 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
2050 icmd
= &elsiocb
->iocb
;
2051 oldcmd
= &oldiocb
->iocb
;
2052 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
2053 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2055 *((uint32_t *) (pcmd
)) = (ELS_CMD_ACC
| (ELS_CMD_PRLI
& ~ELS_RSP_MASK
));
2056 pcmd
+= sizeof (uint32_t);
2058 /* For PRLI, remainder of payload is PRLI parameter page */
2059 memset(pcmd
, 0, sizeof (PRLI
));
2061 npr
= (PRLI
*) pcmd
;
2064 * If our firmware version is 3.20 or later,
2065 * set the following bits for FC-TAPE support.
2067 if (vpd
->rev
.feaLevelHigh
>= 0x02) {
2068 npr
->ConfmComplAllowed
= 1;
2070 npr
->TaskRetryIdReq
= 1;
2073 npr
->acceptRspCode
= PRLI_REQ_EXECUTED
;
2074 npr
->estabImagePair
= 1;
2075 npr
->readXferRdyDis
= 1;
2076 npr
->ConfmComplAllowed
= 1;
2078 npr
->prliType
= PRLI_FCP_TYPE
;
2079 npr
->initiatorFunc
= 1;
2081 phba
->fc_stat
.elsXmitACC
++;
2082 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
2084 spin_lock_irq(phba
->host
->host_lock
);
2085 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
2086 spin_unlock_irq(phba
->host
->host_lock
);
2087 if (rc
== IOCB_ERROR
) {
2088 lpfc_els_free_iocb(phba
, elsiocb
);
2095 lpfc_els_rsp_rnid_acc(struct lpfc_hba
* phba
,
2097 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
)
2102 struct lpfc_iocbq
*elsiocb
;
2103 struct lpfc_sli_ring
*pring
;
2104 struct lpfc_sli
*psli
;
2110 pring
= &psli
->ring
[LPFC_ELS_RING
];
2112 cmdsize
= sizeof (uint32_t) + sizeof (uint32_t)
2113 + (2 * sizeof (struct lpfc_name
));
2115 cmdsize
+= sizeof (RNID_TOP_DISC
);
2117 if ((elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
2118 ndlp
, ELS_CMD_ACC
)) == 0) {
2122 /* Xmit RNID ACC response tag <ulpIoTag> */
2123 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
2124 "%d:0132 Xmit RNID ACC response tag x%x "
2127 elsiocb
->iocb
.ulpIoTag
,
2128 elsiocb
->iocb
.ulpContext
);
2130 icmd
= &elsiocb
->iocb
;
2131 oldcmd
= &oldiocb
->iocb
;
2132 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
2133 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2135 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
2136 pcmd
+= sizeof (uint32_t);
2138 memset(pcmd
, 0, sizeof (RNID
));
2139 rn
= (RNID
*) (pcmd
);
2140 rn
->Format
= format
;
2141 rn
->CommonLen
= (2 * sizeof (struct lpfc_name
));
2142 memcpy(&rn
->portName
, &phba
->fc_portname
, sizeof (struct lpfc_name
));
2143 memcpy(&rn
->nodeName
, &phba
->fc_nodename
, sizeof (struct lpfc_name
));
2146 rn
->SpecificLen
= 0;
2148 case RNID_TOPOLOGY_DISC
:
2149 rn
->SpecificLen
= sizeof (RNID_TOP_DISC
);
2150 memcpy(&rn
->un
.topologyDisc
.portName
,
2151 &phba
->fc_portname
, sizeof (struct lpfc_name
));
2152 rn
->un
.topologyDisc
.unitType
= RNID_HBA
;
2153 rn
->un
.topologyDisc
.physPort
= 0;
2154 rn
->un
.topologyDisc
.attachedNodes
= 0;
2158 rn
->SpecificLen
= 0;
2162 phba
->fc_stat
.elsXmitACC
++;
2163 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
2164 elsiocb
->context1
= NULL
; /* Don't need ndlp for cmpl,
2165 * it could be freed */
2167 spin_lock_irq(phba
->host
->host_lock
);
2168 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
2169 spin_unlock_irq(phba
->host
->host_lock
);
2170 if (rc
== IOCB_ERROR
) {
2171 lpfc_els_free_iocb(phba
, elsiocb
);
2178 lpfc_els_disc_adisc(struct lpfc_hba
* phba
)
2181 struct lpfc_nodelist
*ndlp
, *next_ndlp
;
2184 /* go thru NPR list and issue any remaining ELS ADISCs */
2185 list_for_each_entry_safe(ndlp
, next_ndlp
, &phba
->fc_npr_list
,
2187 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
2188 if (ndlp
->nlp_flag
& NLP_NPR_ADISC
) {
2189 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
2190 ndlp
->nlp_state
= NLP_STE_ADISC_ISSUE
;
2191 lpfc_nlp_list(phba
, ndlp
,
2193 lpfc_issue_els_adisc(phba
, ndlp
, 0);
2195 phba
->num_disc_nodes
++;
2196 if (phba
->num_disc_nodes
>=
2197 phba
->cfg_discovery_threads
) {
2198 spin_lock_irq(phba
->host
->host_lock
);
2199 phba
->fc_flag
|= FC_NLP_MORE
;
2200 spin_unlock_irq(phba
->host
->host_lock
);
2206 if (sentadisc
== 0) {
2207 spin_lock_irq(phba
->host
->host_lock
);
2208 phba
->fc_flag
&= ~FC_NLP_MORE
;
2209 spin_unlock_irq(phba
->host
->host_lock
);
2215 lpfc_els_disc_plogi(struct lpfc_hba
* phba
)
2218 struct lpfc_nodelist
*ndlp
, *next_ndlp
;
2221 /* go thru NPR list and issue any remaining ELS PLOGIs */
2222 list_for_each_entry_safe(ndlp
, next_ndlp
, &phba
->fc_npr_list
,
2224 if ((ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) &&
2225 (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
))) {
2226 if (!(ndlp
->nlp_flag
& NLP_NPR_ADISC
)) {
2227 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
2228 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
2229 lpfc_issue_els_plogi(phba
, ndlp
, 0);
2231 phba
->num_disc_nodes
++;
2232 if (phba
->num_disc_nodes
>=
2233 phba
->cfg_discovery_threads
) {
2234 spin_lock_irq(phba
->host
->host_lock
);
2235 phba
->fc_flag
|= FC_NLP_MORE
;
2236 spin_unlock_irq(phba
->host
->host_lock
);
2242 if (sentplogi
== 0) {
2243 spin_lock_irq(phba
->host
->host_lock
);
2244 phba
->fc_flag
&= ~FC_NLP_MORE
;
2245 spin_unlock_irq(phba
->host
->host_lock
);
2251 lpfc_els_flush_rscn(struct lpfc_hba
* phba
)
2253 struct lpfc_dmabuf
*mp
;
2256 for (i
= 0; i
< phba
->fc_rscn_id_cnt
; i
++) {
2257 mp
= phba
->fc_rscn_id_list
[i
];
2258 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
2260 phba
->fc_rscn_id_list
[i
] = NULL
;
2262 phba
->fc_rscn_id_cnt
= 0;
2263 spin_lock_irq(phba
->host
->host_lock
);
2264 phba
->fc_flag
&= ~(FC_RSCN_MODE
| FC_RSCN_DISCOVERY
);
2265 spin_unlock_irq(phba
->host
->host_lock
);
2266 lpfc_can_disctmo(phba
);
2271 lpfc_rscn_payload_check(struct lpfc_hba
* phba
, uint32_t did
)
2275 struct lpfc_dmabuf
*mp
;
2277 uint32_t payload_len
, cmd
, i
, match
;
2279 ns_did
.un
.word
= did
;
2282 /* Never match fabric nodes for RSCNs */
2283 if ((did
& Fabric_DID_MASK
) == Fabric_DID_MASK
)
2286 /* If we are doing a FULL RSCN rediscovery, match everything */
2287 if (phba
->fc_flag
& FC_RSCN_DISCOVERY
) {
2291 for (i
= 0; i
< phba
->fc_rscn_id_cnt
; i
++) {
2292 mp
= phba
->fc_rscn_id_list
[i
];
2293 lp
= (uint32_t *) mp
->virt
;
2295 payload_len
= be32_to_cpu(cmd
) & 0xffff; /* payload length */
2296 payload_len
-= sizeof (uint32_t); /* take off word 0 */
2297 while (payload_len
) {
2298 rscn_did
.un
.word
= *lp
++;
2299 rscn_did
.un
.word
= be32_to_cpu(rscn_did
.un
.word
);
2300 payload_len
-= sizeof (uint32_t);
2301 switch (rscn_did
.un
.b
.resv
) {
2302 case 0: /* Single N_Port ID effected */
2303 if (ns_did
.un
.word
== rscn_did
.un
.word
) {
2307 case 1: /* Whole N_Port Area effected */
2308 if ((ns_did
.un
.b
.domain
== rscn_did
.un
.b
.domain
)
2309 && (ns_did
.un
.b
.area
== rscn_did
.un
.b
.area
))
2314 case 2: /* Whole N_Port Domain effected */
2315 if (ns_did
.un
.b
.domain
== rscn_did
.un
.b
.domain
)
2320 case 3: /* Whole Fabric effected */
2324 /* Unknown Identifier in RSCN list */
2325 lpfc_printf_log(phba
, KERN_ERR
, LOG_DISCOVERY
,
2326 "%d:0217 Unknown Identifier in "
2327 "RSCN payload Data: x%x\n",
2328 phba
->brd_no
, rscn_did
.un
.word
);
2340 lpfc_rscn_recovery_check(struct lpfc_hba
* phba
)
2342 struct lpfc_nodelist
*ndlp
= NULL
, *next_ndlp
;
2343 struct list_head
*listp
;
2344 struct list_head
*node_list
[7];
2347 /* Look at all nodes effected by pending RSCNs and move
2350 node_list
[0] = &phba
->fc_npr_list
; /* MUST do this list first */
2351 node_list
[1] = &phba
->fc_nlpmap_list
;
2352 node_list
[2] = &phba
->fc_nlpunmap_list
;
2353 node_list
[3] = &phba
->fc_prli_list
;
2354 node_list
[4] = &phba
->fc_reglogin_list
;
2355 node_list
[5] = &phba
->fc_adisc_list
;
2356 node_list
[6] = &phba
->fc_plogi_list
;
2357 for (i
= 0; i
< 7; i
++) {
2358 listp
= node_list
[i
];
2359 if (list_empty(listp
))
2362 list_for_each_entry_safe(ndlp
, next_ndlp
, listp
, nlp_listp
) {
2363 if (!(lpfc_rscn_payload_check(phba
, ndlp
->nlp_DID
)))
2366 lpfc_disc_state_machine(phba
, ndlp
, NULL
,
2367 NLP_EVT_DEVICE_RECOVERY
);
2368 if (ndlp
->nlp_flag
& NLP_DELAY_TMO
) {
2369 ndlp
->nlp_flag
&= ~NLP_DELAY_TMO
;
2370 del_timer_sync(&ndlp
->nlp_delayfunc
);
2371 if (!list_empty(&ndlp
->
2372 els_retry_evt
.evt_listp
))
2373 list_del_init(&ndlp
->
2374 els_retry_evt
.evt_listp
);
2382 lpfc_els_rcv_rscn(struct lpfc_hba
* phba
,
2383 struct lpfc_iocbq
* cmdiocb
,
2384 struct lpfc_nodelist
* ndlp
, uint8_t newnode
)
2386 struct lpfc_dmabuf
*pcmd
;
2389 uint32_t payload_len
, cmd
;
2391 icmd
= &cmdiocb
->iocb
;
2392 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2393 lp
= (uint32_t *) pcmd
->virt
;
2396 payload_len
= be32_to_cpu(cmd
) & 0xffff; /* payload length */
2397 payload_len
-= sizeof (uint32_t); /* take off word 0 */
2398 cmd
&= ELS_CMD_MASK
;
2401 lpfc_printf_log(phba
,
2404 "%d:0214 RSCN received Data: x%x x%x x%x x%x\n",
2406 phba
->fc_flag
, payload_len
, *lp
, phba
->fc_rscn_id_cnt
);
2408 /* If we are about to begin discovery, just ACC the RSCN.
2409 * Discovery processing will satisfy it.
2411 if (phba
->hba_state
< LPFC_NS_QRY
) {
2412 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
,
2417 /* If we are already processing an RSCN, save the received
2418 * RSCN payload buffer, cmdiocb->context2 to process later.
2420 if (phba
->fc_flag
& (FC_RSCN_MODE
| FC_NDISC_ACTIVE
)) {
2421 if ((phba
->fc_rscn_id_cnt
< FC_MAX_HOLD_RSCN
) &&
2422 !(phba
->fc_flag
& FC_RSCN_DISCOVERY
)) {
2423 spin_lock_irq(phba
->host
->host_lock
);
2424 phba
->fc_flag
|= FC_RSCN_MODE
;
2425 spin_unlock_irq(phba
->host
->host_lock
);
2426 phba
->fc_rscn_id_list
[phba
->fc_rscn_id_cnt
++] = pcmd
;
2428 /* If we zero, cmdiocb->context2, the calling
2429 * routine will not try to free it.
2431 cmdiocb
->context2
= NULL
;
2434 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
2435 "%d:0235 Deferred RSCN "
2436 "Data: x%x x%x x%x\n",
2437 phba
->brd_no
, phba
->fc_rscn_id_cnt
,
2438 phba
->fc_flag
, phba
->hba_state
);
2440 spin_lock_irq(phba
->host
->host_lock
);
2441 phba
->fc_flag
|= FC_RSCN_DISCOVERY
;
2442 spin_unlock_irq(phba
->host
->host_lock
);
2443 /* ReDiscovery RSCN */
2444 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
2445 "%d:0234 ReDiscovery RSCN "
2446 "Data: x%x x%x x%x\n",
2447 phba
->brd_no
, phba
->fc_rscn_id_cnt
,
2448 phba
->fc_flag
, phba
->hba_state
);
2451 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
,
2454 /* send RECOVERY event for ALL nodes that match RSCN payload */
2455 lpfc_rscn_recovery_check(phba
);
2459 phba
->fc_flag
|= FC_RSCN_MODE
;
2460 phba
->fc_rscn_id_list
[phba
->fc_rscn_id_cnt
++] = pcmd
;
2462 * If we zero, cmdiocb->context2, the calling routine will
2463 * not try to free it.
2465 cmdiocb
->context2
= NULL
;
2467 lpfc_set_disctmo(phba
);
2470 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, newnode
);
2472 /* send RECOVERY event for ALL nodes that match RSCN payload */
2473 lpfc_rscn_recovery_check(phba
);
2475 return (lpfc_els_handle_rscn(phba
));
2479 lpfc_els_handle_rscn(struct lpfc_hba
* phba
)
2481 struct lpfc_nodelist
*ndlp
;
2483 /* Start timer for RSCN processing */
2484 lpfc_set_disctmo(phba
);
2486 /* RSCN processed */
2487 lpfc_printf_log(phba
,
2490 "%d:0215 RSCN processed Data: x%x x%x x%x x%x\n",
2492 phba
->fc_flag
, 0, phba
->fc_rscn_id_cnt
,
2495 /* To process RSCN, first compare RSCN data with NameServer */
2496 phba
->fc_ns_retry
= 0;
2497 if ((ndlp
= lpfc_findnode_did(phba
, NLP_SEARCH_UNMAPPED
,
2499 /* Good ndlp, issue CT Request to NameServer */
2500 if (lpfc_ns_cmd(phba
, ndlp
, SLI_CTNS_GID_FT
) == 0) {
2501 /* Wait for NameServer query cmpl before we can
2506 /* If login to NameServer does not exist, issue one */
2507 /* Good status, issue PLOGI to NameServer */
2509 lpfc_findnode_did(phba
, NLP_SEARCH_ALL
, NameServer_DID
))) {
2510 /* Wait for NameServer login cmpl before we can
2514 if ((ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
))
2516 lpfc_els_flush_rscn(phba
);
2519 lpfc_nlp_init(phba
, ndlp
, NameServer_DID
);
2520 ndlp
->nlp_type
|= NLP_FABRIC
;
2521 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
2522 lpfc_issue_els_plogi(phba
, ndlp
, 0);
2523 /* Wait for NameServer login cmpl before we can
2529 lpfc_els_flush_rscn(phba
);
2534 lpfc_els_rcv_flogi(struct lpfc_hba
* phba
,
2535 struct lpfc_iocbq
* cmdiocb
,
2536 struct lpfc_nodelist
* ndlp
, uint8_t newnode
)
2538 struct lpfc_dmabuf
*pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2539 uint32_t *lp
= (uint32_t *) pcmd
->virt
;
2540 IOCB_t
*icmd
= &cmdiocb
->iocb
;
2541 struct serv_parm
*sp
;
2548 sp
= (struct serv_parm
*) lp
;
2550 /* FLOGI received */
2552 lpfc_set_disctmo(phba
);
2554 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
2555 /* We should never receive a FLOGI in loop mode, ignore it */
2556 did
= icmd
->un
.elsreq64
.remoteID
;
2558 /* An FLOGI ELS command <elsCmd> was received from DID <did> in
2560 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
2561 "%d:0113 An FLOGI ELS command x%x was received "
2562 "from DID x%x in Loop Mode\n",
2563 phba
->brd_no
, cmd
, did
);
2569 if ((lpfc_check_sparm(phba
, ndlp
, sp
, CLASS3
))) {
2570 /* For a FLOGI we accept, then if our portname is greater
2571 * then the remote portname we initiate Nport login.
2574 rc
= memcmp(&phba
->fc_portname
, &sp
->portName
,
2575 sizeof (struct lpfc_name
));
2578 if ((mbox
= mempool_alloc(phba
->mbox_mem_pool
,
2579 GFP_KERNEL
)) == 0) {
2582 lpfc_linkdown(phba
);
2583 lpfc_init_link(phba
, mbox
,
2585 phba
->cfg_link_speed
);
2586 mbox
->mb
.un
.varInitLnk
.lipsr_AL_PA
= 0;
2587 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
2588 rc
= lpfc_sli_issue_mbox
2589 (phba
, mbox
, (MBX_NOWAIT
| MBX_STOP_IOCB
));
2590 if (rc
== MBX_NOT_FINISHED
) {
2591 mempool_free( mbox
, phba
->mbox_mem_pool
);
2595 else if (rc
> 0) { /* greater than */
2596 spin_lock_irq(phba
->host
->host_lock
);
2597 phba
->fc_flag
|= FC_PT2PT_PLOGI
;
2598 spin_unlock_irq(phba
->host
->host_lock
);
2600 phba
->fc_flag
|= FC_PT2PT
;
2601 phba
->fc_flag
&= ~(FC_FABRIC
| FC_PUBLIC_LOOP
);
2603 /* Reject this request because invalid parameters */
2604 stat
.un
.b
.lsRjtRsvd0
= 0;
2605 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
2606 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_SPARM_OPTIONS
;
2607 stat
.un
.b
.vendorUnique
= 0;
2608 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
2613 lpfc_els_rsp_acc(phba
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
, NULL
, newnode
);
2619 lpfc_els_rcv_rnid(struct lpfc_hba
* phba
,
2620 struct lpfc_iocbq
* cmdiocb
, struct lpfc_nodelist
* ndlp
)
2622 struct lpfc_dmabuf
*pcmd
;
2629 icmd
= &cmdiocb
->iocb
;
2630 did
= icmd
->un
.elsreq64
.remoteID
;
2631 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2632 lp
= (uint32_t *) pcmd
->virt
;
2639 switch (rn
->Format
) {
2641 case RNID_TOPOLOGY_DISC
:
2643 lpfc_els_rsp_rnid_acc(phba
, rn
->Format
, cmdiocb
, ndlp
);
2646 /* Reject this request because format not supported */
2647 stat
.un
.b
.lsRjtRsvd0
= 0;
2648 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
2649 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CANT_GIVE_DATA
;
2650 stat
.un
.b
.vendorUnique
= 0;
2651 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
2657 lpfc_els_rcv_rrq(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
2658 struct lpfc_nodelist
* ndlp
)
2660 struct lpfc_dmabuf
*pcmd
;
2663 struct lpfc_sli_ring
*pring
;
2664 struct lpfc_sli
*psli
;
2669 pring
= &psli
->ring
[LPFC_FCP_RING
];
2670 icmd
= &cmdiocb
->iocb
;
2671 did
= icmd
->un
.elsreq64
.remoteID
;
2672 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2673 lp
= (uint32_t *) pcmd
->virt
;
2679 /* Get oxid / rxid from payload and abort it */
2680 spin_lock_irq(phba
->host
->host_lock
);
2681 if ((rrq
->SID
== be32_to_cpu(phba
->fc_myDID
))) {
2682 lpfc_sli_abort_iocb(phba
, pring
, 0, 0, rrq
->Oxid
,
2685 lpfc_sli_abort_iocb(phba
, pring
, 0, 0, rrq
->Rxid
,
2689 spin_unlock_irq(phba
->host
->host_lock
);
2690 /* ACCEPT the rrq request */
2691 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
2697 lpfc_els_rcv_farp(struct lpfc_hba
* phba
,
2698 struct lpfc_iocbq
* cmdiocb
, struct lpfc_nodelist
* ndlp
)
2700 struct lpfc_dmabuf
*pcmd
;
2704 uint32_t cmd
, cnt
, did
;
2706 icmd
= &cmdiocb
->iocb
;
2707 did
= icmd
->un
.elsreq64
.remoteID
;
2708 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2709 lp
= (uint32_t *) pcmd
->virt
;
2714 /* FARP-REQ received from DID <did> */
2715 lpfc_printf_log(phba
,
2718 "%d:0601 FARP-REQ received from DID x%x\n",
2721 /* We will only support match on WWPN or WWNN */
2722 if (fp
->Mflags
& ~(FARP_MATCH_NODE
| FARP_MATCH_PORT
)) {
2727 /* If this FARP command is searching for my portname */
2728 if (fp
->Mflags
& FARP_MATCH_PORT
) {
2729 if (memcmp(&fp
->RportName
, &phba
->fc_portname
,
2730 sizeof (struct lpfc_name
)) == 0)
2734 /* If this FARP command is searching for my nodename */
2735 if (fp
->Mflags
& FARP_MATCH_NODE
) {
2736 if (memcmp(&fp
->RnodeName
, &phba
->fc_nodename
,
2737 sizeof (struct lpfc_name
)) == 0)
2742 if ((ndlp
->nlp_state
== NLP_STE_UNMAPPED_NODE
) ||
2743 (ndlp
->nlp_state
== NLP_STE_MAPPED_NODE
)) {
2744 /* Log back into the node before sending the FARP. */
2745 if (fp
->Rflags
& FARP_REQUEST_PLOGI
) {
2746 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
2747 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
2748 lpfc_issue_els_plogi(phba
, ndlp
, 0);
2751 /* Send a FARP response to that node */
2752 if (fp
->Rflags
& FARP_REQUEST_FARPR
) {
2753 lpfc_issue_els_farpr(phba
, did
, 0);
2761 lpfc_els_rcv_farpr(struct lpfc_hba
* phba
,
2762 struct lpfc_iocbq
* cmdiocb
, struct lpfc_nodelist
* ndlp
)
2764 struct lpfc_dmabuf
*pcmd
;
2769 icmd
= &cmdiocb
->iocb
;
2770 did
= icmd
->un
.elsreq64
.remoteID
;
2771 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2772 lp
= (uint32_t *) pcmd
->virt
;
2775 /* FARP-RSP received from DID <did> */
2776 lpfc_printf_log(phba
,
2779 "%d:0600 FARP-RSP received from DID x%x\n",
2782 /* ACCEPT the Farp resp request */
2783 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
2789 lpfc_els_rcv_fan(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
2790 struct lpfc_nodelist
* ndlp
)
2792 struct lpfc_dmabuf
*pcmd
;
2798 icmd
= &cmdiocb
->iocb
;
2799 did
= icmd
->un
.elsreq64
.remoteID
;
2800 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2801 lp
= (uint32_t *) pcmd
->virt
;
2808 /* ACCEPT the FAN request */
2809 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
2811 if (phba
->hba_state
== LPFC_LOCAL_CFG_LINK
) {
2812 /* The discovery state machine needs to take a different
2813 * action if this node has switched fabrics
2815 if ((memcmp(&fp
->FportName
, &phba
->fc_fabparam
.portName
,
2816 sizeof (struct lpfc_name
)) != 0)
2818 (memcmp(&fp
->FnodeName
, &phba
->fc_fabparam
.nodeName
,
2819 sizeof (struct lpfc_name
)) != 0)) {
2820 /* This node has switched fabrics. An FLOGI is required
2826 /* Start discovery */
2827 lpfc_disc_start(phba
);
2834 lpfc_els_timeout(unsigned long ptr
)
2836 struct lpfc_hba
*phba
;
2837 unsigned long iflag
;
2839 phba
= (struct lpfc_hba
*)ptr
;
2842 spin_lock_irqsave(phba
->host
->host_lock
, iflag
);
2843 if (!(phba
->work_hba_events
& WORKER_ELS_TMO
)) {
2844 phba
->work_hba_events
|= WORKER_ELS_TMO
;
2845 if (phba
->work_wait
)
2846 wake_up(phba
->work_wait
);
2848 spin_unlock_irqrestore(phba
->host
->host_lock
, iflag
);
2853 lpfc_els_timeout_handler(struct lpfc_hba
*phba
)
2855 struct lpfc_sli_ring
*pring
;
2856 struct lpfc_iocbq
*tmp_iocb
, *piocb
;
2858 struct lpfc_dmabuf
*pcmd
;
2859 struct list_head
*dlp
;
2861 uint32_t els_command
;
2867 spin_lock_irq(phba
->host
->host_lock
);
2868 /* If the timer is already canceled do nothing */
2869 if (!(phba
->work_hba_events
& WORKER_ELS_TMO
)) {
2870 spin_unlock_irq(phba
->host
->host_lock
);
2873 timeout
= (uint32_t)(phba
->fc_ratov
<< 1);
2875 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
2876 dlp
= &pring
->txcmplq
;
2878 list_for_each_entry_safe(piocb
, tmp_iocb
, &pring
->txcmplq
, list
) {
2881 if (piocb
->iocb_flag
& LPFC_IO_LIBDFC
) {
2884 pcmd
= (struct lpfc_dmabuf
*) piocb
->context2
;
2885 elscmd
= (uint32_t *) (pcmd
->virt
);
2886 els_command
= *elscmd
;
2888 if ((els_command
== ELS_CMD_FARP
)
2889 || (els_command
== ELS_CMD_FARPR
)) {
2893 if (piocb
->drvrTimeout
> 0) {
2894 if (piocb
->drvrTimeout
>= timeout
) {
2895 piocb
->drvrTimeout
-= timeout
;
2897 piocb
->drvrTimeout
= 0;
2902 list_del(&piocb
->list
);
2903 pring
->txcmplq_cnt
--;
2905 if (cmd
->ulpCommand
== CMD_GEN_REQUEST64_CR
) {
2906 struct lpfc_nodelist
*ndlp
;
2908 ndlp
= lpfc_findnode_rpi(phba
, cmd
->ulpContext
);
2909 remote_ID
= ndlp
->nlp_DID
;
2910 if (cmd
->un
.elsreq64
.bdl
.ulpIoTag32
) {
2911 lpfc_sli_issue_abort_iotag32(phba
,
2915 remote_ID
= cmd
->un
.elsreq64
.remoteID
;
2918 lpfc_printf_log(phba
,
2921 "%d:0127 ELS timeout Data: x%x x%x x%x x%x\n",
2922 phba
->brd_no
, els_command
,
2923 remote_ID
, cmd
->ulpCommand
, cmd
->ulpIoTag
);
2926 * The iocb has timed out; abort it.
2928 if (piocb
->iocb_cmpl
) {
2929 cmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
2930 cmd
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
2931 spin_unlock_irq(phba
->host
->host_lock
);
2932 (piocb
->iocb_cmpl
) (phba
, piocb
, piocb
);
2933 spin_lock_irq(phba
->host
->host_lock
);
2935 lpfc_sli_release_iocbq(phba
, piocb
);
2937 if (phba
->sli
.ring
[LPFC_ELS_RING
].txcmplq_cnt
) {
2938 phba
->els_tmofunc
.expires
= jiffies
+ HZ
* timeout
;
2939 add_timer(&phba
->els_tmofunc
);
2941 spin_unlock_irq(phba
->host
->host_lock
);
2945 lpfc_els_flush_cmd(struct lpfc_hba
* phba
)
2947 struct lpfc_sli_ring
*pring
;
2948 struct lpfc_iocbq
*tmp_iocb
, *piocb
;
2950 struct lpfc_dmabuf
*pcmd
;
2952 uint32_t els_command
;
2955 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
2956 spin_lock_irq(phba
->host
->host_lock
);
2957 list_for_each_entry_safe(piocb
, tmp_iocb
, &pring
->txq
, list
) {
2960 if (piocb
->iocb_flag
& LPFC_IO_LIBDFC
) {
2964 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
2965 if ((cmd
->ulpCommand
== CMD_QUE_RING_BUF_CN
) ||
2966 (cmd
->ulpCommand
== CMD_QUE_RING_BUF64_CN
) ||
2967 (cmd
->ulpCommand
== CMD_CLOSE_XRI_CN
) ||
2968 (cmd
->ulpCommand
== CMD_ABORT_XRI_CN
)) {
2972 pcmd
= (struct lpfc_dmabuf
*) piocb
->context2
;
2973 elscmd
= (uint32_t *) (pcmd
->virt
);
2974 els_command
= *elscmd
;
2976 if (cmd
->ulpCommand
== CMD_GEN_REQUEST64_CR
) {
2977 struct lpfc_nodelist
*ndlp
;
2979 ndlp
= lpfc_findnode_rpi(phba
, cmd
->ulpContext
);
2980 remote_ID
= ndlp
->nlp_DID
;
2981 if (phba
->hba_state
== LPFC_HBA_READY
) {
2985 remote_ID
= cmd
->un
.elsreq64
.remoteID
;
2988 list_del(&piocb
->list
);
2989 pring
->txcmplq_cnt
--;
2991 cmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
2992 cmd
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
2994 if (piocb
->iocb_cmpl
) {
2995 spin_unlock_irq(phba
->host
->host_lock
);
2996 (piocb
->iocb_cmpl
) (phba
, piocb
, piocb
);
2997 spin_lock_irq(phba
->host
->host_lock
);
3000 lpfc_sli_release_iocbq(phba
, piocb
);
3003 list_for_each_entry_safe(piocb
, tmp_iocb
, &pring
->txcmplq
, list
) {
3006 if (piocb
->iocb_flag
& LPFC_IO_LIBDFC
) {
3009 pcmd
= (struct lpfc_dmabuf
*) piocb
->context2
;
3010 elscmd
= (uint32_t *) (pcmd
->virt
);
3011 els_command
= *elscmd
;
3013 if (cmd
->ulpCommand
== CMD_GEN_REQUEST64_CR
) {
3014 struct lpfc_nodelist
*ndlp
;
3016 ndlp
= lpfc_findnode_rpi(phba
, cmd
->ulpContext
);
3017 remote_ID
= ndlp
->nlp_DID
;
3018 if (phba
->hba_state
== LPFC_HBA_READY
) {
3022 remote_ID
= cmd
->un
.elsreq64
.remoteID
;
3025 list_del(&piocb
->list
);
3026 pring
->txcmplq_cnt
--;
3028 cmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
3029 cmd
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
3031 if (piocb
->iocb_cmpl
) {
3032 spin_unlock_irq(phba
->host
->host_lock
);
3033 (piocb
->iocb_cmpl
) (phba
, piocb
, piocb
);
3034 spin_lock_irq(phba
->host
->host_lock
);
3037 lpfc_sli_release_iocbq(phba
, piocb
);
3039 spin_unlock_irq(phba
->host
->host_lock
);
3044 lpfc_els_unsol_event(struct lpfc_hba
* phba
,
3045 struct lpfc_sli_ring
* pring
, struct lpfc_iocbq
* elsiocb
)
3047 struct lpfc_sli
*psli
;
3048 struct lpfc_nodelist
*ndlp
;
3049 struct lpfc_dmabuf
*mp
;
3056 uint32_t drop_cmd
= 0; /* by default do NOT drop received cmd */
3057 uint32_t rjt_err
= 0;
3060 icmd
= &elsiocb
->iocb
;
3062 if ((icmd
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
3063 ((icmd
->un
.ulpWord
[4] & 0xff) == IOERR_RCV_BUFFER_WAITING
)) {
3064 /* Not enough posted buffers; Try posting more buffers */
3065 phba
->fc_stat
.NoRcvBuf
++;
3066 lpfc_post_buffer(phba
, pring
, 0, 1);
3070 /* If there are no BDEs associated with this IOCB,
3071 * there is nothing to do.
3073 if (icmd
->ulpBdeCount
== 0)
3076 /* type of ELS cmd is first 32bit word in packet */
3077 mp
= lpfc_sli_ringpostbuf_get(phba
, pring
, getPaddr(icmd
->un
.
3081 cont64
[0].addrLow
));
3088 lp
= (uint32_t *) mp
->virt
;
3090 lpfc_post_buffer(phba
, &psli
->ring
[LPFC_ELS_RING
], 1, 1);
3092 if (icmd
->ulpStatus
) {
3093 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3099 /* Check to see if link went down during discovery */
3100 if (lpfc_els_chk_latt(phba
)) {
3101 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3107 did
= icmd
->un
.rcvels
.remoteID
;
3108 if ((ndlp
= lpfc_findnode_did(phba
, NLP_SEARCH_ALL
, did
)) == 0) {
3109 /* Cannot find existing Fabric ndlp, so allocate a new one */
3110 if ((ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
))
3112 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3118 lpfc_nlp_init(phba
, ndlp
, did
);
3120 if ((did
& Fabric_DID_MASK
) == Fabric_DID_MASK
) {
3121 ndlp
->nlp_type
|= NLP_FABRIC
;
3125 phba
->fc_stat
.elsRcvFrame
++;
3126 elsiocb
->context1
= ndlp
;
3127 elsiocb
->context2
= mp
;
3129 if ((cmd
& ELS_CMD_MASK
) == ELS_CMD_RSCN
) {
3130 cmd
&= ELS_CMD_MASK
;
3132 /* ELS command <elsCmd> received from NPORT <did> */
3133 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
3134 "%d:0112 ELS command x%x received from NPORT x%x "
3135 "Data: x%x\n", phba
->brd_no
, cmd
, did
, phba
->hba_state
);
3139 phba
->fc_stat
.elsRcvPLOGI
++;
3140 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3144 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_PLOGI
);
3147 phba
->fc_stat
.elsRcvFLOGI
++;
3148 lpfc_els_rcv_flogi(phba
, elsiocb
, ndlp
, newnode
);
3150 mempool_free( ndlp
, phba
->nlp_mem_pool
);
3154 phba
->fc_stat
.elsRcvLOGO
++;
3155 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3159 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_LOGO
);
3162 phba
->fc_stat
.elsRcvPRLO
++;
3163 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3167 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_PRLO
);
3170 phba
->fc_stat
.elsRcvRSCN
++;
3171 lpfc_els_rcv_rscn(phba
, elsiocb
, ndlp
, newnode
);
3173 mempool_free( ndlp
, phba
->nlp_mem_pool
);
3177 phba
->fc_stat
.elsRcvADISC
++;
3178 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3182 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_ADISC
);
3185 phba
->fc_stat
.elsRcvPDISC
++;
3186 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3190 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_PDISC
);
3193 phba
->fc_stat
.elsRcvFARPR
++;
3194 lpfc_els_rcv_farpr(phba
, elsiocb
, ndlp
);
3197 phba
->fc_stat
.elsRcvFARP
++;
3198 lpfc_els_rcv_farp(phba
, elsiocb
, ndlp
);
3201 phba
->fc_stat
.elsRcvFAN
++;
3202 lpfc_els_rcv_fan(phba
, elsiocb
, ndlp
);
3205 phba
->fc_stat
.elsRcvRRQ
++;
3206 lpfc_els_rcv_rrq(phba
, elsiocb
, ndlp
);
3209 phba
->fc_stat
.elsRcvPRLI
++;
3210 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3214 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_PRLI
);
3217 phba
->fc_stat
.elsRcvRNID
++;
3218 lpfc_els_rcv_rnid(phba
, elsiocb
, ndlp
);
3221 /* Unsupported ELS command, reject */
3224 /* Unknown ELS command <elsCmd> received from NPORT <did> */
3225 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
3226 "%d:0115 Unknown ELS command x%x received from "
3227 "NPORT x%x\n", phba
->brd_no
, cmd
, did
);
3229 mempool_free( ndlp
, phba
->nlp_mem_pool
);
3234 /* check if need to LS_RJT received ELS cmd */
3236 stat
.un
.b
.lsRjtRsvd0
= 0;
3237 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
3238 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
3239 stat
.un
.b
.vendorUnique
= 0;
3240 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, elsiocb
, ndlp
);
3243 if (elsiocb
->context2
) {
3244 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3248 /* check if need to drop received ELS cmd */
3249 if (drop_cmd
== 1) {
3250 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
3251 "%d:0111 Dropping received ELS cmd "
3252 "Data: x%x x%x\n", phba
->brd_no
,
3253 icmd
->ulpStatus
, icmd
->un
.ulpWord
[4]);
3254 phba
->fc_stat
.elsRcvDrop
++;