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 I/O tag: x%x, HBA state: x%x\n",
226 phba->brd_no, elscmd,
227 did, elsiocb->iotag, 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 I/O tag: x%x, size: x%x\n",
233 phba->brd_no, elscmd,
234 ndlp->nlp_DID, elsiocb->iotag, cmdSize);
242 lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
243 struct serv_parm *sp, IOCB_t *irsp)
246 struct lpfc_dmabuf *mp;
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))
306 mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login;
307 mbox->context2 = ndlp;
309 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
310 if (rc == MBX_NOT_FINISHED)
311 goto fail_issue_reg_login;
315 fail_issue_reg_login:
316 mp = (struct lpfc_dmabuf *) mbox->context1;
317 lpfc_mbuf_free(phba, mp->virt, mp->phys);
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 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
391 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
393 /* This side will wait for the PLOGI */
394 mempool_free( ndlp, phba->nlp_mem_pool);
397 spin_lock_irq(phba->host->host_lock);
398 phba->fc_flag |= FC_PT2PT;
399 spin_unlock_irq(phba->host->host_lock);
401 /* Start discovery - this should just do CLEAR_LA */
402 lpfc_disc_start(phba);
409 lpfc_cmpl_els_flogi(struct lpfc_hba * phba,
410 struct lpfc_iocbq * cmdiocb, struct lpfc_iocbq * rspiocb)
412 IOCB_t *irsp = &rspiocb->iocb;
413 struct lpfc_nodelist *ndlp = cmdiocb->context1;
414 struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
415 struct serv_parm *sp;
418 /* Check to see if link went down during discovery */
419 if (lpfc_els_chk_latt(phba)) {
420 lpfc_nlp_remove(phba, ndlp);
424 if (irsp->ulpStatus) {
425 /* Check for retry */
426 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
427 /* ELS command is being retried */
430 /* FLOGI failed, so there is no fabric */
431 spin_lock_irq(phba->host->host_lock);
432 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
433 spin_unlock_irq(phba->host->host_lock);
435 /* If private loop, then allow max outstandting els to be
436 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
437 * alpa map would take too long otherwise.
439 if (phba->alpa_map[0] == 0) {
440 phba->cfg_discovery_threads =
441 LPFC_MAX_DISC_THREADS;
445 lpfc_printf_log(phba,
448 "%d:0100 FLOGI failure Data: x%x x%x x%x\n",
450 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 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
519 ndlp->nlp_DID, ELS_CMD_FLOGI);
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 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
588 spin_unlock_irq(phba->host->host_lock);
594 lpfc_initial_flogi(struct lpfc_hba * phba)
596 struct lpfc_nodelist *ndlp;
598 /* First look for the Fabric ndlp */
599 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, Fabric_DID);
601 /* Cannot find existing Fabric ndlp, so allocate a new one */
602 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
605 lpfc_nlp_init(phba, ndlp, Fabric_DID);
607 lpfc_dequeue_node(phba, ndlp);
609 if (lpfc_issue_els_flogi(phba, ndlp, 0)) {
610 mempool_free( ndlp, phba->nlp_mem_pool);
616 lpfc_more_plogi(struct lpfc_hba * phba)
620 if (phba->num_disc_nodes)
621 phba->num_disc_nodes--;
623 /* Continue discovery with <num_disc_nodes> PLOGIs to go */
624 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
625 "%d:0232 Continue discovery with %d PLOGIs to go "
626 "Data: x%x x%x x%x\n",
627 phba->brd_no, phba->num_disc_nodes, phba->fc_plogi_cnt,
628 phba->fc_flag, phba->hba_state);
630 /* Check to see if there are more PLOGIs to be sent */
631 if (phba->fc_flag & FC_NLP_MORE) {
632 /* go thru NPR list and issue any remaining ELS PLOGIs */
633 sentplogi = lpfc_els_disc_plogi(phba);
638 static struct lpfc_nodelist *
639 lpfc_plogi_confirm_nport(struct lpfc_hba * phba, struct lpfc_dmabuf *prsp,
640 struct lpfc_nodelist *ndlp)
642 struct lpfc_nodelist *new_ndlp;
644 struct serv_parm *sp;
645 uint8_t name[sizeof (struct lpfc_name)];
648 /* Fabric nodes can have the same WWPN so we don't bother searching
649 * by WWPN. Just return the ndlp that was given to us.
651 if (ndlp->nlp_type & NLP_FABRIC)
654 lp = (uint32_t *) prsp->virt;
655 sp = (struct serv_parm *) ((uint8_t *) lp + sizeof (uint32_t));
656 memset(name, 0, sizeof (struct lpfc_name));
658 /* Now we to find out if the NPort we are logging into, matches the WWPN
659 * we have for that ndlp. If not, we have some work to do.
661 new_ndlp = lpfc_findnode_wwpn(phba, NLP_SEARCH_ALL, &sp->portName);
663 if (new_ndlp == ndlp)
668 memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name));
671 new_ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_ATOMIC);
675 lpfc_nlp_init(phba, new_ndlp, ndlp->nlp_DID);
678 lpfc_unreg_rpi(phba, new_ndlp);
679 new_ndlp->nlp_DID = ndlp->nlp_DID;
680 new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
681 lpfc_nlp_set_state(phba, new_ndlp, ndlp->nlp_state);
683 /* Move this back to NPR list */
684 if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0)
685 lpfc_drop_node(phba, ndlp);
687 lpfc_unreg_rpi(phba, ndlp);
688 ndlp->nlp_DID = 0; /* Two ndlps cannot have the same did */
689 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
695 lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
696 struct lpfc_iocbq * rspiocb)
699 struct lpfc_nodelist *ndlp;
700 struct lpfc_dmabuf *prsp;
701 int disc, rc, did, type;
703 /* we pass cmdiocb to state machine which needs rspiocb as well */
704 cmdiocb->context_un.rsp_iocb = rspiocb;
706 irsp = &rspiocb->iocb;
707 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL,
708 irsp->un.elsreq64.remoteID);
712 /* Since ndlp can be freed in the disc state machine, note if this node
713 * is being used during discovery.
715 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
716 spin_lock_irq(phba->host->host_lock);
717 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
718 spin_unlock_irq(phba->host->host_lock);
721 /* PLOGI completes to NPort <nlp_DID> */
722 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
723 "%d:0102 PLOGI completes to NPort x%x "
724 "Data: x%x x%x x%x x%x x%x\n",
725 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
726 irsp->un.ulpWord[4], irsp->ulpTimeout, disc,
727 phba->num_disc_nodes);
729 /* Check to see if link went down during discovery */
730 if (lpfc_els_chk_latt(phba)) {
731 spin_lock_irq(phba->host->host_lock);
732 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
733 spin_unlock_irq(phba->host->host_lock);
737 /* ndlp could be freed in DSM, save these values now */
738 type = ndlp->nlp_type;
741 if (irsp->ulpStatus) {
742 /* Check for retry */
743 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
744 /* ELS command is being retried */
746 spin_lock_irq(phba->host->host_lock);
747 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
748 spin_unlock_irq(phba->host->host_lock);
754 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
755 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
756 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
757 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
758 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
759 rc = NLP_STE_FREED_NODE;
761 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb,
765 /* Good status, call state machine */
766 prsp = list_entry(((struct lpfc_dmabuf *)
767 cmdiocb->context2)->list.next,
768 struct lpfc_dmabuf, list);
769 ndlp = lpfc_plogi_confirm_nport(phba, prsp, ndlp);
770 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb,
774 if (disc && phba->num_disc_nodes) {
775 /* Check to see if there are more PLOGIs to be sent */
776 lpfc_more_plogi(phba);
778 if (phba->num_disc_nodes == 0) {
779 spin_lock_irq(phba->host->host_lock);
780 phba->fc_flag &= ~FC_NDISC_ACTIVE;
781 spin_unlock_irq(phba->host->host_lock);
783 lpfc_can_disctmo(phba);
784 if (phba->fc_flag & FC_RSCN_MODE) {
786 * Check to see if more RSCNs came in while
787 * we were processing this one.
789 if ((phba->fc_rscn_id_cnt == 0) &&
790 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) {
791 spin_lock_irq(phba->host->host_lock);
792 phba->fc_flag &= ~FC_RSCN_MODE;
793 spin_unlock_irq(phba->host->host_lock);
795 lpfc_els_handle_rscn(phba);
802 lpfc_els_free_iocb(phba, cmdiocb);
807 lpfc_issue_els_plogi(struct lpfc_hba * phba, uint32_t did, uint8_t retry)
809 struct serv_parm *sp;
811 struct lpfc_iocbq *elsiocb;
812 struct lpfc_sli_ring *pring;
813 struct lpfc_sli *psli;
818 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
820 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
821 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, NULL, did,
826 icmd = &elsiocb->iocb;
827 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
829 /* For PLOGI request, remainder of payload is service parameters */
830 *((uint32_t *) (pcmd)) = ELS_CMD_PLOGI;
831 pcmd += sizeof (uint32_t);
832 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
833 sp = (struct serv_parm *) pcmd;
835 if (sp->cmn.fcphLow < FC_PH_4_3)
836 sp->cmn.fcphLow = FC_PH_4_3;
838 if (sp->cmn.fcphHigh < FC_PH3)
839 sp->cmn.fcphHigh = FC_PH3;
841 phba->fc_stat.elsXmitPLOGI++;
842 elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi;
843 spin_lock_irq(phba->host->host_lock);
844 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
845 spin_unlock_irq(phba->host->host_lock);
846 lpfc_els_free_iocb(phba, elsiocb);
849 spin_unlock_irq(phba->host->host_lock);
854 lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
855 struct lpfc_iocbq * rspiocb)
858 struct lpfc_sli *psli;
859 struct lpfc_nodelist *ndlp;
862 /* we pass cmdiocb to state machine which needs rspiocb as well */
863 cmdiocb->context_un.rsp_iocb = rspiocb;
865 irsp = &(rspiocb->iocb);
866 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
867 spin_lock_irq(phba->host->host_lock);
868 ndlp->nlp_flag &= ~NLP_PRLI_SND;
869 spin_unlock_irq(phba->host->host_lock);
871 /* PRLI completes to NPort <nlp_DID> */
872 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
873 "%d:0103 PRLI completes to NPort x%x "
874 "Data: x%x x%x x%x x%x\n",
875 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
876 irsp->un.ulpWord[4], irsp->ulpTimeout,
877 phba->num_disc_nodes);
879 phba->fc_prli_sent--;
880 /* Check to see if link went down during discovery */
881 if (lpfc_els_chk_latt(phba))
884 if (irsp->ulpStatus) {
885 /* Check for retry */
886 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
887 /* ELS command is being retried */
891 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
892 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
893 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
894 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
895 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
898 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
902 /* Good status, call state machine */
903 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_PRLI);
907 lpfc_els_free_iocb(phba, cmdiocb);
912 lpfc_issue_els_prli(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
917 struct lpfc_iocbq *elsiocb;
918 struct lpfc_sli_ring *pring;
919 struct lpfc_sli *psli;
924 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
926 cmdsize = (sizeof (uint32_t) + sizeof (PRLI));
927 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
928 ndlp->nlp_DID, ELS_CMD_PRLI);
932 icmd = &elsiocb->iocb;
933 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
935 /* For PRLI request, remainder of payload is service parameters */
936 memset(pcmd, 0, (sizeof (PRLI) + sizeof (uint32_t)));
937 *((uint32_t *) (pcmd)) = ELS_CMD_PRLI;
938 pcmd += sizeof (uint32_t);
940 /* For PRLI, remainder of payload is PRLI parameter page */
943 * If our firmware version is 3.20 or later,
944 * set the following bits for FC-TAPE support.
946 if (phba->vpd.rev.feaLevelHigh >= 0x02) {
947 npr->ConfmComplAllowed = 1;
949 npr->TaskRetryIdReq = 1;
951 npr->estabImagePair = 1;
952 npr->readXferRdyDis = 1;
954 /* For FCP support */
955 npr->prliType = PRLI_FCP_TYPE;
956 npr->initiatorFunc = 1;
958 phba->fc_stat.elsXmitPRLI++;
959 elsiocb->iocb_cmpl = lpfc_cmpl_els_prli;
960 spin_lock_irq(phba->host->host_lock);
961 ndlp->nlp_flag |= NLP_PRLI_SND;
962 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
963 ndlp->nlp_flag &= ~NLP_PRLI_SND;
964 spin_unlock_irq(phba->host->host_lock);
965 lpfc_els_free_iocb(phba, elsiocb);
968 spin_unlock_irq(phba->host->host_lock);
969 phba->fc_prli_sent++;
974 lpfc_more_adisc(struct lpfc_hba * phba)
978 if (phba->num_disc_nodes)
979 phba->num_disc_nodes--;
981 /* Continue discovery with <num_disc_nodes> ADISCs to go */
982 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
983 "%d:0210 Continue discovery with %d ADISCs to go "
984 "Data: x%x x%x x%x\n",
985 phba->brd_no, phba->num_disc_nodes, phba->fc_adisc_cnt,
986 phba->fc_flag, phba->hba_state);
988 /* Check to see if there are more ADISCs to be sent */
989 if (phba->fc_flag & FC_NLP_MORE) {
990 lpfc_set_disctmo(phba);
992 /* go thru NPR list and issue any remaining ELS ADISCs */
993 sentadisc = lpfc_els_disc_adisc(phba);
999 lpfc_rscn_disc(struct lpfc_hba * phba)
1001 /* RSCN discovery */
1002 /* go thru NPR list and issue ELS PLOGIs */
1003 if (phba->fc_npr_cnt) {
1004 if (lpfc_els_disc_plogi(phba))
1007 if (phba->fc_flag & FC_RSCN_MODE) {
1008 /* Check to see if more RSCNs came in while we were
1009 * processing this one.
1011 if ((phba->fc_rscn_id_cnt == 0) &&
1012 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) {
1013 spin_lock_irq(phba->host->host_lock);
1014 phba->fc_flag &= ~FC_RSCN_MODE;
1015 spin_unlock_irq(phba->host->host_lock);
1017 lpfc_els_handle_rscn(phba);
1023 lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1024 struct lpfc_iocbq * rspiocb)
1027 struct lpfc_sli *psli;
1028 struct lpfc_nodelist *ndlp;
1034 /* we pass cmdiocb to state machine which needs rspiocb as well */
1035 cmdiocb->context_un.rsp_iocb = rspiocb;
1037 irsp = &(rspiocb->iocb);
1038 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1040 /* Since ndlp can be freed in the disc state machine, note if this node
1041 * is being used during discovery.
1043 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
1044 spin_lock_irq(phba->host->host_lock);
1045 ndlp->nlp_flag &= ~(NLP_ADISC_SND | NLP_NPR_2B_DISC);
1046 spin_unlock_irq(phba->host->host_lock);
1048 /* ADISC completes to NPort <nlp_DID> */
1049 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1050 "%d:0104 ADISC completes to NPort x%x "
1051 "Data: x%x x%x x%x x%x x%x\n",
1052 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
1053 irsp->un.ulpWord[4], irsp->ulpTimeout, disc,
1054 phba->num_disc_nodes);
1056 /* Check to see if link went down during discovery */
1057 if (lpfc_els_chk_latt(phba)) {
1058 spin_lock_irq(phba->host->host_lock);
1059 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1060 spin_unlock_irq(phba->host->host_lock);
1064 if (irsp->ulpStatus) {
1065 /* Check for retry */
1066 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1067 /* ELS command is being retried */
1069 spin_lock_irq(phba->host->host_lock);
1070 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1071 spin_unlock_irq(phba->host->host_lock);
1072 lpfc_set_disctmo(phba);
1077 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1078 if ((irsp->ulpStatus != IOSTAT_LOCAL_REJECT) ||
1079 ((irsp->un.ulpWord[4] != IOERR_SLI_ABORTED) &&
1080 (irsp->un.ulpWord[4] != IOERR_LINK_DOWN) &&
1081 (irsp->un.ulpWord[4] != IOERR_SLI_DOWN))) {
1082 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1083 NLP_EVT_CMPL_ADISC);
1086 /* Good status, call state machine */
1087 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1088 NLP_EVT_CMPL_ADISC);
1091 if (disc && phba->num_disc_nodes) {
1092 /* Check to see if there are more ADISCs to be sent */
1093 lpfc_more_adisc(phba);
1095 /* Check to see if we are done with ADISC authentication */
1096 if (phba->num_disc_nodes == 0) {
1097 lpfc_can_disctmo(phba);
1098 /* If we get here, there is nothing left to wait for */
1099 if ((phba->hba_state < LPFC_HBA_READY) &&
1100 (phba->hba_state != LPFC_CLEAR_LA)) {
1101 /* Link up discovery */
1102 if ((mbox = mempool_alloc(phba->mbox_mem_pool,
1104 phba->hba_state = LPFC_CLEAR_LA;
1105 lpfc_clear_la(phba, mbox);
1107 lpfc_mbx_cmpl_clear_la;
1108 rc = lpfc_sli_issue_mbox
1110 (MBX_NOWAIT | MBX_STOP_IOCB));
1111 if (rc == MBX_NOT_FINISHED) {
1113 phba->mbox_mem_pool);
1114 lpfc_disc_flush_list(phba);
1115 psli->ring[(psli->extra_ring)].
1117 ~LPFC_STOP_IOCB_EVENT;
1118 psli->ring[(psli->fcp_ring)].
1120 ~LPFC_STOP_IOCB_EVENT;
1121 psli->ring[(psli->next_ring)].
1123 ~LPFC_STOP_IOCB_EVENT;
1129 lpfc_rscn_disc(phba);
1134 lpfc_els_free_iocb(phba, cmdiocb);
1139 lpfc_issue_els_adisc(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1144 struct lpfc_iocbq *elsiocb;
1145 struct lpfc_sli_ring *pring;
1146 struct lpfc_sli *psli;
1151 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1153 cmdsize = (sizeof (uint32_t) + sizeof (ADISC));
1154 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1155 ndlp->nlp_DID, ELS_CMD_ADISC);
1159 icmd = &elsiocb->iocb;
1160 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1162 /* For ADISC request, remainder of payload is service parameters */
1163 *((uint32_t *) (pcmd)) = ELS_CMD_ADISC;
1164 pcmd += sizeof (uint32_t);
1166 /* Fill in ADISC payload */
1167 ap = (ADISC *) pcmd;
1168 ap->hardAL_PA = phba->fc_pref_ALPA;
1169 memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name));
1170 memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
1171 ap->DID = be32_to_cpu(phba->fc_myDID);
1173 phba->fc_stat.elsXmitADISC++;
1174 elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc;
1175 spin_lock_irq(phba->host->host_lock);
1176 ndlp->nlp_flag |= NLP_ADISC_SND;
1177 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1178 ndlp->nlp_flag &= ~NLP_ADISC_SND;
1179 spin_unlock_irq(phba->host->host_lock);
1180 lpfc_els_free_iocb(phba, elsiocb);
1183 spin_unlock_irq(phba->host->host_lock);
1188 lpfc_cmpl_els_logo(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1189 struct lpfc_iocbq * rspiocb)
1192 struct lpfc_sli *psli;
1193 struct lpfc_nodelist *ndlp;
1196 /* we pass cmdiocb to state machine which needs rspiocb as well */
1197 cmdiocb->context_un.rsp_iocb = rspiocb;
1199 irsp = &(rspiocb->iocb);
1200 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1201 spin_lock_irq(phba->host->host_lock);
1202 ndlp->nlp_flag &= ~NLP_LOGO_SND;
1203 spin_unlock_irq(phba->host->host_lock);
1205 /* LOGO completes to NPort <nlp_DID> */
1206 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1207 "%d:0105 LOGO completes to NPort x%x "
1208 "Data: x%x x%x x%x x%x\n",
1209 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
1210 irsp->un.ulpWord[4], irsp->ulpTimeout,
1211 phba->num_disc_nodes);
1213 /* Check to see if link went down during discovery */
1214 if (lpfc_els_chk_latt(phba))
1217 if (irsp->ulpStatus) {
1218 /* Check for retry */
1219 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1220 /* ELS command is being retried */
1224 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1225 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1226 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
1227 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
1228 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
1231 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1235 /* Good status, call state machine.
1236 * This will unregister the rpi if needed.
1238 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_LOGO);
1242 lpfc_els_free_iocb(phba, cmdiocb);
1247 lpfc_issue_els_logo(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1251 struct lpfc_iocbq *elsiocb;
1252 struct lpfc_sli_ring *pring;
1253 struct lpfc_sli *psli;
1258 pring = &psli->ring[LPFC_ELS_RING];
1260 cmdsize = (2 * sizeof (uint32_t)) + sizeof (struct lpfc_name);
1261 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1262 ndlp->nlp_DID, ELS_CMD_LOGO);
1266 icmd = &elsiocb->iocb;
1267 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1268 *((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
1269 pcmd += sizeof (uint32_t);
1271 /* Fill in LOGO payload */
1272 *((uint32_t *) (pcmd)) = be32_to_cpu(phba->fc_myDID);
1273 pcmd += sizeof (uint32_t);
1274 memcpy(pcmd, &phba->fc_portname, sizeof (struct lpfc_name));
1276 phba->fc_stat.elsXmitLOGO++;
1277 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo;
1278 spin_lock_irq(phba->host->host_lock);
1279 ndlp->nlp_flag |= NLP_LOGO_SND;
1280 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1281 ndlp->nlp_flag &= ~NLP_LOGO_SND;
1282 spin_unlock_irq(phba->host->host_lock);
1283 lpfc_els_free_iocb(phba, elsiocb);
1286 spin_unlock_irq(phba->host->host_lock);
1291 lpfc_cmpl_els_cmd(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1292 struct lpfc_iocbq * rspiocb)
1296 irsp = &rspiocb->iocb;
1298 /* ELS cmd tag <ulpIoTag> completes */
1299 lpfc_printf_log(phba,
1302 "%d:0106 ELS cmd tag x%x completes Data: x%x x%x x%x\n",
1304 irsp->ulpIoTag, irsp->ulpStatus,
1305 irsp->un.ulpWord[4], irsp->ulpTimeout);
1307 /* Check to see if link went down during discovery */
1308 lpfc_els_chk_latt(phba);
1309 lpfc_els_free_iocb(phba, cmdiocb);
1314 lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1317 struct lpfc_iocbq *elsiocb;
1318 struct lpfc_sli_ring *pring;
1319 struct lpfc_sli *psli;
1322 struct lpfc_nodelist *ndlp;
1325 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1326 cmdsize = (sizeof (uint32_t) + sizeof (SCR));
1327 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1331 lpfc_nlp_init(phba, ndlp, nportid);
1333 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1334 ndlp->nlp_DID, ELS_CMD_SCR);
1336 mempool_free( ndlp, phba->nlp_mem_pool);
1340 icmd = &elsiocb->iocb;
1341 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1343 *((uint32_t *) (pcmd)) = ELS_CMD_SCR;
1344 pcmd += sizeof (uint32_t);
1346 /* For SCR, remainder of payload is SCR parameter page */
1347 memset(pcmd, 0, sizeof (SCR));
1348 ((SCR *) pcmd)->Function = SCR_FUNC_FULL;
1350 phba->fc_stat.elsXmitSCR++;
1351 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1352 spin_lock_irq(phba->host->host_lock);
1353 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1354 spin_unlock_irq(phba->host->host_lock);
1355 mempool_free( ndlp, phba->nlp_mem_pool);
1356 lpfc_els_free_iocb(phba, elsiocb);
1359 spin_unlock_irq(phba->host->host_lock);
1360 mempool_free( ndlp, phba->nlp_mem_pool);
1365 lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1368 struct lpfc_iocbq *elsiocb;
1369 struct lpfc_sli_ring *pring;
1370 struct lpfc_sli *psli;
1375 struct lpfc_nodelist *ondlp;
1376 struct lpfc_nodelist *ndlp;
1379 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1380 cmdsize = (sizeof (uint32_t) + sizeof (FARP));
1381 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1384 lpfc_nlp_init(phba, ndlp, nportid);
1386 elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry, ndlp,
1387 ndlp->nlp_DID, ELS_CMD_RNID);
1389 mempool_free( ndlp, phba->nlp_mem_pool);
1393 icmd = &elsiocb->iocb;
1394 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1396 *((uint32_t *) (pcmd)) = ELS_CMD_FARPR;
1397 pcmd += sizeof (uint32_t);
1399 /* Fill in FARPR payload */
1400 fp = (FARP *) (pcmd);
1401 memset(fp, 0, sizeof (FARP));
1402 lp = (uint32_t *) pcmd;
1403 *lp++ = be32_to_cpu(nportid);
1404 *lp++ = be32_to_cpu(phba->fc_myDID);
1406 fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE);
1408 memcpy(&fp->RportName, &phba->fc_portname, sizeof (struct lpfc_name));
1409 memcpy(&fp->RnodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
1410 if ((ondlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, nportid))) {
1411 memcpy(&fp->OportName, &ondlp->nlp_portname,
1412 sizeof (struct lpfc_name));
1413 memcpy(&fp->OnodeName, &ondlp->nlp_nodename,
1414 sizeof (struct lpfc_name));
1417 phba->fc_stat.elsXmitFARPR++;
1418 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1419 spin_lock_irq(phba->host->host_lock);
1420 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1421 spin_unlock_irq(phba->host->host_lock);
1422 mempool_free( ndlp, phba->nlp_mem_pool);
1423 lpfc_els_free_iocb(phba, elsiocb);
1426 spin_unlock_irq(phba->host->host_lock);
1427 mempool_free( ndlp, phba->nlp_mem_pool);
1432 lpfc_cancel_retry_delay_tmo(struct lpfc_hba *phba, struct lpfc_nodelist * nlp)
1434 nlp->nlp_flag &= ~NLP_DELAY_TMO;
1435 del_timer_sync(&nlp->nlp_delayfunc);
1436 nlp->nlp_last_elscmd = 0;
1438 if (!list_empty(&nlp->els_retry_evt.evt_listp))
1439 list_del_init(&nlp->els_retry_evt.evt_listp);
1441 if (nlp->nlp_flag & NLP_NPR_2B_DISC) {
1442 nlp->nlp_flag &= ~NLP_NPR_2B_DISC;
1443 if (phba->num_disc_nodes) {
1444 /* Check to see if there are more
1447 lpfc_more_plogi(phba);
1449 if (phba->num_disc_nodes == 0) {
1450 phba->fc_flag &= ~FC_NDISC_ACTIVE;
1451 lpfc_can_disctmo(phba);
1452 if (phba->fc_flag & FC_RSCN_MODE) {
1454 * Check to see if more RSCNs
1455 * came in while we were
1456 * processing this one.
1458 if((phba->fc_rscn_id_cnt==0) &&
1459 !(phba->fc_flag & FC_RSCN_DISCOVERY)) {
1460 phba->fc_flag &= ~FC_RSCN_MODE;
1463 lpfc_els_handle_rscn(phba);
1473 lpfc_els_retry_delay(unsigned long ptr)
1475 struct lpfc_nodelist *ndlp;
1476 struct lpfc_hba *phba;
1477 unsigned long iflag;
1478 struct lpfc_work_evt *evtp;
1480 ndlp = (struct lpfc_nodelist *)ptr;
1481 phba = ndlp->nlp_phba;
1482 evtp = &ndlp->els_retry_evt;
1484 spin_lock_irqsave(phba->host->host_lock, iflag);
1485 if (!list_empty(&evtp->evt_listp)) {
1486 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1490 evtp->evt_arg1 = ndlp;
1491 evtp->evt = LPFC_EVT_ELS_RETRY;
1492 list_add_tail(&evtp->evt_listp, &phba->work_list);
1493 if (phba->work_wait)
1494 wake_up(phba->work_wait);
1496 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1501 lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
1503 struct lpfc_hba *phba;
1508 phba = ndlp->nlp_phba;
1509 spin_lock_irq(phba->host->host_lock);
1510 did = ndlp->nlp_DID;
1511 cmd = ndlp->nlp_last_elscmd;
1512 ndlp->nlp_last_elscmd = 0;
1514 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
1515 spin_unlock_irq(phba->host->host_lock);
1519 ndlp->nlp_flag &= ~NLP_DELAY_TMO;
1520 spin_unlock_irq(phba->host->host_lock);
1522 * If a discovery event readded nlp_delayfunc after timer
1523 * firing and before processing the timer, cancel the
1526 del_timer_sync(&ndlp->nlp_delayfunc);
1527 retry = ndlp->nlp_retry;
1531 lpfc_issue_els_flogi(phba, ndlp, retry);
1534 if(!lpfc_issue_els_plogi(phba, ndlp->nlp_DID, retry)) {
1535 ndlp->nlp_prev_state = ndlp->nlp_state;
1536 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
1540 if (!lpfc_issue_els_adisc(phba, ndlp, retry)) {
1541 ndlp->nlp_prev_state = ndlp->nlp_state;
1542 lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE);
1546 if (!lpfc_issue_els_prli(phba, ndlp, retry)) {
1547 ndlp->nlp_prev_state = ndlp->nlp_state;
1548 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PRLI_ISSUE);
1552 if (!lpfc_issue_els_logo(phba, ndlp, retry)) {
1553 ndlp->nlp_prev_state = ndlp->nlp_state;
1554 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
1562 lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1563 struct lpfc_iocbq * rspiocb)
1566 struct lpfc_dmabuf *pcmd;
1567 struct lpfc_nodelist *ndlp;
1570 int retry, maxretry;
1577 maxretry = lpfc_max_els_tries;
1578 irsp = &rspiocb->iocb;
1579 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1580 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
1583 /* Note: context2 may be 0 for internal driver abort
1584 * of delays ELS command.
1587 if (pcmd && pcmd->virt) {
1588 elscmd = (uint32_t *) (pcmd->virt);
1593 did = ndlp->nlp_DID;
1595 /* We should only hit this case for retrying PLOGI */
1596 did = irsp->un.elsreq64.remoteID;
1597 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did);
1598 if (!ndlp && (cmd != ELS_CMD_PLOGI))
1602 switch (irsp->ulpStatus) {
1603 case IOSTAT_FCP_RSP_ERROR:
1604 case IOSTAT_REMOTE_STOP:
1607 case IOSTAT_LOCAL_REJECT:
1608 switch ((irsp->un.ulpWord[4] & 0xff)) {
1609 case IOERR_LOOP_OPEN_FAILURE:
1610 if (cmd == ELS_CMD_PLOGI) {
1611 if (cmdiocb->retry == 0) {
1618 case IOERR_SEQUENCE_TIMEOUT:
1622 case IOERR_NO_RESOURCES:
1623 if (cmd == ELS_CMD_PLOGI) {
1629 case IOERR_INVALID_RPI:
1635 case IOSTAT_NPORT_RJT:
1636 case IOSTAT_FABRIC_RJT:
1637 if (irsp->un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
1643 case IOSTAT_NPORT_BSY:
1644 case IOSTAT_FABRIC_BSY:
1649 stat.un.lsRjtError = be32_to_cpu(irsp->un.ulpWord[4]);
1650 /* Added for Vendor specifc support
1651 * Just keep retrying for these Rsn / Exp codes
1653 switch (stat.un.b.lsRjtRsnCode) {
1654 case LSRJT_UNABLE_TPC:
1655 if (stat.un.b.lsRjtRsnCodeExp ==
1656 LSEXP_CMD_IN_PROGRESS) {
1657 if (cmd == ELS_CMD_PLOGI) {
1664 if (cmd == ELS_CMD_PLOGI) {
1666 maxretry = lpfc_max_els_tries + 1;
1672 case LSRJT_LOGICAL_BSY:
1673 if (cmd == ELS_CMD_PLOGI) {
1682 case IOSTAT_INTERMED_RSP:
1690 if (did == FDMI_DID)
1693 if ((++cmdiocb->retry) >= maxretry) {
1694 phba->fc_stat.elsRetryExceeded++;
1700 /* Retry ELS command <elsCmd> to remote NPORT <did> */
1701 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1702 "%d:0107 Retry ELS command x%x to remote "
1703 "NPORT x%x Data: x%x x%x\n",
1705 cmd, did, cmdiocb->retry, delay);
1707 if ((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) {
1708 /* If discovery / RSCN timer is running, reset it */
1709 if (timer_pending(&phba->fc_disctmo) ||
1710 (phba->fc_flag & FC_RSCN_MODE)) {
1711 lpfc_set_disctmo(phba);
1715 phba->fc_stat.elsXmitRetry++;
1716 if (ndlp && delay) {
1717 phba->fc_stat.elsDelayRetry++;
1718 ndlp->nlp_retry = cmdiocb->retry;
1720 mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
1721 ndlp->nlp_flag |= NLP_DELAY_TMO;
1723 ndlp->nlp_prev_state = ndlp->nlp_state;
1724 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
1725 ndlp->nlp_last_elscmd = cmd;
1731 lpfc_issue_els_flogi(phba, ndlp, cmdiocb->retry);
1735 ndlp->nlp_prev_state = ndlp->nlp_state;
1736 lpfc_nlp_set_state(phba, ndlp,
1737 NLP_STE_PLOGI_ISSUE);
1739 lpfc_issue_els_plogi(phba, did, cmdiocb->retry);
1742 ndlp->nlp_prev_state = ndlp->nlp_state;
1743 lpfc_nlp_set_state(phba, ndlp, NLP_STE_ADISC_ISSUE);
1744 lpfc_issue_els_adisc(phba, ndlp, cmdiocb->retry);
1747 ndlp->nlp_prev_state = ndlp->nlp_state;
1748 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PRLI_ISSUE);
1749 lpfc_issue_els_prli(phba, ndlp, cmdiocb->retry);
1752 ndlp->nlp_prev_state = ndlp->nlp_state;
1753 lpfc_nlp_set_state(phba, ndlp, NLP_STE_NPR_NODE);
1754 lpfc_issue_els_logo(phba, ndlp, cmdiocb->retry);
1759 /* No retry ELS command <elsCmd> to remote NPORT <did> */
1760 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1761 "%d:0108 No retry ELS command x%x to remote NPORT x%x "
1764 cmd, did, cmdiocb->retry);
1770 lpfc_els_free_iocb(struct lpfc_hba * phba, struct lpfc_iocbq * elsiocb)
1772 struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
1774 /* context2 = cmd, context2->next = rsp, context3 = bpl */
1775 if (elsiocb->context2) {
1776 buf_ptr1 = (struct lpfc_dmabuf *) elsiocb->context2;
1777 /* Free the response before processing the command. */
1778 if (!list_empty(&buf_ptr1->list)) {
1779 list_remove_head(&buf_ptr1->list, buf_ptr,
1782 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1785 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
1789 if (elsiocb->context3) {
1790 buf_ptr = (struct lpfc_dmabuf *) elsiocb->context3;
1791 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1794 spin_lock_irq(phba->host->host_lock);
1795 lpfc_sli_release_iocbq(phba, elsiocb);
1796 spin_unlock_irq(phba->host->host_lock);
1801 lpfc_cmpl_els_logo_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1802 struct lpfc_iocbq * rspiocb)
1804 struct lpfc_nodelist *ndlp;
1806 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1808 /* ACC to LOGO completes to NPort <nlp_DID> */
1809 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1810 "%d:0109 ACC to LOGO completes to NPort x%x "
1811 "Data: x%x x%x x%x\n",
1812 phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag,
1813 ndlp->nlp_state, ndlp->nlp_rpi);
1815 switch (ndlp->nlp_state) {
1816 case NLP_STE_UNUSED_NODE: /* node is just allocated */
1817 lpfc_drop_node(phba, ndlp);
1819 case NLP_STE_NPR_NODE: /* NPort Recovery mode */
1820 lpfc_unreg_rpi(phba, ndlp);
1825 lpfc_els_free_iocb(phba, cmdiocb);
1830 lpfc_cmpl_els_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1831 struct lpfc_iocbq * rspiocb)
1834 struct lpfc_nodelist *ndlp;
1835 LPFC_MBOXQ_t *mbox = NULL;
1836 struct lpfc_dmabuf *mp;
1838 irsp = &rspiocb->iocb;
1840 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1841 if (cmdiocb->context_un.mbox)
1842 mbox = cmdiocb->context_un.mbox;
1845 /* Check to see if link went down during discovery */
1846 if ((lpfc_els_chk_latt(phba)) || !ndlp) {
1848 mp = (struct lpfc_dmabuf *) mbox->context1;
1850 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1853 mempool_free( mbox, phba->mbox_mem_pool);
1858 /* ELS response tag <ulpIoTag> completes */
1859 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1860 "%d:0110 ELS response tag x%x completes "
1861 "Data: x%x x%x x%x x%x x%x x%x x%x\n",
1863 cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus,
1864 rspiocb->iocb.un.ulpWord[4], rspiocb->iocb.ulpTimeout,
1865 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
1869 if ((rspiocb->iocb.ulpStatus == 0)
1870 && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) {
1871 lpfc_unreg_rpi(phba, ndlp);
1872 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
1873 mbox->context2 = ndlp;
1874 ndlp->nlp_prev_state = ndlp->nlp_state;
1875 lpfc_nlp_set_state(phba, ndlp, NLP_STE_REG_LOGIN_ISSUE);
1876 if (lpfc_sli_issue_mbox(phba, mbox,
1877 (MBX_NOWAIT | MBX_STOP_IOCB))
1878 != MBX_NOT_FINISHED) {
1881 /* NOTE: we should have messages for unsuccessful
1884 /* Do not call NO_LIST for lpfc_els_abort'ed ELS cmds */
1885 if (!((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1886 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
1887 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
1888 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN)))) {
1889 if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
1890 lpfc_drop_node(phba, ndlp);
1895 mp = (struct lpfc_dmabuf *) mbox->context1;
1897 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1900 mempool_free(mbox, phba->mbox_mem_pool);
1904 spin_lock_irq(phba->host->host_lock);
1905 ndlp->nlp_flag &= ~NLP_ACC_REGLOGIN;
1906 spin_unlock_irq(phba->host->host_lock);
1908 lpfc_els_free_iocb(phba, cmdiocb);
1913 lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
1914 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp,
1915 LPFC_MBOXQ_t * mbox, uint8_t newnode)
1919 struct lpfc_iocbq *elsiocb;
1920 struct lpfc_sli_ring *pring;
1921 struct lpfc_sli *psli;
1925 ELS_PKT *els_pkt_ptr;
1928 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1929 oldcmd = &oldiocb->iocb;
1933 cmdsize = sizeof (uint32_t);
1934 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1935 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
1937 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
1940 icmd = &elsiocb->iocb;
1941 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1942 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1943 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
1944 pcmd += sizeof (uint32_t);
1947 cmdsize = (sizeof (struct serv_parm) + sizeof (uint32_t));
1948 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1949 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
1953 icmd = &elsiocb->iocb;
1954 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1955 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1958 elsiocb->context_un.mbox = mbox;
1960 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
1961 pcmd += sizeof (uint32_t);
1962 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
1965 cmdsize = sizeof (uint32_t) + sizeof (PRLO);
1966 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1967 ndlp, ndlp->nlp_DID, ELS_CMD_PRLO);
1971 icmd = &elsiocb->iocb;
1972 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1973 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1975 memcpy(pcmd, ((struct lpfc_dmabuf *) oldiocb->context2)->virt,
1976 sizeof (uint32_t) + sizeof (PRLO));
1977 *((uint32_t *) (pcmd)) = ELS_CMD_PRLO_ACC;
1978 els_pkt_ptr = (ELS_PKT *) pcmd;
1979 els_pkt_ptr->un.prlo.acceptRspCode = PRLO_REQ_EXECUTED;
1986 elsiocb->context1 = NULL;
1988 /* Xmit ELS ACC response tag <ulpIoTag> */
1989 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1990 "%d:0128 Xmit ELS ACC response tag x%x, XRI: x%x, "
1991 "DID: x%x, nlp_flag: x%x nlp_state: x%x RPI: x%x\n",
1992 phba->brd_no, elsiocb->iotag,
1993 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
1994 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
1996 if (ndlp->nlp_flag & NLP_LOGO_ACC) {
1997 spin_lock_irq(phba->host->host_lock);
1998 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
1999 spin_unlock_irq(phba->host->host_lock);
2000 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc;
2002 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2005 phba->fc_stat.elsXmitACC++;
2006 spin_lock_irq(phba->host->host_lock);
2007 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2008 spin_unlock_irq(phba->host->host_lock);
2009 if (rc == IOCB_ERROR) {
2010 lpfc_els_free_iocb(phba, elsiocb);
2017 lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError,
2018 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 = 2 * sizeof (uint32_t);
2033 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2034 ndlp, ndlp->nlp_DID, ELS_CMD_LS_RJT);
2038 icmd = &elsiocb->iocb;
2039 oldcmd = &oldiocb->iocb;
2040 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2041 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2043 *((uint32_t *) (pcmd)) = ELS_CMD_LS_RJT;
2044 pcmd += sizeof (uint32_t);
2045 *((uint32_t *) (pcmd)) = rejectError;
2047 /* Xmit ELS RJT <err> response tag <ulpIoTag> */
2048 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2049 "%d:0129 Xmit ELS RJT x%x response tag x%x "
2050 "Data: x%x x%x x%x x%x x%x\n",
2052 rejectError, elsiocb->iocb.ulpIoTag,
2053 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2054 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2056 phba->fc_stat.elsXmitLSRJT++;
2057 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2058 spin_lock_irq(phba->host->host_lock);
2059 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2060 spin_unlock_irq(phba->host->host_lock);
2061 if (rc == IOCB_ERROR) {
2062 lpfc_els_free_iocb(phba, elsiocb);
2069 lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba,
2070 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2075 struct lpfc_iocbq *elsiocb;
2076 struct lpfc_sli_ring *pring;
2077 struct lpfc_sli *psli;
2083 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2085 cmdsize = sizeof (uint32_t) + sizeof (ADISC);
2086 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2087 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2091 /* Xmit ADISC ACC response tag <ulpIoTag> */
2092 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2093 "%d:0130 Xmit ADISC ACC response tag x%x "
2094 "Data: x%x x%x x%x x%x x%x\n",
2096 elsiocb->iocb.ulpIoTag,
2097 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2098 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2100 icmd = &elsiocb->iocb;
2101 oldcmd = &oldiocb->iocb;
2102 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2103 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2105 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2106 pcmd += sizeof (uint32_t);
2108 ap = (ADISC *) (pcmd);
2109 ap->hardAL_PA = phba->fc_pref_ALPA;
2110 memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name));
2111 memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
2112 ap->DID = be32_to_cpu(phba->fc_myDID);
2114 phba->fc_stat.elsXmitACC++;
2115 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2116 spin_lock_irq(phba->host->host_lock);
2117 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2118 spin_unlock_irq(phba->host->host_lock);
2119 if (rc == IOCB_ERROR) {
2120 lpfc_els_free_iocb(phba, elsiocb);
2127 lpfc_els_rsp_prli_acc(struct lpfc_hba * phba,
2128 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2134 struct lpfc_iocbq *elsiocb;
2135 struct lpfc_sli_ring *pring;
2136 struct lpfc_sli *psli;
2142 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2144 cmdsize = sizeof (uint32_t) + sizeof (PRLI);
2145 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry, ndlp,
2146 ndlp->nlp_DID, (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK)));
2150 /* Xmit PRLI ACC response tag <ulpIoTag> */
2151 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2152 "%d:0131 Xmit PRLI ACC response tag x%x "
2153 "Data: x%x x%x x%x x%x x%x\n",
2155 elsiocb->iocb.ulpIoTag,
2156 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2157 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2159 icmd = &elsiocb->iocb;
2160 oldcmd = &oldiocb->iocb;
2161 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2162 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2164 *((uint32_t *) (pcmd)) = (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK));
2165 pcmd += sizeof (uint32_t);
2167 /* For PRLI, remainder of payload is PRLI parameter page */
2168 memset(pcmd, 0, sizeof (PRLI));
2170 npr = (PRLI *) pcmd;
2173 * If our firmware version is 3.20 or later,
2174 * set the following bits for FC-TAPE support.
2176 if (vpd->rev.feaLevelHigh >= 0x02) {
2177 npr->ConfmComplAllowed = 1;
2179 npr->TaskRetryIdReq = 1;
2182 npr->acceptRspCode = PRLI_REQ_EXECUTED;
2183 npr->estabImagePair = 1;
2184 npr->readXferRdyDis = 1;
2185 npr->ConfmComplAllowed = 1;
2187 npr->prliType = PRLI_FCP_TYPE;
2188 npr->initiatorFunc = 1;
2190 phba->fc_stat.elsXmitACC++;
2191 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2193 spin_lock_irq(phba->host->host_lock);
2194 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2195 spin_unlock_irq(phba->host->host_lock);
2196 if (rc == IOCB_ERROR) {
2197 lpfc_els_free_iocb(phba, elsiocb);
2204 lpfc_els_rsp_rnid_acc(struct lpfc_hba * phba,
2206 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2211 struct lpfc_iocbq *elsiocb;
2212 struct lpfc_sli_ring *pring;
2213 struct lpfc_sli *psli;
2219 pring = &psli->ring[LPFC_ELS_RING];
2221 cmdsize = sizeof (uint32_t) + sizeof (uint32_t)
2222 + (2 * sizeof (struct lpfc_name));
2224 cmdsize += sizeof (RNID_TOP_DISC);
2226 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2227 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2231 /* Xmit RNID ACC response tag <ulpIoTag> */
2232 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2233 "%d:0132 Xmit RNID ACC response tag x%x "
2236 elsiocb->iocb.ulpIoTag,
2237 elsiocb->iocb.ulpContext);
2239 icmd = &elsiocb->iocb;
2240 oldcmd = &oldiocb->iocb;
2241 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2242 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2244 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2245 pcmd += sizeof (uint32_t);
2247 memset(pcmd, 0, sizeof (RNID));
2248 rn = (RNID *) (pcmd);
2249 rn->Format = format;
2250 rn->CommonLen = (2 * sizeof (struct lpfc_name));
2251 memcpy(&rn->portName, &phba->fc_portname, sizeof (struct lpfc_name));
2252 memcpy(&rn->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
2255 rn->SpecificLen = 0;
2257 case RNID_TOPOLOGY_DISC:
2258 rn->SpecificLen = sizeof (RNID_TOP_DISC);
2259 memcpy(&rn->un.topologyDisc.portName,
2260 &phba->fc_portname, sizeof (struct lpfc_name));
2261 rn->un.topologyDisc.unitType = RNID_HBA;
2262 rn->un.topologyDisc.physPort = 0;
2263 rn->un.topologyDisc.attachedNodes = 0;
2267 rn->SpecificLen = 0;
2271 phba->fc_stat.elsXmitACC++;
2272 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2273 elsiocb->context1 = NULL; /* Don't need ndlp for cmpl,
2274 * it could be freed */
2276 spin_lock_irq(phba->host->host_lock);
2277 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2278 spin_unlock_irq(phba->host->host_lock);
2279 if (rc == IOCB_ERROR) {
2280 lpfc_els_free_iocb(phba, elsiocb);
2287 lpfc_els_disc_adisc(struct lpfc_hba * phba)
2290 struct lpfc_nodelist *ndlp, *next_ndlp;
2293 /* go thru NPR list and issue any remaining ELS ADISCs */
2294 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
2296 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
2297 if (ndlp->nlp_flag & NLP_NPR_ADISC) {
2298 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2299 ndlp->nlp_prev_state = ndlp->nlp_state;
2300 lpfc_nlp_set_state(phba, ndlp,
2301 NLP_STE_ADISC_ISSUE);
2302 lpfc_issue_els_adisc(phba, ndlp, 0);
2304 phba->num_disc_nodes++;
2305 if (phba->num_disc_nodes >=
2306 phba->cfg_discovery_threads) {
2307 spin_lock_irq(phba->host->host_lock);
2308 phba->fc_flag |= FC_NLP_MORE;
2309 spin_unlock_irq(phba->host->host_lock);
2315 if (sentadisc == 0) {
2316 spin_lock_irq(phba->host->host_lock);
2317 phba->fc_flag &= ~FC_NLP_MORE;
2318 spin_unlock_irq(phba->host->host_lock);
2324 lpfc_els_disc_plogi(struct lpfc_hba * phba)
2327 struct lpfc_nodelist *ndlp, *next_ndlp;
2330 /* go thru NPR list and issue any remaining ELS PLOGIs */
2331 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
2333 if ((ndlp->nlp_flag & NLP_NPR_2B_DISC) &&
2334 (!(ndlp->nlp_flag & NLP_DELAY_TMO))) {
2335 if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
2336 ndlp->nlp_prev_state = ndlp->nlp_state;
2337 lpfc_nlp_set_state(phba, ndlp,
2338 NLP_STE_PLOGI_ISSUE);
2339 lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
2341 phba->num_disc_nodes++;
2342 if (phba->num_disc_nodes >=
2343 phba->cfg_discovery_threads) {
2344 spin_lock_irq(phba->host->host_lock);
2345 phba->fc_flag |= FC_NLP_MORE;
2346 spin_unlock_irq(phba->host->host_lock);
2352 if (sentplogi == 0) {
2353 spin_lock_irq(phba->host->host_lock);
2354 phba->fc_flag &= ~FC_NLP_MORE;
2355 spin_unlock_irq(phba->host->host_lock);
2361 lpfc_els_flush_rscn(struct lpfc_hba * phba)
2363 struct lpfc_dmabuf *mp;
2366 for (i = 0; i < phba->fc_rscn_id_cnt; i++) {
2367 mp = phba->fc_rscn_id_list[i];
2368 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2370 phba->fc_rscn_id_list[i] = NULL;
2372 phba->fc_rscn_id_cnt = 0;
2373 spin_lock_irq(phba->host->host_lock);
2374 phba->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY);
2375 spin_unlock_irq(phba->host->host_lock);
2376 lpfc_can_disctmo(phba);
2381 lpfc_rscn_payload_check(struct lpfc_hba * phba, uint32_t did)
2385 struct lpfc_dmabuf *mp;
2387 uint32_t payload_len, cmd, i, match;
2389 ns_did.un.word = did;
2392 /* Never match fabric nodes for RSCNs */
2393 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
2396 /* If we are doing a FULL RSCN rediscovery, match everything */
2397 if (phba->fc_flag & FC_RSCN_DISCOVERY) {
2401 for (i = 0; i < phba->fc_rscn_id_cnt; i++) {
2402 mp = phba->fc_rscn_id_list[i];
2403 lp = (uint32_t *) mp->virt;
2405 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */
2406 payload_len -= sizeof (uint32_t); /* take off word 0 */
2407 while (payload_len) {
2408 rscn_did.un.word = *lp++;
2409 rscn_did.un.word = be32_to_cpu(rscn_did.un.word);
2410 payload_len -= sizeof (uint32_t);
2411 switch (rscn_did.un.b.resv) {
2412 case 0: /* Single N_Port ID effected */
2413 if (ns_did.un.word == rscn_did.un.word) {
2417 case 1: /* Whole N_Port Area effected */
2418 if ((ns_did.un.b.domain == rscn_did.un.b.domain)
2419 && (ns_did.un.b.area == rscn_did.un.b.area))
2424 case 2: /* Whole N_Port Domain effected */
2425 if (ns_did.un.b.domain == rscn_did.un.b.domain)
2430 case 3: /* Whole Fabric effected */
2434 /* Unknown Identifier in RSCN list */
2435 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
2436 "%d:0217 Unknown Identifier in "
2437 "RSCN payload Data: x%x\n",
2438 phba->brd_no, rscn_did.un.word);
2450 lpfc_rscn_recovery_check(struct lpfc_hba * phba)
2452 struct lpfc_nodelist *ndlp = NULL, *next_ndlp;
2453 struct list_head *listp;
2454 struct list_head *node_list[7];
2457 /* Look at all nodes effected by pending RSCNs and move
2460 node_list[0] = &phba->fc_npr_list; /* MUST do this list first */
2461 node_list[1] = &phba->fc_nlpmap_list;
2462 node_list[2] = &phba->fc_nlpunmap_list;
2463 node_list[3] = &phba->fc_prli_list;
2464 node_list[4] = &phba->fc_reglogin_list;
2465 node_list[5] = &phba->fc_adisc_list;
2466 node_list[6] = &phba->fc_plogi_list;
2467 for (i = 0; i < 7; i++) {
2468 listp = node_list[i];
2469 if (list_empty(listp))
2472 list_for_each_entry_safe(ndlp, next_ndlp, listp, nlp_listp) {
2473 if (!(lpfc_rscn_payload_check(phba, ndlp->nlp_DID)))
2476 lpfc_disc_state_machine(phba, ndlp, NULL,
2477 NLP_EVT_DEVICE_RECOVERY);
2479 /* Make sure NLP_DELAY_TMO is NOT running
2480 * after a device recovery event.
2482 if (ndlp->nlp_flag & NLP_DELAY_TMO)
2483 lpfc_cancel_retry_delay_tmo(phba, ndlp);
2490 lpfc_els_rcv_rscn(struct lpfc_hba * phba,
2491 struct lpfc_iocbq * cmdiocb,
2492 struct lpfc_nodelist * ndlp, uint8_t newnode)
2494 struct lpfc_dmabuf *pcmd;
2497 uint32_t payload_len, cmd;
2500 icmd = &cmdiocb->iocb;
2501 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2502 lp = (uint32_t *) pcmd->virt;
2505 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */
2506 payload_len -= sizeof (uint32_t); /* take off word 0 */
2507 cmd &= ELS_CMD_MASK;
2510 lpfc_printf_log(phba,
2513 "%d:0214 RSCN received Data: x%x x%x x%x x%x\n",
2515 phba->fc_flag, payload_len, *lp, phba->fc_rscn_id_cnt);
2517 for (i = 0; i < payload_len/sizeof(uint32_t); i++)
2518 fc_host_post_event(phba->host, fc_get_event_number(),
2519 FCH_EVT_RSCN, lp[i]);
2521 /* If we are about to begin discovery, just ACC the RSCN.
2522 * Discovery processing will satisfy it.
2524 if (phba->hba_state <= LPFC_NS_QRY) {
2525 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
2530 /* If we are already processing an RSCN, save the received
2531 * RSCN payload buffer, cmdiocb->context2 to process later.
2533 if (phba->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) {
2534 if ((phba->fc_rscn_id_cnt < FC_MAX_HOLD_RSCN) &&
2535 !(phba->fc_flag & FC_RSCN_DISCOVERY)) {
2536 spin_lock_irq(phba->host->host_lock);
2537 phba->fc_flag |= FC_RSCN_MODE;
2538 spin_unlock_irq(phba->host->host_lock);
2539 phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd;
2541 /* If we zero, cmdiocb->context2, the calling
2542 * routine will not try to free it.
2544 cmdiocb->context2 = NULL;
2547 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2548 "%d:0235 Deferred RSCN "
2549 "Data: x%x x%x x%x\n",
2550 phba->brd_no, phba->fc_rscn_id_cnt,
2551 phba->fc_flag, phba->hba_state);
2553 spin_lock_irq(phba->host->host_lock);
2554 phba->fc_flag |= FC_RSCN_DISCOVERY;
2555 spin_unlock_irq(phba->host->host_lock);
2556 /* ReDiscovery RSCN */
2557 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2558 "%d:0234 ReDiscovery RSCN "
2559 "Data: x%x x%x x%x\n",
2560 phba->brd_no, phba->fc_rscn_id_cnt,
2561 phba->fc_flag, phba->hba_state);
2564 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
2567 /* send RECOVERY event for ALL nodes that match RSCN payload */
2568 lpfc_rscn_recovery_check(phba);
2572 phba->fc_flag |= FC_RSCN_MODE;
2573 phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd;
2575 * If we zero, cmdiocb->context2, the calling routine will
2576 * not try to free it.
2578 cmdiocb->context2 = NULL;
2580 lpfc_set_disctmo(phba);
2583 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, newnode);
2585 /* send RECOVERY event for ALL nodes that match RSCN payload */
2586 lpfc_rscn_recovery_check(phba);
2588 return lpfc_els_handle_rscn(phba);
2592 lpfc_els_handle_rscn(struct lpfc_hba * phba)
2594 struct lpfc_nodelist *ndlp;
2596 /* Start timer for RSCN processing */
2597 lpfc_set_disctmo(phba);
2599 /* RSCN processed */
2600 lpfc_printf_log(phba,
2603 "%d:0215 RSCN processed Data: x%x x%x x%x x%x\n",
2605 phba->fc_flag, 0, phba->fc_rscn_id_cnt,
2608 /* To process RSCN, first compare RSCN data with NameServer */
2609 phba->fc_ns_retry = 0;
2610 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED, NameServer_DID);
2612 /* Good ndlp, issue CT Request to NameServer */
2613 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) == 0) {
2614 /* Wait for NameServer query cmpl before we can
2619 /* If login to NameServer does not exist, issue one */
2620 /* Good status, issue PLOGI to NameServer */
2621 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, NameServer_DID);
2623 /* Wait for NameServer login cmpl before we can
2627 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
2629 lpfc_els_flush_rscn(phba);
2632 lpfc_nlp_init(phba, ndlp, NameServer_DID);
2633 ndlp->nlp_type |= NLP_FABRIC;
2634 ndlp->nlp_prev_state = ndlp->nlp_state;
2635 lpfc_nlp_set_state(phba, ndlp, NLP_STE_PLOGI_ISSUE);
2636 lpfc_issue_els_plogi(phba, NameServer_DID, 0);
2637 /* Wait for NameServer login cmpl before we can
2643 lpfc_els_flush_rscn(phba);
2648 lpfc_els_rcv_flogi(struct lpfc_hba * phba,
2649 struct lpfc_iocbq * cmdiocb,
2650 struct lpfc_nodelist * ndlp, uint8_t newnode)
2652 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2653 uint32_t *lp = (uint32_t *) pcmd->virt;
2654 IOCB_t *icmd = &cmdiocb->iocb;
2655 struct serv_parm *sp;
2662 sp = (struct serv_parm *) lp;
2664 /* FLOGI received */
2666 lpfc_set_disctmo(phba);
2668 if (phba->fc_topology == TOPOLOGY_LOOP) {
2669 /* We should never receive a FLOGI in loop mode, ignore it */
2670 did = icmd->un.elsreq64.remoteID;
2672 /* An FLOGI ELS command <elsCmd> was received from DID <did> in
2674 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
2675 "%d:0113 An FLOGI ELS command x%x was received "
2676 "from DID x%x in Loop Mode\n",
2677 phba->brd_no, cmd, did);
2683 if ((lpfc_check_sparm(phba, ndlp, sp, CLASS3))) {
2684 /* For a FLOGI we accept, then if our portname is greater
2685 * then the remote portname we initiate Nport login.
2688 rc = memcmp(&phba->fc_portname, &sp->portName,
2689 sizeof (struct lpfc_name));
2692 if ((mbox = mempool_alloc(phba->mbox_mem_pool,
2693 GFP_KERNEL)) == 0) {
2696 lpfc_linkdown(phba);
2697 lpfc_init_link(phba, mbox,
2699 phba->cfg_link_speed);
2700 mbox->mb.un.varInitLnk.lipsr_AL_PA = 0;
2701 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2702 rc = lpfc_sli_issue_mbox
2703 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB));
2704 if (rc == MBX_NOT_FINISHED) {
2705 mempool_free( mbox, phba->mbox_mem_pool);
2708 } else if (rc > 0) { /* greater than */
2709 spin_lock_irq(phba->host->host_lock);
2710 phba->fc_flag |= FC_PT2PT_PLOGI;
2711 spin_unlock_irq(phba->host->host_lock);
2713 phba->fc_flag |= FC_PT2PT;
2714 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
2716 /* Reject this request because invalid parameters */
2717 stat.un.b.lsRjtRsvd0 = 0;
2718 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2719 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
2720 stat.un.b.vendorUnique = 0;
2721 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2726 lpfc_els_rsp_acc(phba, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL, newnode);
2732 lpfc_els_rcv_rnid(struct lpfc_hba * phba,
2733 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
2735 struct lpfc_dmabuf *pcmd;
2742 icmd = &cmdiocb->iocb;
2743 did = icmd->un.elsreq64.remoteID;
2744 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2745 lp = (uint32_t *) pcmd->virt;
2752 switch (rn->Format) {
2754 case RNID_TOPOLOGY_DISC:
2756 lpfc_els_rsp_rnid_acc(phba, rn->Format, cmdiocb, ndlp);
2759 /* Reject this request because format not supported */
2760 stat.un.b.lsRjtRsvd0 = 0;
2761 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2762 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2763 stat.un.b.vendorUnique = 0;
2764 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2770 lpfc_els_rcv_lirr(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2771 struct lpfc_nodelist * ndlp)
2775 /* For now, unconditionally reject this command */
2776 stat.un.b.lsRjtRsvd0 = 0;
2777 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2778 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2779 stat.un.b.vendorUnique = 0;
2780 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2785 lpfc_els_rsp_rps_acc(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb)
2787 struct lpfc_sli *psli;
2788 struct lpfc_sli_ring *pring;
2793 struct lpfc_iocbq *elsiocb;
2794 struct lpfc_nodelist *ndlp;
2795 uint16_t xri, status;
2799 pring = &psli->ring[LPFC_ELS_RING];
2802 ndlp = (struct lpfc_nodelist *) pmb->context2;
2803 xri = (uint16_t) ((unsigned long)(pmb->context1));
2804 pmb->context1 = NULL;
2805 pmb->context2 = NULL;
2807 if (mb->mbxStatus) {
2808 mempool_free( pmb, phba->mbox_mem_pool);
2812 cmdsize = sizeof(RPS_RSP) + sizeof(uint32_t);
2813 mempool_free( pmb, phba->mbox_mem_pool);
2814 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, lpfc_max_els_tries, ndlp,
2815 ndlp->nlp_DID, ELS_CMD_ACC);
2819 icmd = &elsiocb->iocb;
2820 icmd->ulpContext = xri;
2822 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2823 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2824 pcmd += sizeof (uint32_t); /* Skip past command */
2825 rps_rsp = (RPS_RSP *)pcmd;
2827 if (phba->fc_topology != TOPOLOGY_LOOP)
2831 if (phba->fc_flag & FC_FABRIC)
2835 rps_rsp->portStatus = be16_to_cpu(status);
2836 rps_rsp->linkFailureCnt = be32_to_cpu(mb->un.varRdLnk.linkFailureCnt);
2837 rps_rsp->lossSyncCnt = be32_to_cpu(mb->un.varRdLnk.lossSyncCnt);
2838 rps_rsp->lossSignalCnt = be32_to_cpu(mb->un.varRdLnk.lossSignalCnt);
2839 rps_rsp->primSeqErrCnt = be32_to_cpu(mb->un.varRdLnk.primSeqErrCnt);
2840 rps_rsp->invalidXmitWord = be32_to_cpu(mb->un.varRdLnk.invalidXmitWord);
2841 rps_rsp->crcCnt = be32_to_cpu(mb->un.varRdLnk.crcCnt);
2843 /* Xmit ELS RPS ACC response tag <ulpIoTag> */
2844 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2845 "%d:0118 Xmit ELS RPS ACC response tag x%x "
2846 "Data: x%x x%x x%x x%x x%x\n",
2848 elsiocb->iocb.ulpIoTag,
2849 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2850 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2852 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2853 phba->fc_stat.elsXmitACC++;
2854 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2855 lpfc_els_free_iocb(phba, elsiocb);
2861 lpfc_els_rcv_rps(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2862 struct lpfc_nodelist * ndlp)
2867 struct lpfc_dmabuf *pcmd;
2871 if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
2872 (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
2873 stat.un.b.lsRjtRsvd0 = 0;
2874 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2875 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2876 stat.un.b.vendorUnique = 0;
2877 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2880 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2881 lp = (uint32_t *) pcmd->virt;
2882 flag = (be32_to_cpu(*lp++) & 0xf);
2886 ((flag == 1) && (be32_to_cpu(rps->un.portNum) == 0)) ||
2887 ((flag == 2) && (memcmp(&rps->un.portName, &phba->fc_portname,
2888 sizeof (struct lpfc_name)) == 0))) {
2889 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC))) {
2890 lpfc_read_lnk_stat(phba, mbox);
2892 (void *)((unsigned long)cmdiocb->iocb.ulpContext);
2893 mbox->context2 = ndlp;
2894 mbox->mbox_cmpl = lpfc_els_rsp_rps_acc;
2895 if (lpfc_sli_issue_mbox (phba, mbox,
2896 (MBX_NOWAIT | MBX_STOP_IOCB)) != MBX_NOT_FINISHED) {
2897 /* Mbox completion will send ELS Response */
2900 mempool_free(mbox, phba->mbox_mem_pool);
2903 stat.un.b.lsRjtRsvd0 = 0;
2904 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2905 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2906 stat.un.b.vendorUnique = 0;
2907 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2912 lpfc_els_rsp_rpl_acc(struct lpfc_hba * phba, uint16_t cmdsize,
2913 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2918 struct lpfc_iocbq *elsiocb;
2919 struct lpfc_sli_ring *pring;
2920 struct lpfc_sli *psli;
2924 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2926 elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2927 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2931 icmd = &elsiocb->iocb;
2932 oldcmd = &oldiocb->iocb;
2933 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2935 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2936 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2937 pcmd += sizeof (uint16_t);
2938 *((uint16_t *)(pcmd)) = be16_to_cpu(cmdsize);
2939 pcmd += sizeof(uint16_t);
2941 /* Setup the RPL ACC payload */
2942 rpl_rsp.listLen = be32_to_cpu(1);
2944 rpl_rsp.port_num_blk.portNum = 0;
2945 rpl_rsp.port_num_blk.portID = be32_to_cpu(phba->fc_myDID);
2946 memcpy(&rpl_rsp.port_num_blk.portName, &phba->fc_portname,
2947 sizeof(struct lpfc_name));
2949 memcpy(pcmd, &rpl_rsp, cmdsize - sizeof(uint32_t));
2952 /* Xmit ELS RPL ACC response tag <ulpIoTag> */
2953 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2954 "%d:0120 Xmit ELS RPL ACC response tag x%x "
2955 "Data: x%x x%x x%x x%x x%x\n",
2957 elsiocb->iocb.ulpIoTag,
2958 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2959 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2961 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2963 phba->fc_stat.elsXmitACC++;
2964 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2965 lpfc_els_free_iocb(phba, elsiocb);
2972 lpfc_els_rcv_rpl(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2973 struct lpfc_nodelist * ndlp)
2975 struct lpfc_dmabuf *pcmd;
2982 if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
2983 (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
2984 stat.un.b.lsRjtRsvd0 = 0;
2985 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2986 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2987 stat.un.b.vendorUnique = 0;
2988 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2991 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2992 lp = (uint32_t *) pcmd->virt;
2993 rpl = (RPL *) (lp + 1);
2995 maxsize = be32_to_cpu(rpl->maxsize);
2997 /* We support only one port */
2998 if ((rpl->index == 0) &&
3000 ((maxsize * sizeof(uint32_t)) >= sizeof(RPL_RSP)))) {
3001 cmdsize = sizeof(uint32_t) + sizeof(RPL_RSP);
3003 cmdsize = sizeof(uint32_t) + maxsize * sizeof(uint32_t);
3005 lpfc_els_rsp_rpl_acc(phba, cmdsize, cmdiocb, ndlp);
3011 lpfc_els_rcv_farp(struct lpfc_hba * phba,
3012 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
3014 struct lpfc_dmabuf *pcmd;
3018 uint32_t cmd, cnt, did;
3020 icmd = &cmdiocb->iocb;
3021 did = icmd->un.elsreq64.remoteID;
3022 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3023 lp = (uint32_t *) pcmd->virt;
3028 /* FARP-REQ received from DID <did> */
3029 lpfc_printf_log(phba,
3032 "%d:0601 FARP-REQ received from DID x%x\n",
3035 /* We will only support match on WWPN or WWNN */
3036 if (fp->Mflags & ~(FARP_MATCH_NODE | FARP_MATCH_PORT)) {
3041 /* If this FARP command is searching for my portname */
3042 if (fp->Mflags & FARP_MATCH_PORT) {
3043 if (memcmp(&fp->RportName, &phba->fc_portname,
3044 sizeof (struct lpfc_name)) == 0)
3048 /* If this FARP command is searching for my nodename */
3049 if (fp->Mflags & FARP_MATCH_NODE) {
3050 if (memcmp(&fp->RnodeName, &phba->fc_nodename,
3051 sizeof (struct lpfc_name)) == 0)
3056 if ((ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) ||
3057 (ndlp->nlp_state == NLP_STE_MAPPED_NODE)) {
3058 /* Log back into the node before sending the FARP. */
3059 if (fp->Rflags & FARP_REQUEST_PLOGI) {
3060 ndlp->nlp_prev_state = ndlp->nlp_state;
3061 lpfc_nlp_set_state(phba, ndlp,
3062 NLP_STE_PLOGI_ISSUE);
3063 lpfc_issue_els_plogi(phba, ndlp->nlp_DID, 0);
3066 /* Send a FARP response to that node */
3067 if (fp->Rflags & FARP_REQUEST_FARPR) {
3068 lpfc_issue_els_farpr(phba, did, 0);
3076 lpfc_els_rcv_farpr(struct lpfc_hba * phba,
3077 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
3079 struct lpfc_dmabuf *pcmd;
3084 icmd = &cmdiocb->iocb;
3085 did = icmd->un.elsreq64.remoteID;
3086 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3087 lp = (uint32_t *) pcmd->virt;
3090 /* FARP-RSP received from DID <did> */
3091 lpfc_printf_log(phba,
3094 "%d:0600 FARP-RSP received from DID x%x\n",
3097 /* ACCEPT the Farp resp request */
3098 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
3104 lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
3105 struct lpfc_nodelist * fan_ndlp)
3107 struct lpfc_dmabuf *pcmd;
3112 struct lpfc_nodelist *ndlp, *next_ndlp;
3115 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, "%d:0265 FAN received\n",
3118 icmd = &cmdiocb->iocb;
3119 did = icmd->un.elsreq64.remoteID;
3120 pcmd = (struct lpfc_dmabuf *)cmdiocb->context2;
3121 lp = (uint32_t *)pcmd->virt;
3126 /* FAN received; Fan does not have a reply sequence */
3128 if (phba->hba_state == LPFC_LOCAL_CFG_LINK) {
3129 if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName,
3130 sizeof(struct lpfc_name)) != 0) ||
3131 (memcmp(&phba->fc_fabparam.portName, &fp->FportName,
3132 sizeof(struct lpfc_name)) != 0)) {
3134 * This node has switched fabrics. FLOGI is required
3135 * Clean up the old rpi's
3138 list_for_each_entry_safe(ndlp, next_ndlp,
3139 &phba->fc_npr_list, nlp_listp) {
3141 if (ndlp->nlp_type & NLP_FABRIC) {
3143 * Clean up old Fabric, Nameserver and
3144 * other NLP_FABRIC logins
3146 lpfc_drop_node(phba, ndlp);
3147 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
3148 /* Fail outstanding I/O now since this
3149 * device is marked for PLOGI
3151 lpfc_unreg_rpi(phba, ndlp);
3155 phba->hba_state = LPFC_FLOGI;
3156 lpfc_set_disctmo(phba);
3157 lpfc_initial_flogi(phba);
3160 /* Discovery not needed,
3161 * move the nodes to their original state.
3163 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
3166 switch (ndlp->nlp_prev_state) {
3167 case NLP_STE_UNMAPPED_NODE:
3168 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
3169 lpfc_nlp_set_state(phba, ndlp,
3170 NLP_STE_UNMAPPED_NODE);
3173 case NLP_STE_MAPPED_NODE:
3174 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
3175 lpfc_nlp_set_state(phba, ndlp,
3176 NLP_STE_MAPPED_NODE);
3184 /* Start discovery - this should just do CLEAR_LA */
3185 lpfc_disc_start(phba);
3191 lpfc_els_timeout(unsigned long ptr)
3193 struct lpfc_hba *phba;
3194 unsigned long iflag;
3196 phba = (struct lpfc_hba *)ptr;
3199 spin_lock_irqsave(phba->host->host_lock, iflag);
3200 if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
3201 phba->work_hba_events |= WORKER_ELS_TMO;
3202 if (phba->work_wait)
3203 wake_up(phba->work_wait);
3205 spin_unlock_irqrestore(phba->host->host_lock, iflag);
3210 lpfc_els_timeout_handler(struct lpfc_hba *phba)
3212 struct lpfc_sli_ring *pring;
3213 struct lpfc_iocbq *tmp_iocb, *piocb;
3215 struct lpfc_dmabuf *pcmd;
3217 uint32_t els_command;
3223 spin_lock_irq(phba->host->host_lock);
3224 /* If the timer is already canceled do nothing */
3225 if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
3226 spin_unlock_irq(phba->host->host_lock);
3229 timeout = (uint32_t)(phba->fc_ratov << 1);
3231 pring = &phba->sli.ring[LPFC_ELS_RING];
3233 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3236 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3239 pcmd = (struct lpfc_dmabuf *) piocb->context2;
3240 elscmd = (uint32_t *) (pcmd->virt);
3241 els_command = *elscmd;
3243 if ((els_command == ELS_CMD_FARP)
3244 || (els_command == ELS_CMD_FARPR)) {
3248 if (piocb->drvrTimeout > 0) {
3249 if (piocb->drvrTimeout >= timeout) {
3250 piocb->drvrTimeout -= timeout;
3252 piocb->drvrTimeout = 0;
3257 if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) {
3258 struct lpfc_nodelist *ndlp;
3259 ndlp = __lpfc_findnode_rpi(phba, cmd->ulpContext);
3260 remote_ID = ndlp->nlp_DID;
3262 remote_ID = cmd->un.elsreq64.remoteID;
3265 lpfc_printf_log(phba,
3268 "%d:0127 ELS timeout Data: x%x x%x x%x x%x\n",
3269 phba->brd_no, els_command,
3270 remote_ID, cmd->ulpCommand, cmd->ulpIoTag);
3272 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3274 if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt)
3275 mod_timer(&phba->els_tmofunc, jiffies + HZ * timeout);
3277 spin_unlock_irq(phba->host->host_lock);
3281 lpfc_els_flush_cmd(struct lpfc_hba * phba)
3283 LIST_HEAD(completions);
3284 struct lpfc_sli_ring *pring;
3285 struct lpfc_iocbq *tmp_iocb, *piocb;
3288 pring = &phba->sli.ring[LPFC_ELS_RING];
3289 spin_lock_irq(phba->host->host_lock);
3290 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
3293 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3297 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
3298 if ((cmd->ulpCommand == CMD_QUE_RING_BUF_CN) ||
3299 (cmd->ulpCommand == CMD_QUE_RING_BUF64_CN) ||
3300 (cmd->ulpCommand == CMD_CLOSE_XRI_CN) ||
3301 (cmd->ulpCommand == CMD_ABORT_XRI_CN)) {
3305 list_move_tail(&piocb->list, &completions);
3310 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3313 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3317 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3319 spin_unlock_irq(phba->host->host_lock);
3321 while(!list_empty(&completions)) {
3322 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
3324 list_del(&piocb->list);
3326 if (piocb->iocb_cmpl) {
3327 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3328 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3329 (piocb->iocb_cmpl) (phba, piocb, piocb);
3331 lpfc_sli_release_iocbq(phba, piocb);
3338 lpfc_els_unsol_event(struct lpfc_hba * phba,
3339 struct lpfc_sli_ring * pring, struct lpfc_iocbq * elsiocb)
3341 struct lpfc_sli *psli;
3342 struct lpfc_nodelist *ndlp;
3343 struct lpfc_dmabuf *mp;
3350 uint32_t drop_cmd = 0; /* by default do NOT drop received cmd */
3351 uint32_t rjt_err = 0;
3354 icmd = &elsiocb->iocb;
3356 if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
3357 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) {
3358 /* Not enough posted buffers; Try posting more buffers */
3359 phba->fc_stat.NoRcvBuf++;
3360 lpfc_post_buffer(phba, pring, 0, 1);
3364 /* If there are no BDEs associated with this IOCB,
3365 * there is nothing to do.
3367 if (icmd->ulpBdeCount == 0)
3370 /* type of ELS cmd is first 32bit word in packet */
3371 mp = lpfc_sli_ringpostbuf_get(phba, pring, getPaddr(icmd->un.
3375 cont64[0].addrLow));
3382 lp = (uint32_t *) mp->virt;
3384 lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], 1, 1);
3386 if (icmd->ulpStatus) {
3387 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3393 /* Check to see if link went down during discovery */
3394 if (lpfc_els_chk_latt(phba)) {
3395 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3401 did = icmd->un.rcvels.remoteID;
3402 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did);
3404 /* Cannot find existing Fabric ndlp, so allocate a new one */
3405 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
3407 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3413 lpfc_nlp_init(phba, ndlp, did);
3415 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) {
3416 ndlp->nlp_type |= NLP_FABRIC;
3418 lpfc_nlp_set_state(phba, ndlp, NLP_STE_UNUSED_NODE);
3421 phba->fc_stat.elsRcvFrame++;
3422 elsiocb->context1 = ndlp;
3423 elsiocb->context2 = mp;
3425 if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) {
3426 cmd &= ELS_CMD_MASK;
3428 /* ELS command <elsCmd> received from NPORT <did> */
3429 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
3430 "%d:0112 ELS command x%x received from NPORT x%x "
3431 "Data: x%x\n", phba->brd_no, cmd, did, phba->hba_state);
3435 phba->fc_stat.elsRcvPLOGI++;
3436 if (phba->hba_state < LPFC_DISC_AUTH) {
3440 ndlp = lpfc_plogi_confirm_nport(phba, mp, ndlp);
3441 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PLOGI);
3444 phba->fc_stat.elsRcvFLOGI++;
3445 lpfc_els_rcv_flogi(phba, elsiocb, ndlp, newnode);
3447 lpfc_drop_node(phba, ndlp);
3450 phba->fc_stat.elsRcvLOGO++;
3451 if (phba->hba_state < LPFC_DISC_AUTH) {
3455 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_LOGO);
3458 phba->fc_stat.elsRcvPRLO++;
3459 if (phba->hba_state < LPFC_DISC_AUTH) {
3463 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLO);
3466 phba->fc_stat.elsRcvRSCN++;
3467 lpfc_els_rcv_rscn(phba, elsiocb, ndlp, newnode);
3469 lpfc_drop_node(phba, ndlp);
3472 phba->fc_stat.elsRcvADISC++;
3473 if (phba->hba_state < LPFC_DISC_AUTH) {
3477 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_ADISC);
3480 phba->fc_stat.elsRcvPDISC++;
3481 if (phba->hba_state < LPFC_DISC_AUTH) {
3485 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PDISC);
3488 phba->fc_stat.elsRcvFARPR++;
3489 lpfc_els_rcv_farpr(phba, elsiocb, ndlp);
3492 phba->fc_stat.elsRcvFARP++;
3493 lpfc_els_rcv_farp(phba, elsiocb, ndlp);
3496 phba->fc_stat.elsRcvFAN++;
3497 lpfc_els_rcv_fan(phba, elsiocb, ndlp);
3500 phba->fc_stat.elsRcvPRLI++;
3501 if (phba->hba_state < LPFC_DISC_AUTH) {
3505 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLI);
3508 phba->fc_stat.elsRcvLIRR++;
3509 lpfc_els_rcv_lirr(phba, elsiocb, ndlp);
3511 lpfc_drop_node(phba, ndlp);
3514 phba->fc_stat.elsRcvRPS++;
3515 lpfc_els_rcv_rps(phba, elsiocb, ndlp);
3517 lpfc_drop_node(phba, ndlp);
3520 phba->fc_stat.elsRcvRPL++;
3521 lpfc_els_rcv_rpl(phba, elsiocb, ndlp);
3523 lpfc_drop_node(phba, ndlp);
3526 phba->fc_stat.elsRcvRNID++;
3527 lpfc_els_rcv_rnid(phba, elsiocb, ndlp);
3529 lpfc_drop_node(phba, ndlp);
3532 /* Unsupported ELS command, reject */
3535 /* Unknown ELS command <elsCmd> received from NPORT <did> */
3536 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3537 "%d:0115 Unknown ELS command x%x received from "
3538 "NPORT x%x\n", phba->brd_no, cmd, did);
3540 lpfc_drop_node(phba, ndlp);
3544 /* check if need to LS_RJT received ELS cmd */
3546 stat.un.b.lsRjtRsvd0 = 0;
3547 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3548 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
3549 stat.un.b.vendorUnique = 0;
3550 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, elsiocb, ndlp);
3553 if (elsiocb->context2) {
3554 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3558 /* check if need to drop received ELS cmd */
3559 if (drop_cmd == 1) {
3560 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3561 "%d:0111 Dropping received ELS cmd "
3562 "Data: x%x x%x x%x\n", phba->brd_no,
3563 icmd->ulpStatus, icmd->un.ulpWord[4],
3565 phba->fc_stat.elsRcvDrop++;