1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2006 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
26 #include <scsi/scsi.h>
27 #include <scsi/scsi_device.h>
28 #include <scsi/scsi_host.h>
29 #include <scsi/scsi_transport_fc.h>
33 #include "lpfc_disc.h"
34 #include "lpfc_scsi.h"
36 #include "lpfc_logmsg.h"
37 #include "lpfc_crtn.h"
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
, uint8_t expectRsp
,
101 uint16_t cmdSize
, uint8_t retry
, struct lpfc_nodelist
* ndlp
,
102 uint32_t did
, uint32_t elscmd
)
104 struct lpfc_sli_ring
*pring
;
105 struct lpfc_iocbq
*elsiocb
;
106 struct lpfc_dmabuf
*pcmd
, *prsp
, *pbuflist
;
107 struct ulp_bde64
*bpl
;
110 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
112 if (phba
->hba_state
< LPFC_LINK_UP
)
115 /* Allocate buffer for command iocb */
116 spin_lock_irq(phba
->host
->host_lock
);
117 elsiocb
= lpfc_sli_get_iocbq(phba
);
118 spin_unlock_irq(phba
->host
->host_lock
);
122 icmd
= &elsiocb
->iocb
;
124 /* fill in BDEs for command */
125 /* Allocate buffer for command payload */
126 if (((pcmd
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
)) == 0) ||
127 ((pcmd
->virt
= lpfc_mbuf_alloc(phba
,
128 MEM_PRI
, &(pcmd
->phys
))) == 0)) {
131 spin_lock_irq(phba
->host
->host_lock
);
132 lpfc_sli_release_iocbq(phba
, elsiocb
);
133 spin_unlock_irq(phba
->host
->host_lock
);
137 INIT_LIST_HEAD(&pcmd
->list
);
139 /* Allocate buffer for response payload */
141 prsp
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
);
143 prsp
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
,
145 if (prsp
== 0 || prsp
->virt
== 0) {
147 lpfc_mbuf_free(phba
, pcmd
->virt
, pcmd
->phys
);
149 spin_lock_irq(phba
->host
->host_lock
);
150 lpfc_sli_release_iocbq(phba
, elsiocb
);
151 spin_unlock_irq(phba
->host
->host_lock
);
154 INIT_LIST_HEAD(&prsp
->list
);
159 /* Allocate buffer for Buffer ptr list */
160 pbuflist
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
);
162 pbuflist
->virt
= lpfc_mbuf_alloc(phba
, MEM_PRI
,
164 if (pbuflist
== 0 || pbuflist
->virt
== 0) {
165 spin_lock_irq(phba
->host
->host_lock
);
166 lpfc_sli_release_iocbq(phba
, elsiocb
);
167 spin_unlock_irq(phba
->host
->host_lock
);
168 lpfc_mbuf_free(phba
, pcmd
->virt
, pcmd
->phys
);
169 lpfc_mbuf_free(phba
, prsp
->virt
, prsp
->phys
);
176 INIT_LIST_HEAD(&pbuflist
->list
);
178 icmd
->un
.elsreq64
.bdl
.addrHigh
= putPaddrHigh(pbuflist
->phys
);
179 icmd
->un
.elsreq64
.bdl
.addrLow
= putPaddrLow(pbuflist
->phys
);
180 icmd
->un
.elsreq64
.bdl
.bdeFlags
= BUFF_TYPE_BDL
;
182 icmd
->un
.elsreq64
.bdl
.bdeSize
= (2 * sizeof (struct ulp_bde64
));
183 icmd
->un
.elsreq64
.remoteID
= did
; /* DID */
184 icmd
->ulpCommand
= CMD_ELS_REQUEST64_CR
;
186 icmd
->un
.elsreq64
.bdl
.bdeSize
= sizeof (struct ulp_bde64
);
187 icmd
->ulpCommand
= CMD_XMIT_ELS_RSP64_CX
;
190 icmd
->ulpBdeCount
= 1;
192 icmd
->ulpClass
= CLASS3
;
194 bpl
= (struct ulp_bde64
*) pbuflist
->virt
;
195 bpl
->addrLow
= le32_to_cpu(putPaddrLow(pcmd
->phys
));
196 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(pcmd
->phys
));
197 bpl
->tus
.f
.bdeSize
= cmdSize
;
198 bpl
->tus
.f
.bdeFlags
= 0;
199 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
203 bpl
->addrLow
= le32_to_cpu(putPaddrLow(prsp
->phys
));
204 bpl
->addrHigh
= le32_to_cpu(putPaddrHigh(prsp
->phys
));
205 bpl
->tus
.f
.bdeSize
= FCELSSIZE
;
206 bpl
->tus
.f
.bdeFlags
= BUFF_USE_RCV
;
207 bpl
->tus
.w
= le32_to_cpu(bpl
->tus
.w
);
210 /* Save for completion so we can release these resources */
211 elsiocb
->context1
= (uint8_t *) ndlp
;
212 elsiocb
->context2
= (uint8_t *) pcmd
;
213 elsiocb
->context3
= (uint8_t *) pbuflist
;
214 elsiocb
->retry
= retry
;
215 elsiocb
->drvrTimeout
= (phba
->fc_ratov
<< 1) + LPFC_DRVR_TIMEOUT
;
218 list_add(&prsp
->list
, &pcmd
->list
);
222 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
223 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
224 "%d:0116 Xmit ELS command x%x to remote "
225 "NPORT x%x Data: x%x x%x\n",
226 phba
->brd_no
, elscmd
,
227 did
, icmd
->ulpIoTag
, phba
->hba_state
);
229 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
230 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
231 "%d:0117 Xmit ELS response x%x to remote "
232 "NPORT x%x Data: x%x x%x\n",
233 phba
->brd_no
, elscmd
,
234 ndlp
->nlp_DID
, icmd
->ulpIoTag
, cmdSize
);
242 lpfc_cmpl_els_flogi_fabric(struct lpfc_hba
*phba
, struct lpfc_nodelist
*ndlp
,
243 struct serv_parm
*sp
, IOCB_t
*irsp
)
248 spin_lock_irq(phba
->host
->host_lock
);
249 phba
->fc_flag
|= FC_FABRIC
;
250 spin_unlock_irq(phba
->host
->host_lock
);
252 phba
->fc_edtov
= be32_to_cpu(sp
->cmn
.e_d_tov
);
253 if (sp
->cmn
.edtovResolution
) /* E_D_TOV ticks are in nanoseconds */
254 phba
->fc_edtov
= (phba
->fc_edtov
+ 999999) / 1000000;
256 phba
->fc_ratov
= (be32_to_cpu(sp
->cmn
.w2
.r_a_tov
) + 999) / 1000;
258 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
259 spin_lock_irq(phba
->host
->host_lock
);
260 phba
->fc_flag
|= FC_PUBLIC_LOOP
;
261 spin_unlock_irq(phba
->host
->host_lock
);
264 * If we are a N-port connected to a Fabric, fixup sparam's so
265 * logins to devices on remote loops work.
267 phba
->fc_sparam
.cmn
.altBbCredit
= 1;
270 phba
->fc_myDID
= irsp
->un
.ulpWord
[4] & Mask_DID
;
271 memcpy(&ndlp
->nlp_portname
, &sp
->portName
, sizeof(struct lpfc_name
));
272 memcpy(&ndlp
->nlp_nodename
, &sp
->nodeName
, sizeof (struct lpfc_name
));
273 ndlp
->nlp_class_sup
= 0;
274 if (sp
->cls1
.classValid
)
275 ndlp
->nlp_class_sup
|= FC_COS_CLASS1
;
276 if (sp
->cls2
.classValid
)
277 ndlp
->nlp_class_sup
|= FC_COS_CLASS2
;
278 if (sp
->cls3
.classValid
)
279 ndlp
->nlp_class_sup
|= FC_COS_CLASS3
;
280 if (sp
->cls4
.classValid
)
281 ndlp
->nlp_class_sup
|= FC_COS_CLASS4
;
282 ndlp
->nlp_maxframe
= ((sp
->cmn
.bbRcvSizeMsb
& 0x0F) << 8) |
283 sp
->cmn
.bbRcvSizeLsb
;
284 memcpy(&phba
->fc_fabparam
, sp
, sizeof(struct serv_parm
));
286 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
290 phba
->hba_state
= LPFC_FABRIC_CFG_LINK
;
291 lpfc_config_link(phba
, mbox
);
292 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
294 rc
= lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
| MBX_STOP_IOCB
);
295 if (rc
== MBX_NOT_FINISHED
)
298 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
302 if (lpfc_reg_login(phba
, Fabric_DID
, (uint8_t *) sp
, mbox
, 0))
305 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_fabric_reg_login
;
306 mbox
->context2
= ndlp
;
308 rc
= lpfc_sli_issue_mbox(phba
, mbox
, MBX_NOWAIT
| MBX_STOP_IOCB
);
309 if (rc
== MBX_NOT_FINISHED
)
315 mempool_free(mbox
, phba
->mbox_mem_pool
);
321 * We FLOGIed into an NPort, initiate pt2pt protocol
324 lpfc_cmpl_els_flogi_nport(struct lpfc_hba
*phba
, struct lpfc_nodelist
*ndlp
,
325 struct serv_parm
*sp
)
330 spin_lock_irq(phba
->host
->host_lock
);
331 phba
->fc_flag
&= ~(FC_FABRIC
| FC_PUBLIC_LOOP
);
332 spin_unlock_irq(phba
->host
->host_lock
);
334 phba
->fc_edtov
= FF_DEF_EDTOV
;
335 phba
->fc_ratov
= FF_DEF_RATOV
;
336 rc
= memcmp(&phba
->fc_portname
, &sp
->portName
,
337 sizeof(struct lpfc_name
));
339 /* This side will initiate the PLOGI */
340 spin_lock_irq(phba
->host
->host_lock
);
341 phba
->fc_flag
|= FC_PT2PT_PLOGI
;
342 spin_unlock_irq(phba
->host
->host_lock
);
345 * N_Port ID cannot be 0, set our to LocalID the other
346 * side will be RemoteID.
351 phba
->fc_myDID
= PT2PT_LocalID
;
353 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
357 lpfc_config_link(phba
, mbox
);
359 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
360 rc
= lpfc_sli_issue_mbox(phba
, mbox
,
361 MBX_NOWAIT
| MBX_STOP_IOCB
);
362 if (rc
== MBX_NOT_FINISHED
) {
363 mempool_free(mbox
, phba
->mbox_mem_pool
);
366 mempool_free(ndlp
, phba
->nlp_mem_pool
);
368 ndlp
= lpfc_findnode_did(phba
, NLP_SEARCH_ALL
, PT2PT_RemoteID
);
371 * Cannot find existing Fabric ndlp, so allocate a
374 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
378 lpfc_nlp_init(phba
, ndlp
, PT2PT_RemoteID
);
381 memcpy(&ndlp
->nlp_portname
, &sp
->portName
,
382 sizeof(struct lpfc_name
));
383 memcpy(&ndlp
->nlp_nodename
, &sp
->nodeName
,
384 sizeof(struct lpfc_name
));
385 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
386 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
387 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
389 /* This side will wait for the PLOGI */
390 mempool_free( ndlp
, phba
->nlp_mem_pool
);
393 spin_lock_irq(phba
->host
->host_lock
);
394 phba
->fc_flag
|= FC_PT2PT
;
395 spin_unlock_irq(phba
->host
->host_lock
);
397 /* Start discovery - this should just do CLEAR_LA */
398 lpfc_disc_start(phba
);
405 lpfc_cmpl_els_flogi(struct lpfc_hba
* phba
,
406 struct lpfc_iocbq
* cmdiocb
, struct lpfc_iocbq
* rspiocb
)
408 IOCB_t
*irsp
= &rspiocb
->iocb
;
409 struct lpfc_nodelist
*ndlp
= cmdiocb
->context1
;
410 struct lpfc_dmabuf
*pcmd
= cmdiocb
->context2
, *prsp
;
411 struct serv_parm
*sp
;
414 /* Check to see if link went down during discovery */
415 if (lpfc_els_chk_latt(phba
)) {
416 lpfc_nlp_remove(phba
, ndlp
);
420 if (irsp
->ulpStatus
) {
421 /* Check for retry */
422 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
423 /* ELS command is being retried */
426 /* FLOGI failed, so there is no fabric */
427 spin_lock_irq(phba
->host
->host_lock
);
428 phba
->fc_flag
&= ~(FC_FABRIC
| FC_PUBLIC_LOOP
);
429 spin_unlock_irq(phba
->host
->host_lock
);
431 /* If private loop, then allow max outstandting els to be
432 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
433 * alpa map would take too long otherwise.
435 if (phba
->alpa_map
[0] == 0) {
436 phba
->cfg_discovery_threads
=
437 LPFC_MAX_DISC_THREADS
;
441 lpfc_printf_log(phba
,
444 "%d:0100 FLOGI failure Data: x%x x%x x%x\n",
446 irsp
->ulpStatus
, irsp
->un
.ulpWord
[4],
452 * The FLogI succeeded. Sync the data for the CPU before
455 prsp
= list_get_first(&pcmd
->list
, struct lpfc_dmabuf
, list
);
457 sp
= prsp
->virt
+ sizeof(uint32_t);
459 /* FLOGI completes successfully */
460 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
461 "%d:0101 FLOGI completes sucessfully "
462 "Data: x%x x%x x%x x%x\n",
464 irsp
->un
.ulpWord
[4], sp
->cmn
.e_d_tov
,
465 sp
->cmn
.w2
.r_a_tov
, sp
->cmn
.edtovResolution
);
467 if (phba
->hba_state
== LPFC_FLOGI
) {
469 * If Common Service Parameters indicate Nport
470 * we are point to point, if Fport we are Fabric.
473 rc
= lpfc_cmpl_els_flogi_fabric(phba
, ndlp
, sp
, irsp
);
475 rc
= lpfc_cmpl_els_flogi_nport(phba
, ndlp
, sp
);
482 lpfc_nlp_remove(phba
, ndlp
);
484 if (irsp
->ulpStatus
!= IOSTAT_LOCAL_REJECT
||
485 (irsp
->un
.ulpWord
[4] != IOERR_SLI_ABORTED
&&
486 irsp
->un
.ulpWord
[4] != IOERR_SLI_DOWN
)) {
487 /* FLOGI failed, so just use loop map to make discovery list */
488 lpfc_disc_list_loopmap(phba
);
490 /* Start discovery */
491 lpfc_disc_start(phba
);
495 lpfc_els_free_iocb(phba
, cmdiocb
);
499 lpfc_issue_els_flogi(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
502 struct serv_parm
*sp
;
504 struct lpfc_iocbq
*elsiocb
;
505 struct lpfc_sli_ring
*pring
;
511 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
513 cmdsize
= (sizeof (uint32_t) + sizeof (struct serv_parm
));
514 elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
, ndlp
,
515 ndlp
->nlp_DID
, ELS_CMD_FLOGI
);
519 icmd
= &elsiocb
->iocb
;
520 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
522 /* For FLOGI request, remainder of payload is service parameters */
523 *((uint32_t *) (pcmd
)) = ELS_CMD_FLOGI
;
524 pcmd
+= sizeof (uint32_t);
525 memcpy(pcmd
, &phba
->fc_sparam
, sizeof (struct serv_parm
));
526 sp
= (struct serv_parm
*) pcmd
;
528 /* Setup CSPs accordingly for Fabric */
530 sp
->cmn
.w2
.r_a_tov
= 0;
531 sp
->cls1
.classValid
= 0;
532 sp
->cls2
.seqDelivery
= 1;
533 sp
->cls3
.seqDelivery
= 1;
534 if (sp
->cmn
.fcphLow
< FC_PH3
)
535 sp
->cmn
.fcphLow
= FC_PH3
;
536 if (sp
->cmn
.fcphHigh
< FC_PH3
)
537 sp
->cmn
.fcphHigh
= FC_PH3
;
539 tmo
= phba
->fc_ratov
;
540 phba
->fc_ratov
= LPFC_DISC_FLOGI_TMO
;
541 lpfc_set_disctmo(phba
);
542 phba
->fc_ratov
= tmo
;
544 phba
->fc_stat
.elsXmitFLOGI
++;
545 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_flogi
;
546 spin_lock_irq(phba
->host
->host_lock
);
547 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
548 spin_unlock_irq(phba
->host
->host_lock
);
549 if (rc
== IOCB_ERROR
) {
550 lpfc_els_free_iocb(phba
, elsiocb
);
557 lpfc_els_abort_flogi(struct lpfc_hba
* phba
)
559 struct lpfc_sli_ring
*pring
;
560 struct lpfc_iocbq
*iocb
, *next_iocb
;
561 struct lpfc_nodelist
*ndlp
;
564 /* Abort outstanding I/O on NPort <nlp_DID> */
565 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
566 "%d:0201 Abort outstanding I/O on NPort x%x\n",
567 phba
->brd_no
, Fabric_DID
);
569 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
572 * Check the txcmplq for an iocb that matches the nport the driver is
575 spin_lock_irq(phba
->host
->host_lock
);
576 list_for_each_entry_safe(iocb
, next_iocb
, &pring
->txcmplq
, list
) {
578 if (icmd
->ulpCommand
== CMD_ELS_REQUEST64_CR
) {
579 ndlp
= (struct lpfc_nodelist
*)(iocb
->context1
);
580 if (ndlp
&& (ndlp
->nlp_DID
== Fabric_DID
)) {
581 list_del(&iocb
->list
);
582 pring
->txcmplq_cnt
--;
584 if ((icmd
->un
.elsreq64
.bdl
.ulpIoTag32
)) {
585 lpfc_sli_issue_abort_iotag32
588 if (iocb
->iocb_cmpl
) {
589 icmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
590 icmd
->un
.ulpWord
[4] =
592 spin_unlock_irq(phba
->host
->host_lock
);
593 (iocb
->iocb_cmpl
) (phba
, iocb
, iocb
);
594 spin_lock_irq(phba
->host
->host_lock
);
596 lpfc_sli_release_iocbq(phba
, iocb
);
600 spin_unlock_irq(phba
->host
->host_lock
);
606 lpfc_initial_flogi(struct lpfc_hba
* phba
)
608 struct lpfc_nodelist
*ndlp
;
610 /* First look for the Fabric ndlp */
611 ndlp
= lpfc_findnode_did(phba
, NLP_SEARCH_ALL
, Fabric_DID
);
613 /* Cannot find existing Fabric ndlp, so allocate a new one */
614 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
617 lpfc_nlp_init(phba
, ndlp
, Fabric_DID
);
619 lpfc_nlp_list(phba
, ndlp
, NLP_JUST_DQ
);
621 if (lpfc_issue_els_flogi(phba
, ndlp
, 0)) {
622 mempool_free( ndlp
, phba
->nlp_mem_pool
);
628 lpfc_more_plogi(struct lpfc_hba
* phba
)
632 if (phba
->num_disc_nodes
)
633 phba
->num_disc_nodes
--;
635 /* Continue discovery with <num_disc_nodes> PLOGIs to go */
636 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
637 "%d:0232 Continue discovery with %d PLOGIs to go "
638 "Data: x%x x%x x%x\n",
639 phba
->brd_no
, phba
->num_disc_nodes
, phba
->fc_plogi_cnt
,
640 phba
->fc_flag
, phba
->hba_state
);
642 /* Check to see if there are more PLOGIs to be sent */
643 if (phba
->fc_flag
& FC_NLP_MORE
) {
644 /* go thru NPR list and issue any remaining ELS PLOGIs */
645 sentplogi
= lpfc_els_disc_plogi(phba
);
650 static struct lpfc_nodelist
*
651 lpfc_plogi_confirm_nport(struct lpfc_hba
* phba
, struct lpfc_dmabuf
*prsp
,
652 struct lpfc_nodelist
*ndlp
)
654 struct lpfc_nodelist
*new_ndlp
;
656 struct serv_parm
*sp
;
657 uint8_t name
[sizeof (struct lpfc_name
)];
660 /* Fabric nodes can have the same WWPN so we don't bother searching
661 * by WWPN. Just return the ndlp that was given to us.
663 if (ndlp
->nlp_type
& NLP_FABRIC
)
666 lp
= (uint32_t *) prsp
->virt
;
667 sp
= (struct serv_parm
*) ((uint8_t *) lp
+ sizeof (uint32_t));
668 memset(name
, 0, sizeof (struct lpfc_name
));
670 /* Now we to find out if the NPort we are logging into, matches the WWPN
671 * we have for that ndlp. If not, we have some work to do.
673 new_ndlp
= lpfc_findnode_wwpn(phba
, NLP_SEARCH_ALL
, &sp
->portName
);
675 if (new_ndlp
== ndlp
)
680 memcmp(&ndlp
->nlp_portname
, name
, sizeof(struct lpfc_name
));
683 new_ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_ATOMIC
);
687 lpfc_nlp_init(phba
, new_ndlp
, ndlp
->nlp_DID
);
690 lpfc_unreg_rpi(phba
, new_ndlp
);
691 new_ndlp
->nlp_DID
= ndlp
->nlp_DID
;
692 new_ndlp
->nlp_prev_state
= ndlp
->nlp_prev_state
;
693 new_ndlp
->nlp_state
= ndlp
->nlp_state
;
694 lpfc_nlp_list(phba
, new_ndlp
, ndlp
->nlp_flag
& NLP_LIST_MASK
);
696 /* Move this back to NPR list */
697 if (memcmp(&ndlp
->nlp_portname
, name
, sizeof(struct lpfc_name
)) == 0) {
698 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
701 lpfc_unreg_rpi(phba
, ndlp
);
702 ndlp
->nlp_DID
= 0; /* Two ndlps cannot have the same did */
703 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
704 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
710 lpfc_cmpl_els_plogi(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
711 struct lpfc_iocbq
* rspiocb
)
714 struct lpfc_nodelist
*ndlp
;
715 struct lpfc_dmabuf
*prsp
;
716 int disc
, rc
, did
, type
;
719 /* we pass cmdiocb to state machine which needs rspiocb as well */
720 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
722 irsp
= &rspiocb
->iocb
;
723 ndlp
= lpfc_findnode_did(phba
, NLP_SEARCH_ALL
,
724 irsp
->un
.elsreq64
.remoteID
);
728 /* Since ndlp can be freed in the disc state machine, note if this node
729 * is being used during discovery.
731 disc
= (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
);
732 spin_lock_irq(phba
->host
->host_lock
);
733 ndlp
->nlp_flag
&= ~NLP_NPR_2B_DISC
;
734 spin_unlock_irq(phba
->host
->host_lock
);
737 /* PLOGI completes to NPort <nlp_DID> */
738 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
739 "%d:0102 PLOGI completes to NPort x%x "
740 "Data: x%x x%x x%x x%x x%x\n",
741 phba
->brd_no
, ndlp
->nlp_DID
, irsp
->ulpStatus
,
742 irsp
->un
.ulpWord
[4], irsp
->ulpTimeout
, disc
,
743 phba
->num_disc_nodes
);
745 /* Check to see if link went down during discovery */
746 if (lpfc_els_chk_latt(phba
)) {
747 spin_lock_irq(phba
->host
->host_lock
);
748 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
749 spin_unlock_irq(phba
->host
->host_lock
);
753 /* ndlp could be freed in DSM, save these values now */
754 type
= ndlp
->nlp_type
;
757 if (irsp
->ulpStatus
) {
758 /* Check for retry */
759 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
760 /* ELS command is being retried */
762 spin_lock_irq(phba
->host
->host_lock
);
763 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
764 spin_unlock_irq(phba
->host
->host_lock
);
770 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
771 if ((irsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
772 ((irsp
->un
.ulpWord
[4] == IOERR_SLI_ABORTED
) ||
773 (irsp
->un
.ulpWord
[4] == IOERR_LINK_DOWN
) ||
774 (irsp
->un
.ulpWord
[4] == IOERR_SLI_DOWN
))) {
775 rc
= NLP_STE_FREED_NODE
;
777 rc
= lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
781 /* Good status, call state machine */
782 prsp
= list_entry(((struct lpfc_dmabuf
*)
783 cmdiocb
->context2
)->list
.next
,
784 struct lpfc_dmabuf
, list
);
785 ndlp
= lpfc_plogi_confirm_nport(phba
, prsp
, ndlp
);
786 rc
= lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
790 if (disc
&& phba
->num_disc_nodes
) {
791 /* Check to see if there are more PLOGIs to be sent */
792 lpfc_more_plogi(phba
);
794 if (phba
->num_disc_nodes
== 0) {
795 spin_lock_irq(phba
->host
->host_lock
);
796 phba
->fc_flag
&= ~FC_NDISC_ACTIVE
;
797 spin_unlock_irq(phba
->host
->host_lock
);
799 lpfc_can_disctmo(phba
);
800 if (phba
->fc_flag
& FC_RSCN_MODE
) {
802 * Check to see if more RSCNs came in while
803 * we were processing this one.
805 if ((phba
->fc_rscn_id_cnt
== 0) &&
806 (!(phba
->fc_flag
& FC_RSCN_DISCOVERY
))) {
807 spin_lock_irq(phba
->host
->host_lock
);
808 phba
->fc_flag
&= ~FC_RSCN_MODE
;
809 spin_unlock_irq(phba
->host
->host_lock
);
811 lpfc_els_handle_rscn(phba
);
818 lpfc_els_free_iocb(phba
, cmdiocb
);
823 lpfc_issue_els_plogi(struct lpfc_hba
* phba
, uint32_t did
, uint8_t retry
)
825 struct serv_parm
*sp
;
827 struct lpfc_iocbq
*elsiocb
;
828 struct lpfc_sli_ring
*pring
;
829 struct lpfc_sli
*psli
;
834 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
836 cmdsize
= (sizeof (uint32_t) + sizeof (struct serv_parm
));
837 elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
, NULL
, did
,
842 icmd
= &elsiocb
->iocb
;
843 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
845 /* For PLOGI request, remainder of payload is service parameters */
846 *((uint32_t *) (pcmd
)) = ELS_CMD_PLOGI
;
847 pcmd
+= sizeof (uint32_t);
848 memcpy(pcmd
, &phba
->fc_sparam
, sizeof (struct serv_parm
));
849 sp
= (struct serv_parm
*) pcmd
;
851 if (sp
->cmn
.fcphLow
< FC_PH_4_3
)
852 sp
->cmn
.fcphLow
= FC_PH_4_3
;
854 if (sp
->cmn
.fcphHigh
< FC_PH3
)
855 sp
->cmn
.fcphHigh
= FC_PH3
;
857 phba
->fc_stat
.elsXmitPLOGI
++;
858 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_plogi
;
859 spin_lock_irq(phba
->host
->host_lock
);
860 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
861 spin_unlock_irq(phba
->host
->host_lock
);
862 lpfc_els_free_iocb(phba
, elsiocb
);
865 spin_unlock_irq(phba
->host
->host_lock
);
870 lpfc_cmpl_els_prli(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
871 struct lpfc_iocbq
* rspiocb
)
874 struct lpfc_sli
*psli
;
875 struct lpfc_nodelist
*ndlp
;
878 /* we pass cmdiocb to state machine which needs rspiocb as well */
879 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
881 irsp
= &(rspiocb
->iocb
);
882 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
883 spin_lock_irq(phba
->host
->host_lock
);
884 ndlp
->nlp_flag
&= ~NLP_PRLI_SND
;
885 spin_unlock_irq(phba
->host
->host_lock
);
887 /* PRLI completes to NPort <nlp_DID> */
888 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
889 "%d:0103 PRLI completes to NPort x%x "
890 "Data: x%x x%x x%x x%x\n",
891 phba
->brd_no
, ndlp
->nlp_DID
, irsp
->ulpStatus
,
892 irsp
->un
.ulpWord
[4], irsp
->ulpTimeout
,
893 phba
->num_disc_nodes
);
895 phba
->fc_prli_sent
--;
896 /* Check to see if link went down during discovery */
897 if (lpfc_els_chk_latt(phba
))
900 if (irsp
->ulpStatus
) {
901 /* Check for retry */
902 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
903 /* ELS command is being retried */
907 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
908 if ((irsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
909 ((irsp
->un
.ulpWord
[4] == IOERR_SLI_ABORTED
) ||
910 (irsp
->un
.ulpWord
[4] == IOERR_LINK_DOWN
) ||
911 (irsp
->un
.ulpWord
[4] == IOERR_SLI_DOWN
))) {
914 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
918 /* Good status, call state machine */
919 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
, NLP_EVT_CMPL_PRLI
);
923 lpfc_els_free_iocb(phba
, cmdiocb
);
928 lpfc_issue_els_prli(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
933 struct lpfc_iocbq
*elsiocb
;
934 struct lpfc_sli_ring
*pring
;
935 struct lpfc_sli
*psli
;
940 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
942 cmdsize
= (sizeof (uint32_t) + sizeof (PRLI
));
943 elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
, ndlp
,
944 ndlp
->nlp_DID
, ELS_CMD_PRLI
);
948 icmd
= &elsiocb
->iocb
;
949 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
951 /* For PRLI request, remainder of payload is service parameters */
952 memset(pcmd
, 0, (sizeof (PRLI
) + sizeof (uint32_t)));
953 *((uint32_t *) (pcmd
)) = ELS_CMD_PRLI
;
954 pcmd
+= sizeof (uint32_t);
956 /* For PRLI, remainder of payload is PRLI parameter page */
959 * If our firmware version is 3.20 or later,
960 * set the following bits for FC-TAPE support.
962 if (phba
->vpd
.rev
.feaLevelHigh
>= 0x02) {
963 npr
->ConfmComplAllowed
= 1;
965 npr
->TaskRetryIdReq
= 1;
967 npr
->estabImagePair
= 1;
968 npr
->readXferRdyDis
= 1;
970 /* For FCP support */
971 npr
->prliType
= PRLI_FCP_TYPE
;
972 npr
->initiatorFunc
= 1;
974 phba
->fc_stat
.elsXmitPRLI
++;
975 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_prli
;
976 spin_lock_irq(phba
->host
->host_lock
);
977 ndlp
->nlp_flag
|= NLP_PRLI_SND
;
978 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
979 ndlp
->nlp_flag
&= ~NLP_PRLI_SND
;
980 spin_unlock_irq(phba
->host
->host_lock
);
981 lpfc_els_free_iocb(phba
, elsiocb
);
984 spin_unlock_irq(phba
->host
->host_lock
);
985 phba
->fc_prli_sent
++;
990 lpfc_more_adisc(struct lpfc_hba
* phba
)
994 if (phba
->num_disc_nodes
)
995 phba
->num_disc_nodes
--;
997 /* Continue discovery with <num_disc_nodes> ADISCs to go */
998 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
999 "%d:0210 Continue discovery with %d ADISCs to go "
1000 "Data: x%x x%x x%x\n",
1001 phba
->brd_no
, phba
->num_disc_nodes
, phba
->fc_adisc_cnt
,
1002 phba
->fc_flag
, phba
->hba_state
);
1004 /* Check to see if there are more ADISCs to be sent */
1005 if (phba
->fc_flag
& FC_NLP_MORE
) {
1006 lpfc_set_disctmo(phba
);
1008 /* go thru NPR list and issue any remaining ELS ADISCs */
1009 sentadisc
= lpfc_els_disc_adisc(phba
);
1015 lpfc_rscn_disc(struct lpfc_hba
* phba
)
1017 /* RSCN discovery */
1018 /* go thru NPR list and issue ELS PLOGIs */
1019 if (phba
->fc_npr_cnt
) {
1020 if (lpfc_els_disc_plogi(phba
))
1023 if (phba
->fc_flag
& FC_RSCN_MODE
) {
1024 /* Check to see if more RSCNs came in while we were
1025 * processing this one.
1027 if ((phba
->fc_rscn_id_cnt
== 0) &&
1028 (!(phba
->fc_flag
& FC_RSCN_DISCOVERY
))) {
1029 spin_lock_irq(phba
->host
->host_lock
);
1030 phba
->fc_flag
&= ~FC_RSCN_MODE
;
1031 spin_unlock_irq(phba
->host
->host_lock
);
1033 lpfc_els_handle_rscn(phba
);
1039 lpfc_cmpl_els_adisc(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1040 struct lpfc_iocbq
* rspiocb
)
1043 struct lpfc_sli
*psli
;
1044 struct lpfc_nodelist
*ndlp
;
1050 /* we pass cmdiocb to state machine which needs rspiocb as well */
1051 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
1053 irsp
= &(rspiocb
->iocb
);
1054 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1056 /* Since ndlp can be freed in the disc state machine, note if this node
1057 * is being used during discovery.
1059 disc
= (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
);
1060 spin_lock_irq(phba
->host
->host_lock
);
1061 ndlp
->nlp_flag
&= ~(NLP_ADISC_SND
| NLP_NPR_2B_DISC
);
1062 spin_unlock_irq(phba
->host
->host_lock
);
1064 /* ADISC completes to NPort <nlp_DID> */
1065 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1066 "%d:0104 ADISC completes to NPort x%x "
1067 "Data: x%x x%x x%x x%x x%x\n",
1068 phba
->brd_no
, ndlp
->nlp_DID
, irsp
->ulpStatus
,
1069 irsp
->un
.ulpWord
[4], irsp
->ulpTimeout
, disc
,
1070 phba
->num_disc_nodes
);
1072 /* Check to see if link went down during discovery */
1073 if (lpfc_els_chk_latt(phba
)) {
1074 spin_lock_irq(phba
->host
->host_lock
);
1075 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
1076 spin_unlock_irq(phba
->host
->host_lock
);
1080 if (irsp
->ulpStatus
) {
1081 /* Check for retry */
1082 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
1083 /* ELS command is being retried */
1085 spin_lock_irq(phba
->host
->host_lock
);
1086 ndlp
->nlp_flag
|= NLP_NPR_2B_DISC
;
1087 spin_unlock_irq(phba
->host
->host_lock
);
1088 lpfc_set_disctmo(phba
);
1093 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1094 if ((irsp
->ulpStatus
!= IOSTAT_LOCAL_REJECT
) ||
1095 ((irsp
->un
.ulpWord
[4] != IOERR_SLI_ABORTED
) &&
1096 (irsp
->un
.ulpWord
[4] != IOERR_LINK_DOWN
) &&
1097 (irsp
->un
.ulpWord
[4] != IOERR_SLI_DOWN
))) {
1098 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
1099 NLP_EVT_CMPL_ADISC
);
1102 /* Good status, call state machine */
1103 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
1104 NLP_EVT_CMPL_ADISC
);
1107 if (disc
&& phba
->num_disc_nodes
) {
1108 /* Check to see if there are more ADISCs to be sent */
1109 lpfc_more_adisc(phba
);
1111 /* Check to see if we are done with ADISC authentication */
1112 if (phba
->num_disc_nodes
== 0) {
1113 lpfc_can_disctmo(phba
);
1114 /* If we get here, there is nothing left to wait for */
1115 if ((phba
->hba_state
< LPFC_HBA_READY
) &&
1116 (phba
->hba_state
!= LPFC_CLEAR_LA
)) {
1117 /* Link up discovery */
1118 if ((mbox
= mempool_alloc(phba
->mbox_mem_pool
,
1120 phba
->hba_state
= LPFC_CLEAR_LA
;
1121 lpfc_clear_la(phba
, mbox
);
1123 lpfc_mbx_cmpl_clear_la
;
1124 rc
= lpfc_sli_issue_mbox
1126 (MBX_NOWAIT
| MBX_STOP_IOCB
));
1127 if (rc
== MBX_NOT_FINISHED
) {
1129 phba
->mbox_mem_pool
);
1130 lpfc_disc_flush_list(phba
);
1131 psli
->ring
[(psli
->ip_ring
)].
1133 ~LPFC_STOP_IOCB_EVENT
;
1134 psli
->ring
[(psli
->fcp_ring
)].
1136 ~LPFC_STOP_IOCB_EVENT
;
1137 psli
->ring
[(psli
->next_ring
)].
1139 ~LPFC_STOP_IOCB_EVENT
;
1145 lpfc_rscn_disc(phba
);
1150 lpfc_els_free_iocb(phba
, cmdiocb
);
1155 lpfc_issue_els_adisc(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
1160 struct lpfc_iocbq
*elsiocb
;
1161 struct lpfc_sli_ring
*pring
;
1162 struct lpfc_sli
*psli
;
1167 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
1169 cmdsize
= (sizeof (uint32_t) + sizeof (ADISC
));
1170 elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
, ndlp
,
1171 ndlp
->nlp_DID
, ELS_CMD_ADISC
);
1175 icmd
= &elsiocb
->iocb
;
1176 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1178 /* For ADISC request, remainder of payload is service parameters */
1179 *((uint32_t *) (pcmd
)) = ELS_CMD_ADISC
;
1180 pcmd
+= sizeof (uint32_t);
1182 /* Fill in ADISC payload */
1183 ap
= (ADISC
*) pcmd
;
1184 ap
->hardAL_PA
= phba
->fc_pref_ALPA
;
1185 memcpy(&ap
->portName
, &phba
->fc_portname
, sizeof (struct lpfc_name
));
1186 memcpy(&ap
->nodeName
, &phba
->fc_nodename
, sizeof (struct lpfc_name
));
1187 ap
->DID
= be32_to_cpu(phba
->fc_myDID
);
1189 phba
->fc_stat
.elsXmitADISC
++;
1190 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_adisc
;
1191 spin_lock_irq(phba
->host
->host_lock
);
1192 ndlp
->nlp_flag
|= NLP_ADISC_SND
;
1193 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
1194 ndlp
->nlp_flag
&= ~NLP_ADISC_SND
;
1195 spin_unlock_irq(phba
->host
->host_lock
);
1196 lpfc_els_free_iocb(phba
, elsiocb
);
1199 spin_unlock_irq(phba
->host
->host_lock
);
1204 lpfc_cmpl_els_logo(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1205 struct lpfc_iocbq
* rspiocb
)
1208 struct lpfc_sli
*psli
;
1209 struct lpfc_nodelist
*ndlp
;
1212 /* we pass cmdiocb to state machine which needs rspiocb as well */
1213 cmdiocb
->context_un
.rsp_iocb
= rspiocb
;
1215 irsp
= &(rspiocb
->iocb
);
1216 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1217 spin_lock_irq(phba
->host
->host_lock
);
1218 ndlp
->nlp_flag
&= ~NLP_LOGO_SND
;
1219 spin_unlock_irq(phba
->host
->host_lock
);
1221 /* LOGO completes to NPort <nlp_DID> */
1222 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1223 "%d:0105 LOGO completes to NPort x%x "
1224 "Data: x%x x%x x%x x%x\n",
1225 phba
->brd_no
, ndlp
->nlp_DID
, irsp
->ulpStatus
,
1226 irsp
->un
.ulpWord
[4], irsp
->ulpTimeout
,
1227 phba
->num_disc_nodes
);
1229 /* Check to see if link went down during discovery */
1230 if (lpfc_els_chk_latt(phba
))
1233 if (irsp
->ulpStatus
) {
1234 /* Check for retry */
1235 if (lpfc_els_retry(phba
, cmdiocb
, rspiocb
)) {
1236 /* ELS command is being retried */
1240 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1241 if ((irsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
1242 ((irsp
->un
.ulpWord
[4] == IOERR_SLI_ABORTED
) ||
1243 (irsp
->un
.ulpWord
[4] == IOERR_LINK_DOWN
) ||
1244 (irsp
->un
.ulpWord
[4] == IOERR_SLI_DOWN
))) {
1247 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
,
1251 /* Good status, call state machine.
1252 * This will unregister the rpi if needed.
1254 lpfc_disc_state_machine(phba
, ndlp
, cmdiocb
, NLP_EVT_CMPL_LOGO
);
1258 lpfc_els_free_iocb(phba
, cmdiocb
);
1263 lpfc_issue_els_logo(struct lpfc_hba
* phba
, struct lpfc_nodelist
* ndlp
,
1267 struct lpfc_iocbq
*elsiocb
;
1268 struct lpfc_sli_ring
*pring
;
1269 struct lpfc_sli
*psli
;
1274 pring
= &psli
->ring
[LPFC_ELS_RING
];
1276 cmdsize
= (2 * sizeof (uint32_t)) + sizeof (struct lpfc_name
);
1277 elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
, ndlp
,
1278 ndlp
->nlp_DID
, ELS_CMD_LOGO
);
1282 icmd
= &elsiocb
->iocb
;
1283 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1284 *((uint32_t *) (pcmd
)) = ELS_CMD_LOGO
;
1285 pcmd
+= sizeof (uint32_t);
1287 /* Fill in LOGO payload */
1288 *((uint32_t *) (pcmd
)) = be32_to_cpu(phba
->fc_myDID
);
1289 pcmd
+= sizeof (uint32_t);
1290 memcpy(pcmd
, &phba
->fc_portname
, sizeof (struct lpfc_name
));
1292 phba
->fc_stat
.elsXmitLOGO
++;
1293 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_logo
;
1294 spin_lock_irq(phba
->host
->host_lock
);
1295 ndlp
->nlp_flag
|= NLP_LOGO_SND
;
1296 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
1297 ndlp
->nlp_flag
&= ~NLP_LOGO_SND
;
1298 spin_unlock_irq(phba
->host
->host_lock
);
1299 lpfc_els_free_iocb(phba
, elsiocb
);
1302 spin_unlock_irq(phba
->host
->host_lock
);
1307 lpfc_cmpl_els_cmd(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1308 struct lpfc_iocbq
* rspiocb
)
1312 irsp
= &rspiocb
->iocb
;
1314 /* ELS cmd tag <ulpIoTag> completes */
1315 lpfc_printf_log(phba
,
1318 "%d:0106 ELS cmd tag x%x completes Data: x%x x%x x%x\n",
1320 irsp
->ulpIoTag
, irsp
->ulpStatus
,
1321 irsp
->un
.ulpWord
[4], irsp
->ulpTimeout
);
1323 /* Check to see if link went down during discovery */
1324 lpfc_els_chk_latt(phba
);
1325 lpfc_els_free_iocb(phba
, cmdiocb
);
1330 lpfc_issue_els_scr(struct lpfc_hba
* phba
, uint32_t nportid
, uint8_t retry
)
1333 struct lpfc_iocbq
*elsiocb
;
1334 struct lpfc_sli_ring
*pring
;
1335 struct lpfc_sli
*psli
;
1338 struct lpfc_nodelist
*ndlp
;
1341 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
1342 cmdsize
= (sizeof (uint32_t) + sizeof (SCR
));
1343 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
1347 lpfc_nlp_init(phba
, ndlp
, nportid
);
1349 elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
, ndlp
,
1350 ndlp
->nlp_DID
, ELS_CMD_SCR
);
1352 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1356 icmd
= &elsiocb
->iocb
;
1357 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1359 *((uint32_t *) (pcmd
)) = ELS_CMD_SCR
;
1360 pcmd
+= sizeof (uint32_t);
1362 /* For SCR, remainder of payload is SCR parameter page */
1363 memset(pcmd
, 0, sizeof (SCR
));
1364 ((SCR
*) pcmd
)->Function
= SCR_FUNC_FULL
;
1366 phba
->fc_stat
.elsXmitSCR
++;
1367 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_cmd
;
1368 spin_lock_irq(phba
->host
->host_lock
);
1369 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
1370 spin_unlock_irq(phba
->host
->host_lock
);
1371 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1372 lpfc_els_free_iocb(phba
, elsiocb
);
1375 spin_unlock_irq(phba
->host
->host_lock
);
1376 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1381 lpfc_issue_els_farpr(struct lpfc_hba
* phba
, uint32_t nportid
, uint8_t retry
)
1384 struct lpfc_iocbq
*elsiocb
;
1385 struct lpfc_sli_ring
*pring
;
1386 struct lpfc_sli
*psli
;
1391 struct lpfc_nodelist
*ondlp
;
1392 struct lpfc_nodelist
*ndlp
;
1395 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
1396 cmdsize
= (sizeof (uint32_t) + sizeof (FARP
));
1397 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
1400 lpfc_nlp_init(phba
, ndlp
, nportid
);
1402 elsiocb
= lpfc_prep_els_iocb(phba
, 1, cmdsize
, retry
, ndlp
,
1403 ndlp
->nlp_DID
, ELS_CMD_RNID
);
1405 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1409 icmd
= &elsiocb
->iocb
;
1410 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1412 *((uint32_t *) (pcmd
)) = ELS_CMD_FARPR
;
1413 pcmd
+= sizeof (uint32_t);
1415 /* Fill in FARPR payload */
1416 fp
= (FARP
*) (pcmd
);
1417 memset(fp
, 0, sizeof (FARP
));
1418 lp
= (uint32_t *) pcmd
;
1419 *lp
++ = be32_to_cpu(nportid
);
1420 *lp
++ = be32_to_cpu(phba
->fc_myDID
);
1422 fp
->Mflags
= (FARP_MATCH_PORT
| FARP_MATCH_NODE
);
1424 memcpy(&fp
->RportName
, &phba
->fc_portname
, sizeof (struct lpfc_name
));
1425 memcpy(&fp
->RnodeName
, &phba
->fc_nodename
, sizeof (struct lpfc_name
));
1426 if ((ondlp
= lpfc_findnode_did(phba
, NLP_SEARCH_ALL
, nportid
))) {
1427 memcpy(&fp
->OportName
, &ondlp
->nlp_portname
,
1428 sizeof (struct lpfc_name
));
1429 memcpy(&fp
->OnodeName
, &ondlp
->nlp_nodename
,
1430 sizeof (struct lpfc_name
));
1433 phba
->fc_stat
.elsXmitFARPR
++;
1434 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_cmd
;
1435 spin_lock_irq(phba
->host
->host_lock
);
1436 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
1437 spin_unlock_irq(phba
->host
->host_lock
);
1438 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1439 lpfc_els_free_iocb(phba
, elsiocb
);
1442 spin_unlock_irq(phba
->host
->host_lock
);
1443 mempool_free( ndlp
, phba
->nlp_mem_pool
);
1448 lpfc_cancel_retry_delay_tmo(struct lpfc_hba
*phba
, struct lpfc_nodelist
* nlp
)
1450 nlp
->nlp_flag
&= ~NLP_DELAY_TMO
;
1451 del_timer_sync(&nlp
->nlp_delayfunc
);
1452 nlp
->nlp_last_elscmd
= 0;
1454 if (!list_empty(&nlp
->els_retry_evt
.evt_listp
))
1455 list_del_init(&nlp
->els_retry_evt
.evt_listp
);
1457 if (nlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
1458 nlp
->nlp_flag
&= ~NLP_NPR_2B_DISC
;
1459 if (phba
->num_disc_nodes
) {
1460 /* Check to see if there are more
1463 lpfc_more_plogi(phba
);
1465 if (phba
->num_disc_nodes
== 0) {
1466 phba
->fc_flag
&= ~FC_NDISC_ACTIVE
;
1467 lpfc_can_disctmo(phba
);
1468 if (phba
->fc_flag
& FC_RSCN_MODE
) {
1470 * Check to see if more RSCNs
1471 * came in while we were
1472 * processing this one.
1474 if((phba
->fc_rscn_id_cnt
==0) &&
1475 !(phba
->fc_flag
& FC_RSCN_DISCOVERY
)) {
1476 phba
->fc_flag
&= ~FC_RSCN_MODE
;
1479 lpfc_els_handle_rscn(phba
);
1489 lpfc_els_retry_delay(unsigned long ptr
)
1491 struct lpfc_nodelist
*ndlp
;
1492 struct lpfc_hba
*phba
;
1493 unsigned long iflag
;
1494 struct lpfc_work_evt
*evtp
;
1496 ndlp
= (struct lpfc_nodelist
*)ptr
;
1497 phba
= ndlp
->nlp_phba
;
1498 evtp
= &ndlp
->els_retry_evt
;
1500 spin_lock_irqsave(phba
->host
->host_lock
, iflag
);
1501 if (!list_empty(&evtp
->evt_listp
)) {
1502 spin_unlock_irqrestore(phba
->host
->host_lock
, iflag
);
1506 evtp
->evt_arg1
= ndlp
;
1507 evtp
->evt
= LPFC_EVT_ELS_RETRY
;
1508 list_add_tail(&evtp
->evt_listp
, &phba
->work_list
);
1509 if (phba
->work_wait
)
1510 wake_up(phba
->work_wait
);
1512 spin_unlock_irqrestore(phba
->host
->host_lock
, iflag
);
1517 lpfc_els_retry_delay_handler(struct lpfc_nodelist
*ndlp
)
1519 struct lpfc_hba
*phba
;
1524 phba
= ndlp
->nlp_phba
;
1525 spin_lock_irq(phba
->host
->host_lock
);
1526 did
= ndlp
->nlp_DID
;
1527 cmd
= ndlp
->nlp_last_elscmd
;
1528 ndlp
->nlp_last_elscmd
= 0;
1530 if (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
)) {
1531 spin_unlock_irq(phba
->host
->host_lock
);
1535 ndlp
->nlp_flag
&= ~NLP_DELAY_TMO
;
1536 spin_unlock_irq(phba
->host
->host_lock
);
1538 * If a discovery event readded nlp_delayfunc after timer
1539 * firing and before processing the timer, cancel the
1542 del_timer_sync(&ndlp
->nlp_delayfunc
);
1543 retry
= ndlp
->nlp_retry
;
1547 lpfc_issue_els_flogi(phba
, ndlp
, retry
);
1550 if(!lpfc_issue_els_plogi(phba
, ndlp
->nlp_DID
, retry
)) {
1551 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
1552 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
1553 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
1557 if (!lpfc_issue_els_adisc(phba
, ndlp
, retry
)) {
1558 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
1559 ndlp
->nlp_state
= NLP_STE_ADISC_ISSUE
;
1560 lpfc_nlp_list(phba
, ndlp
, NLP_ADISC_LIST
);
1564 if (!lpfc_issue_els_prli(phba
, ndlp
, retry
)) {
1565 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
1566 ndlp
->nlp_state
= NLP_STE_PRLI_ISSUE
;
1567 lpfc_nlp_list(phba
, ndlp
, NLP_PRLI_LIST
);
1571 if (!lpfc_issue_els_logo(phba
, ndlp
, retry
)) {
1572 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
1573 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1574 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1582 lpfc_els_retry(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1583 struct lpfc_iocbq
* rspiocb
)
1586 struct lpfc_dmabuf
*pcmd
;
1587 struct lpfc_nodelist
*ndlp
;
1590 int retry
, maxretry
;
1597 maxretry
= lpfc_max_els_tries
;
1598 irsp
= &rspiocb
->iocb
;
1599 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1600 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
1603 /* Note: context2 may be 0 for internal driver abort
1604 * of delays ELS command.
1607 if (pcmd
&& pcmd
->virt
) {
1608 elscmd
= (uint32_t *) (pcmd
->virt
);
1613 did
= ndlp
->nlp_DID
;
1615 /* We should only hit this case for retrying PLOGI */
1616 did
= irsp
->un
.elsreq64
.remoteID
;
1617 ndlp
= lpfc_findnode_did(phba
, NLP_SEARCH_ALL
, did
);
1618 if (!ndlp
&& (cmd
!= ELS_CMD_PLOGI
))
1622 switch (irsp
->ulpStatus
) {
1623 case IOSTAT_FCP_RSP_ERROR
:
1624 case IOSTAT_REMOTE_STOP
:
1627 case IOSTAT_LOCAL_REJECT
:
1628 switch ((irsp
->un
.ulpWord
[4] & 0xff)) {
1629 case IOERR_LOOP_OPEN_FAILURE
:
1630 if (cmd
== ELS_CMD_PLOGI
) {
1631 if (cmdiocb
->retry
== 0) {
1638 case IOERR_SEQUENCE_TIMEOUT
:
1642 case IOERR_NO_RESOURCES
:
1643 if (cmd
== ELS_CMD_PLOGI
) {
1649 case IOERR_INVALID_RPI
:
1655 case IOSTAT_NPORT_RJT
:
1656 case IOSTAT_FABRIC_RJT
:
1657 if (irsp
->un
.ulpWord
[4] & RJT_UNAVAIL_TEMP
) {
1663 case IOSTAT_NPORT_BSY
:
1664 case IOSTAT_FABRIC_BSY
:
1669 stat
.un
.lsRjtError
= be32_to_cpu(irsp
->un
.ulpWord
[4]);
1670 /* Added for Vendor specifc support
1671 * Just keep retrying for these Rsn / Exp codes
1673 switch (stat
.un
.b
.lsRjtRsnCode
) {
1674 case LSRJT_UNABLE_TPC
:
1675 if (stat
.un
.b
.lsRjtRsnCodeExp
==
1676 LSEXP_CMD_IN_PROGRESS
) {
1677 if (cmd
== ELS_CMD_PLOGI
) {
1684 if (cmd
== ELS_CMD_PLOGI
) {
1686 maxretry
= lpfc_max_els_tries
+ 1;
1692 case LSRJT_LOGICAL_BSY
:
1693 if (cmd
== ELS_CMD_PLOGI
) {
1702 case IOSTAT_INTERMED_RSP
:
1710 if (did
== FDMI_DID
)
1713 if ((++cmdiocb
->retry
) >= maxretry
) {
1714 phba
->fc_stat
.elsRetryExceeded
++;
1720 /* Retry ELS command <elsCmd> to remote NPORT <did> */
1721 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1722 "%d:0107 Retry ELS command x%x to remote "
1723 "NPORT x%x Data: x%x x%x\n",
1725 cmd
, did
, cmdiocb
->retry
, delay
);
1727 if ((cmd
== ELS_CMD_PLOGI
) || (cmd
== ELS_CMD_ADISC
)) {
1728 /* If discovery / RSCN timer is running, reset it */
1729 if (timer_pending(&phba
->fc_disctmo
) ||
1730 (phba
->fc_flag
& FC_RSCN_MODE
)) {
1731 lpfc_set_disctmo(phba
);
1735 phba
->fc_stat
.elsXmitRetry
++;
1736 if (ndlp
&& delay
) {
1737 phba
->fc_stat
.elsDelayRetry
++;
1738 ndlp
->nlp_retry
= cmdiocb
->retry
;
1740 mod_timer(&ndlp
->nlp_delayfunc
, jiffies
+ HZ
);
1741 ndlp
->nlp_flag
|= NLP_DELAY_TMO
;
1743 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
1744 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1745 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1746 ndlp
->nlp_last_elscmd
= cmd
;
1752 lpfc_issue_els_flogi(phba
, ndlp
, cmdiocb
->retry
);
1756 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
1757 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
1758 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
1760 lpfc_issue_els_plogi(phba
, did
, cmdiocb
->retry
);
1763 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
1764 ndlp
->nlp_state
= NLP_STE_ADISC_ISSUE
;
1765 lpfc_nlp_list(phba
, ndlp
, NLP_ADISC_LIST
);
1766 lpfc_issue_els_adisc(phba
, ndlp
, cmdiocb
->retry
);
1769 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
1770 ndlp
->nlp_state
= NLP_STE_PRLI_ISSUE
;
1771 lpfc_nlp_list(phba
, ndlp
, NLP_PRLI_LIST
);
1772 lpfc_issue_els_prli(phba
, ndlp
, cmdiocb
->retry
);
1775 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
1776 ndlp
->nlp_state
= NLP_STE_NPR_NODE
;
1777 lpfc_nlp_list(phba
, ndlp
, NLP_NPR_LIST
);
1778 lpfc_issue_els_logo(phba
, ndlp
, cmdiocb
->retry
);
1783 /* No retry ELS command <elsCmd> to remote NPORT <did> */
1784 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1785 "%d:0108 No retry ELS command x%x to remote NPORT x%x "
1788 cmd
, did
, cmdiocb
->retry
);
1794 lpfc_els_free_iocb(struct lpfc_hba
* phba
, struct lpfc_iocbq
* elsiocb
)
1796 struct lpfc_dmabuf
*buf_ptr
, *buf_ptr1
;
1798 /* context2 = cmd, context2->next = rsp, context3 = bpl */
1799 if (elsiocb
->context2
) {
1800 buf_ptr1
= (struct lpfc_dmabuf
*) elsiocb
->context2
;
1801 /* Free the response before processing the command. */
1802 if (!list_empty(&buf_ptr1
->list
)) {
1803 list_remove_head(&buf_ptr1
->list
, buf_ptr
,
1806 lpfc_mbuf_free(phba
, buf_ptr
->virt
, buf_ptr
->phys
);
1809 lpfc_mbuf_free(phba
, buf_ptr1
->virt
, buf_ptr1
->phys
);
1813 if (elsiocb
->context3
) {
1814 buf_ptr
= (struct lpfc_dmabuf
*) elsiocb
->context3
;
1815 lpfc_mbuf_free(phba
, buf_ptr
->virt
, buf_ptr
->phys
);
1818 spin_lock_irq(phba
->host
->host_lock
);
1819 lpfc_sli_release_iocbq(phba
, elsiocb
);
1820 spin_unlock_irq(phba
->host
->host_lock
);
1825 lpfc_cmpl_els_logo_acc(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1826 struct lpfc_iocbq
* rspiocb
)
1828 struct lpfc_nodelist
*ndlp
;
1830 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1832 /* ACC to LOGO completes to NPort <nlp_DID> */
1833 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1834 "%d:0109 ACC to LOGO completes to NPort x%x "
1835 "Data: x%x x%x x%x\n",
1836 phba
->brd_no
, ndlp
->nlp_DID
, ndlp
->nlp_flag
,
1837 ndlp
->nlp_state
, ndlp
->nlp_rpi
);
1839 switch (ndlp
->nlp_state
) {
1840 case NLP_STE_UNUSED_NODE
: /* node is just allocated */
1841 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1843 case NLP_STE_NPR_NODE
: /* NPort Recovery mode */
1844 lpfc_unreg_rpi(phba
, ndlp
);
1849 lpfc_els_free_iocb(phba
, cmdiocb
);
1854 lpfc_cmpl_els_acc(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
1855 struct lpfc_iocbq
* rspiocb
)
1858 struct lpfc_nodelist
*ndlp
;
1859 LPFC_MBOXQ_t
*mbox
= NULL
;
1861 irsp
= &rspiocb
->iocb
;
1863 ndlp
= (struct lpfc_nodelist
*) cmdiocb
->context1
;
1864 if (cmdiocb
->context_un
.mbox
)
1865 mbox
= cmdiocb
->context_un
.mbox
;
1868 /* Check to see if link went down during discovery */
1869 if ((lpfc_els_chk_latt(phba
)) || !ndlp
) {
1871 mempool_free( mbox
, phba
->mbox_mem_pool
);
1876 /* ELS response tag <ulpIoTag> completes */
1877 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
1878 "%d:0110 ELS response tag x%x completes "
1879 "Data: x%x x%x x%x x%x x%x x%x x%x\n",
1881 cmdiocb
->iocb
.ulpIoTag
, rspiocb
->iocb
.ulpStatus
,
1882 rspiocb
->iocb
.un
.ulpWord
[4], rspiocb
->iocb
.ulpTimeout
,
1883 ndlp
->nlp_DID
, ndlp
->nlp_flag
, ndlp
->nlp_state
,
1887 if ((rspiocb
->iocb
.ulpStatus
== 0)
1888 && (ndlp
->nlp_flag
& NLP_ACC_REGLOGIN
)) {
1889 lpfc_unreg_rpi(phba
, ndlp
);
1890 mbox
->mbox_cmpl
= lpfc_mbx_cmpl_reg_login
;
1891 mbox
->context2
= ndlp
;
1892 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
1893 ndlp
->nlp_state
= NLP_STE_REG_LOGIN_ISSUE
;
1894 lpfc_nlp_list(phba
, ndlp
, NLP_REGLOGIN_LIST
);
1895 if (lpfc_sli_issue_mbox(phba
, mbox
,
1896 (MBX_NOWAIT
| MBX_STOP_IOCB
))
1897 != MBX_NOT_FINISHED
) {
1900 /* NOTE: we should have messages for unsuccessful
1902 mempool_free( mbox
, phba
->mbox_mem_pool
);
1904 mempool_free( mbox
, phba
->mbox_mem_pool
);
1905 /* Do not call NO_LIST for lpfc_els_abort'ed ELS cmds */
1906 if (!((irsp
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
1907 ((irsp
->un
.ulpWord
[4] == IOERR_SLI_ABORTED
) ||
1908 (irsp
->un
.ulpWord
[4] == IOERR_LINK_DOWN
) ||
1909 (irsp
->un
.ulpWord
[4] == IOERR_SLI_DOWN
)))) {
1910 if (ndlp
->nlp_flag
& NLP_ACC_REGLOGIN
) {
1911 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
1919 spin_lock_irq(phba
->host
->host_lock
);
1920 ndlp
->nlp_flag
&= ~NLP_ACC_REGLOGIN
;
1921 spin_unlock_irq(phba
->host
->host_lock
);
1923 lpfc_els_free_iocb(phba
, cmdiocb
);
1928 lpfc_els_rsp_acc(struct lpfc_hba
* phba
, uint32_t flag
,
1929 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
,
1930 LPFC_MBOXQ_t
* mbox
, uint8_t newnode
)
1934 struct lpfc_iocbq
*elsiocb
;
1935 struct lpfc_sli_ring
*pring
;
1936 struct lpfc_sli
*psli
;
1940 ELS_PKT
*els_pkt_ptr
;
1943 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
1944 oldcmd
= &oldiocb
->iocb
;
1948 cmdsize
= sizeof (uint32_t);
1949 elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
1950 ndlp
, ndlp
->nlp_DID
, ELS_CMD_ACC
);
1952 ndlp
->nlp_flag
&= ~NLP_LOGO_ACC
;
1955 icmd
= &elsiocb
->iocb
;
1956 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
1957 pcmd
= (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1958 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
1959 pcmd
+= sizeof (uint32_t);
1962 cmdsize
= (sizeof (struct serv_parm
) + sizeof (uint32_t));
1963 elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
1964 ndlp
, ndlp
->nlp_DID
, ELS_CMD_ACC
);
1968 icmd
= &elsiocb
->iocb
;
1969 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
1970 pcmd
= (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1973 elsiocb
->context_un
.mbox
= mbox
;
1975 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
1976 pcmd
+= sizeof (uint32_t);
1977 memcpy(pcmd
, &phba
->fc_sparam
, sizeof (struct serv_parm
));
1980 cmdsize
= sizeof (uint32_t) + sizeof (PRLO
);
1981 elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
1982 ndlp
, ndlp
->nlp_DID
, ELS_CMD_PRLO
);
1986 icmd
= &elsiocb
->iocb
;
1987 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
1988 pcmd
= (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
1990 memcpy(pcmd
, ((struct lpfc_dmabuf
*) oldiocb
->context2
)->virt
,
1991 sizeof (uint32_t) + sizeof (PRLO
));
1992 *((uint32_t *) (pcmd
)) = ELS_CMD_PRLO_ACC
;
1993 els_pkt_ptr
= (ELS_PKT
*) pcmd
;
1994 els_pkt_ptr
->un
.prlo
.acceptRspCode
= PRLO_REQ_EXECUTED
;
2001 elsiocb
->context1
= NULL
;
2003 /* Xmit ELS ACC response tag <ulpIoTag> */
2004 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
2005 "%d:0128 Xmit ELS ACC response tag x%x "
2006 "Data: x%x x%x x%x x%x x%x\n",
2008 elsiocb
->iocb
.ulpIoTag
,
2009 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
2010 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
2012 if (ndlp
->nlp_flag
& NLP_LOGO_ACC
) {
2013 spin_lock_irq(phba
->host
->host_lock
);
2014 ndlp
->nlp_flag
&= ~NLP_LOGO_ACC
;
2015 spin_unlock_irq(phba
->host
->host_lock
);
2016 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_logo_acc
;
2018 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
2021 phba
->fc_stat
.elsXmitACC
++;
2022 spin_lock_irq(phba
->host
->host_lock
);
2023 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
2024 spin_unlock_irq(phba
->host
->host_lock
);
2025 if (rc
== IOCB_ERROR
) {
2026 lpfc_els_free_iocb(phba
, elsiocb
);
2033 lpfc_els_rsp_reject(struct lpfc_hba
* phba
, uint32_t rejectError
,
2034 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
)
2038 struct lpfc_iocbq
*elsiocb
;
2039 struct lpfc_sli_ring
*pring
;
2040 struct lpfc_sli
*psli
;
2046 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
2048 cmdsize
= 2 * sizeof (uint32_t);
2049 elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
2050 ndlp
, ndlp
->nlp_DID
, ELS_CMD_LS_RJT
);
2054 icmd
= &elsiocb
->iocb
;
2055 oldcmd
= &oldiocb
->iocb
;
2056 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
2057 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2059 *((uint32_t *) (pcmd
)) = ELS_CMD_LS_RJT
;
2060 pcmd
+= sizeof (uint32_t);
2061 *((uint32_t *) (pcmd
)) = rejectError
;
2063 /* Xmit ELS RJT <err> response tag <ulpIoTag> */
2064 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
2065 "%d:0129 Xmit ELS RJT x%x response tag x%x "
2066 "Data: x%x x%x x%x x%x x%x\n",
2068 rejectError
, elsiocb
->iocb
.ulpIoTag
,
2069 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
2070 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
2072 phba
->fc_stat
.elsXmitLSRJT
++;
2073 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
2074 spin_lock_irq(phba
->host
->host_lock
);
2075 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
2076 spin_unlock_irq(phba
->host
->host_lock
);
2077 if (rc
== IOCB_ERROR
) {
2078 lpfc_els_free_iocb(phba
, elsiocb
);
2085 lpfc_els_rsp_adisc_acc(struct lpfc_hba
* phba
,
2086 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
)
2091 struct lpfc_iocbq
*elsiocb
;
2092 struct lpfc_sli_ring
*pring
;
2093 struct lpfc_sli
*psli
;
2099 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
2101 cmdsize
= sizeof (uint32_t) + sizeof (ADISC
);
2102 elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
2103 ndlp
, ndlp
->nlp_DID
, ELS_CMD_ACC
);
2107 /* Xmit ADISC ACC response tag <ulpIoTag> */
2108 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
2109 "%d:0130 Xmit ADISC ACC response tag x%x "
2110 "Data: x%x x%x x%x x%x x%x\n",
2112 elsiocb
->iocb
.ulpIoTag
,
2113 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
2114 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
2116 icmd
= &elsiocb
->iocb
;
2117 oldcmd
= &oldiocb
->iocb
;
2118 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
2119 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2121 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
2122 pcmd
+= sizeof (uint32_t);
2124 ap
= (ADISC
*) (pcmd
);
2125 ap
->hardAL_PA
= phba
->fc_pref_ALPA
;
2126 memcpy(&ap
->portName
, &phba
->fc_portname
, sizeof (struct lpfc_name
));
2127 memcpy(&ap
->nodeName
, &phba
->fc_nodename
, sizeof (struct lpfc_name
));
2128 ap
->DID
= be32_to_cpu(phba
->fc_myDID
);
2130 phba
->fc_stat
.elsXmitACC
++;
2131 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
2132 spin_lock_irq(phba
->host
->host_lock
);
2133 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
2134 spin_unlock_irq(phba
->host
->host_lock
);
2135 if (rc
== IOCB_ERROR
) {
2136 lpfc_els_free_iocb(phba
, elsiocb
);
2143 lpfc_els_rsp_prli_acc(struct lpfc_hba
* phba
,
2144 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
)
2150 struct lpfc_iocbq
*elsiocb
;
2151 struct lpfc_sli_ring
*pring
;
2152 struct lpfc_sli
*psli
;
2158 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
2160 cmdsize
= sizeof (uint32_t) + sizeof (PRLI
);
2161 elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
, ndlp
,
2162 ndlp
->nlp_DID
, (ELS_CMD_ACC
| (ELS_CMD_PRLI
& ~ELS_RSP_MASK
)));
2166 /* Xmit PRLI ACC response tag <ulpIoTag> */
2167 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
2168 "%d:0131 Xmit PRLI ACC response tag x%x "
2169 "Data: x%x x%x x%x x%x x%x\n",
2171 elsiocb
->iocb
.ulpIoTag
,
2172 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
2173 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
2175 icmd
= &elsiocb
->iocb
;
2176 oldcmd
= &oldiocb
->iocb
;
2177 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
2178 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2180 *((uint32_t *) (pcmd
)) = (ELS_CMD_ACC
| (ELS_CMD_PRLI
& ~ELS_RSP_MASK
));
2181 pcmd
+= sizeof (uint32_t);
2183 /* For PRLI, remainder of payload is PRLI parameter page */
2184 memset(pcmd
, 0, sizeof (PRLI
));
2186 npr
= (PRLI
*) pcmd
;
2189 * If our firmware version is 3.20 or later,
2190 * set the following bits for FC-TAPE support.
2192 if (vpd
->rev
.feaLevelHigh
>= 0x02) {
2193 npr
->ConfmComplAllowed
= 1;
2195 npr
->TaskRetryIdReq
= 1;
2198 npr
->acceptRspCode
= PRLI_REQ_EXECUTED
;
2199 npr
->estabImagePair
= 1;
2200 npr
->readXferRdyDis
= 1;
2201 npr
->ConfmComplAllowed
= 1;
2203 npr
->prliType
= PRLI_FCP_TYPE
;
2204 npr
->initiatorFunc
= 1;
2206 phba
->fc_stat
.elsXmitACC
++;
2207 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
2209 spin_lock_irq(phba
->host
->host_lock
);
2210 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
2211 spin_unlock_irq(phba
->host
->host_lock
);
2212 if (rc
== IOCB_ERROR
) {
2213 lpfc_els_free_iocb(phba
, elsiocb
);
2220 lpfc_els_rsp_rnid_acc(struct lpfc_hba
* phba
,
2222 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
)
2227 struct lpfc_iocbq
*elsiocb
;
2228 struct lpfc_sli_ring
*pring
;
2229 struct lpfc_sli
*psli
;
2235 pring
= &psli
->ring
[LPFC_ELS_RING
];
2237 cmdsize
= sizeof (uint32_t) + sizeof (uint32_t)
2238 + (2 * sizeof (struct lpfc_name
));
2240 cmdsize
+= sizeof (RNID_TOP_DISC
);
2242 elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
2243 ndlp
, ndlp
->nlp_DID
, ELS_CMD_ACC
);
2247 /* Xmit RNID ACC response tag <ulpIoTag> */
2248 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
2249 "%d:0132 Xmit RNID ACC response tag x%x "
2252 elsiocb
->iocb
.ulpIoTag
,
2253 elsiocb
->iocb
.ulpContext
);
2255 icmd
= &elsiocb
->iocb
;
2256 oldcmd
= &oldiocb
->iocb
;
2257 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
2258 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2260 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
2261 pcmd
+= sizeof (uint32_t);
2263 memset(pcmd
, 0, sizeof (RNID
));
2264 rn
= (RNID
*) (pcmd
);
2265 rn
->Format
= format
;
2266 rn
->CommonLen
= (2 * sizeof (struct lpfc_name
));
2267 memcpy(&rn
->portName
, &phba
->fc_portname
, sizeof (struct lpfc_name
));
2268 memcpy(&rn
->nodeName
, &phba
->fc_nodename
, sizeof (struct lpfc_name
));
2271 rn
->SpecificLen
= 0;
2273 case RNID_TOPOLOGY_DISC
:
2274 rn
->SpecificLen
= sizeof (RNID_TOP_DISC
);
2275 memcpy(&rn
->un
.topologyDisc
.portName
,
2276 &phba
->fc_portname
, sizeof (struct lpfc_name
));
2277 rn
->un
.topologyDisc
.unitType
= RNID_HBA
;
2278 rn
->un
.topologyDisc
.physPort
= 0;
2279 rn
->un
.topologyDisc
.attachedNodes
= 0;
2283 rn
->SpecificLen
= 0;
2287 phba
->fc_stat
.elsXmitACC
++;
2288 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
2289 elsiocb
->context1
= NULL
; /* Don't need ndlp for cmpl,
2290 * it could be freed */
2292 spin_lock_irq(phba
->host
->host_lock
);
2293 rc
= lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0);
2294 spin_unlock_irq(phba
->host
->host_lock
);
2295 if (rc
== IOCB_ERROR
) {
2296 lpfc_els_free_iocb(phba
, elsiocb
);
2303 lpfc_els_disc_adisc(struct lpfc_hba
* phba
)
2306 struct lpfc_nodelist
*ndlp
, *next_ndlp
;
2309 /* go thru NPR list and issue any remaining ELS ADISCs */
2310 list_for_each_entry_safe(ndlp
, next_ndlp
, &phba
->fc_npr_list
,
2312 if (ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) {
2313 if (ndlp
->nlp_flag
& NLP_NPR_ADISC
) {
2314 ndlp
->nlp_flag
&= ~NLP_NPR_ADISC
;
2315 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2316 ndlp
->nlp_state
= NLP_STE_ADISC_ISSUE
;
2317 lpfc_nlp_list(phba
, ndlp
,
2319 lpfc_issue_els_adisc(phba
, ndlp
, 0);
2321 phba
->num_disc_nodes
++;
2322 if (phba
->num_disc_nodes
>=
2323 phba
->cfg_discovery_threads
) {
2324 spin_lock_irq(phba
->host
->host_lock
);
2325 phba
->fc_flag
|= FC_NLP_MORE
;
2326 spin_unlock_irq(phba
->host
->host_lock
);
2332 if (sentadisc
== 0) {
2333 spin_lock_irq(phba
->host
->host_lock
);
2334 phba
->fc_flag
&= ~FC_NLP_MORE
;
2335 spin_unlock_irq(phba
->host
->host_lock
);
2341 lpfc_els_disc_plogi(struct lpfc_hba
* phba
)
2344 struct lpfc_nodelist
*ndlp
, *next_ndlp
;
2347 /* go thru NPR list and issue any remaining ELS PLOGIs */
2348 list_for_each_entry_safe(ndlp
, next_ndlp
, &phba
->fc_npr_list
,
2350 if ((ndlp
->nlp_flag
& NLP_NPR_2B_DISC
) &&
2351 (!(ndlp
->nlp_flag
& NLP_DELAY_TMO
))) {
2352 if (!(ndlp
->nlp_flag
& NLP_NPR_ADISC
)) {
2353 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2354 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
2355 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
2356 lpfc_issue_els_plogi(phba
, ndlp
->nlp_DID
, 0);
2358 phba
->num_disc_nodes
++;
2359 if (phba
->num_disc_nodes
>=
2360 phba
->cfg_discovery_threads
) {
2361 spin_lock_irq(phba
->host
->host_lock
);
2362 phba
->fc_flag
|= FC_NLP_MORE
;
2363 spin_unlock_irq(phba
->host
->host_lock
);
2369 if (sentplogi
== 0) {
2370 spin_lock_irq(phba
->host
->host_lock
);
2371 phba
->fc_flag
&= ~FC_NLP_MORE
;
2372 spin_unlock_irq(phba
->host
->host_lock
);
2378 lpfc_els_flush_rscn(struct lpfc_hba
* phba
)
2380 struct lpfc_dmabuf
*mp
;
2383 for (i
= 0; i
< phba
->fc_rscn_id_cnt
; i
++) {
2384 mp
= phba
->fc_rscn_id_list
[i
];
2385 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
2387 phba
->fc_rscn_id_list
[i
] = NULL
;
2389 phba
->fc_rscn_id_cnt
= 0;
2390 spin_lock_irq(phba
->host
->host_lock
);
2391 phba
->fc_flag
&= ~(FC_RSCN_MODE
| FC_RSCN_DISCOVERY
);
2392 spin_unlock_irq(phba
->host
->host_lock
);
2393 lpfc_can_disctmo(phba
);
2398 lpfc_rscn_payload_check(struct lpfc_hba
* phba
, uint32_t did
)
2402 struct lpfc_dmabuf
*mp
;
2404 uint32_t payload_len
, cmd
, i
, match
;
2406 ns_did
.un
.word
= did
;
2409 /* Never match fabric nodes for RSCNs */
2410 if ((did
& Fabric_DID_MASK
) == Fabric_DID_MASK
)
2413 /* If we are doing a FULL RSCN rediscovery, match everything */
2414 if (phba
->fc_flag
& FC_RSCN_DISCOVERY
) {
2418 for (i
= 0; i
< phba
->fc_rscn_id_cnt
; i
++) {
2419 mp
= phba
->fc_rscn_id_list
[i
];
2420 lp
= (uint32_t *) mp
->virt
;
2422 payload_len
= be32_to_cpu(cmd
) & 0xffff; /* payload length */
2423 payload_len
-= sizeof (uint32_t); /* take off word 0 */
2424 while (payload_len
) {
2425 rscn_did
.un
.word
= *lp
++;
2426 rscn_did
.un
.word
= be32_to_cpu(rscn_did
.un
.word
);
2427 payload_len
-= sizeof (uint32_t);
2428 switch (rscn_did
.un
.b
.resv
) {
2429 case 0: /* Single N_Port ID effected */
2430 if (ns_did
.un
.word
== rscn_did
.un
.word
) {
2434 case 1: /* Whole N_Port Area effected */
2435 if ((ns_did
.un
.b
.domain
== rscn_did
.un
.b
.domain
)
2436 && (ns_did
.un
.b
.area
== rscn_did
.un
.b
.area
))
2441 case 2: /* Whole N_Port Domain effected */
2442 if (ns_did
.un
.b
.domain
== rscn_did
.un
.b
.domain
)
2447 case 3: /* Whole Fabric effected */
2451 /* Unknown Identifier in RSCN list */
2452 lpfc_printf_log(phba
, KERN_ERR
, LOG_DISCOVERY
,
2453 "%d:0217 Unknown Identifier in "
2454 "RSCN payload Data: x%x\n",
2455 phba
->brd_no
, rscn_did
.un
.word
);
2467 lpfc_rscn_recovery_check(struct lpfc_hba
* phba
)
2469 struct lpfc_nodelist
*ndlp
= NULL
, *next_ndlp
;
2470 struct list_head
*listp
;
2471 struct list_head
*node_list
[7];
2474 /* Look at all nodes effected by pending RSCNs and move
2477 node_list
[0] = &phba
->fc_npr_list
; /* MUST do this list first */
2478 node_list
[1] = &phba
->fc_nlpmap_list
;
2479 node_list
[2] = &phba
->fc_nlpunmap_list
;
2480 node_list
[3] = &phba
->fc_prli_list
;
2481 node_list
[4] = &phba
->fc_reglogin_list
;
2482 node_list
[5] = &phba
->fc_adisc_list
;
2483 node_list
[6] = &phba
->fc_plogi_list
;
2484 for (i
= 0; i
< 7; i
++) {
2485 listp
= node_list
[i
];
2486 if (list_empty(listp
))
2489 list_for_each_entry_safe(ndlp
, next_ndlp
, listp
, nlp_listp
) {
2490 if (!(lpfc_rscn_payload_check(phba
, ndlp
->nlp_DID
)))
2493 lpfc_disc_state_machine(phba
, ndlp
, NULL
,
2494 NLP_EVT_DEVICE_RECOVERY
);
2496 /* Make sure NLP_DELAY_TMO is NOT running
2497 * after a device recovery event.
2499 if (ndlp
->nlp_flag
& NLP_DELAY_TMO
)
2500 lpfc_cancel_retry_delay_tmo(phba
, ndlp
);
2507 lpfc_els_rcv_rscn(struct lpfc_hba
* phba
,
2508 struct lpfc_iocbq
* cmdiocb
,
2509 struct lpfc_nodelist
* ndlp
, uint8_t newnode
)
2511 struct lpfc_dmabuf
*pcmd
;
2514 uint32_t payload_len
, cmd
;
2517 icmd
= &cmdiocb
->iocb
;
2518 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2519 lp
= (uint32_t *) pcmd
->virt
;
2522 payload_len
= be32_to_cpu(cmd
) & 0xffff; /* payload length */
2523 payload_len
-= sizeof (uint32_t); /* take off word 0 */
2524 cmd
&= ELS_CMD_MASK
;
2527 lpfc_printf_log(phba
,
2530 "%d:0214 RSCN received Data: x%x x%x x%x x%x\n",
2532 phba
->fc_flag
, payload_len
, *lp
, phba
->fc_rscn_id_cnt
);
2534 for (i
= 0; i
< payload_len
/sizeof(uint32_t); i
++)
2535 fc_host_post_event(phba
->host
, fc_get_event_number(),
2536 FCH_EVT_RSCN
, lp
[i
]);
2538 /* If we are about to begin discovery, just ACC the RSCN.
2539 * Discovery processing will satisfy it.
2541 if (phba
->hba_state
<= LPFC_NS_QRY
) {
2542 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
,
2547 /* If we are already processing an RSCN, save the received
2548 * RSCN payload buffer, cmdiocb->context2 to process later.
2550 if (phba
->fc_flag
& (FC_RSCN_MODE
| FC_NDISC_ACTIVE
)) {
2551 if ((phba
->fc_rscn_id_cnt
< FC_MAX_HOLD_RSCN
) &&
2552 !(phba
->fc_flag
& FC_RSCN_DISCOVERY
)) {
2553 spin_lock_irq(phba
->host
->host_lock
);
2554 phba
->fc_flag
|= FC_RSCN_MODE
;
2555 spin_unlock_irq(phba
->host
->host_lock
);
2556 phba
->fc_rscn_id_list
[phba
->fc_rscn_id_cnt
++] = pcmd
;
2558 /* If we zero, cmdiocb->context2, the calling
2559 * routine will not try to free it.
2561 cmdiocb
->context2
= NULL
;
2564 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
2565 "%d:0235 Deferred RSCN "
2566 "Data: x%x x%x x%x\n",
2567 phba
->brd_no
, phba
->fc_rscn_id_cnt
,
2568 phba
->fc_flag
, phba
->hba_state
);
2570 spin_lock_irq(phba
->host
->host_lock
);
2571 phba
->fc_flag
|= FC_RSCN_DISCOVERY
;
2572 spin_unlock_irq(phba
->host
->host_lock
);
2573 /* ReDiscovery RSCN */
2574 lpfc_printf_log(phba
, KERN_INFO
, LOG_DISCOVERY
,
2575 "%d:0234 ReDiscovery RSCN "
2576 "Data: x%x x%x x%x\n",
2577 phba
->brd_no
, phba
->fc_rscn_id_cnt
,
2578 phba
->fc_flag
, phba
->hba_state
);
2581 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
,
2584 /* send RECOVERY event for ALL nodes that match RSCN payload */
2585 lpfc_rscn_recovery_check(phba
);
2589 phba
->fc_flag
|= FC_RSCN_MODE
;
2590 phba
->fc_rscn_id_list
[phba
->fc_rscn_id_cnt
++] = pcmd
;
2592 * If we zero, cmdiocb->context2, the calling routine will
2593 * not try to free it.
2595 cmdiocb
->context2
= NULL
;
2597 lpfc_set_disctmo(phba
);
2600 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, newnode
);
2602 /* send RECOVERY event for ALL nodes that match RSCN payload */
2603 lpfc_rscn_recovery_check(phba
);
2605 return lpfc_els_handle_rscn(phba
);
2609 lpfc_els_handle_rscn(struct lpfc_hba
* phba
)
2611 struct lpfc_nodelist
*ndlp
;
2613 /* Start timer for RSCN processing */
2614 lpfc_set_disctmo(phba
);
2616 /* RSCN processed */
2617 lpfc_printf_log(phba
,
2620 "%d:0215 RSCN processed Data: x%x x%x x%x x%x\n",
2622 phba
->fc_flag
, 0, phba
->fc_rscn_id_cnt
,
2625 /* To process RSCN, first compare RSCN data with NameServer */
2626 phba
->fc_ns_retry
= 0;
2627 ndlp
= lpfc_findnode_did(phba
, NLP_SEARCH_UNMAPPED
, NameServer_DID
);
2629 /* Good ndlp, issue CT Request to NameServer */
2630 if (lpfc_ns_cmd(phba
, ndlp
, SLI_CTNS_GID_FT
) == 0) {
2631 /* Wait for NameServer query cmpl before we can
2636 /* If login to NameServer does not exist, issue one */
2637 /* Good status, issue PLOGI to NameServer */
2638 ndlp
= lpfc_findnode_did(phba
, NLP_SEARCH_ALL
, NameServer_DID
);
2640 /* Wait for NameServer login cmpl before we can
2644 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
2646 lpfc_els_flush_rscn(phba
);
2649 lpfc_nlp_init(phba
, ndlp
, NameServer_DID
);
2650 ndlp
->nlp_type
|= NLP_FABRIC
;
2651 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
2652 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
2653 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
2654 lpfc_issue_els_plogi(phba
, NameServer_DID
, 0);
2655 /* Wait for NameServer login cmpl before we can
2661 lpfc_els_flush_rscn(phba
);
2666 lpfc_els_rcv_flogi(struct lpfc_hba
* phba
,
2667 struct lpfc_iocbq
* cmdiocb
,
2668 struct lpfc_nodelist
* ndlp
, uint8_t newnode
)
2670 struct lpfc_dmabuf
*pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2671 uint32_t *lp
= (uint32_t *) pcmd
->virt
;
2672 IOCB_t
*icmd
= &cmdiocb
->iocb
;
2673 struct serv_parm
*sp
;
2680 sp
= (struct serv_parm
*) lp
;
2682 /* FLOGI received */
2684 lpfc_set_disctmo(phba
);
2686 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
2687 /* We should never receive a FLOGI in loop mode, ignore it */
2688 did
= icmd
->un
.elsreq64
.remoteID
;
2690 /* An FLOGI ELS command <elsCmd> was received from DID <did> in
2692 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
2693 "%d:0113 An FLOGI ELS command x%x was received "
2694 "from DID x%x in Loop Mode\n",
2695 phba
->brd_no
, cmd
, did
);
2701 if ((lpfc_check_sparm(phba
, ndlp
, sp
, CLASS3
))) {
2702 /* For a FLOGI we accept, then if our portname is greater
2703 * then the remote portname we initiate Nport login.
2706 rc
= memcmp(&phba
->fc_portname
, &sp
->portName
,
2707 sizeof (struct lpfc_name
));
2710 if ((mbox
= mempool_alloc(phba
->mbox_mem_pool
,
2711 GFP_KERNEL
)) == 0) {
2714 lpfc_linkdown(phba
);
2715 lpfc_init_link(phba
, mbox
,
2717 phba
->cfg_link_speed
);
2718 mbox
->mb
.un
.varInitLnk
.lipsr_AL_PA
= 0;
2719 mbox
->mbox_cmpl
= lpfc_sli_def_mbox_cmpl
;
2720 rc
= lpfc_sli_issue_mbox
2721 (phba
, mbox
, (MBX_NOWAIT
| MBX_STOP_IOCB
));
2722 if (rc
== MBX_NOT_FINISHED
) {
2723 mempool_free( mbox
, phba
->mbox_mem_pool
);
2726 } else if (rc
> 0) { /* greater than */
2727 spin_lock_irq(phba
->host
->host_lock
);
2728 phba
->fc_flag
|= FC_PT2PT_PLOGI
;
2729 spin_unlock_irq(phba
->host
->host_lock
);
2731 phba
->fc_flag
|= FC_PT2PT
;
2732 phba
->fc_flag
&= ~(FC_FABRIC
| FC_PUBLIC_LOOP
);
2734 /* Reject this request because invalid parameters */
2735 stat
.un
.b
.lsRjtRsvd0
= 0;
2736 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
2737 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_SPARM_OPTIONS
;
2738 stat
.un
.b
.vendorUnique
= 0;
2739 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
2744 lpfc_els_rsp_acc(phba
, ELS_CMD_PLOGI
, cmdiocb
, ndlp
, NULL
, newnode
);
2750 lpfc_els_rcv_rnid(struct lpfc_hba
* phba
,
2751 struct lpfc_iocbq
* cmdiocb
, struct lpfc_nodelist
* ndlp
)
2753 struct lpfc_dmabuf
*pcmd
;
2760 icmd
= &cmdiocb
->iocb
;
2761 did
= icmd
->un
.elsreq64
.remoteID
;
2762 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2763 lp
= (uint32_t *) pcmd
->virt
;
2770 switch (rn
->Format
) {
2772 case RNID_TOPOLOGY_DISC
:
2774 lpfc_els_rsp_rnid_acc(phba
, rn
->Format
, cmdiocb
, ndlp
);
2777 /* Reject this request because format not supported */
2778 stat
.un
.b
.lsRjtRsvd0
= 0;
2779 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
2780 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CANT_GIVE_DATA
;
2781 stat
.un
.b
.vendorUnique
= 0;
2782 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
2788 lpfc_els_rcv_lirr(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
2789 struct lpfc_nodelist
* ndlp
)
2793 /* For now, unconditionally reject this command */
2794 stat
.un
.b
.lsRjtRsvd0
= 0;
2795 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
2796 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CANT_GIVE_DATA
;
2797 stat
.un
.b
.vendorUnique
= 0;
2798 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
2803 lpfc_els_rsp_rps_acc(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
)
2805 struct lpfc_sli
*psli
;
2806 struct lpfc_sli_ring
*pring
;
2811 struct lpfc_iocbq
*elsiocb
;
2812 struct lpfc_nodelist
*ndlp
;
2813 uint16_t xri
, status
;
2817 pring
= &psli
->ring
[LPFC_ELS_RING
];
2820 ndlp
= (struct lpfc_nodelist
*) pmb
->context2
;
2821 xri
= (uint16_t) ((unsigned long)(pmb
->context1
));
2822 pmb
->context1
= NULL
;
2823 pmb
->context2
= NULL
;
2825 if (mb
->mbxStatus
) {
2826 mempool_free( pmb
, phba
->mbox_mem_pool
);
2830 cmdsize
= sizeof(RPS_RSP
) + sizeof(uint32_t);
2831 mempool_free( pmb
, phba
->mbox_mem_pool
);
2832 elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, lpfc_max_els_tries
, ndlp
,
2833 ndlp
->nlp_DID
, ELS_CMD_ACC
);
2837 icmd
= &elsiocb
->iocb
;
2838 icmd
->ulpContext
= xri
;
2840 pcmd
= (uint8_t *) (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2841 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
2842 pcmd
+= sizeof (uint32_t); /* Skip past command */
2843 rps_rsp
= (RPS_RSP
*)pcmd
;
2845 if (phba
->fc_topology
!= TOPOLOGY_LOOP
)
2849 if (phba
->fc_flag
& FC_FABRIC
)
2853 rps_rsp
->portStatus
= be16_to_cpu(status
);
2854 rps_rsp
->linkFailureCnt
= be32_to_cpu(mb
->un
.varRdLnk
.linkFailureCnt
);
2855 rps_rsp
->lossSyncCnt
= be32_to_cpu(mb
->un
.varRdLnk
.lossSyncCnt
);
2856 rps_rsp
->lossSignalCnt
= be32_to_cpu(mb
->un
.varRdLnk
.lossSignalCnt
);
2857 rps_rsp
->primSeqErrCnt
= be32_to_cpu(mb
->un
.varRdLnk
.primSeqErrCnt
);
2858 rps_rsp
->invalidXmitWord
= be32_to_cpu(mb
->un
.varRdLnk
.invalidXmitWord
);
2859 rps_rsp
->crcCnt
= be32_to_cpu(mb
->un
.varRdLnk
.crcCnt
);
2861 /* Xmit ELS RPS ACC response tag <ulpIoTag> */
2862 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
2863 "%d:0118 Xmit ELS RPS ACC response tag x%x "
2864 "Data: x%x x%x x%x x%x x%x\n",
2866 elsiocb
->iocb
.ulpIoTag
,
2867 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
2868 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
2870 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
2871 phba
->fc_stat
.elsXmitACC
++;
2872 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
2873 lpfc_els_free_iocb(phba
, elsiocb
);
2879 lpfc_els_rcv_rps(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
2880 struct lpfc_nodelist
* ndlp
)
2885 struct lpfc_dmabuf
*pcmd
;
2889 if ((ndlp
->nlp_state
!= NLP_STE_UNMAPPED_NODE
) &&
2890 (ndlp
->nlp_state
!= NLP_STE_MAPPED_NODE
)) {
2891 stat
.un
.b
.lsRjtRsvd0
= 0;
2892 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
2893 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CANT_GIVE_DATA
;
2894 stat
.un
.b
.vendorUnique
= 0;
2895 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
2898 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
2899 lp
= (uint32_t *) pcmd
->virt
;
2900 flag
= (be32_to_cpu(*lp
++) & 0xf);
2904 ((flag
== 1) && (be32_to_cpu(rps
->un
.portNum
) == 0)) ||
2905 ((flag
== 2) && (memcmp(&rps
->un
.portName
, &phba
->fc_portname
,
2906 sizeof (struct lpfc_name
)) == 0))) {
2907 if ((mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_ATOMIC
))) {
2908 lpfc_read_lnk_stat(phba
, mbox
);
2910 (void *)((unsigned long)cmdiocb
->iocb
.ulpContext
);
2911 mbox
->context2
= ndlp
;
2912 mbox
->mbox_cmpl
= lpfc_els_rsp_rps_acc
;
2913 if (lpfc_sli_issue_mbox (phba
, mbox
,
2914 (MBX_NOWAIT
| MBX_STOP_IOCB
)) != MBX_NOT_FINISHED
) {
2915 /* Mbox completion will send ELS Response */
2918 mempool_free(mbox
, phba
->mbox_mem_pool
);
2921 stat
.un
.b
.lsRjtRsvd0
= 0;
2922 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
2923 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CANT_GIVE_DATA
;
2924 stat
.un
.b
.vendorUnique
= 0;
2925 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
2930 lpfc_els_rsp_rpl_acc(struct lpfc_hba
* phba
, uint16_t cmdsize
,
2931 struct lpfc_iocbq
* oldiocb
, struct lpfc_nodelist
* ndlp
)
2936 struct lpfc_iocbq
*elsiocb
;
2937 struct lpfc_sli_ring
*pring
;
2938 struct lpfc_sli
*psli
;
2942 pring
= &psli
->ring
[LPFC_ELS_RING
]; /* ELS ring */
2944 elsiocb
= lpfc_prep_els_iocb(phba
, 0, cmdsize
, oldiocb
->retry
,
2945 ndlp
, ndlp
->nlp_DID
, ELS_CMD_ACC
);
2949 icmd
= &elsiocb
->iocb
;
2950 oldcmd
= &oldiocb
->iocb
;
2951 icmd
->ulpContext
= oldcmd
->ulpContext
; /* Xri */
2953 pcmd
= (((struct lpfc_dmabuf
*) elsiocb
->context2
)->virt
);
2954 *((uint32_t *) (pcmd
)) = ELS_CMD_ACC
;
2955 pcmd
+= sizeof (uint16_t);
2956 *((uint16_t *)(pcmd
)) = be16_to_cpu(cmdsize
);
2957 pcmd
+= sizeof(uint16_t);
2959 /* Setup the RPL ACC payload */
2960 rpl_rsp
.listLen
= be32_to_cpu(1);
2962 rpl_rsp
.port_num_blk
.portNum
= 0;
2963 rpl_rsp
.port_num_blk
.portID
= be32_to_cpu(phba
->fc_myDID
);
2964 memcpy(&rpl_rsp
.port_num_blk
.portName
, &phba
->fc_portname
,
2965 sizeof(struct lpfc_name
));
2967 memcpy(pcmd
, &rpl_rsp
, cmdsize
- sizeof(uint32_t));
2970 /* Xmit ELS RPL ACC response tag <ulpIoTag> */
2971 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
2972 "%d:0120 Xmit ELS RPL ACC response tag x%x "
2973 "Data: x%x x%x x%x x%x x%x\n",
2975 elsiocb
->iocb
.ulpIoTag
,
2976 elsiocb
->iocb
.ulpContext
, ndlp
->nlp_DID
,
2977 ndlp
->nlp_flag
, ndlp
->nlp_state
, ndlp
->nlp_rpi
);
2979 elsiocb
->iocb_cmpl
= lpfc_cmpl_els_acc
;
2981 phba
->fc_stat
.elsXmitACC
++;
2982 if (lpfc_sli_issue_iocb(phba
, pring
, elsiocb
, 0) == IOCB_ERROR
) {
2983 lpfc_els_free_iocb(phba
, elsiocb
);
2990 lpfc_els_rcv_rpl(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
2991 struct lpfc_nodelist
* ndlp
)
2993 struct lpfc_dmabuf
*pcmd
;
3000 if ((ndlp
->nlp_state
!= NLP_STE_UNMAPPED_NODE
) &&
3001 (ndlp
->nlp_state
!= NLP_STE_MAPPED_NODE
)) {
3002 stat
.un
.b
.lsRjtRsvd0
= 0;
3003 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
3004 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_CANT_GIVE_DATA
;
3005 stat
.un
.b
.vendorUnique
= 0;
3006 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, cmdiocb
, ndlp
);
3009 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
3010 lp
= (uint32_t *) pcmd
->virt
;
3011 rpl
= (RPL
*) (lp
+ 1);
3013 maxsize
= be32_to_cpu(rpl
->maxsize
);
3015 /* We support only one port */
3016 if ((rpl
->index
== 0) &&
3018 ((maxsize
* sizeof(uint32_t)) >= sizeof(RPL_RSP
)))) {
3019 cmdsize
= sizeof(uint32_t) + sizeof(RPL_RSP
);
3021 cmdsize
= sizeof(uint32_t) + maxsize
* sizeof(uint32_t);
3023 lpfc_els_rsp_rpl_acc(phba
, cmdsize
, cmdiocb
, ndlp
);
3029 lpfc_els_rcv_farp(struct lpfc_hba
* phba
,
3030 struct lpfc_iocbq
* cmdiocb
, struct lpfc_nodelist
* ndlp
)
3032 struct lpfc_dmabuf
*pcmd
;
3036 uint32_t cmd
, cnt
, did
;
3038 icmd
= &cmdiocb
->iocb
;
3039 did
= icmd
->un
.elsreq64
.remoteID
;
3040 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
3041 lp
= (uint32_t *) pcmd
->virt
;
3046 /* FARP-REQ received from DID <did> */
3047 lpfc_printf_log(phba
,
3050 "%d:0601 FARP-REQ received from DID x%x\n",
3053 /* We will only support match on WWPN or WWNN */
3054 if (fp
->Mflags
& ~(FARP_MATCH_NODE
| FARP_MATCH_PORT
)) {
3059 /* If this FARP command is searching for my portname */
3060 if (fp
->Mflags
& FARP_MATCH_PORT
) {
3061 if (memcmp(&fp
->RportName
, &phba
->fc_portname
,
3062 sizeof (struct lpfc_name
)) == 0)
3066 /* If this FARP command is searching for my nodename */
3067 if (fp
->Mflags
& FARP_MATCH_NODE
) {
3068 if (memcmp(&fp
->RnodeName
, &phba
->fc_nodename
,
3069 sizeof (struct lpfc_name
)) == 0)
3074 if ((ndlp
->nlp_state
== NLP_STE_UNMAPPED_NODE
) ||
3075 (ndlp
->nlp_state
== NLP_STE_MAPPED_NODE
)) {
3076 /* Log back into the node before sending the FARP. */
3077 if (fp
->Rflags
& FARP_REQUEST_PLOGI
) {
3078 ndlp
->nlp_prev_state
= ndlp
->nlp_state
;
3079 ndlp
->nlp_state
= NLP_STE_PLOGI_ISSUE
;
3080 lpfc_nlp_list(phba
, ndlp
, NLP_PLOGI_LIST
);
3081 lpfc_issue_els_plogi(phba
, ndlp
->nlp_DID
, 0);
3084 /* Send a FARP response to that node */
3085 if (fp
->Rflags
& FARP_REQUEST_FARPR
) {
3086 lpfc_issue_els_farpr(phba
, did
, 0);
3094 lpfc_els_rcv_farpr(struct lpfc_hba
* phba
,
3095 struct lpfc_iocbq
* cmdiocb
, struct lpfc_nodelist
* ndlp
)
3097 struct lpfc_dmabuf
*pcmd
;
3102 icmd
= &cmdiocb
->iocb
;
3103 did
= icmd
->un
.elsreq64
.remoteID
;
3104 pcmd
= (struct lpfc_dmabuf
*) cmdiocb
->context2
;
3105 lp
= (uint32_t *) pcmd
->virt
;
3108 /* FARP-RSP received from DID <did> */
3109 lpfc_printf_log(phba
,
3112 "%d:0600 FARP-RSP received from DID x%x\n",
3115 /* ACCEPT the Farp resp request */
3116 lpfc_els_rsp_acc(phba
, ELS_CMD_ACC
, cmdiocb
, ndlp
, NULL
, 0);
3122 lpfc_els_rcv_fan(struct lpfc_hba
* phba
, struct lpfc_iocbq
* cmdiocb
,
3123 struct lpfc_nodelist
* fan_ndlp
)
3125 struct lpfc_dmabuf
*pcmd
;
3130 struct lpfc_nodelist
*ndlp
, *next_ndlp
;
3133 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
, "%d:0265 FAN received\n",
3136 icmd
= &cmdiocb
->iocb
;
3137 did
= icmd
->un
.elsreq64
.remoteID
;
3138 pcmd
= (struct lpfc_dmabuf
*)cmdiocb
->context2
;
3139 lp
= (uint32_t *)pcmd
->virt
;
3144 /* FAN received; Fan does not have a reply sequence */
3146 if (phba
->hba_state
== LPFC_LOCAL_CFG_LINK
) {
3147 if ((memcmp(&phba
->fc_fabparam
.nodeName
, &fp
->FnodeName
,
3148 sizeof(struct lpfc_name
)) != 0) ||
3149 (memcmp(&phba
->fc_fabparam
.portName
, &fp
->FportName
,
3150 sizeof(struct lpfc_name
)) != 0)) {
3152 * This node has switched fabrics. FLOGI is required
3153 * Clean up the old rpi's
3156 list_for_each_entry_safe(ndlp
, next_ndlp
,
3157 &phba
->fc_npr_list
, nlp_listp
) {
3159 if (ndlp
->nlp_type
& NLP_FABRIC
) {
3161 * Clean up old Fabric, Nameserver and
3162 * other NLP_FABRIC logins
3164 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
3165 } else if (!(ndlp
->nlp_flag
& NLP_NPR_ADISC
)) {
3166 /* Fail outstanding I/O now since this
3167 * device is marked for PLOGI
3169 lpfc_unreg_rpi(phba
, ndlp
);
3173 phba
->hba_state
= LPFC_FLOGI
;
3174 lpfc_set_disctmo(phba
);
3175 lpfc_initial_flogi(phba
);
3178 /* Discovery not needed,
3179 * move the nodes to their original state.
3181 list_for_each_entry_safe(ndlp
, next_ndlp
, &phba
->fc_npr_list
,
3184 switch (ndlp
->nlp_prev_state
) {
3185 case NLP_STE_UNMAPPED_NODE
:
3186 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
3187 ndlp
->nlp_state
= NLP_STE_UNMAPPED_NODE
;
3188 lpfc_nlp_list(phba
, ndlp
, NLP_UNMAPPED_LIST
);
3191 case NLP_STE_MAPPED_NODE
:
3192 ndlp
->nlp_prev_state
= NLP_STE_NPR_NODE
;
3193 ndlp
->nlp_state
= NLP_STE_MAPPED_NODE
;
3194 lpfc_nlp_list(phba
, ndlp
, NLP_MAPPED_LIST
);
3202 /* Start discovery - this should just do CLEAR_LA */
3203 lpfc_disc_start(phba
);
3209 lpfc_els_timeout(unsigned long ptr
)
3211 struct lpfc_hba
*phba
;
3212 unsigned long iflag
;
3214 phba
= (struct lpfc_hba
*)ptr
;
3217 spin_lock_irqsave(phba
->host
->host_lock
, iflag
);
3218 if (!(phba
->work_hba_events
& WORKER_ELS_TMO
)) {
3219 phba
->work_hba_events
|= WORKER_ELS_TMO
;
3220 if (phba
->work_wait
)
3221 wake_up(phba
->work_wait
);
3223 spin_unlock_irqrestore(phba
->host
->host_lock
, iflag
);
3228 lpfc_els_timeout_handler(struct lpfc_hba
*phba
)
3230 struct lpfc_sli_ring
*pring
;
3231 struct lpfc_iocbq
*tmp_iocb
, *piocb
;
3233 struct lpfc_dmabuf
*pcmd
;
3234 struct list_head
*dlp
;
3236 uint32_t els_command
;
3242 spin_lock_irq(phba
->host
->host_lock
);
3243 /* If the timer is already canceled do nothing */
3244 if (!(phba
->work_hba_events
& WORKER_ELS_TMO
)) {
3245 spin_unlock_irq(phba
->host
->host_lock
);
3248 timeout
= (uint32_t)(phba
->fc_ratov
<< 1);
3250 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
3251 dlp
= &pring
->txcmplq
;
3253 list_for_each_entry_safe(piocb
, tmp_iocb
, &pring
->txcmplq
, list
) {
3256 if (piocb
->iocb_flag
& LPFC_IO_LIBDFC
) {
3259 pcmd
= (struct lpfc_dmabuf
*) piocb
->context2
;
3260 elscmd
= (uint32_t *) (pcmd
->virt
);
3261 els_command
= *elscmd
;
3263 if ((els_command
== ELS_CMD_FARP
)
3264 || (els_command
== ELS_CMD_FARPR
)) {
3268 if (piocb
->drvrTimeout
> 0) {
3269 if (piocb
->drvrTimeout
>= timeout
) {
3270 piocb
->drvrTimeout
-= timeout
;
3272 piocb
->drvrTimeout
= 0;
3277 list_del(&piocb
->list
);
3278 pring
->txcmplq_cnt
--;
3280 if (cmd
->ulpCommand
== CMD_GEN_REQUEST64_CR
) {
3281 struct lpfc_nodelist
*ndlp
;
3282 spin_unlock_irq(phba
->host
->host_lock
);
3283 ndlp
= lpfc_findnode_rpi(phba
, cmd
->ulpContext
);
3284 spin_lock_irq(phba
->host
->host_lock
);
3285 remote_ID
= ndlp
->nlp_DID
;
3286 if (cmd
->un
.elsreq64
.bdl
.ulpIoTag32
) {
3287 lpfc_sli_issue_abort_iotag32(phba
,
3291 remote_ID
= cmd
->un
.elsreq64
.remoteID
;
3294 lpfc_printf_log(phba
,
3297 "%d:0127 ELS timeout Data: x%x x%x x%x x%x\n",
3298 phba
->brd_no
, els_command
,
3299 remote_ID
, cmd
->ulpCommand
, cmd
->ulpIoTag
);
3302 * The iocb has timed out; abort it.
3304 if (piocb
->iocb_cmpl
) {
3305 cmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
3306 cmd
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
3307 spin_unlock_irq(phba
->host
->host_lock
);
3308 (piocb
->iocb_cmpl
) (phba
, piocb
, piocb
);
3309 spin_lock_irq(phba
->host
->host_lock
);
3311 lpfc_sli_release_iocbq(phba
, piocb
);
3313 if (phba
->sli
.ring
[LPFC_ELS_RING
].txcmplq_cnt
)
3314 mod_timer(&phba
->els_tmofunc
, jiffies
+ HZ
* timeout
);
3316 spin_unlock_irq(phba
->host
->host_lock
);
3320 lpfc_els_flush_cmd(struct lpfc_hba
* phba
)
3322 struct lpfc_sli_ring
*pring
;
3323 struct lpfc_iocbq
*tmp_iocb
, *piocb
;
3325 struct lpfc_dmabuf
*pcmd
;
3327 uint32_t els_command
;
3329 pring
= &phba
->sli
.ring
[LPFC_ELS_RING
];
3330 spin_lock_irq(phba
->host
->host_lock
);
3331 list_for_each_entry_safe(piocb
, tmp_iocb
, &pring
->txq
, list
) {
3334 if (piocb
->iocb_flag
& LPFC_IO_LIBDFC
) {
3338 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
3339 if ((cmd
->ulpCommand
== CMD_QUE_RING_BUF_CN
) ||
3340 (cmd
->ulpCommand
== CMD_QUE_RING_BUF64_CN
) ||
3341 (cmd
->ulpCommand
== CMD_CLOSE_XRI_CN
) ||
3342 (cmd
->ulpCommand
== CMD_ABORT_XRI_CN
)) {
3346 pcmd
= (struct lpfc_dmabuf
*) piocb
->context2
;
3347 elscmd
= (uint32_t *) (pcmd
->virt
);
3348 els_command
= *elscmd
;
3350 list_del(&piocb
->list
);
3351 pring
->txcmplq_cnt
--;
3353 cmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
3354 cmd
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
3356 if (piocb
->iocb_cmpl
) {
3357 spin_unlock_irq(phba
->host
->host_lock
);
3358 (piocb
->iocb_cmpl
) (phba
, piocb
, piocb
);
3359 spin_lock_irq(phba
->host
->host_lock
);
3361 lpfc_sli_release_iocbq(phba
, piocb
);
3364 list_for_each_entry_safe(piocb
, tmp_iocb
, &pring
->txcmplq
, list
) {
3367 if (piocb
->iocb_flag
& LPFC_IO_LIBDFC
) {
3370 pcmd
= (struct lpfc_dmabuf
*) piocb
->context2
;
3371 elscmd
= (uint32_t *) (pcmd
->virt
);
3372 els_command
= *elscmd
;
3374 list_del(&piocb
->list
);
3375 pring
->txcmplq_cnt
--;
3377 cmd
->ulpStatus
= IOSTAT_LOCAL_REJECT
;
3378 cmd
->un
.ulpWord
[4] = IOERR_SLI_ABORTED
;
3380 if (piocb
->iocb_cmpl
) {
3381 spin_unlock_irq(phba
->host
->host_lock
);
3382 (piocb
->iocb_cmpl
) (phba
, piocb
, piocb
);
3383 spin_lock_irq(phba
->host
->host_lock
);
3385 lpfc_sli_release_iocbq(phba
, piocb
);
3387 spin_unlock_irq(phba
->host
->host_lock
);
3392 lpfc_els_unsol_event(struct lpfc_hba
* phba
,
3393 struct lpfc_sli_ring
* pring
, struct lpfc_iocbq
* elsiocb
)
3395 struct lpfc_sli
*psli
;
3396 struct lpfc_nodelist
*ndlp
;
3397 struct lpfc_dmabuf
*mp
;
3404 uint32_t drop_cmd
= 0; /* by default do NOT drop received cmd */
3405 uint32_t rjt_err
= 0;
3408 icmd
= &elsiocb
->iocb
;
3410 if ((icmd
->ulpStatus
== IOSTAT_LOCAL_REJECT
) &&
3411 ((icmd
->un
.ulpWord
[4] & 0xff) == IOERR_RCV_BUFFER_WAITING
)) {
3412 /* Not enough posted buffers; Try posting more buffers */
3413 phba
->fc_stat
.NoRcvBuf
++;
3414 lpfc_post_buffer(phba
, pring
, 0, 1);
3418 /* If there are no BDEs associated with this IOCB,
3419 * there is nothing to do.
3421 if (icmd
->ulpBdeCount
== 0)
3424 /* type of ELS cmd is first 32bit word in packet */
3425 mp
= lpfc_sli_ringpostbuf_get(phba
, pring
, getPaddr(icmd
->un
.
3429 cont64
[0].addrLow
));
3436 lp
= (uint32_t *) mp
->virt
;
3438 lpfc_post_buffer(phba
, &psli
->ring
[LPFC_ELS_RING
], 1, 1);
3440 if (icmd
->ulpStatus
) {
3441 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3447 /* Check to see if link went down during discovery */
3448 if (lpfc_els_chk_latt(phba
)) {
3449 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3455 did
= icmd
->un
.rcvels
.remoteID
;
3456 ndlp
= lpfc_findnode_did(phba
, NLP_SEARCH_ALL
, did
);
3458 /* Cannot find existing Fabric ndlp, so allocate a new one */
3459 ndlp
= mempool_alloc(phba
->nlp_mem_pool
, GFP_KERNEL
);
3461 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3467 lpfc_nlp_init(phba
, ndlp
, did
);
3469 if ((did
& Fabric_DID_MASK
) == Fabric_DID_MASK
) {
3470 ndlp
->nlp_type
|= NLP_FABRIC
;
3472 ndlp
->nlp_state
= NLP_STE_UNUSED_NODE
;
3473 lpfc_nlp_list(phba
, ndlp
, NLP_UNUSED_LIST
);
3476 phba
->fc_stat
.elsRcvFrame
++;
3477 elsiocb
->context1
= ndlp
;
3478 elsiocb
->context2
= mp
;
3480 if ((cmd
& ELS_CMD_MASK
) == ELS_CMD_RSCN
) {
3481 cmd
&= ELS_CMD_MASK
;
3483 /* ELS command <elsCmd> received from NPORT <did> */
3484 lpfc_printf_log(phba
, KERN_INFO
, LOG_ELS
,
3485 "%d:0112 ELS command x%x received from NPORT x%x "
3486 "Data: x%x\n", phba
->brd_no
, cmd
, did
, phba
->hba_state
);
3490 phba
->fc_stat
.elsRcvPLOGI
++;
3491 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3495 ndlp
= lpfc_plogi_confirm_nport(phba
, mp
, ndlp
);
3496 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_PLOGI
);
3499 phba
->fc_stat
.elsRcvFLOGI
++;
3500 lpfc_els_rcv_flogi(phba
, elsiocb
, ndlp
, newnode
);
3502 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
3506 phba
->fc_stat
.elsRcvLOGO
++;
3507 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3511 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_LOGO
);
3514 phba
->fc_stat
.elsRcvPRLO
++;
3515 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3519 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_PRLO
);
3522 phba
->fc_stat
.elsRcvRSCN
++;
3523 lpfc_els_rcv_rscn(phba
, elsiocb
, ndlp
, newnode
);
3525 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
3529 phba
->fc_stat
.elsRcvADISC
++;
3530 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3534 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_ADISC
);
3537 phba
->fc_stat
.elsRcvPDISC
++;
3538 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3542 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_PDISC
);
3545 phba
->fc_stat
.elsRcvFARPR
++;
3546 lpfc_els_rcv_farpr(phba
, elsiocb
, ndlp
);
3549 phba
->fc_stat
.elsRcvFARP
++;
3550 lpfc_els_rcv_farp(phba
, elsiocb
, ndlp
);
3553 phba
->fc_stat
.elsRcvFAN
++;
3554 lpfc_els_rcv_fan(phba
, elsiocb
, ndlp
);
3557 phba
->fc_stat
.elsRcvPRLI
++;
3558 if (phba
->hba_state
< LPFC_DISC_AUTH
) {
3562 lpfc_disc_state_machine(phba
, ndlp
, elsiocb
, NLP_EVT_RCV_PRLI
);
3565 phba
->fc_stat
.elsRcvLIRR
++;
3566 lpfc_els_rcv_lirr(phba
, elsiocb
, ndlp
);
3568 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
3572 phba
->fc_stat
.elsRcvRPS
++;
3573 lpfc_els_rcv_rps(phba
, elsiocb
, ndlp
);
3575 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
3579 phba
->fc_stat
.elsRcvRPL
++;
3580 lpfc_els_rcv_rpl(phba
, elsiocb
, ndlp
);
3582 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
3586 phba
->fc_stat
.elsRcvRNID
++;
3587 lpfc_els_rcv_rnid(phba
, elsiocb
, ndlp
);
3589 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
3593 /* Unsupported ELS command, reject */
3596 /* Unknown ELS command <elsCmd> received from NPORT <did> */
3597 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
3598 "%d:0115 Unknown ELS command x%x received from "
3599 "NPORT x%x\n", phba
->brd_no
, cmd
, did
);
3601 lpfc_nlp_list(phba
, ndlp
, NLP_NO_LIST
);
3606 /* check if need to LS_RJT received ELS cmd */
3608 stat
.un
.b
.lsRjtRsvd0
= 0;
3609 stat
.un
.b
.lsRjtRsnCode
= LSRJT_UNABLE_TPC
;
3610 stat
.un
.b
.lsRjtRsnCodeExp
= LSEXP_NOTHING_MORE
;
3611 stat
.un
.b
.vendorUnique
= 0;
3612 lpfc_els_rsp_reject(phba
, stat
.un
.lsRjtError
, elsiocb
, ndlp
);
3615 if (elsiocb
->context2
) {
3616 lpfc_mbuf_free(phba
, mp
->virt
, mp
->phys
);
3620 /* check if need to drop received ELS cmd */
3621 if (drop_cmd
== 1) {
3622 lpfc_printf_log(phba
, KERN_ERR
, LOG_ELS
,
3623 "%d:0111 Dropping received ELS cmd "
3624 "Data: x%x x%x x%x\n", phba
->brd_no
,
3625 icmd
->ulpStatus
, icmd
->un
.ulpWord
[4],
3627 phba
->fc_stat
.elsRcvDrop
++;