1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2005 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
26 #include <scsi/scsi.h>
27 #include <scsi/scsi_device.h>
28 #include <scsi/scsi_host.h>
29 #include <scsi/scsi_transport_fc.h>
33 #include "lpfc_disc.h"
34 #include "lpfc_scsi.h"
36 #include "lpfc_logmsg.h"
37 #include "lpfc_crtn.h"
39 static int lpfc_els_retry(struct lpfc_hba *, struct lpfc_iocbq *,
41 static int lpfc_max_els_tries = 3;
44 lpfc_els_chk_latt(struct lpfc_hba * phba)
46 struct lpfc_sli *psli;
53 if ((phba->hba_state >= LPFC_HBA_READY) ||
54 (phba->hba_state == LPFC_LINK_DOWN))
57 /* Read the HBA Host Attention Register */
58 spin_lock_irq(phba->host->host_lock);
59 ha_copy = readl(phba->HAregaddr);
60 spin_unlock_irq(phba->host->host_lock);
62 if (!(ha_copy & HA_LATT))
65 /* Pending Link Event during Discovery */
66 lpfc_printf_log(phba, KERN_WARNING, LOG_DISCOVERY,
67 "%d:0237 Pending Link Event during "
68 "Discovery: State x%x\n",
69 phba->brd_no, phba->hba_state);
71 /* CLEAR_LA should re-enable link attention events and
72 * we should then imediately take a LATT event. The
73 * LATT processing should call lpfc_linkdown() which
74 * will cleanup any left over in-progress discovery
77 spin_lock_irq(phba->host->host_lock);
78 phba->fc_flag |= FC_ABORT_DISCOVERY;
79 spin_unlock_irq(phba->host->host_lock);
81 if (phba->hba_state != LPFC_CLEAR_LA) {
82 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) {
83 phba->hba_state = LPFC_CLEAR_LA;
84 lpfc_clear_la(phba, mbox);
85 mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la;
86 rc = lpfc_sli_issue_mbox (phba, mbox,
87 (MBX_NOWAIT | MBX_STOP_IOCB));
88 if (rc == MBX_NOT_FINISHED) {
89 mempool_free(mbox, phba->mbox_mem_pool);
90 phba->hba_state = LPFC_HBA_ERROR;
99 static struct lpfc_iocbq *
100 lpfc_prep_els_iocb(struct lpfc_hba * phba,
103 uint8_t retry, struct lpfc_nodelist * ndlp, uint32_t elscmd)
105 struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
106 struct lpfc_sli_ring *pring;
107 struct lpfc_iocbq *elsiocb = NULL;
108 struct lpfc_dmabuf *pcmd, *prsp, *pbuflist;
109 struct ulp_bde64 *bpl;
112 pring = &phba->sli.ring[LPFC_ELS_RING];
114 if (phba->hba_state < LPFC_LINK_UP)
118 /* Allocate buffer for command iocb */
119 spin_lock_irq(phba->host->host_lock);
120 list_remove_head(lpfc_iocb_list, elsiocb, struct lpfc_iocbq, list);
121 spin_unlock_irq(phba->host->host_lock);
125 icmd = &elsiocb->iocb;
127 /* fill in BDEs for command */
128 /* Allocate buffer for command payload */
129 if (((pcmd = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL)) == 0) ||
130 ((pcmd->virt = lpfc_mbuf_alloc(phba,
131 MEM_PRI, &(pcmd->phys))) == 0)) {
135 spin_lock_irq(phba->host->host_lock);
136 lpfc_sli_release_iocbq(phba, elsiocb);
137 spin_unlock_irq(phba->host->host_lock);
141 INIT_LIST_HEAD(&pcmd->list);
143 /* Allocate buffer for response payload */
145 prsp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
147 prsp->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
149 if (prsp == 0 || prsp->virt == 0) {
152 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
154 spin_lock_irq(phba->host->host_lock);
155 lpfc_sli_release_iocbq(phba, elsiocb);
156 spin_unlock_irq(phba->host->host_lock);
159 INIT_LIST_HEAD(&prsp->list);
164 /* Allocate buffer for Buffer ptr list */
165 pbuflist = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
167 pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
169 if (pbuflist == 0 || pbuflist->virt == 0) {
170 spin_lock_irq(phba->host->host_lock);
171 lpfc_sli_release_iocbq(phba, elsiocb);
172 spin_unlock_irq(phba->host->host_lock);
173 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
174 lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
182 INIT_LIST_HEAD(&pbuflist->list);
184 icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
185 icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
186 icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BDL;
188 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64));
189 icmd->un.elsreq64.remoteID = ndlp->nlp_DID; /* DID */
190 icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
192 icmd->un.elsreq64.bdl.bdeSize = sizeof (struct ulp_bde64);
193 icmd->ulpCommand = CMD_XMIT_ELS_RSP64_CX;
196 icmd->ulpBdeCount = 1;
198 icmd->ulpClass = CLASS3;
200 bpl = (struct ulp_bde64 *) pbuflist->virt;
201 bpl->addrLow = le32_to_cpu(putPaddrLow(pcmd->phys));
202 bpl->addrHigh = le32_to_cpu(putPaddrHigh(pcmd->phys));
203 bpl->tus.f.bdeSize = cmdSize;
204 bpl->tus.f.bdeFlags = 0;
205 bpl->tus.w = le32_to_cpu(bpl->tus.w);
209 bpl->addrLow = le32_to_cpu(putPaddrLow(prsp->phys));
210 bpl->addrHigh = le32_to_cpu(putPaddrHigh(prsp->phys));
211 bpl->tus.f.bdeSize = FCELSSIZE;
212 bpl->tus.f.bdeFlags = BUFF_USE_RCV;
213 bpl->tus.w = le32_to_cpu(bpl->tus.w);
216 /* Save for completion so we can release these resources */
217 elsiocb->context1 = (uint8_t *) ndlp;
218 elsiocb->context2 = (uint8_t *) pcmd;
219 elsiocb->context3 = (uint8_t *) pbuflist;
220 elsiocb->retry = retry;
221 elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
224 list_add(&prsp->list, &pcmd->list);
228 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
229 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
230 "%d:0116 Xmit ELS command x%x to remote "
231 "NPORT x%x Data: x%x x%x\n",
232 phba->brd_no, elscmd,
233 ndlp->nlp_DID, icmd->ulpIoTag, phba->hba_state);
235 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
236 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
237 "%d:0117 Xmit ELS response x%x to remote "
238 "NPORT x%x Data: x%x x%x\n",
239 phba->brd_no, elscmd,
240 ndlp->nlp_DID, icmd->ulpIoTag, cmdSize);
248 lpfc_cmpl_els_flogi_fabric(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
249 struct serv_parm *sp, IOCB_t *irsp)
254 spin_lock_irq(phba->host->host_lock);
255 phba->fc_flag |= FC_FABRIC;
256 spin_unlock_irq(phba->host->host_lock);
258 phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov);
259 if (sp->cmn.edtovResolution) /* E_D_TOV ticks are in nanoseconds */
260 phba->fc_edtov = (phba->fc_edtov + 999999) / 1000000;
262 phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
264 if (phba->fc_topology == TOPOLOGY_LOOP) {
265 spin_lock_irq(phba->host->host_lock);
266 phba->fc_flag |= FC_PUBLIC_LOOP;
267 spin_unlock_irq(phba->host->host_lock);
270 * If we are a N-port connected to a Fabric, fixup sparam's so
271 * logins to devices on remote loops work.
273 phba->fc_sparam.cmn.altBbCredit = 1;
276 phba->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
277 memcpy(&ndlp->nlp_portname, &sp->portName, sizeof(struct lpfc_name));
278 memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof (struct lpfc_name));
279 ndlp->nlp_class_sup = 0;
280 if (sp->cls1.classValid)
281 ndlp->nlp_class_sup |= FC_COS_CLASS1;
282 if (sp->cls2.classValid)
283 ndlp->nlp_class_sup |= FC_COS_CLASS2;
284 if (sp->cls3.classValid)
285 ndlp->nlp_class_sup |= FC_COS_CLASS3;
286 if (sp->cls4.classValid)
287 ndlp->nlp_class_sup |= FC_COS_CLASS4;
288 ndlp->nlp_maxframe = ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) |
289 sp->cmn.bbRcvSizeLsb;
290 memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
292 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
296 phba->hba_state = LPFC_FABRIC_CFG_LINK;
297 lpfc_config_link(phba, mbox);
298 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
300 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
301 if (rc == MBX_NOT_FINISHED)
304 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
308 if (lpfc_reg_login(phba, Fabric_DID, (uint8_t *) sp, mbox, 0))
312 * set_slim mailbox command needs to execute first,
313 * queue this command to be processed later.
315 mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login;
316 mbox->context2 = ndlp;
318 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
319 if (rc == MBX_NOT_FINISHED)
325 mempool_free(mbox, phba->mbox_mem_pool);
331 * We FLOGIed into an NPort, initiate pt2pt protocol
334 lpfc_cmpl_els_flogi_nport(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
335 struct serv_parm *sp)
340 spin_lock_irq(phba->host->host_lock);
341 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
342 spin_unlock_irq(phba->host->host_lock);
344 phba->fc_edtov = FF_DEF_EDTOV;
345 phba->fc_ratov = FF_DEF_RATOV;
346 rc = memcmp(&phba->fc_portname, &sp->portName,
347 sizeof(struct lpfc_name));
349 /* This side will initiate the PLOGI */
350 spin_lock_irq(phba->host->host_lock);
351 phba->fc_flag |= FC_PT2PT_PLOGI;
352 spin_unlock_irq(phba->host->host_lock);
355 * N_Port ID cannot be 0, set our to LocalID the other
356 * side will be RemoteID.
361 phba->fc_myDID = PT2PT_LocalID;
363 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
367 lpfc_config_link(phba, mbox);
369 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
370 rc = lpfc_sli_issue_mbox(phba, mbox,
371 MBX_NOWAIT | MBX_STOP_IOCB);
372 if (rc == MBX_NOT_FINISHED) {
373 mempool_free(mbox, phba->mbox_mem_pool);
376 mempool_free(ndlp, phba->nlp_mem_pool);
378 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, PT2PT_RemoteID);
381 * Cannot find existing Fabric ndlp, so allocate a
384 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
388 lpfc_nlp_init(phba, ndlp, PT2PT_RemoteID);
391 memcpy(&ndlp->nlp_portname, &sp->portName,
392 sizeof(struct lpfc_name));
393 memcpy(&ndlp->nlp_nodename, &sp->nodeName,
394 sizeof(struct lpfc_name));
395 ndlp->nlp_state = NLP_STE_NPR_NODE;
396 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
397 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
399 /* This side will wait for the PLOGI */
400 mempool_free( ndlp, phba->nlp_mem_pool);
403 spin_lock_irq(phba->host->host_lock);
404 phba->fc_flag |= FC_PT2PT;
405 spin_unlock_irq(phba->host->host_lock);
407 /* Start discovery - this should just do CLEAR_LA */
408 lpfc_disc_start(phba);
415 lpfc_cmpl_els_flogi(struct lpfc_hba * phba,
416 struct lpfc_iocbq * cmdiocb, struct lpfc_iocbq * rspiocb)
418 IOCB_t *irsp = &rspiocb->iocb;
419 struct lpfc_nodelist *ndlp = cmdiocb->context1;
420 struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
421 struct serv_parm *sp;
424 /* Check to see if link went down during discovery */
425 if (lpfc_els_chk_latt(phba)) {
426 lpfc_nlp_remove(phba, ndlp);
430 if (irsp->ulpStatus) {
431 /* Check for retry */
432 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
433 /* ELS command is being retried */
436 /* FLOGI failed, so there is no fabric */
437 spin_lock_irq(phba->host->host_lock);
438 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
439 spin_unlock_irq(phba->host->host_lock);
441 /* If private loop, then allow max outstandting els to be
442 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
443 * alpa map would take too long otherwise.
445 if (phba->alpa_map[0] == 0) {
446 phba->cfg_discovery_threads =
447 LPFC_MAX_DISC_THREADS;
451 lpfc_printf_log(phba,
454 "%d:0100 FLOGI failure Data: x%x x%x\n",
456 irsp->ulpStatus, irsp->un.ulpWord[4]);
461 * The FLogI succeeded. Sync the data for the CPU before
464 prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list);
466 sp = prsp->virt + sizeof(uint32_t);
468 /* FLOGI completes successfully */
469 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
470 "%d:0101 FLOGI completes sucessfully "
471 "Data: x%x x%x x%x x%x\n",
473 irsp->un.ulpWord[4], sp->cmn.e_d_tov,
474 sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
476 if (phba->hba_state == LPFC_FLOGI) {
478 * If Common Service Parameters indicate Nport
479 * we are point to point, if Fport we are Fabric.
482 rc = lpfc_cmpl_els_flogi_fabric(phba, ndlp, sp, irsp);
484 rc = lpfc_cmpl_els_flogi_nport(phba, ndlp, sp);
491 lpfc_nlp_remove(phba, ndlp);
493 if (irsp->ulpStatus != IOSTAT_LOCAL_REJECT ||
494 (irsp->un.ulpWord[4] != IOERR_SLI_ABORTED &&
495 irsp->un.ulpWord[4] != IOERR_SLI_DOWN)) {
496 /* FLOGI failed, so just use loop map to make discovery list */
497 lpfc_disc_list_loopmap(phba);
499 /* Start discovery */
500 lpfc_disc_start(phba);
504 lpfc_els_free_iocb(phba, cmdiocb);
508 lpfc_issue_els_flogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
511 struct serv_parm *sp;
513 struct lpfc_iocbq *elsiocb;
514 struct lpfc_sli_ring *pring;
520 pring = &phba->sli.ring[LPFC_ELS_RING];
522 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
523 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry,
524 ndlp, ELS_CMD_FLOGI)) == 0) {
528 icmd = &elsiocb->iocb;
529 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
531 /* For FLOGI request, remainder of payload is service parameters */
532 *((uint32_t *) (pcmd)) = ELS_CMD_FLOGI;
533 pcmd += sizeof (uint32_t);
534 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
535 sp = (struct serv_parm *) pcmd;
537 /* Setup CSPs accordingly for Fabric */
539 sp->cmn.w2.r_a_tov = 0;
540 sp->cls1.classValid = 0;
541 sp->cls2.seqDelivery = 1;
542 sp->cls3.seqDelivery = 1;
543 if (sp->cmn.fcphLow < FC_PH3)
544 sp->cmn.fcphLow = FC_PH3;
545 if (sp->cmn.fcphHigh < FC_PH3)
546 sp->cmn.fcphHigh = FC_PH3;
548 tmo = phba->fc_ratov;
549 phba->fc_ratov = LPFC_DISC_FLOGI_TMO;
550 lpfc_set_disctmo(phba);
551 phba->fc_ratov = tmo;
553 phba->fc_stat.elsXmitFLOGI++;
554 elsiocb->iocb_cmpl = lpfc_cmpl_els_flogi;
555 spin_lock_irq(phba->host->host_lock);
556 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
557 spin_unlock_irq(phba->host->host_lock);
558 if (rc == IOCB_ERROR) {
559 lpfc_els_free_iocb(phba, elsiocb);
566 lpfc_els_abort_flogi(struct lpfc_hba * phba)
568 struct lpfc_sli_ring *pring;
569 struct lpfc_iocbq *iocb, *next_iocb;
570 struct lpfc_nodelist *ndlp;
573 /* Abort outstanding I/O on NPort <nlp_DID> */
574 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
575 "%d:0201 Abort outstanding I/O on NPort x%x\n",
576 phba->brd_no, Fabric_DID);
578 pring = &phba->sli.ring[LPFC_ELS_RING];
581 * Check the txcmplq for an iocb that matches the nport the driver is
584 spin_lock_irq(phba->host->host_lock);
585 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
587 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR) {
588 ndlp = (struct lpfc_nodelist *)(iocb->context1);
589 if (ndlp && (ndlp->nlp_DID == Fabric_DID)) {
590 list_del(&iocb->list);
591 pring->txcmplq_cnt--;
593 if ((icmd->un.elsreq64.bdl.ulpIoTag32)) {
594 lpfc_sli_issue_abort_iotag32
597 if (iocb->iocb_cmpl) {
598 icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
599 icmd->un.ulpWord[4] =
601 spin_unlock_irq(phba->host->host_lock);
602 (iocb->iocb_cmpl) (phba, iocb, iocb);
603 spin_lock_irq(phba->host->host_lock);
605 lpfc_sli_release_iocbq(phba, iocb);
609 spin_unlock_irq(phba->host->host_lock);
615 lpfc_initial_flogi(struct lpfc_hba * phba)
617 struct lpfc_nodelist *ndlp;
619 /* First look for Fabric ndlp on the unmapped list */
622 lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED,
624 /* Cannot find existing Fabric ndlp, so allocate a new one */
625 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL))
629 lpfc_nlp_init(phba, ndlp, Fabric_DID);
632 phba->fc_unmap_cnt--;
633 list_del(&ndlp->nlp_listp);
634 spin_lock_irq(phba->host->host_lock);
635 ndlp->nlp_flag &= ~NLP_LIST_MASK;
636 spin_unlock_irq(phba->host->host_lock);
638 if (lpfc_issue_els_flogi(phba, ndlp, 0)) {
639 mempool_free( ndlp, phba->nlp_mem_pool);
645 lpfc_more_plogi(struct lpfc_hba * phba)
649 if (phba->num_disc_nodes)
650 phba->num_disc_nodes--;
652 /* Continue discovery with <num_disc_nodes> PLOGIs to go */
653 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
654 "%d:0232 Continue discovery with %d PLOGIs to go "
655 "Data: x%x x%x x%x\n",
656 phba->brd_no, phba->num_disc_nodes, phba->fc_plogi_cnt,
657 phba->fc_flag, phba->hba_state);
659 /* Check to see if there are more PLOGIs to be sent */
660 if (phba->fc_flag & FC_NLP_MORE) {
661 /* go thru NPR list and issue any remaining ELS PLOGIs */
662 sentplogi = lpfc_els_disc_plogi(phba);
668 lpfc_cmpl_els_plogi(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
669 struct lpfc_iocbq * rspiocb)
672 struct lpfc_sli *psli;
673 struct lpfc_nodelist *ndlp;
674 int disc, rc, did, type;
678 /* we pass cmdiocb to state machine which needs rspiocb as well */
679 cmdiocb->context_un.rsp_iocb = rspiocb;
681 irsp = &rspiocb->iocb;
682 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
683 spin_lock_irq(phba->host->host_lock);
684 ndlp->nlp_flag &= ~NLP_PLOGI_SND;
685 spin_unlock_irq(phba->host->host_lock);
687 /* Since ndlp can be freed in the disc state machine, note if this node
688 * is being used during discovery.
690 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
693 /* PLOGI completes to NPort <nlp_DID> */
694 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
695 "%d:0102 PLOGI completes to NPort x%x "
696 "Data: x%x x%x x%x x%x\n",
697 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
698 irsp->un.ulpWord[4], disc, phba->num_disc_nodes);
700 /* Check to see if link went down during discovery */
701 if (lpfc_els_chk_latt(phba)) {
702 spin_lock_irq(phba->host->host_lock);
703 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
704 spin_unlock_irq(phba->host->host_lock);
708 /* ndlp could be freed in DSM, save these values now */
709 type = ndlp->nlp_type;
712 if (irsp->ulpStatus) {
713 /* Check for retry */
714 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
715 /* ELS command is being retried */
717 spin_lock_irq(phba->host->host_lock);
718 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
719 spin_unlock_irq(phba->host->host_lock);
725 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
726 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
727 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
728 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
729 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
732 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb,
736 /* Good status, call state machine */
737 rc = lpfc_disc_state_machine(phba, ndlp, cmdiocb,
741 if (type & NLP_FABRIC) {
742 /* If we cannot login to Nameserver, kick off discovery now */
743 if ((did == NameServer_DID) && (rc == NLP_STE_FREED_NODE)) {
744 lpfc_disc_start(phba);
749 if (disc && phba->num_disc_nodes) {
750 /* Check to see if there are more PLOGIs to be sent */
751 lpfc_more_plogi(phba);
754 if (rc != NLP_STE_FREED_NODE) {
755 spin_lock_irq(phba->host->host_lock);
756 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
757 spin_unlock_irq(phba->host->host_lock);
760 if (phba->num_disc_nodes == 0) {
762 spin_lock_irq(phba->host->host_lock);
763 phba->fc_flag &= ~FC_NDISC_ACTIVE;
764 spin_unlock_irq(phba->host->host_lock);
766 lpfc_can_disctmo(phba);
767 if (phba->fc_flag & FC_RSCN_MODE) {
768 /* Check to see if more RSCNs came in while we were
769 * processing this one.
771 if ((phba->fc_rscn_id_cnt == 0) &&
772 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) {
773 spin_lock_irq(phba->host->host_lock);
774 phba->fc_flag &= ~FC_RSCN_MODE;
775 spin_unlock_irq(phba->host->host_lock);
777 lpfc_els_handle_rscn(phba);
783 lpfc_els_free_iocb(phba, cmdiocb);
788 lpfc_issue_els_plogi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
791 struct serv_parm *sp;
793 struct lpfc_iocbq *elsiocb;
794 struct lpfc_sli_ring *pring;
795 struct lpfc_sli *psli;
800 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
802 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
803 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry,
804 ndlp, ELS_CMD_PLOGI)) == 0) {
808 icmd = &elsiocb->iocb;
809 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
811 /* For PLOGI request, remainder of payload is service parameters */
812 *((uint32_t *) (pcmd)) = ELS_CMD_PLOGI;
813 pcmd += sizeof (uint32_t);
814 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
815 sp = (struct serv_parm *) pcmd;
817 if (sp->cmn.fcphLow < FC_PH_4_3)
818 sp->cmn.fcphLow = FC_PH_4_3;
820 if (sp->cmn.fcphHigh < FC_PH3)
821 sp->cmn.fcphHigh = FC_PH3;
823 phba->fc_stat.elsXmitPLOGI++;
824 elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi;
825 spin_lock_irq(phba->host->host_lock);
826 ndlp->nlp_flag |= NLP_PLOGI_SND;
827 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
828 ndlp->nlp_flag &= ~NLP_PLOGI_SND;
829 spin_unlock_irq(phba->host->host_lock);
830 lpfc_els_free_iocb(phba, elsiocb);
833 spin_unlock_irq(phba->host->host_lock);
838 lpfc_cmpl_els_prli(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
839 struct lpfc_iocbq * rspiocb)
842 struct lpfc_sli *psli;
843 struct lpfc_nodelist *ndlp;
846 /* we pass cmdiocb to state machine which needs rspiocb as well */
847 cmdiocb->context_un.rsp_iocb = rspiocb;
849 irsp = &(rspiocb->iocb);
850 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
851 spin_lock_irq(phba->host->host_lock);
852 ndlp->nlp_flag &= ~NLP_PRLI_SND;
853 spin_unlock_irq(phba->host->host_lock);
855 /* PRLI completes to NPort <nlp_DID> */
856 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
857 "%d:0103 PRLI completes to NPort x%x "
858 "Data: x%x x%x x%x\n",
859 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
860 irsp->un.ulpWord[4], phba->num_disc_nodes);
862 phba->fc_prli_sent--;
863 /* Check to see if link went down during discovery */
864 if (lpfc_els_chk_latt(phba))
867 if (irsp->ulpStatus) {
868 /* Check for retry */
869 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
870 /* ELS command is being retried */
874 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
875 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
876 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
877 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
881 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
885 /* Good status, call state machine */
886 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_PRLI);
890 lpfc_els_free_iocb(phba, cmdiocb);
895 lpfc_issue_els_prli(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
900 struct lpfc_iocbq *elsiocb;
901 struct lpfc_sli_ring *pring;
902 struct lpfc_sli *psli;
907 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
909 cmdsize = (sizeof (uint32_t) + sizeof (PRLI));
910 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry,
911 ndlp, ELS_CMD_PRLI)) == 0) {
915 icmd = &elsiocb->iocb;
916 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
918 /* For PRLI request, remainder of payload is service parameters */
919 memset(pcmd, 0, (sizeof (PRLI) + sizeof (uint32_t)));
920 *((uint32_t *) (pcmd)) = ELS_CMD_PRLI;
921 pcmd += sizeof (uint32_t);
923 /* For PRLI, remainder of payload is PRLI parameter page */
926 * If our firmware version is 3.20 or later,
927 * set the following bits for FC-TAPE support.
929 if (phba->vpd.rev.feaLevelHigh >= 0x02) {
930 npr->ConfmComplAllowed = 1;
932 npr->TaskRetryIdReq = 1;
934 npr->estabImagePair = 1;
935 npr->readXferRdyDis = 1;
937 /* For FCP support */
938 npr->prliType = PRLI_FCP_TYPE;
939 npr->initiatorFunc = 1;
941 phba->fc_stat.elsXmitPRLI++;
942 elsiocb->iocb_cmpl = lpfc_cmpl_els_prli;
943 spin_lock_irq(phba->host->host_lock);
944 ndlp->nlp_flag |= NLP_PRLI_SND;
945 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
946 ndlp->nlp_flag &= ~NLP_PRLI_SND;
947 spin_unlock_irq(phba->host->host_lock);
948 lpfc_els_free_iocb(phba, elsiocb);
951 spin_unlock_irq(phba->host->host_lock);
952 phba->fc_prli_sent++;
957 lpfc_more_adisc(struct lpfc_hba * phba)
961 if (phba->num_disc_nodes)
962 phba->num_disc_nodes--;
964 /* Continue discovery with <num_disc_nodes> ADISCs to go */
965 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
966 "%d:0210 Continue discovery with %d ADISCs to go "
967 "Data: x%x x%x x%x\n",
968 phba->brd_no, phba->num_disc_nodes, phba->fc_adisc_cnt,
969 phba->fc_flag, phba->hba_state);
971 /* Check to see if there are more ADISCs to be sent */
972 if (phba->fc_flag & FC_NLP_MORE) {
973 lpfc_set_disctmo(phba);
975 /* go thru NPR list and issue any remaining ELS ADISCs */
976 sentadisc = lpfc_els_disc_adisc(phba);
982 lpfc_rscn_disc(struct lpfc_hba * phba)
985 /* go thru NPR list and issue ELS PLOGIs */
986 if (phba->fc_npr_cnt) {
987 if (lpfc_els_disc_plogi(phba))
990 if (phba->fc_flag & FC_RSCN_MODE) {
991 /* Check to see if more RSCNs came in while we were
992 * processing this one.
994 if ((phba->fc_rscn_id_cnt == 0) &&
995 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) {
996 spin_lock_irq(phba->host->host_lock);
997 phba->fc_flag &= ~FC_RSCN_MODE;
998 spin_unlock_irq(phba->host->host_lock);
1000 lpfc_els_handle_rscn(phba);
1006 lpfc_cmpl_els_adisc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1007 struct lpfc_iocbq * rspiocb)
1010 struct lpfc_sli *psli;
1011 struct lpfc_nodelist *ndlp;
1017 /* we pass cmdiocb to state machine which needs rspiocb as well */
1018 cmdiocb->context_un.rsp_iocb = rspiocb;
1020 irsp = &(rspiocb->iocb);
1021 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1022 spin_lock_irq(phba->host->host_lock);
1023 ndlp->nlp_flag &= ~NLP_ADISC_SND;
1024 spin_unlock_irq(phba->host->host_lock);
1026 /* Since ndlp can be freed in the disc state machine, note if this node
1027 * is being used during discovery.
1029 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
1031 /* ADISC completes to NPort <nlp_DID> */
1032 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1033 "%d:0104 ADISC completes to NPort x%x "
1034 "Data: x%x x%x x%x x%x\n",
1035 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
1036 irsp->un.ulpWord[4], disc, phba->num_disc_nodes);
1038 /* Check to see if link went down during discovery */
1039 if (lpfc_els_chk_latt(phba)) {
1040 spin_lock_irq(phba->host->host_lock);
1041 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1042 spin_unlock_irq(phba->host->host_lock);
1046 if (irsp->ulpStatus) {
1047 /* Check for retry */
1048 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1049 /* ELS command is being retried */
1051 spin_lock_irq(phba->host->host_lock);
1052 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1053 spin_unlock_irq(phba->host->host_lock);
1054 lpfc_set_disctmo(phba);
1059 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1060 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1061 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
1062 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
1063 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
1066 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1067 NLP_EVT_CMPL_ADISC);
1070 /* Good status, call state machine */
1071 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1072 NLP_EVT_CMPL_ADISC);
1075 if (disc && phba->num_disc_nodes) {
1076 /* Check to see if there are more ADISCs to be sent */
1077 lpfc_more_adisc(phba);
1079 /* Check to see if we are done with ADISC authentication */
1080 if (phba->num_disc_nodes == 0) {
1081 lpfc_can_disctmo(phba);
1082 /* If we get here, there is nothing left to wait for */
1083 if ((phba->hba_state < LPFC_HBA_READY) &&
1084 (phba->hba_state != LPFC_CLEAR_LA)) {
1085 /* Link up discovery */
1086 if ((mbox = mempool_alloc(phba->mbox_mem_pool,
1088 phba->hba_state = LPFC_CLEAR_LA;
1089 lpfc_clear_la(phba, mbox);
1091 lpfc_mbx_cmpl_clear_la;
1092 rc = lpfc_sli_issue_mbox
1094 (MBX_NOWAIT | MBX_STOP_IOCB));
1095 if (rc == MBX_NOT_FINISHED) {
1097 phba->mbox_mem_pool);
1098 lpfc_disc_flush_list(phba);
1099 psli->ring[(psli->ip_ring)].
1101 ~LPFC_STOP_IOCB_EVENT;
1102 psli->ring[(psli->fcp_ring)].
1104 ~LPFC_STOP_IOCB_EVENT;
1105 psli->ring[(psli->next_ring)].
1107 ~LPFC_STOP_IOCB_EVENT;
1113 lpfc_rscn_disc(phba);
1117 spin_lock_irq(phba->host->host_lock);
1118 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
1119 spin_unlock_irq(phba->host->host_lock);
1121 lpfc_els_free_iocb(phba, cmdiocb);
1126 lpfc_issue_els_adisc(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1131 struct lpfc_iocbq *elsiocb;
1132 struct lpfc_sli_ring *pring;
1133 struct lpfc_sli *psli;
1138 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1140 cmdsize = (sizeof (uint32_t) + sizeof (ADISC));
1141 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry,
1142 ndlp, ELS_CMD_ADISC)) == 0) {
1146 icmd = &elsiocb->iocb;
1147 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1149 /* For ADISC request, remainder of payload is service parameters */
1150 *((uint32_t *) (pcmd)) = ELS_CMD_ADISC;
1151 pcmd += sizeof (uint32_t);
1153 /* Fill in ADISC payload */
1154 ap = (ADISC *) pcmd;
1155 ap->hardAL_PA = phba->fc_pref_ALPA;
1156 memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name));
1157 memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
1158 ap->DID = be32_to_cpu(phba->fc_myDID);
1160 phba->fc_stat.elsXmitADISC++;
1161 elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc;
1162 spin_lock_irq(phba->host->host_lock);
1163 ndlp->nlp_flag |= NLP_ADISC_SND;
1164 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1165 ndlp->nlp_flag &= ~NLP_ADISC_SND;
1166 spin_unlock_irq(phba->host->host_lock);
1167 lpfc_els_free_iocb(phba, elsiocb);
1170 spin_unlock_irq(phba->host->host_lock);
1175 lpfc_cmpl_els_logo(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1176 struct lpfc_iocbq * rspiocb)
1179 struct lpfc_sli *psli;
1180 struct lpfc_nodelist *ndlp;
1183 /* we pass cmdiocb to state machine which needs rspiocb as well */
1184 cmdiocb->context_un.rsp_iocb = rspiocb;
1186 irsp = &(rspiocb->iocb);
1187 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1188 spin_lock_irq(phba->host->host_lock);
1189 ndlp->nlp_flag &= ~NLP_LOGO_SND;
1190 spin_unlock_irq(phba->host->host_lock);
1192 /* LOGO completes to NPort <nlp_DID> */
1193 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1194 "%d:0105 LOGO completes to NPort x%x "
1195 "Data: x%x x%x x%x\n",
1196 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
1197 irsp->un.ulpWord[4], phba->num_disc_nodes);
1199 /* Check to see if link went down during discovery */
1200 if (lpfc_els_chk_latt(phba))
1203 if (irsp->ulpStatus) {
1204 /* Check for retry */
1205 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1206 /* ELS command is being retried */
1210 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1211 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1212 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
1213 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
1217 lpfc_disc_state_machine(phba, ndlp, cmdiocb,
1221 /* Good status, call state machine */
1222 lpfc_disc_state_machine(phba, ndlp, cmdiocb, NLP_EVT_CMPL_LOGO);
1224 if (ndlp->nlp_flag & NLP_DELAY_TMO) {
1225 lpfc_unreg_rpi(phba, ndlp);
1230 lpfc_els_free_iocb(phba, cmdiocb);
1235 lpfc_issue_els_logo(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp,
1239 struct lpfc_iocbq *elsiocb;
1240 struct lpfc_sli_ring *pring;
1241 struct lpfc_sli *psli;
1246 pring = &psli->ring[LPFC_ELS_RING];
1248 cmdsize = 2 * (sizeof (uint32_t) + sizeof (struct lpfc_name));
1249 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry,
1250 ndlp, ELS_CMD_LOGO)) == 0) {
1254 icmd = &elsiocb->iocb;
1255 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1256 *((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
1257 pcmd += sizeof (uint32_t);
1259 /* Fill in LOGO payload */
1260 *((uint32_t *) (pcmd)) = be32_to_cpu(phba->fc_myDID);
1261 pcmd += sizeof (uint32_t);
1262 memcpy(pcmd, &phba->fc_portname, sizeof (struct lpfc_name));
1264 phba->fc_stat.elsXmitLOGO++;
1265 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo;
1266 spin_lock_irq(phba->host->host_lock);
1267 ndlp->nlp_flag |= NLP_LOGO_SND;
1268 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1269 ndlp->nlp_flag &= ~NLP_LOGO_SND;
1270 spin_unlock_irq(phba->host->host_lock);
1271 lpfc_els_free_iocb(phba, elsiocb);
1274 spin_unlock_irq(phba->host->host_lock);
1279 lpfc_cmpl_els_cmd(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1280 struct lpfc_iocbq * rspiocb)
1284 irsp = &rspiocb->iocb;
1286 /* ELS cmd tag <ulpIoTag> completes */
1287 lpfc_printf_log(phba,
1290 "%d:0106 ELS cmd tag x%x completes Data: x%x x%x\n",
1292 irsp->ulpIoTag, irsp->ulpStatus, irsp->un.ulpWord[4]);
1294 /* Check to see if link went down during discovery */
1295 lpfc_els_chk_latt(phba);
1296 lpfc_els_free_iocb(phba, cmdiocb);
1301 lpfc_issue_els_scr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1304 struct lpfc_iocbq *elsiocb;
1305 struct lpfc_sli_ring *pring;
1306 struct lpfc_sli *psli;
1309 struct lpfc_nodelist *ndlp;
1312 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1313 cmdsize = (sizeof (uint32_t) + sizeof (SCR));
1314 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL)) == 0) {
1318 lpfc_nlp_init(phba, ndlp, nportid);
1320 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry,
1321 ndlp, ELS_CMD_SCR)) == 0) {
1322 mempool_free( ndlp, phba->nlp_mem_pool);
1326 icmd = &elsiocb->iocb;
1327 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1329 *((uint32_t *) (pcmd)) = ELS_CMD_SCR;
1330 pcmd += sizeof (uint32_t);
1332 /* For SCR, remainder of payload is SCR parameter page */
1333 memset(pcmd, 0, sizeof (SCR));
1334 ((SCR *) pcmd)->Function = SCR_FUNC_FULL;
1336 phba->fc_stat.elsXmitSCR++;
1337 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1338 spin_lock_irq(phba->host->host_lock);
1339 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1340 spin_unlock_irq(phba->host->host_lock);
1341 mempool_free( ndlp, phba->nlp_mem_pool);
1342 lpfc_els_free_iocb(phba, elsiocb);
1345 spin_unlock_irq(phba->host->host_lock);
1346 mempool_free( ndlp, phba->nlp_mem_pool);
1351 lpfc_issue_els_farpr(struct lpfc_hba * phba, uint32_t nportid, uint8_t retry)
1354 struct lpfc_iocbq *elsiocb;
1355 struct lpfc_sli_ring *pring;
1356 struct lpfc_sli *psli;
1361 struct lpfc_nodelist *ondlp;
1362 struct lpfc_nodelist *ndlp;
1365 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1366 cmdsize = (sizeof (uint32_t) + sizeof (FARP));
1367 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL)) == 0) {
1370 lpfc_nlp_init(phba, ndlp, nportid);
1372 if ((elsiocb = lpfc_prep_els_iocb(phba, 1, cmdsize, retry,
1373 ndlp, ELS_CMD_RNID)) == 0) {
1374 mempool_free( ndlp, phba->nlp_mem_pool);
1378 icmd = &elsiocb->iocb;
1379 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1381 *((uint32_t *) (pcmd)) = ELS_CMD_FARPR;
1382 pcmd += sizeof (uint32_t);
1384 /* Fill in FARPR payload */
1385 fp = (FARP *) (pcmd);
1386 memset(fp, 0, sizeof (FARP));
1387 lp = (uint32_t *) pcmd;
1388 *lp++ = be32_to_cpu(nportid);
1389 *lp++ = be32_to_cpu(phba->fc_myDID);
1391 fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE);
1393 memcpy(&fp->RportName, &phba->fc_portname, sizeof (struct lpfc_name));
1394 memcpy(&fp->RnodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
1395 if ((ondlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, nportid))) {
1396 memcpy(&fp->OportName, &ondlp->nlp_portname,
1397 sizeof (struct lpfc_name));
1398 memcpy(&fp->OnodeName, &ondlp->nlp_nodename,
1399 sizeof (struct lpfc_name));
1402 phba->fc_stat.elsXmitFARPR++;
1403 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1404 spin_lock_irq(phba->host->host_lock);
1405 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1406 spin_unlock_irq(phba->host->host_lock);
1407 mempool_free( ndlp, phba->nlp_mem_pool);
1408 lpfc_els_free_iocb(phba, elsiocb);
1411 spin_unlock_irq(phba->host->host_lock);
1412 mempool_free( ndlp, phba->nlp_mem_pool);
1417 lpfc_els_retry_delay(unsigned long ptr)
1419 struct lpfc_nodelist *ndlp;
1420 struct lpfc_hba *phba;
1421 unsigned long iflag;
1422 struct lpfc_work_evt *evtp;
1424 ndlp = (struct lpfc_nodelist *)ptr;
1425 phba = ndlp->nlp_phba;
1426 evtp = &ndlp->els_retry_evt;
1428 spin_lock_irqsave(phba->host->host_lock, iflag);
1429 if (!list_empty(&evtp->evt_listp)) {
1430 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1434 evtp->evt_arg1 = ndlp;
1435 evtp->evt = LPFC_EVT_ELS_RETRY;
1436 list_add_tail(&evtp->evt_listp, &phba->work_list);
1437 if (phba->work_wait)
1438 wake_up(phba->work_wait);
1440 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1445 lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
1447 struct lpfc_hba *phba;
1452 phba = ndlp->nlp_phba;
1453 spin_lock_irq(phba->host->host_lock);
1454 did = (uint32_t) (ndlp->nlp_DID);
1455 cmd = (uint32_t) (ndlp->nlp_last_elscmd);
1457 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
1458 spin_unlock_irq(phba->host->host_lock);
1462 ndlp->nlp_flag &= ~NLP_DELAY_TMO;
1463 spin_unlock_irq(phba->host->host_lock);
1464 retry = ndlp->nlp_retry;
1468 lpfc_issue_els_flogi(phba, ndlp, retry);
1471 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
1472 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
1473 lpfc_issue_els_plogi(phba, ndlp, retry);
1476 ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
1477 lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST);
1478 lpfc_issue_els_adisc(phba, ndlp, retry);
1481 ndlp->nlp_state = NLP_STE_PRLI_ISSUE;
1482 lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST);
1483 lpfc_issue_els_prli(phba, ndlp, retry);
1486 ndlp->nlp_state = NLP_STE_NPR_NODE;
1487 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
1488 lpfc_issue_els_logo(phba, ndlp, retry);
1495 lpfc_els_retry(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1496 struct lpfc_iocbq * rspiocb)
1499 struct lpfc_dmabuf *pcmd;
1500 struct lpfc_nodelist *ndlp;
1503 int retry, maxretry;
1509 maxretry = lpfc_max_els_tries;
1510 irsp = &rspiocb->iocb;
1511 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1512 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
1514 /* Note: context2 may be 0 for internal driver abort
1515 * of delays ELS command.
1518 if (pcmd && pcmd->virt) {
1519 elscmd = (uint32_t *) (pcmd->virt);
1523 switch (irsp->ulpStatus) {
1524 case IOSTAT_FCP_RSP_ERROR:
1525 case IOSTAT_REMOTE_STOP:
1528 case IOSTAT_LOCAL_REJECT:
1529 switch ((irsp->un.ulpWord[4] & 0xff)) {
1530 case IOERR_LOOP_OPEN_FAILURE:
1531 if (cmd == ELS_CMD_PLOGI) {
1532 if (cmdiocb->retry == 0) {
1539 case IOERR_SEQUENCE_TIMEOUT:
1541 if ((cmd == ELS_CMD_FLOGI)
1542 && (phba->fc_topology != TOPOLOGY_LOOP)) {
1548 case IOERR_NO_RESOURCES:
1549 if (cmd == ELS_CMD_PLOGI) {
1555 case IOERR_INVALID_RPI:
1561 case IOSTAT_NPORT_RJT:
1562 case IOSTAT_FABRIC_RJT:
1563 if (irsp->un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
1569 case IOSTAT_NPORT_BSY:
1570 case IOSTAT_FABRIC_BSY:
1575 stat.un.lsRjtError = be32_to_cpu(irsp->un.ulpWord[4]);
1576 /* Added for Vendor specifc support
1577 * Just keep retrying for these Rsn / Exp codes
1579 switch (stat.un.b.lsRjtRsnCode) {
1580 case LSRJT_UNABLE_TPC:
1581 if (stat.un.b.lsRjtRsnCodeExp ==
1582 LSEXP_CMD_IN_PROGRESS) {
1583 if (cmd == ELS_CMD_PLOGI) {
1590 if (cmd == ELS_CMD_PLOGI) {
1592 maxretry = lpfc_max_els_tries + 1;
1598 case LSRJT_LOGICAL_BSY:
1599 if (cmd == ELS_CMD_PLOGI) {
1608 case IOSTAT_INTERMED_RSP:
1616 if (ndlp->nlp_DID == FDMI_DID) {
1620 if ((++cmdiocb->retry) >= maxretry) {
1621 phba->fc_stat.elsRetryExceeded++;
1627 /* Retry ELS command <elsCmd> to remote NPORT <did> */
1628 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1629 "%d:0107 Retry ELS command x%x to remote "
1630 "NPORT x%x Data: x%x x%x\n",
1632 cmd, ndlp->nlp_DID, cmdiocb->retry, delay);
1634 if ((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) {
1635 /* If discovery / RSCN timer is running, reset it */
1636 if (timer_pending(&phba->fc_disctmo) ||
1637 (phba->fc_flag & FC_RSCN_MODE)) {
1638 lpfc_set_disctmo(phba);
1642 phba->fc_stat.elsXmitRetry++;
1644 phba->fc_stat.elsDelayRetry++;
1645 ndlp->nlp_retry = cmdiocb->retry;
1647 mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
1648 ndlp->nlp_flag |= NLP_DELAY_TMO;
1650 ndlp->nlp_state = NLP_STE_NPR_NODE;
1651 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
1652 ndlp->nlp_last_elscmd = cmd;
1658 lpfc_issue_els_flogi(phba, ndlp, cmdiocb->retry);
1661 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
1662 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
1663 lpfc_issue_els_plogi(phba, ndlp, cmdiocb->retry);
1666 ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
1667 lpfc_nlp_list(phba, ndlp, NLP_ADISC_LIST);
1668 lpfc_issue_els_adisc(phba, ndlp, cmdiocb->retry);
1671 ndlp->nlp_state = NLP_STE_PRLI_ISSUE;
1672 lpfc_nlp_list(phba, ndlp, NLP_PRLI_LIST);
1673 lpfc_issue_els_prli(phba, ndlp, cmdiocb->retry);
1676 ndlp->nlp_state = NLP_STE_NPR_NODE;
1677 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST);
1678 lpfc_issue_els_logo(phba, ndlp, cmdiocb->retry);
1683 /* No retry ELS command <elsCmd> to remote NPORT <did> */
1684 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1685 "%d:0108 No retry ELS command x%x to remote NPORT x%x "
1688 cmd, ndlp->nlp_DID, cmdiocb->retry, ndlp->nlp_flag);
1694 lpfc_els_free_iocb(struct lpfc_hba * phba, struct lpfc_iocbq * elsiocb)
1696 struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
1698 /* context2 = cmd, context2->next = rsp, context3 = bpl */
1699 if (elsiocb->context2) {
1700 buf_ptr1 = (struct lpfc_dmabuf *) elsiocb->context2;
1701 /* Free the response before processing the command. */
1702 if (!list_empty(&buf_ptr1->list)) {
1703 list_remove_head(&buf_ptr1->list, buf_ptr,
1706 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1709 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
1713 if (elsiocb->context3) {
1714 buf_ptr = (struct lpfc_dmabuf *) elsiocb->context3;
1715 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1718 spin_lock_irq(phba->host->host_lock);
1719 lpfc_sli_release_iocbq(phba, elsiocb);
1720 spin_unlock_irq(phba->host->host_lock);
1725 lpfc_cmpl_els_logo_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1726 struct lpfc_iocbq * rspiocb)
1728 struct lpfc_nodelist *ndlp;
1730 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1732 /* ACC to LOGO completes to NPort <nlp_DID> */
1733 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1734 "%d:0109 ACC to LOGO completes to NPort x%x "
1735 "Data: x%x x%x x%x\n",
1736 phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag,
1737 ndlp->nlp_state, ndlp->nlp_rpi);
1739 spin_lock_irq(phba->host->host_lock);
1740 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
1741 spin_unlock_irq(phba->host->host_lock);
1743 switch (ndlp->nlp_state) {
1744 case NLP_STE_UNUSED_NODE: /* node is just allocated */
1745 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
1747 case NLP_STE_NPR_NODE: /* NPort Recovery mode */
1748 lpfc_unreg_rpi(phba, ndlp);
1753 lpfc_els_free_iocb(phba, cmdiocb);
1758 lpfc_cmpl_els_acc(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
1759 struct lpfc_iocbq * rspiocb)
1761 struct lpfc_nodelist *ndlp;
1762 LPFC_MBOXQ_t *mbox = NULL;
1764 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1765 if (cmdiocb->context_un.mbox)
1766 mbox = cmdiocb->context_un.mbox;
1769 /* Check to see if link went down during discovery */
1770 if ((lpfc_els_chk_latt(phba)) || !ndlp) {
1772 mempool_free( mbox, phba->mbox_mem_pool);
1777 /* ELS response tag <ulpIoTag> completes */
1778 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1779 "%d:0110 ELS response tag x%x completes "
1780 "Data: x%x x%x x%x x%x x%x x%x\n",
1782 cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus,
1783 rspiocb->iocb.un.ulpWord[4], ndlp->nlp_DID,
1784 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
1787 if ((rspiocb->iocb.ulpStatus == 0)
1788 && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) {
1789 /* set_slim mailbox command needs to execute first,
1790 * queue this command to be processed later.
1792 lpfc_unreg_rpi(phba, ndlp);
1793 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
1794 mbox->context2 = ndlp;
1795 ndlp->nlp_state = NLP_STE_REG_LOGIN_ISSUE;
1796 lpfc_nlp_list(phba, ndlp, NLP_REGLOGIN_LIST);
1797 if (lpfc_sli_issue_mbox(phba, mbox,
1798 (MBX_NOWAIT | MBX_STOP_IOCB))
1799 != MBX_NOT_FINISHED) {
1802 /* NOTE: we should have messages for unsuccessful
1804 mempool_free( mbox, phba->mbox_mem_pool);
1806 mempool_free( mbox, phba->mbox_mem_pool);
1807 if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
1808 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST);
1814 spin_lock_irq(phba->host->host_lock);
1815 ndlp->nlp_flag &= ~NLP_ACC_REGLOGIN;
1816 spin_unlock_irq(phba->host->host_lock);
1818 lpfc_els_free_iocb(phba, cmdiocb);
1823 lpfc_els_rsp_acc(struct lpfc_hba * phba, uint32_t flag,
1824 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp,
1825 LPFC_MBOXQ_t * mbox, uint8_t newnode)
1829 struct lpfc_iocbq *elsiocb;
1830 struct lpfc_sli_ring *pring;
1831 struct lpfc_sli *psli;
1837 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1838 oldcmd = &oldiocb->iocb;
1842 cmdsize = sizeof (uint32_t);
1844 lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1845 ndlp, ELS_CMD_ACC)) == 0) {
1848 icmd = &elsiocb->iocb;
1849 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1850 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1851 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
1852 pcmd += sizeof (uint32_t);
1855 cmdsize = (sizeof (struct serv_parm) + sizeof (uint32_t));
1857 lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1858 ndlp, ELS_CMD_ACC)) == 0) {
1861 icmd = &elsiocb->iocb;
1862 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1863 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1866 elsiocb->context_un.mbox = mbox;
1868 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
1869 pcmd += sizeof (uint32_t);
1870 memcpy(pcmd, &phba->fc_sparam, sizeof (struct serv_parm));
1877 elsiocb->context1 = NULL;
1879 /* Xmit ELS ACC response tag <ulpIoTag> */
1880 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1881 "%d:0128 Xmit ELS ACC response tag x%x "
1882 "Data: x%x x%x x%x x%x x%x\n",
1884 elsiocb->iocb.ulpIoTag,
1885 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
1886 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
1888 if (ndlp->nlp_flag & NLP_LOGO_ACC) {
1889 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc;
1891 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
1894 phba->fc_stat.elsXmitACC++;
1895 spin_lock_irq(phba->host->host_lock);
1896 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
1897 spin_unlock_irq(phba->host->host_lock);
1898 if (rc == IOCB_ERROR) {
1899 lpfc_els_free_iocb(phba, elsiocb);
1906 lpfc_els_rsp_reject(struct lpfc_hba * phba, uint32_t rejectError,
1907 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
1911 struct lpfc_iocbq *elsiocb;
1912 struct lpfc_sli_ring *pring;
1913 struct lpfc_sli *psli;
1919 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1921 cmdsize = 2 * sizeof (uint32_t);
1922 if ((elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1923 ndlp, ELS_CMD_LS_RJT)) == 0) {
1927 icmd = &elsiocb->iocb;
1928 oldcmd = &oldiocb->iocb;
1929 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1930 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1932 *((uint32_t *) (pcmd)) = ELS_CMD_LS_RJT;
1933 pcmd += sizeof (uint32_t);
1934 *((uint32_t *) (pcmd)) = rejectError;
1936 /* Xmit ELS RJT <err> response tag <ulpIoTag> */
1937 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1938 "%d:0129 Xmit ELS RJT x%x response tag x%x "
1939 "Data: x%x x%x x%x x%x x%x\n",
1941 rejectError, elsiocb->iocb.ulpIoTag,
1942 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
1943 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
1945 phba->fc_stat.elsXmitLSRJT++;
1946 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
1947 spin_lock_irq(phba->host->host_lock);
1948 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
1949 spin_unlock_irq(phba->host->host_lock);
1950 if (rc == IOCB_ERROR) {
1951 lpfc_els_free_iocb(phba, elsiocb);
1958 lpfc_els_rsp_adisc_acc(struct lpfc_hba * phba,
1959 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
1964 struct lpfc_iocbq *elsiocb;
1965 struct lpfc_sli_ring *pring;
1966 struct lpfc_sli *psli;
1972 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1974 cmdsize = sizeof (uint32_t) + sizeof (ADISC);
1975 if ((elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
1976 ndlp, ELS_CMD_ACC)) == 0) {
1980 /* Xmit ADISC ACC response tag <ulpIoTag> */
1981 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1982 "%d:0130 Xmit ADISC ACC response tag x%x "
1983 "Data: x%x x%x x%x x%x x%x\n",
1985 elsiocb->iocb.ulpIoTag,
1986 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
1987 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
1989 icmd = &elsiocb->iocb;
1990 oldcmd = &oldiocb->iocb;
1991 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1992 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1994 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
1995 pcmd += sizeof (uint32_t);
1997 ap = (ADISC *) (pcmd);
1998 ap->hardAL_PA = phba->fc_pref_ALPA;
1999 memcpy(&ap->portName, &phba->fc_portname, sizeof (struct lpfc_name));
2000 memcpy(&ap->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
2001 ap->DID = be32_to_cpu(phba->fc_myDID);
2003 phba->fc_stat.elsXmitACC++;
2004 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2005 spin_lock_irq(phba->host->host_lock);
2006 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2007 spin_unlock_irq(phba->host->host_lock);
2008 if (rc == IOCB_ERROR) {
2009 lpfc_els_free_iocb(phba, elsiocb);
2016 lpfc_els_rsp_prli_acc(struct lpfc_hba * phba,
2017 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2023 struct lpfc_iocbq *elsiocb;
2024 struct lpfc_sli_ring *pring;
2025 struct lpfc_sli *psli;
2031 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2033 cmdsize = sizeof (uint32_t) + sizeof (PRLI);
2034 if ((elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2037 (ELS_CMD_PRLI & ~ELS_RSP_MASK)))) ==
2042 /* Xmit PRLI ACC response tag <ulpIoTag> */
2043 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2044 "%d:0131 Xmit PRLI ACC response tag x%x "
2045 "Data: x%x x%x x%x x%x x%x\n",
2047 elsiocb->iocb.ulpIoTag,
2048 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2049 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2051 icmd = &elsiocb->iocb;
2052 oldcmd = &oldiocb->iocb;
2053 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2054 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2056 *((uint32_t *) (pcmd)) = (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK));
2057 pcmd += sizeof (uint32_t);
2059 /* For PRLI, remainder of payload is PRLI parameter page */
2060 memset(pcmd, 0, sizeof (PRLI));
2062 npr = (PRLI *) pcmd;
2065 * If our firmware version is 3.20 or later,
2066 * set the following bits for FC-TAPE support.
2068 if (vpd->rev.feaLevelHigh >= 0x02) {
2069 npr->ConfmComplAllowed = 1;
2071 npr->TaskRetryIdReq = 1;
2074 npr->acceptRspCode = PRLI_REQ_EXECUTED;
2075 npr->estabImagePair = 1;
2076 npr->readXferRdyDis = 1;
2077 npr->ConfmComplAllowed = 1;
2079 npr->prliType = PRLI_FCP_TYPE;
2080 npr->initiatorFunc = 1;
2082 phba->fc_stat.elsXmitACC++;
2083 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2085 spin_lock_irq(phba->host->host_lock);
2086 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2087 spin_unlock_irq(phba->host->host_lock);
2088 if (rc == IOCB_ERROR) {
2089 lpfc_els_free_iocb(phba, elsiocb);
2096 lpfc_els_rsp_rnid_acc(struct lpfc_hba * phba,
2098 struct lpfc_iocbq * oldiocb, struct lpfc_nodelist * ndlp)
2103 struct lpfc_iocbq *elsiocb;
2104 struct lpfc_sli_ring *pring;
2105 struct lpfc_sli *psli;
2111 pring = &psli->ring[LPFC_ELS_RING];
2113 cmdsize = sizeof (uint32_t) + sizeof (uint32_t)
2114 + (2 * sizeof (struct lpfc_name));
2116 cmdsize += sizeof (RNID_TOP_DISC);
2118 if ((elsiocb = lpfc_prep_els_iocb(phba, 0, cmdsize, oldiocb->retry,
2119 ndlp, ELS_CMD_ACC)) == 0) {
2123 /* Xmit RNID ACC response tag <ulpIoTag> */
2124 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2125 "%d:0132 Xmit RNID ACC response tag x%x "
2128 elsiocb->iocb.ulpIoTag,
2129 elsiocb->iocb.ulpContext);
2131 icmd = &elsiocb->iocb;
2132 oldcmd = &oldiocb->iocb;
2133 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2134 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2136 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2137 pcmd += sizeof (uint32_t);
2139 memset(pcmd, 0, sizeof (RNID));
2140 rn = (RNID *) (pcmd);
2141 rn->Format = format;
2142 rn->CommonLen = (2 * sizeof (struct lpfc_name));
2143 memcpy(&rn->portName, &phba->fc_portname, sizeof (struct lpfc_name));
2144 memcpy(&rn->nodeName, &phba->fc_nodename, sizeof (struct lpfc_name));
2147 rn->SpecificLen = 0;
2149 case RNID_TOPOLOGY_DISC:
2150 rn->SpecificLen = sizeof (RNID_TOP_DISC);
2151 memcpy(&rn->un.topologyDisc.portName,
2152 &phba->fc_portname, sizeof (struct lpfc_name));
2153 rn->un.topologyDisc.unitType = RNID_HBA;
2154 rn->un.topologyDisc.physPort = 0;
2155 rn->un.topologyDisc.attachedNodes = 0;
2159 rn->SpecificLen = 0;
2163 phba->fc_stat.elsXmitACC++;
2164 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2165 elsiocb->context1 = NULL; /* Don't need ndlp for cmpl,
2166 * it could be freed */
2168 spin_lock_irq(phba->host->host_lock);
2169 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2170 spin_unlock_irq(phba->host->host_lock);
2171 if (rc == IOCB_ERROR) {
2172 lpfc_els_free_iocb(phba, elsiocb);
2179 lpfc_els_disc_adisc(struct lpfc_hba * phba)
2182 struct lpfc_nodelist *ndlp, *next_ndlp;
2185 /* go thru NPR list and issue any remaining ELS ADISCs */
2186 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
2188 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) {
2189 if (ndlp->nlp_flag & NLP_NPR_ADISC) {
2190 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2191 ndlp->nlp_state = NLP_STE_ADISC_ISSUE;
2192 lpfc_nlp_list(phba, ndlp,
2194 lpfc_issue_els_adisc(phba, ndlp, 0);
2196 phba->num_disc_nodes++;
2197 if (phba->num_disc_nodes >=
2198 phba->cfg_discovery_threads) {
2199 spin_lock_irq(phba->host->host_lock);
2200 phba->fc_flag |= FC_NLP_MORE;
2201 spin_unlock_irq(phba->host->host_lock);
2207 if (sentadisc == 0) {
2208 spin_lock_irq(phba->host->host_lock);
2209 phba->fc_flag &= ~FC_NLP_MORE;
2210 spin_unlock_irq(phba->host->host_lock);
2216 lpfc_els_disc_plogi(struct lpfc_hba * phba)
2219 struct lpfc_nodelist *ndlp, *next_ndlp;
2222 /* go thru NPR list and issue any remaining ELS PLOGIs */
2223 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list,
2225 if ((ndlp->nlp_flag & NLP_NPR_2B_DISC) &&
2226 (!(ndlp->nlp_flag & NLP_DELAY_TMO))) {
2227 if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
2228 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
2229 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
2230 lpfc_issue_els_plogi(phba, ndlp, 0);
2232 phba->num_disc_nodes++;
2233 if (phba->num_disc_nodes >=
2234 phba->cfg_discovery_threads) {
2235 spin_lock_irq(phba->host->host_lock);
2236 phba->fc_flag |= FC_NLP_MORE;
2237 spin_unlock_irq(phba->host->host_lock);
2243 if (sentplogi == 0) {
2244 spin_lock_irq(phba->host->host_lock);
2245 phba->fc_flag &= ~FC_NLP_MORE;
2246 spin_unlock_irq(phba->host->host_lock);
2252 lpfc_els_flush_rscn(struct lpfc_hba * phba)
2254 struct lpfc_dmabuf *mp;
2257 for (i = 0; i < phba->fc_rscn_id_cnt; i++) {
2258 mp = phba->fc_rscn_id_list[i];
2259 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2261 phba->fc_rscn_id_list[i] = NULL;
2263 phba->fc_rscn_id_cnt = 0;
2264 spin_lock_irq(phba->host->host_lock);
2265 phba->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY);
2266 spin_unlock_irq(phba->host->host_lock);
2267 lpfc_can_disctmo(phba);
2272 lpfc_rscn_payload_check(struct lpfc_hba * phba, uint32_t did)
2276 struct lpfc_dmabuf *mp;
2278 uint32_t payload_len, cmd, i, match;
2280 ns_did.un.word = did;
2283 /* Never match fabric nodes for RSCNs */
2284 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
2287 /* If we are doing a FULL RSCN rediscovery, match everything */
2288 if (phba->fc_flag & FC_RSCN_DISCOVERY) {
2292 for (i = 0; i < phba->fc_rscn_id_cnt; i++) {
2293 mp = phba->fc_rscn_id_list[i];
2294 lp = (uint32_t *) mp->virt;
2296 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */
2297 payload_len -= sizeof (uint32_t); /* take off word 0 */
2298 while (payload_len) {
2299 rscn_did.un.word = *lp++;
2300 rscn_did.un.word = be32_to_cpu(rscn_did.un.word);
2301 payload_len -= sizeof (uint32_t);
2302 switch (rscn_did.un.b.resv) {
2303 case 0: /* Single N_Port ID effected */
2304 if (ns_did.un.word == rscn_did.un.word) {
2308 case 1: /* Whole N_Port Area effected */
2309 if ((ns_did.un.b.domain == rscn_did.un.b.domain)
2310 && (ns_did.un.b.area == rscn_did.un.b.area))
2315 case 2: /* Whole N_Port Domain effected */
2316 if (ns_did.un.b.domain == rscn_did.un.b.domain)
2321 case 3: /* Whole Fabric effected */
2325 /* Unknown Identifier in RSCN list */
2326 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
2327 "%d:0217 Unknown Identifier in "
2328 "RSCN payload Data: x%x\n",
2329 phba->brd_no, rscn_did.un.word);
2341 lpfc_rscn_recovery_check(struct lpfc_hba * phba)
2343 struct lpfc_nodelist *ndlp = NULL, *next_ndlp;
2344 struct list_head *listp;
2345 struct list_head *node_list[7];
2348 /* Look at all nodes effected by pending RSCNs and move
2351 node_list[0] = &phba->fc_npr_list; /* MUST do this list first */
2352 node_list[1] = &phba->fc_nlpmap_list;
2353 node_list[2] = &phba->fc_nlpunmap_list;
2354 node_list[3] = &phba->fc_prli_list;
2355 node_list[4] = &phba->fc_reglogin_list;
2356 node_list[5] = &phba->fc_adisc_list;
2357 node_list[6] = &phba->fc_plogi_list;
2358 for (i = 0; i < 7; i++) {
2359 listp = node_list[i];
2360 if (list_empty(listp))
2363 list_for_each_entry_safe(ndlp, next_ndlp, listp, nlp_listp) {
2364 if (!(lpfc_rscn_payload_check(phba, ndlp->nlp_DID)))
2367 lpfc_disc_state_machine(phba, ndlp, NULL,
2368 NLP_EVT_DEVICE_RECOVERY);
2369 if (ndlp->nlp_flag & NLP_DELAY_TMO) {
2370 ndlp->nlp_flag &= ~NLP_DELAY_TMO;
2371 del_timer_sync(&ndlp->nlp_delayfunc);
2372 if (!list_empty(&ndlp->
2373 els_retry_evt.evt_listp))
2374 list_del_init(&ndlp->
2375 els_retry_evt.evt_listp);
2383 lpfc_els_rcv_rscn(struct lpfc_hba * phba,
2384 struct lpfc_iocbq * cmdiocb,
2385 struct lpfc_nodelist * ndlp, uint8_t newnode)
2387 struct lpfc_dmabuf *pcmd;
2390 uint32_t payload_len, cmd;
2392 icmd = &cmdiocb->iocb;
2393 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2394 lp = (uint32_t *) pcmd->virt;
2397 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */
2398 payload_len -= sizeof (uint32_t); /* take off word 0 */
2399 cmd &= ELS_CMD_MASK;
2402 lpfc_printf_log(phba,
2405 "%d:0214 RSCN received Data: x%x x%x x%x x%x\n",
2407 phba->fc_flag, payload_len, *lp, phba->fc_rscn_id_cnt);
2409 /* If we are about to begin discovery, just ACC the RSCN.
2410 * Discovery processing will satisfy it.
2412 if (phba->hba_state < LPFC_NS_QRY) {
2413 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
2418 /* If we are already processing an RSCN, save the received
2419 * RSCN payload buffer, cmdiocb->context2 to process later.
2421 if (phba->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) {
2422 if ((phba->fc_rscn_id_cnt < FC_MAX_HOLD_RSCN) &&
2423 !(phba->fc_flag & FC_RSCN_DISCOVERY)) {
2424 spin_lock_irq(phba->host->host_lock);
2425 phba->fc_flag |= FC_RSCN_MODE;
2426 spin_unlock_irq(phba->host->host_lock);
2427 phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd;
2429 /* If we zero, cmdiocb->context2, the calling
2430 * routine will not try to free it.
2432 cmdiocb->context2 = NULL;
2435 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2436 "%d:0235 Deferred RSCN "
2437 "Data: x%x x%x x%x\n",
2438 phba->brd_no, phba->fc_rscn_id_cnt,
2439 phba->fc_flag, phba->hba_state);
2441 spin_lock_irq(phba->host->host_lock);
2442 phba->fc_flag |= FC_RSCN_DISCOVERY;
2443 spin_unlock_irq(phba->host->host_lock);
2444 /* ReDiscovery RSCN */
2445 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2446 "%d:0234 ReDiscovery RSCN "
2447 "Data: x%x x%x x%x\n",
2448 phba->brd_no, phba->fc_rscn_id_cnt,
2449 phba->fc_flag, phba->hba_state);
2452 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
2455 /* send RECOVERY event for ALL nodes that match RSCN payload */
2456 lpfc_rscn_recovery_check(phba);
2460 phba->fc_flag |= FC_RSCN_MODE;
2461 phba->fc_rscn_id_list[phba->fc_rscn_id_cnt++] = pcmd;
2463 * If we zero, cmdiocb->context2, the calling routine will
2464 * not try to free it.
2466 cmdiocb->context2 = NULL;
2468 lpfc_set_disctmo(phba);
2471 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, newnode);
2473 /* send RECOVERY event for ALL nodes that match RSCN payload */
2474 lpfc_rscn_recovery_check(phba);
2476 return (lpfc_els_handle_rscn(phba));
2480 lpfc_els_handle_rscn(struct lpfc_hba * phba)
2482 struct lpfc_nodelist *ndlp;
2484 /* Start timer for RSCN processing */
2485 lpfc_set_disctmo(phba);
2487 /* RSCN processed */
2488 lpfc_printf_log(phba,
2491 "%d:0215 RSCN processed Data: x%x x%x x%x x%x\n",
2493 phba->fc_flag, 0, phba->fc_rscn_id_cnt,
2496 /* To process RSCN, first compare RSCN data with NameServer */
2497 phba->fc_ns_retry = 0;
2498 if ((ndlp = lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED,
2500 /* Good ndlp, issue CT Request to NameServer */
2501 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT) == 0) {
2502 /* Wait for NameServer query cmpl before we can
2507 /* If login to NameServer does not exist, issue one */
2508 /* Good status, issue PLOGI to NameServer */
2510 lpfc_findnode_did(phba, NLP_SEARCH_ALL, NameServer_DID))) {
2511 /* Wait for NameServer login cmpl before we can
2515 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL))
2517 lpfc_els_flush_rscn(phba);
2520 lpfc_nlp_init(phba, ndlp, NameServer_DID);
2521 ndlp->nlp_type |= NLP_FABRIC;
2522 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
2523 lpfc_issue_els_plogi(phba, ndlp, 0);
2524 /* Wait for NameServer login cmpl before we can
2530 lpfc_els_flush_rscn(phba);
2535 lpfc_els_rcv_flogi(struct lpfc_hba * phba,
2536 struct lpfc_iocbq * cmdiocb,
2537 struct lpfc_nodelist * ndlp, uint8_t newnode)
2539 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2540 uint32_t *lp = (uint32_t *) pcmd->virt;
2541 IOCB_t *icmd = &cmdiocb->iocb;
2542 struct serv_parm *sp;
2549 sp = (struct serv_parm *) lp;
2551 /* FLOGI received */
2553 lpfc_set_disctmo(phba);
2555 if (phba->fc_topology == TOPOLOGY_LOOP) {
2556 /* We should never receive a FLOGI in loop mode, ignore it */
2557 did = icmd->un.elsreq64.remoteID;
2559 /* An FLOGI ELS command <elsCmd> was received from DID <did> in
2561 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
2562 "%d:0113 An FLOGI ELS command x%x was received "
2563 "from DID x%x in Loop Mode\n",
2564 phba->brd_no, cmd, did);
2570 if ((lpfc_check_sparm(phba, ndlp, sp, CLASS3))) {
2571 /* For a FLOGI we accept, then if our portname is greater
2572 * then the remote portname we initiate Nport login.
2575 rc = memcmp(&phba->fc_portname, &sp->portName,
2576 sizeof (struct lpfc_name));
2579 if ((mbox = mempool_alloc(phba->mbox_mem_pool,
2580 GFP_KERNEL)) == 0) {
2583 lpfc_linkdown(phba);
2584 lpfc_init_link(phba, mbox,
2586 phba->cfg_link_speed);
2587 mbox->mb.un.varInitLnk.lipsr_AL_PA = 0;
2588 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2589 rc = lpfc_sli_issue_mbox
2590 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB));
2591 if (rc == MBX_NOT_FINISHED) {
2592 mempool_free( mbox, phba->mbox_mem_pool);
2596 else if (rc > 0) { /* greater than */
2597 spin_lock_irq(phba->host->host_lock);
2598 phba->fc_flag |= FC_PT2PT_PLOGI;
2599 spin_unlock_irq(phba->host->host_lock);
2601 phba->fc_flag |= FC_PT2PT;
2602 phba->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
2604 /* Reject this request because invalid parameters */
2605 stat.un.b.lsRjtRsvd0 = 0;
2606 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2607 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
2608 stat.un.b.vendorUnique = 0;
2609 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2614 lpfc_els_rsp_acc(phba, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL, newnode);
2620 lpfc_els_rcv_rnid(struct lpfc_hba * phba,
2621 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
2623 struct lpfc_dmabuf *pcmd;
2630 icmd = &cmdiocb->iocb;
2631 did = icmd->un.elsreq64.remoteID;
2632 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2633 lp = (uint32_t *) pcmd->virt;
2640 switch (rn->Format) {
2642 case RNID_TOPOLOGY_DISC:
2644 lpfc_els_rsp_rnid_acc(phba, rn->Format, cmdiocb, ndlp);
2647 /* Reject this request because format not supported */
2648 stat.un.b.lsRjtRsvd0 = 0;
2649 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2650 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2651 stat.un.b.vendorUnique = 0;
2652 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, cmdiocb, ndlp);
2658 lpfc_els_rcv_rrq(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2659 struct lpfc_nodelist * ndlp)
2661 struct lpfc_dmabuf *pcmd;
2664 struct lpfc_sli_ring *pring;
2665 struct lpfc_sli *psli;
2670 pring = &psli->ring[LPFC_FCP_RING];
2671 icmd = &cmdiocb->iocb;
2672 did = icmd->un.elsreq64.remoteID;
2673 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2674 lp = (uint32_t *) pcmd->virt;
2680 /* Get oxid / rxid from payload and abort it */
2681 spin_lock_irq(phba->host->host_lock);
2682 if ((rrq->SID == be32_to_cpu(phba->fc_myDID))) {
2683 lpfc_sli_abort_iocb(phba, pring, 0, 0, rrq->Oxid,
2686 lpfc_sli_abort_iocb(phba, pring, 0, 0, rrq->Rxid,
2690 spin_unlock_irq(phba->host->host_lock);
2691 /* ACCEPT the rrq request */
2692 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
2698 lpfc_els_rcv_farp(struct lpfc_hba * phba,
2699 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
2701 struct lpfc_dmabuf *pcmd;
2705 uint32_t cmd, cnt, did;
2707 icmd = &cmdiocb->iocb;
2708 did = icmd->un.elsreq64.remoteID;
2709 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2710 lp = (uint32_t *) pcmd->virt;
2715 /* FARP-REQ received from DID <did> */
2716 lpfc_printf_log(phba,
2719 "%d:0601 FARP-REQ received from DID x%x\n",
2722 /* We will only support match on WWPN or WWNN */
2723 if (fp->Mflags & ~(FARP_MATCH_NODE | FARP_MATCH_PORT)) {
2728 /* If this FARP command is searching for my portname */
2729 if (fp->Mflags & FARP_MATCH_PORT) {
2730 if (memcmp(&fp->RportName, &phba->fc_portname,
2731 sizeof (struct lpfc_name)) == 0)
2735 /* If this FARP command is searching for my nodename */
2736 if (fp->Mflags & FARP_MATCH_NODE) {
2737 if (memcmp(&fp->RnodeName, &phba->fc_nodename,
2738 sizeof (struct lpfc_name)) == 0)
2743 if ((ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) ||
2744 (ndlp->nlp_state == NLP_STE_MAPPED_NODE)) {
2745 /* Log back into the node before sending the FARP. */
2746 if (fp->Rflags & FARP_REQUEST_PLOGI) {
2747 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE;
2748 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST);
2749 lpfc_issue_els_plogi(phba, ndlp, 0);
2752 /* Send a FARP response to that node */
2753 if (fp->Rflags & FARP_REQUEST_FARPR) {
2754 lpfc_issue_els_farpr(phba, did, 0);
2762 lpfc_els_rcv_farpr(struct lpfc_hba * phba,
2763 struct lpfc_iocbq * cmdiocb, struct lpfc_nodelist * ndlp)
2765 struct lpfc_dmabuf *pcmd;
2770 icmd = &cmdiocb->iocb;
2771 did = icmd->un.elsreq64.remoteID;
2772 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2773 lp = (uint32_t *) pcmd->virt;
2776 /* FARP-RSP received from DID <did> */
2777 lpfc_printf_log(phba,
2780 "%d:0600 FARP-RSP received from DID x%x\n",
2783 /* ACCEPT the Farp resp request */
2784 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
2790 lpfc_els_rcv_fan(struct lpfc_hba * phba, struct lpfc_iocbq * cmdiocb,
2791 struct lpfc_nodelist * ndlp)
2793 struct lpfc_dmabuf *pcmd;
2799 icmd = &cmdiocb->iocb;
2800 did = icmd->un.elsreq64.remoteID;
2801 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2802 lp = (uint32_t *) pcmd->virt;
2809 /* ACCEPT the FAN request */
2810 lpfc_els_rsp_acc(phba, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
2812 if (phba->hba_state == LPFC_LOCAL_CFG_LINK) {
2813 /* The discovery state machine needs to take a different
2814 * action if this node has switched fabrics
2816 if ((memcmp(&fp->FportName, &phba->fc_fabparam.portName,
2817 sizeof (struct lpfc_name)) != 0)
2819 (memcmp(&fp->FnodeName, &phba->fc_fabparam.nodeName,
2820 sizeof (struct lpfc_name)) != 0)) {
2821 /* This node has switched fabrics. An FLOGI is required
2827 /* Start discovery */
2828 lpfc_disc_start(phba);
2835 lpfc_els_timeout(unsigned long ptr)
2837 struct lpfc_hba *phba;
2838 unsigned long iflag;
2840 phba = (struct lpfc_hba *)ptr;
2843 spin_lock_irqsave(phba->host->host_lock, iflag);
2844 if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
2845 phba->work_hba_events |= WORKER_ELS_TMO;
2846 if (phba->work_wait)
2847 wake_up(phba->work_wait);
2849 spin_unlock_irqrestore(phba->host->host_lock, iflag);
2854 lpfc_els_timeout_handler(struct lpfc_hba *phba)
2856 struct lpfc_sli_ring *pring;
2857 struct lpfc_iocbq *tmp_iocb, *piocb;
2859 struct lpfc_dmabuf *pcmd;
2860 struct list_head *dlp;
2862 uint32_t els_command;
2868 spin_lock_irq(phba->host->host_lock);
2869 /* If the timer is already canceled do nothing */
2870 if (!(phba->work_hba_events & WORKER_ELS_TMO)) {
2871 spin_unlock_irq(phba->host->host_lock);
2874 timeout = (uint32_t)(phba->fc_ratov << 1);
2876 pring = &phba->sli.ring[LPFC_ELS_RING];
2877 dlp = &pring->txcmplq;
2879 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
2882 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
2885 pcmd = (struct lpfc_dmabuf *) piocb->context2;
2886 elscmd = (uint32_t *) (pcmd->virt);
2887 els_command = *elscmd;
2889 if ((els_command == ELS_CMD_FARP)
2890 || (els_command == ELS_CMD_FARPR)) {
2894 if (piocb->drvrTimeout > 0) {
2895 if (piocb->drvrTimeout >= timeout) {
2896 piocb->drvrTimeout -= timeout;
2898 piocb->drvrTimeout = 0;
2903 list_del(&piocb->list);
2904 pring->txcmplq_cnt--;
2906 if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) {
2907 struct lpfc_nodelist *ndlp;
2909 ndlp = lpfc_findnode_rpi(phba, cmd->ulpContext);
2910 remote_ID = ndlp->nlp_DID;
2911 if (cmd->un.elsreq64.bdl.ulpIoTag32) {
2912 lpfc_sli_issue_abort_iotag32(phba,
2916 remote_ID = cmd->un.elsreq64.remoteID;
2919 lpfc_printf_log(phba,
2922 "%d:0127 ELS timeout Data: x%x x%x x%x x%x\n",
2923 phba->brd_no, els_command,
2924 remote_ID, cmd->ulpCommand, cmd->ulpIoTag);
2927 * The iocb has timed out; abort it.
2929 if (piocb->iocb_cmpl) {
2930 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
2931 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
2932 spin_unlock_irq(phba->host->host_lock);
2933 (piocb->iocb_cmpl) (phba, piocb, piocb);
2934 spin_lock_irq(phba->host->host_lock);
2936 lpfc_sli_release_iocbq(phba, piocb);
2938 if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt) {
2939 phba->els_tmofunc.expires = jiffies + HZ * timeout;
2940 add_timer(&phba->els_tmofunc);
2942 spin_unlock_irq(phba->host->host_lock);
2946 lpfc_els_flush_cmd(struct lpfc_hba * phba)
2948 struct lpfc_sli_ring *pring;
2949 struct lpfc_iocbq *tmp_iocb, *piocb;
2951 struct lpfc_dmabuf *pcmd;
2953 uint32_t els_command;
2956 pring = &phba->sli.ring[LPFC_ELS_RING];
2957 spin_lock_irq(phba->host->host_lock);
2958 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
2961 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
2965 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
2966 if ((cmd->ulpCommand == CMD_QUE_RING_BUF_CN) ||
2967 (cmd->ulpCommand == CMD_QUE_RING_BUF64_CN) ||
2968 (cmd->ulpCommand == CMD_CLOSE_XRI_CN) ||
2969 (cmd->ulpCommand == CMD_ABORT_XRI_CN)) {
2973 pcmd = (struct lpfc_dmabuf *) piocb->context2;
2974 elscmd = (uint32_t *) (pcmd->virt);
2975 els_command = *elscmd;
2977 if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) {
2978 struct lpfc_nodelist *ndlp;
2980 ndlp = lpfc_findnode_rpi(phba, cmd->ulpContext);
2981 remote_ID = ndlp->nlp_DID;
2982 if (phba->hba_state == LPFC_HBA_READY) {
2986 remote_ID = cmd->un.elsreq64.remoteID;
2989 list_del(&piocb->list);
2990 pring->txcmplq_cnt--;
2992 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
2993 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
2995 if (piocb->iocb_cmpl) {
2996 spin_unlock_irq(phba->host->host_lock);
2997 (piocb->iocb_cmpl) (phba, piocb, piocb);
2998 spin_lock_irq(phba->host->host_lock);
3001 lpfc_sli_release_iocbq(phba, piocb);
3004 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3007 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3010 pcmd = (struct lpfc_dmabuf *) piocb->context2;
3011 elscmd = (uint32_t *) (pcmd->virt);
3012 els_command = *elscmd;
3014 if (cmd->ulpCommand == CMD_GEN_REQUEST64_CR) {
3015 struct lpfc_nodelist *ndlp;
3017 ndlp = lpfc_findnode_rpi(phba, cmd->ulpContext);
3018 remote_ID = ndlp->nlp_DID;
3019 if (phba->hba_state == LPFC_HBA_READY) {
3023 remote_ID = cmd->un.elsreq64.remoteID;
3026 list_del(&piocb->list);
3027 pring->txcmplq_cnt--;
3029 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3030 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3032 if (piocb->iocb_cmpl) {
3033 spin_unlock_irq(phba->host->host_lock);
3034 (piocb->iocb_cmpl) (phba, piocb, piocb);
3035 spin_lock_irq(phba->host->host_lock);
3038 lpfc_sli_release_iocbq(phba, piocb);
3040 spin_unlock_irq(phba->host->host_lock);
3045 lpfc_els_unsol_event(struct lpfc_hba * phba,
3046 struct lpfc_sli_ring * pring, struct lpfc_iocbq * elsiocb)
3048 struct lpfc_sli *psli;
3049 struct lpfc_nodelist *ndlp;
3050 struct lpfc_dmabuf *mp;
3057 uint32_t drop_cmd = 0; /* by default do NOT drop received cmd */
3058 uint32_t rjt_err = 0;
3061 icmd = &elsiocb->iocb;
3063 if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
3064 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) {
3065 /* Not enough posted buffers; Try posting more buffers */
3066 phba->fc_stat.NoRcvBuf++;
3067 lpfc_post_buffer(phba, pring, 0, 1);
3071 /* If there are no BDEs associated with this IOCB,
3072 * there is nothing to do.
3074 if (icmd->ulpBdeCount == 0)
3077 /* type of ELS cmd is first 32bit word in packet */
3078 mp = lpfc_sli_ringpostbuf_get(phba, pring, getPaddr(icmd->un.
3082 cont64[0].addrLow));
3089 lp = (uint32_t *) mp->virt;
3091 lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], 1, 1);
3093 if (icmd->ulpStatus) {
3094 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3100 /* Check to see if link went down during discovery */
3101 if (lpfc_els_chk_latt(phba)) {
3102 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3108 did = icmd->un.rcvels.remoteID;
3109 if ((ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did)) == 0) {
3110 /* Cannot find existing Fabric ndlp, so allocate a new one */
3111 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL))
3113 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3119 lpfc_nlp_init(phba, ndlp, did);
3121 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) {
3122 ndlp->nlp_type |= NLP_FABRIC;
3126 phba->fc_stat.elsRcvFrame++;
3127 elsiocb->context1 = ndlp;
3128 elsiocb->context2 = mp;
3130 if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) {
3131 cmd &= ELS_CMD_MASK;
3133 /* ELS command <elsCmd> received from NPORT <did> */
3134 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
3135 "%d:0112 ELS command x%x received from NPORT x%x "
3136 "Data: x%x\n", phba->brd_no, cmd, did, phba->hba_state);
3140 phba->fc_stat.elsRcvPLOGI++;
3141 if (phba->hba_state < LPFC_DISC_AUTH) {
3145 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PLOGI);
3148 phba->fc_stat.elsRcvFLOGI++;
3149 lpfc_els_rcv_flogi(phba, elsiocb, ndlp, newnode);
3151 mempool_free( ndlp, phba->nlp_mem_pool);
3155 phba->fc_stat.elsRcvLOGO++;
3156 if (phba->hba_state < LPFC_DISC_AUTH) {
3160 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_LOGO);
3163 phba->fc_stat.elsRcvPRLO++;
3164 if (phba->hba_state < LPFC_DISC_AUTH) {
3168 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLO);
3171 phba->fc_stat.elsRcvRSCN++;
3172 lpfc_els_rcv_rscn(phba, elsiocb, ndlp, newnode);
3174 mempool_free( ndlp, phba->nlp_mem_pool);
3178 phba->fc_stat.elsRcvADISC++;
3179 if (phba->hba_state < LPFC_DISC_AUTH) {
3183 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_ADISC);
3186 phba->fc_stat.elsRcvPDISC++;
3187 if (phba->hba_state < LPFC_DISC_AUTH) {
3191 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PDISC);
3194 phba->fc_stat.elsRcvFARPR++;
3195 lpfc_els_rcv_farpr(phba, elsiocb, ndlp);
3198 phba->fc_stat.elsRcvFARP++;
3199 lpfc_els_rcv_farp(phba, elsiocb, ndlp);
3202 phba->fc_stat.elsRcvFAN++;
3203 lpfc_els_rcv_fan(phba, elsiocb, ndlp);
3206 phba->fc_stat.elsRcvRRQ++;
3207 lpfc_els_rcv_rrq(phba, elsiocb, ndlp);
3210 phba->fc_stat.elsRcvPRLI++;
3211 if (phba->hba_state < LPFC_DISC_AUTH) {
3215 lpfc_disc_state_machine(phba, ndlp, elsiocb, NLP_EVT_RCV_PRLI);
3218 phba->fc_stat.elsRcvRNID++;
3219 lpfc_els_rcv_rnid(phba, elsiocb, ndlp);
3222 /* Unsupported ELS command, reject */
3225 /* Unknown ELS command <elsCmd> received from NPORT <did> */
3226 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3227 "%d:0115 Unknown ELS command x%x received from "
3228 "NPORT x%x\n", phba->brd_no, cmd, did);
3230 mempool_free( ndlp, phba->nlp_mem_pool);
3235 /* check if need to LS_RJT received ELS cmd */
3237 stat.un.b.lsRjtRsvd0 = 0;
3238 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3239 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
3240 stat.un.b.vendorUnique = 0;
3241 lpfc_els_rsp_reject(phba, stat.un.lsRjtError, elsiocb, ndlp);
3244 if (elsiocb->context2) {
3245 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3249 /* check if need to drop received ELS cmd */
3250 if (drop_cmd == 1) {
3251 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3252 "%d:0111 Dropping received ELS cmd "
3253 "Data: x%x x%x\n", phba->brd_no,
3254 icmd->ulpStatus, icmd->un.ulpWord[4]);
3255 phba->fc_stat.elsRcvDrop++;