]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/scsi/lpfc/lpfc_els.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] lpfc 8.2.3 : NPIV bug fixes
[net-next-2.6.git] / drivers / scsi / lpfc / lpfc_els.c
CommitLineData
dea3101e
JB		 1/*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
c44ce173 3 * Fibre Channel Host Bus Adapters. *
9413afff 4 * Copyright (C) 2004-2007 Emulex. All rights reserved. *
c44ce173 5 * EMULEX and SLI are trademarks of Emulex. *
dea3101e 6 * www.emulex.com *
c44ce173 7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
dea3101e
JB		 8 * *
9 * This program is free software; you can redistribute it and/or *
c44ce173
JSEC		 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. *
dea3101e
JB		 20 *******************************************************************/
21
dea3101e
JB		 22#include <linux/blkdev.h>
23#include <linux/pci.h>
24#include <linux/interrupt.h>
25
91886523 26#include <scsi/scsi.h>
dea3101e
JB		 27#include <scsi/scsi_device.h>
28#include <scsi/scsi_host.h>
29#include <scsi/scsi_transport_fc.h>
30
31#include "lpfc_hw.h"
32#include "lpfc_sli.h"
33#include "lpfc_disc.h"
34#include "lpfc_scsi.h"
35#include "lpfc.h"
36#include "lpfc_logmsg.h"
37#include "lpfc_crtn.h"
92d7f7b0 38#include "lpfc_vport.h"
858c9f6c 39#include "lpfc_debugfs.h"
dea3101e
JB		 40
41static int lpfc_els_retry(struct lpfc_hba *, struct lpfc_iocbq *,
42 struct lpfc_iocbq *);
92d7f7b0
JS		 43static void lpfc_cmpl_fabric_iocb(struct lpfc_hba *, struct lpfc_iocbq *,
44 struct lpfc_iocbq *);
45
dea3101e
JB		 46static int lpfc_max_els_tries = 3;
47
858c9f6c 48int
2e0fef85 49lpfc_els_chk_latt(struct lpfc_vport *vport)
dea3101e 50{
2e0fef85
JS		 51 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
52 struct lpfc_hba *phba = vport->phba;
dea3101e 53 uint32_t ha_copy;
dea3101e 54
2e0fef85
JS		 55 if (vport->port_state >= LPFC_VPORT_READY ||
56 phba->link_state == LPFC_LINK_DOWN)
dea3101e
JB		 57 return 0;
58
59 /* Read the HBA Host Attention Register */
dea3101e 60 ha_copy = readl(phba->HAregaddr);
dea3101e
JB		 61
62 if (!(ha_copy & HA_LATT))
63 return 0;
64
65 /* Pending Link Event during Discovery */
e8b62011
JS		 66 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
67 "0237 Pending Link Event during "
68 "Discovery: State x%x\n",
69 phba->pport->port_state);
dea3101e
JB		 70
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
75 * events.
76 */
2e0fef85
JS		 77 spin_lock_irq(shost->host_lock);
78 vport->fc_flag |= FC_ABORT_DISCOVERY;
79 spin_unlock_irq(shost->host_lock);
dea3101e 80
92d7f7b0 81 if (phba->link_state != LPFC_CLEAR_LA)
ed957684 82 lpfc_issue_clear_la(phba, vport);
dea3101e 83
c9f8735b 84 return 1;
dea3101e
JB		 85}
86
87static struct lpfc_iocbq *
2e0fef85
JS		 88lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
89 uint16_t cmdSize, uint8_t retry,
90 struct lpfc_nodelist *ndlp, uint32_t did,
91 uint32_t elscmd)
dea3101e 92{
2e0fef85 93 struct lpfc_hba *phba = vport->phba;
0bd4ca25 94 struct lpfc_iocbq *elsiocb;
dea3101e
JB		 95 struct lpfc_dmabuf *pcmd, *prsp, *pbuflist;
96 struct ulp_bde64 *bpl;
97 IOCB_t *icmd;
98
dea3101e 99
2e0fef85
JS		 100 if (!lpfc_is_link_up(phba))
101 return NULL;
dea3101e 102
dea3101e 103 /* Allocate buffer for command iocb */
0bd4ca25 104 elsiocb = lpfc_sli_get_iocbq(phba);
dea3101e
JB		 105
106 if (elsiocb == NULL)
107 return NULL;
dea3101e
JB		 108 icmd = &elsiocb->iocb;
109
110 /* fill in BDEs for command */
111 /* Allocate buffer for command payload */
92d7f7b0 112 if (((pcmd = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL)) == 0) ||
dea3101e
JB		 113 ((pcmd->virt = lpfc_mbuf_alloc(phba,
114 MEM_PRI, &(pcmd->phys))) == 0)) {
c9475cb0 115 kfree(pcmd);
dea3101e 116
604a3e30 117 lpfc_sli_release_iocbq(phba, elsiocb);
dea3101e
JB		 118 return NULL;
119 }
120
121 INIT_LIST_HEAD(&pcmd->list);
122
123 /* Allocate buffer for response payload */
124 if (expectRsp) {
92d7f7b0 125 prsp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
dea3101e
JB		 126 if (prsp)
127 prsp->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
128 &prsp->phys);
129 if (prsp == 0 || prsp->virt == 0) {
c9475cb0 130 kfree(prsp);
dea3101e
JB		 131 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
132 kfree(pcmd);
604a3e30 133 lpfc_sli_release_iocbq(phba, elsiocb);
dea3101e
JB		 134 return NULL;
135 }
136 INIT_LIST_HEAD(&prsp->list);
137 } else {
138 prsp = NULL;
139 }
140
141 /* Allocate buffer for Buffer ptr list */
92d7f7b0 142 pbuflist = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
dea3101e 143 if (pbuflist)
ed957684
JS		 144 pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
145 &pbuflist->phys);
dea3101e 146 if (pbuflist == 0 || pbuflist->virt == 0) {
604a3e30 147 lpfc_sli_release_iocbq(phba, elsiocb);
dea3101e
JB		 148 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
149 lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
150 kfree(pcmd);
151 kfree(prsp);
c9475cb0 152 kfree(pbuflist);
dea3101e
JB		 153 return NULL;
154 }
155
156 INIT_LIST_HEAD(&pbuflist->list);
157
158 icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
159 icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
160 icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BDL;
2e0fef85 161 icmd->un.elsreq64.remoteID = did; /* DID */
dea3101e 162 if (expectRsp) {
92d7f7b0 163 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64));
dea3101e 164 icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
2680eeaa 165 icmd->ulpTimeout = phba->fc_ratov * 2;
dea3101e 166 } else {
92d7f7b0 167 icmd->un.elsreq64.bdl.bdeSize = sizeof(struct ulp_bde64);
dea3101e
JB		 168 icmd->ulpCommand = CMD_XMIT_ELS_RSP64_CX;
169 }
dea3101e
JB		 170 icmd->ulpBdeCount = 1;
171 icmd->ulpLe = 1;
172 icmd->ulpClass = CLASS3;
173
92d7f7b0
JS		 174 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
175 icmd->un.elsreq64.myID = vport->fc_myDID;
176
177 /* For ELS_REQUEST64_CR, use the VPI by default */
178 icmd->ulpContext = vport->vpi;
179 icmd->ulpCt_h = 0;
180 icmd->ulpCt_l = 1;
181 }
182
dea3101e
JB		 183 bpl = (struct ulp_bde64 *) pbuflist->virt;
184 bpl->addrLow = le32_to_cpu(putPaddrLow(pcmd->phys));
185 bpl->addrHigh = le32_to_cpu(putPaddrHigh(pcmd->phys));
186 bpl->tus.f.bdeSize = cmdSize;
187 bpl->tus.f.bdeFlags = 0;
188 bpl->tus.w = le32_to_cpu(bpl->tus.w);
189
190 if (expectRsp) {
191 bpl++;
192 bpl->addrLow = le32_to_cpu(putPaddrLow(prsp->phys));
193 bpl->addrHigh = le32_to_cpu(putPaddrHigh(prsp->phys));
194 bpl->tus.f.bdeSize = FCELSSIZE;
195 bpl->tus.f.bdeFlags = BUFF_USE_RCV;
196 bpl->tus.w = le32_to_cpu(bpl->tus.w);
197 }
198
51ef4c26 199 elsiocb->context1 = lpfc_nlp_get(ndlp);
329f9bc7
JS		 200 elsiocb->context2 = pcmd;
201 elsiocb->context3 = pbuflist;
dea3101e 202 elsiocb->retry = retry;
2e0fef85 203 elsiocb->vport = vport;
dea3101e
JB		 204 elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
205
206 if (prsp) {
207 list_add(&prsp->list, &pcmd->list);
208 }
dea3101e
JB		 209 if (expectRsp) {
210 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
e8b62011
JS		 211 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
212 "0116 Xmit ELS command x%x to remote "
213 "NPORT x%x I/O tag: x%x, port state: x%x\n",
214 elscmd, did, elsiocb->iotag,
215 vport->port_state);
dea3101e
JB		 216 } else {
217 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
e8b62011
JS		 218 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
219 "0117 Xmit ELS response x%x to remote "
220 "NPORT x%x I/O tag: x%x, size: x%x\n",
221 elscmd, ndlp->nlp_DID, elsiocb->iotag,
222 cmdSize);
dea3101e 223 }
c9f8735b 224 return elsiocb;
dea3101e
JB		 225}
226
227
228static int
92d7f7b0 229lpfc_issue_fabric_reglogin(struct lpfc_vport *vport)
dea3101e 230{
2e0fef85 231 struct lpfc_hba *phba = vport->phba;
dea3101e 232 LPFC_MBOXQ_t *mbox;
14691150 233 struct lpfc_dmabuf *mp;
92d7f7b0
JS		 234 struct lpfc_nodelist *ndlp;
235 struct serv_parm *sp;
dea3101e
JB		 236 int rc;
237
92d7f7b0
JS		 238 sp = &phba->fc_fabparam;
239 ndlp = lpfc_findnode_did(vport, Fabric_DID);
240 if (!ndlp)
241 goto fail;
242
243 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
244 if (!mbox)
245 goto fail;
246
247 vport->port_state = LPFC_FABRIC_CFG_LINK;
248 lpfc_config_link(phba, mbox);
249 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
250 mbox->vport = vport;
251
252 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
253 if (rc == MBX_NOT_FINISHED)
254 goto fail_free_mbox;
255
256 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
257 if (!mbox)
258 goto fail;
259 rc = lpfc_reg_login(phba, vport->vpi, Fabric_DID, (uint8_t *)sp, mbox,
260 0);
261 if (rc)
262 goto fail_free_mbox;
263
264 mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login;
265 mbox->vport = vport;
266 mbox->context2 = lpfc_nlp_get(ndlp);
267
268 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
269 if (rc == MBX_NOT_FINISHED)
270 goto fail_issue_reg_login;
271
272 return 0;
273
274fail_issue_reg_login:
275 lpfc_nlp_put(ndlp);
276 mp = (struct lpfc_dmabuf *) mbox->context1;
277 lpfc_mbuf_free(phba, mp->virt, mp->phys);
278 kfree(mp);
279fail_free_mbox:
280 mempool_free(mbox, phba->mbox_mem_pool);
281
282fail:
283 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
e8b62011
JS		 284 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
285 "0249 Cannot issue Register Fabric login\n");
92d7f7b0
JS		 286 return -ENXIO;
287}
288
289static int
290lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
291 struct serv_parm *sp, IOCB_t *irsp)
292{
293 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
294 struct lpfc_hba *phba = vport->phba;
295 struct lpfc_nodelist *np;
296 struct lpfc_nodelist *next_np;
297
2e0fef85
JS		 298 spin_lock_irq(shost->host_lock);
299 vport->fc_flag |= FC_FABRIC;
300 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 301
302 phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov);
303 if (sp->cmn.edtovResolution) /* E_D_TOV ticks are in nanoseconds */
304 phba->fc_edtov = (phba->fc_edtov + 999999) / 1000000;
305
306 phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
307
308 if (phba->fc_topology == TOPOLOGY_LOOP) {
2e0fef85
JS		 309 spin_lock_irq(shost->host_lock);
310 vport->fc_flag |= FC_PUBLIC_LOOP;
311 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 312 } else {
313 /*
314 * If we are a N-port connected to a Fabric, fixup sparam's so
315 * logins to devices on remote loops work.
316 */
2e0fef85 317 vport->fc_sparam.cmn.altBbCredit = 1;
dea3101e
JB		 318 }
319
2e0fef85 320 vport->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
dea3101e 321 memcpy(&ndlp->nlp_portname, &sp->portName, sizeof(struct lpfc_name));
92d7f7b0 322 memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof(struct lpfc_name));
dea3101e
JB		 323 ndlp->nlp_class_sup = 0;
324 if (sp->cls1.classValid)
325 ndlp->nlp_class_sup |= FC_COS_CLASS1;
326 if (sp->cls2.classValid)
327 ndlp->nlp_class_sup |= FC_COS_CLASS2;
328 if (sp->cls3.classValid)
329 ndlp->nlp_class_sup |= FC_COS_CLASS3;
330 if (sp->cls4.classValid)
331 ndlp->nlp_class_sup |= FC_COS_CLASS4;
332 ndlp->nlp_maxframe = ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) |
333 sp->cmn.bbRcvSizeLsb;
334 memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
335
92d7f7b0
JS		 336 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
337 if (sp->cmn.response_multiple_NPort) {
e8b62011
JS		 338 lpfc_printf_vlog(vport, KERN_WARNING,
339 LOG_ELS | LOG_VPORT,
340 "1816 FLOGI NPIV supported, "
341 "response data 0x%x\n",
342 sp->cmn.response_multiple_NPort);
92d7f7b0 343 phba->link_flag |= LS_NPIV_FAB_SUPPORTED;
92d7f7b0
JS		 344 } else {
345 /* Because we asked f/w for NPIV it still expects us
e8b62011
JS		 346 to call reg_vnpid atleast for the physcial host */
347 lpfc_printf_vlog(vport, KERN_WARNING,
348 LOG_ELS | LOG_VPORT,
349 "1817 Fabric does not support NPIV "
350 "- configuring single port mode.\n");
92d7f7b0
JS		 351 phba->link_flag &= ~LS_NPIV_FAB_SUPPORTED;
352 }
353 }
dea3101e 354
92d7f7b0
JS		 355 if ((vport->fc_prevDID != vport->fc_myDID) &&
356 !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) {
dea3101e 357
92d7f7b0
JS		 358 /* If our NportID changed, we need to ensure all
359 * remaining NPORTs get unreg_login'ed.
360 */
361 list_for_each_entry_safe(np, next_np,
362 &vport->fc_nodes, nlp_listp) {
363 if ((np->nlp_state != NLP_STE_NPR_NODE) ||
364 !(np->nlp_flag & NLP_NPR_ADISC))
365 continue;
366 spin_lock_irq(shost->host_lock);
367 np->nlp_flag &= ~NLP_NPR_ADISC;
368 spin_unlock_irq(shost->host_lock);
369 lpfc_unreg_rpi(vport, np);
370 }
371 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
372 lpfc_mbx_unreg_vpi(vport);
373 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
374 }
375 }
dea3101e 376
92d7f7b0
JS		 377 ndlp->nlp_sid = irsp->un.ulpWord[4] & Mask_DID;
378 lpfc_nlp_set_state(vport, ndlp, NLP_STE_REG_LOGIN_ISSUE);
dea3101e 379
92d7f7b0
JS		 380 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED &&
381 vport->fc_flag & FC_VPORT_NEEDS_REG_VPI) {
382 lpfc_register_new_vport(phba, vport, ndlp);
383 return 0;
384 }
385 lpfc_issue_fabric_reglogin(vport);
dea3101e 386 return 0;
dea3101e
JB		 387}
388
389/*
390 * We FLOGIed into an NPort, initiate pt2pt protocol
391 */
392static int
2e0fef85
JS		 393lpfc_cmpl_els_flogi_nport(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
394 struct serv_parm *sp)
dea3101e 395{
2e0fef85
JS		 396 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
397 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 398 LPFC_MBOXQ_t *mbox;
399 int rc;
400
2e0fef85
JS		 401 spin_lock_irq(shost->host_lock);
402 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
403 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 404
405 phba->fc_edtov = FF_DEF_EDTOV;
406 phba->fc_ratov = FF_DEF_RATOV;
2e0fef85 407 rc = memcmp(&vport->fc_portname, &sp->portName,
92d7f7b0 408 sizeof(vport->fc_portname));
dea3101e
JB		 409 if (rc >= 0) {
410 /* This side will initiate the PLOGI */
2e0fef85
JS		 411 spin_lock_irq(shost->host_lock);
412 vport->fc_flag |= FC_PT2PT_PLOGI;
413 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 414
415 /*
416 * N_Port ID cannot be 0, set our to LocalID the other
417 * side will be RemoteID.
418 */
419
420 /* not equal */
421 if (rc)
2e0fef85 422 vport->fc_myDID = PT2PT_LocalID;
dea3101e
JB		 423
424 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
425 if (!mbox)
426 goto fail;
427
428 lpfc_config_link(phba, mbox);
429
430 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
ed957684 431 mbox->vport = vport;
dea3101e 432 rc = lpfc_sli_issue_mbox(phba, mbox,
92d7f7b0 433 MBX_NOWAIT | MBX_STOP_IOCB);
dea3101e
JB		 434 if (rc == MBX_NOT_FINISHED) {
435 mempool_free(mbox, phba->mbox_mem_pool);
436 goto fail;
437 }
329f9bc7 438 lpfc_nlp_put(ndlp);
dea3101e 439
2e0fef85 440 ndlp = lpfc_findnode_did(vport, PT2PT_RemoteID);
dea3101e
JB		 441 if (!ndlp) {
442 /*
443 * Cannot find existing Fabric ndlp, so allocate a
444 * new one
445 */
446 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
447 if (!ndlp)
448 goto fail;
449
2e0fef85 450 lpfc_nlp_init(vport, ndlp, PT2PT_RemoteID);
dea3101e
JB		 451 }
452
453 memcpy(&ndlp->nlp_portname, &sp->portName,
2e0fef85 454 sizeof(struct lpfc_name));
dea3101e 455 memcpy(&ndlp->nlp_nodename, &sp->nodeName,
2e0fef85
JS		 456 sizeof(struct lpfc_name));
457 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
458 spin_lock_irq(shost->host_lock);
dea3101e 459 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2e0fef85 460 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 461 } else {
462 /* This side will wait for the PLOGI */
329f9bc7 463 lpfc_nlp_put(ndlp);
dea3101e
JB		 464 }
465
2e0fef85
JS		 466 spin_lock_irq(shost->host_lock);
467 vport->fc_flag |= FC_PT2PT;
468 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 469
470 /* Start discovery - this should just do CLEAR_LA */
2e0fef85 471 lpfc_disc_start(vport);
dea3101e 472 return 0;
92d7f7b0 473fail:
dea3101e
JB		 474 return -ENXIO;
475}
476
477static void
329f9bc7
JS		 478lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
479 struct lpfc_iocbq *rspiocb)
dea3101e 480{
2e0fef85
JS		 481 struct lpfc_vport *vport = cmdiocb->vport;
482 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e
JB		 483 IOCB_t *irsp = &rspiocb->iocb;
484 struct lpfc_nodelist *ndlp = cmdiocb->context1;
485 struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
486 struct serv_parm *sp;
487 int rc;
488
489 /* Check to see if link went down during discovery */
2e0fef85 490 if (lpfc_els_chk_latt(vport)) {
329f9bc7 491 lpfc_nlp_put(ndlp);
dea3101e
JB		 492 goto out;
493 }
494
858c9f6c
JS		 495 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
496 "FLOGI cmpl: status:x%x/x%x state:x%x",
497 irsp->ulpStatus, irsp->un.ulpWord[4],
498 vport->port_state);
499
dea3101e
JB		 500 if (irsp->ulpStatus) {
501 /* Check for retry */
2e0fef85 502 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
dea3101e 503 goto out;
2e0fef85 504
dea3101e 505 /* FLOGI failed, so there is no fabric */
2e0fef85
JS		 506 spin_lock_irq(shost->host_lock);
507 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
508 spin_unlock_irq(shost->host_lock);
dea3101e 509
329f9bc7 510 /* If private loop, then allow max outstanding els to be
dea3101e
JB		 511 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
512 * alpa map would take too long otherwise.
513 */
514 if (phba->alpa_map[0] == 0) {
3de2a653 515 vport->cfg_discovery_threads = LPFC_MAX_DISC_THREADS;
dea3101e
JB		 516 }
517
518 /* FLOGI failure */
e8b62011
JS		 519 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
520 "0100 FLOGI failure Data: x%x x%x "
521 "x%x\n",
522 irsp->ulpStatus, irsp->un.ulpWord[4],
523 irsp->ulpTimeout);
dea3101e
JB		 524 goto flogifail;
525 }
526
527 /*
528 * The FLogI succeeded. Sync the data for the CPU before
529 * accessing it.
530 */
531 prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list);
532
533 sp = prsp->virt + sizeof(uint32_t);
534
535 /* FLOGI completes successfully */
e8b62011
JS		 536 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
537 "0101 FLOGI completes sucessfully "
538 "Data: x%x x%x x%x x%x\n",
539 irsp->un.ulpWord[4], sp->cmn.e_d_tov,
540 sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
dea3101e 541
2e0fef85 542 if (vport->port_state == LPFC_FLOGI) {
dea3101e
JB		 543 /*
544 * If Common Service Parameters indicate Nport
545 * we are point to point, if Fport we are Fabric.
546 */
547 if (sp->cmn.fPort)
2e0fef85 548 rc = lpfc_cmpl_els_flogi_fabric(vport, ndlp, sp, irsp);
dea3101e 549 else
2e0fef85 550 rc = lpfc_cmpl_els_flogi_nport(vport, ndlp, sp);
dea3101e
JB		 551
552 if (!rc)
553 goto out;
554 }
555
556flogifail:
329f9bc7 557 lpfc_nlp_put(ndlp);
dea3101e 558
858c9f6c 559 if (!lpfc_error_lost_link(irsp)) {
dea3101e 560 /* FLOGI failed, so just use loop map to make discovery list */
2e0fef85 561 lpfc_disc_list_loopmap(vport);
dea3101e
JB		 562
563 /* Start discovery */
2e0fef85 564 lpfc_disc_start(vport);
dea3101e
JB		 565 }
566
567out:
568 lpfc_els_free_iocb(phba, cmdiocb);
569}
570
571static int
2e0fef85 572lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
dea3101e
JB		 573 uint8_t retry)
574{
2e0fef85 575 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 576 struct serv_parm *sp;
577 IOCB_t *icmd;
578 struct lpfc_iocbq *elsiocb;
579 struct lpfc_sli_ring *pring;
580 uint8_t *pcmd;
581 uint16_t cmdsize;
582 uint32_t tmo;
583 int rc;
584
585 pring = &phba->sli.ring[LPFC_ELS_RING];
586
92d7f7b0 587 cmdsize = (sizeof(uint32_t) + sizeof(struct serv_parm));
2e0fef85
JS		 588 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
589 ndlp->nlp_DID, ELS_CMD_FLOGI);
92d7f7b0 590
488d1469 591 if (!elsiocb)
c9f8735b 592 return 1;
dea3101e
JB		 593
594 icmd = &elsiocb->iocb;
595 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
596
597 /* For FLOGI request, remainder of payload is service parameters */
598 *((uint32_t *) (pcmd)) = ELS_CMD_FLOGI;
92d7f7b0
JS		 599 pcmd += sizeof(uint32_t);
600 memcpy(pcmd, &vport->fc_sparam, sizeof(struct serv_parm));
dea3101e
JB		 601 sp = (struct serv_parm *) pcmd;
602
603 /* Setup CSPs accordingly for Fabric */
604 sp->cmn.e_d_tov = 0;
605 sp->cmn.w2.r_a_tov = 0;
606 sp->cls1.classValid = 0;
607 sp->cls2.seqDelivery = 1;
608 sp->cls3.seqDelivery = 1;
609 if (sp->cmn.fcphLow < FC_PH3)
610 sp->cmn.fcphLow = FC_PH3;
611 if (sp->cmn.fcphHigh < FC_PH3)
612 sp->cmn.fcphHigh = FC_PH3;
613
92d7f7b0
JS		 614 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
615 sp->cmn.request_multiple_Nport = 1;
616
617 /* For FLOGI, Let FLOGI rsp set the NPortID for VPI 0 */
618 icmd->ulpCt_h = 1;
619 icmd->ulpCt_l = 0;
620 }
621
858c9f6c
JS		 622 if (phba->fc_topology != TOPOLOGY_LOOP) {
623 icmd->un.elsreq64.myID = 0;
624 icmd->un.elsreq64.fl = 1;
625 }
626
dea3101e
JB		 627 tmo = phba->fc_ratov;
628 phba->fc_ratov = LPFC_DISC_FLOGI_TMO;
2e0fef85 629 lpfc_set_disctmo(vport);
dea3101e
JB		 630 phba->fc_ratov = tmo;
631
632 phba->fc_stat.elsXmitFLOGI++;
633 elsiocb->iocb_cmpl = lpfc_cmpl_els_flogi;
858c9f6c
JS		 634
635 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
636 "Issue FLOGI: opt:x%x",
637 phba->sli3_options, 0, 0);
638
92d7f7b0 639 rc = lpfc_issue_fabric_iocb(phba, elsiocb);
dea3101e
JB		 640 if (rc == IOCB_ERROR) {
641 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 642 return 1;
dea3101e 643 }
c9f8735b 644 return 0;
dea3101e
JB		 645}
646
647int
2e0fef85 648lpfc_els_abort_flogi(struct lpfc_hba *phba)
dea3101e
JB		 649{
650 struct lpfc_sli_ring *pring;
651 struct lpfc_iocbq *iocb, *next_iocb;
652 struct lpfc_nodelist *ndlp;
653 IOCB_t *icmd;
654
655 /* Abort outstanding I/O on NPort <nlp_DID> */
656 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
e8b62011
JS		 657 "0201 Abort outstanding I/O on NPort x%x\n",
658 Fabric_DID);
dea3101e
JB		 659
660 pring = &phba->sli.ring[LPFC_ELS_RING];
661
662 /*
663 * Check the txcmplq for an iocb that matches the nport the driver is
664 * searching for.
665 */
2e0fef85 666 spin_lock_irq(&phba->hbalock);
dea3101e
JB		 667 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
668 icmd = &iocb->iocb;
2e0fef85
JS		 669 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR &&
670 icmd->un.elsreq64.bdl.ulpIoTag32) {
dea3101e 671 ndlp = (struct lpfc_nodelist *)(iocb->context1);
92d7f7b0 672 if (ndlp && (ndlp->nlp_DID == Fabric_DID)) {
07951076 673 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
92d7f7b0 674 }
dea3101e
JB		 675 }
676 }
2e0fef85 677 spin_unlock_irq(&phba->hbalock);
dea3101e
JB		 678
679 return 0;
680}
681
682int
2e0fef85 683lpfc_initial_flogi(struct lpfc_vport *vport)
dea3101e 684{
2e0fef85 685 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 686 struct lpfc_nodelist *ndlp;
687
c9f8735b 688 /* First look for the Fabric ndlp */
2e0fef85 689 ndlp = lpfc_findnode_did(vport, Fabric_DID);
c9f8735b 690 if (!ndlp) {
dea3101e 691 /* Cannot find existing Fabric ndlp, so allocate a new one */
c9f8735b
JW		 692 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
693 if (!ndlp)
694 return 0;
2e0fef85 695 lpfc_nlp_init(vport, ndlp, Fabric_DID);
c9f8735b 696 } else {
2e0fef85 697 lpfc_dequeue_node(vport, ndlp);
dea3101e 698 }
2e0fef85 699 if (lpfc_issue_els_flogi(vport, ndlp, 0)) {
329f9bc7 700 lpfc_nlp_put(ndlp);
dea3101e 701 }
c9f8735b 702 return 1;
dea3101e
JB		 703}
704
92d7f7b0
JS		 705int
706lpfc_initial_fdisc(struct lpfc_vport *vport)
707{
708 struct lpfc_hba *phba = vport->phba;
709 struct lpfc_nodelist *ndlp;
710
711 /* First look for the Fabric ndlp */
712 ndlp = lpfc_findnode_did(vport, Fabric_DID);
713 if (!ndlp) {
714 /* Cannot find existing Fabric ndlp, so allocate a new one */
715 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
716 if (!ndlp)
717 return 0;
718 lpfc_nlp_init(vport, ndlp, Fabric_DID);
719 } else {
720 lpfc_dequeue_node(vport, ndlp);
721 }
722 if (lpfc_issue_els_fdisc(vport, ndlp, 0)) {
723 lpfc_nlp_put(ndlp);
724 }
725 return 1;
726}
dea3101e 727static void
2e0fef85 728lpfc_more_plogi(struct lpfc_vport *vport)
dea3101e
JB		 729{
730 int sentplogi;
731
2e0fef85
JS		 732 if (vport->num_disc_nodes)
733 vport->num_disc_nodes--;
dea3101e
JB		 734
735 /* Continue discovery with <num_disc_nodes> PLOGIs to go */
e8b62011
JS		 736 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
737 "0232 Continue discovery with %d PLOGIs to go "
738 "Data: x%x x%x x%x\n",
739 vport->num_disc_nodes, vport->fc_plogi_cnt,
740 vport->fc_flag, vport->port_state);
dea3101e 741 /* Check to see if there are more PLOGIs to be sent */
2e0fef85
JS		 742 if (vport->fc_flag & FC_NLP_MORE)
743 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
744 sentplogi = lpfc_els_disc_plogi(vport);
745
dea3101e
JB		 746 return;
747}
748
488d1469 749static struct lpfc_nodelist *
92d7f7b0 750lpfc_plogi_confirm_nport(struct lpfc_hba *phba, uint32_t *prsp,
488d1469
JS		 751 struct lpfc_nodelist *ndlp)
752{
2e0fef85 753 struct lpfc_vport *vport = ndlp->vport;
488d1469 754 struct lpfc_nodelist *new_ndlp;
488d1469 755 struct serv_parm *sp;
92d7f7b0 756 uint8_t name[sizeof(struct lpfc_name)];
488d1469
JS		 757 uint32_t rc;
758
2fb9bd8b
JS		 759 /* Fabric nodes can have the same WWPN so we don't bother searching
760 * by WWPN. Just return the ndlp that was given to us.
761 */
762 if (ndlp->nlp_type & NLP_FABRIC)
763 return ndlp;
764
92d7f7b0 765 sp = (struct serv_parm *) ((uint8_t *) prsp + sizeof(uint32_t));
685f0bf7 766 memset(name, 0, sizeof(struct lpfc_name));
488d1469 767
685f0bf7 768 /* Now we find out if the NPort we are logging into, matches the WWPN
488d1469
JS		 769 * we have for that ndlp. If not, we have some work to do.
770 */
2e0fef85 771 new_ndlp = lpfc_findnode_wwpn(vport, &sp->portName);
488d1469 772
92795650 773 if (new_ndlp == ndlp)
488d1469 774 return ndlp;
488d1469
JS		 775
776 if (!new_ndlp) {
2e0fef85
JS		 777 rc = memcmp(&ndlp->nlp_portname, name,
778 sizeof(struct lpfc_name));
92795650
JS		 779 if (!rc)
780 return ndlp;
488d1469
JS		 781 new_ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_ATOMIC);
782 if (!new_ndlp)
783 return ndlp;
784
2e0fef85 785 lpfc_nlp_init(vport, new_ndlp, ndlp->nlp_DID);
488d1469
JS		 786 }
787
2e0fef85 788 lpfc_unreg_rpi(vport, new_ndlp);
488d1469 789 new_ndlp->nlp_DID = ndlp->nlp_DID;
92795650 790 new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
2e0fef85 791 lpfc_nlp_set_state(vport, new_ndlp, ndlp->nlp_state);
488d1469 792
2e0fef85 793 /* Move this back to NPR state */
de0c5b32 794 if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0)
2e0fef85 795 lpfc_drop_node(vport, ndlp);
92795650 796 else {
2e0fef85 797 lpfc_unreg_rpi(vport, ndlp);
92795650 798 ndlp->nlp_DID = 0; /* Two ndlps cannot have the same did */
2e0fef85 799 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
92795650 800 }
488d1469
JS		 801 return new_ndlp;
802}
803
dea3101e 804static void
2e0fef85
JS		 805lpfc_cmpl_els_plogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
806 struct lpfc_iocbq *rspiocb)
dea3101e 807{
2e0fef85
JS		 808 struct lpfc_vport *vport = cmdiocb->vport;
809 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e 810 IOCB_t *irsp;
dea3101e 811 struct lpfc_nodelist *ndlp;
92795650 812 struct lpfc_dmabuf *prsp;
dea3101e
JB		 813 int disc, rc, did, type;
814
dea3101e
JB		 815 /* we pass cmdiocb to state machine which needs rspiocb as well */
816 cmdiocb->context_un.rsp_iocb = rspiocb;
817
818 irsp = &rspiocb->iocb;
858c9f6c
JS		 819 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
820 "PLOGI cmpl: status:x%x/x%x did:x%x",
821 irsp->ulpStatus, irsp->un.ulpWord[4],
822 irsp->un.elsreq64.remoteID);
823
2e0fef85 824 ndlp = lpfc_findnode_did(vport, irsp->un.elsreq64.remoteID);
ed957684 825 if (!ndlp) {
e8b62011
JS		 826 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
827 "0136 PLOGI completes to NPort x%x "
828 "with no ndlp. Data: x%x x%x x%x\n",
829 irsp->un.elsreq64.remoteID,
830 irsp->ulpStatus, irsp->un.ulpWord[4],
831 irsp->ulpIoTag);
488d1469 832 goto out;
ed957684 833 }
dea3101e
JB		 834
835 /* Since ndlp can be freed in the disc state machine, note if this node
836 * is being used during discovery.
837 */
2e0fef85 838 spin_lock_irq(shost->host_lock);
dea3101e 839 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
488d1469 840 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
2e0fef85 841 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 842 rc = 0;
843
844 /* PLOGI completes to NPort <nlp_DID> */
e8b62011
JS		 845 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
846 "0102 PLOGI completes to NPort x%x "
847 "Data: x%x x%x x%x x%x x%x\n",
848 ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
849 irsp->ulpTimeout, disc, vport->num_disc_nodes);
dea3101e 850 /* Check to see if link went down during discovery */
2e0fef85
JS		 851 if (lpfc_els_chk_latt(vport)) {
852 spin_lock_irq(shost->host_lock);
dea3101e 853 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2e0fef85 854 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 855 goto out;
856 }
857
858 /* ndlp could be freed in DSM, save these values now */
859 type = ndlp->nlp_type;
860 did = ndlp->nlp_DID;
861
862 if (irsp->ulpStatus) {
863 /* Check for retry */
864 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
865 /* ELS command is being retried */
866 if (disc) {
2e0fef85 867 spin_lock_irq(shost->host_lock);
dea3101e 868 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2e0fef85 869 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 870 }
871 goto out;
872 }
dea3101e 873 /* PLOGI failed */
92d7f7b0
JS		 874 if (ndlp->nlp_DID == NameServer_DID) {
875 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
e8b62011
JS		 876 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
877 "0250 Nameserver login error: "
878 "0x%x / 0x%x\n",
879 irsp->ulpStatus, irsp->un.ulpWord[4]);
92d7f7b0 880 }
dea3101e 881 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
858c9f6c 882 if (lpfc_error_lost_link(irsp)) {
c9f8735b 883 rc = NLP_STE_FREED_NODE;
2fe165b6 884 } else {
2e0fef85 885 rc = lpfc_disc_state_machine(vport, ndlp, cmdiocb,
92d7f7b0 886 NLP_EVT_CMPL_PLOGI);
dea3101e
JB		 887 }
888 } else {
889 /* Good status, call state machine */
92795650 890 prsp = list_entry(((struct lpfc_dmabuf *)
92d7f7b0
JS		 891 cmdiocb->context2)->list.next,
892 struct lpfc_dmabuf, list);
893 ndlp = lpfc_plogi_confirm_nport(phba, prsp->virt, ndlp);
2e0fef85 894 rc = lpfc_disc_state_machine(vport, ndlp, cmdiocb,
92d7f7b0 895 NLP_EVT_CMPL_PLOGI);
dea3101e
JB		 896 }
897
2e0fef85 898 if (disc && vport->num_disc_nodes) {
dea3101e 899 /* Check to see if there are more PLOGIs to be sent */
2e0fef85 900 lpfc_more_plogi(vport);
dea3101e 901
2e0fef85
JS		 902 if (vport->num_disc_nodes == 0) {
903 spin_lock_irq(shost->host_lock);
904 vport->fc_flag &= ~FC_NDISC_ACTIVE;
905 spin_unlock_irq(shost->host_lock);
dea3101e 906
2e0fef85
JS		 907 lpfc_can_disctmo(vport);
908 if (vport->fc_flag & FC_RSCN_MODE) {
10d4e957
JS		 909 /*
910 * Check to see if more RSCNs came in while
911 * we were processing this one.
912 */
2e0fef85
JS		 913 if ((vport->fc_rscn_id_cnt == 0) &&
914 (!(vport->fc_flag & FC_RSCN_DISCOVERY))) {
915 spin_lock_irq(shost->host_lock);
916 vport->fc_flag &= ~FC_RSCN_MODE;
917 spin_unlock_irq(shost->host_lock);
10d4e957 918 } else {
2e0fef85 919 lpfc_els_handle_rscn(vport);
10d4e957 920 }
dea3101e
JB		 921 }
922 }
923 }
924
925out:
926 lpfc_els_free_iocb(phba, cmdiocb);
927 return;
928}
929
930int
2e0fef85 931lpfc_issue_els_plogi(struct lpfc_vport *vport, uint32_t did, uint8_t retry)
dea3101e 932{
2e0fef85 933 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 934 struct serv_parm *sp;
935 IOCB_t *icmd;
936 struct lpfc_iocbq *elsiocb;
937 struct lpfc_sli_ring *pring;
938 struct lpfc_sli *psli;
939 uint8_t *pcmd;
940 uint16_t cmdsize;
92d7f7b0 941 int ret;
dea3101e
JB		 942
943 psli = &phba->sli;
944 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
945
92d7f7b0 946 cmdsize = (sizeof(uint32_t) + sizeof(struct serv_parm));
2e0fef85
JS		 947 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, NULL, did,
948 ELS_CMD_PLOGI);
c9f8735b
JW		 949 if (!elsiocb)
950 return 1;
dea3101e
JB		 951
952 icmd = &elsiocb->iocb;
953 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
954
955 /* For PLOGI request, remainder of payload is service parameters */
956 *((uint32_t *) (pcmd)) = ELS_CMD_PLOGI;
92d7f7b0
JS		 957 pcmd += sizeof(uint32_t);
958 memcpy(pcmd, &vport->fc_sparam, sizeof(struct serv_parm));
dea3101e
JB		 959 sp = (struct serv_parm *) pcmd;
960
961 if (sp->cmn.fcphLow < FC_PH_4_3)
962 sp->cmn.fcphLow = FC_PH_4_3;
963
964 if (sp->cmn.fcphHigh < FC_PH3)
965 sp->cmn.fcphHigh = FC_PH3;
966
858c9f6c
JS		 967 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
968 "Issue PLOGI: did:x%x",
969 did, 0, 0);
970
dea3101e
JB		 971 phba->fc_stat.elsXmitPLOGI++;
972 elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi;
92d7f7b0
JS		 973 ret = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
974
975 if (ret == IOCB_ERROR) {
dea3101e 976 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 977 return 1;
dea3101e 978 }
c9f8735b 979 return 0;
dea3101e
JB		 980}
981
982static void
2e0fef85
JS		 983lpfc_cmpl_els_prli(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
984 struct lpfc_iocbq *rspiocb)
dea3101e 985{
2e0fef85
JS		 986 struct lpfc_vport *vport = cmdiocb->vport;
987 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e
JB		 988 IOCB_t *irsp;
989 struct lpfc_sli *psli;
990 struct lpfc_nodelist *ndlp;
991
992 psli = &phba->sli;
993 /* we pass cmdiocb to state machine which needs rspiocb as well */
994 cmdiocb->context_un.rsp_iocb = rspiocb;
995
996 irsp = &(rspiocb->iocb);
997 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
2e0fef85 998 spin_lock_irq(shost->host_lock);
dea3101e 999 ndlp->nlp_flag &= ~NLP_PRLI_SND;
2e0fef85 1000 spin_unlock_irq(shost->host_lock);
dea3101e 1001
858c9f6c
JS		 1002 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1003 "PRLI cmpl: status:x%x/x%x did:x%x",
1004 irsp->ulpStatus, irsp->un.ulpWord[4],
1005 ndlp->nlp_DID);
dea3101e 1006 /* PRLI completes to NPort <nlp_DID> */
e8b62011
JS		 1007 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1008 "0103 PRLI completes to NPort x%x "
1009 "Data: x%x x%x x%x x%x\n",
1010 ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
1011 irsp->ulpTimeout, vport->num_disc_nodes);
dea3101e 1012
2e0fef85 1013 vport->fc_prli_sent--;
dea3101e 1014 /* Check to see if link went down during discovery */
2e0fef85 1015 if (lpfc_els_chk_latt(vport))
dea3101e
JB		 1016 goto out;
1017
1018 if (irsp->ulpStatus) {
1019 /* Check for retry */
1020 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1021 /* ELS command is being retried */
1022 goto out;
1023 }
1024 /* PRLI failed */
1025 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
858c9f6c 1026 if (lpfc_error_lost_link(irsp)) {
dea3101e 1027 goto out;
2fe165b6 1028 } else {
2e0fef85 1029 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
92d7f7b0 1030 NLP_EVT_CMPL_PRLI);
dea3101e
JB		 1031 }
1032 } else {
1033 /* Good status, call state machine */
2e0fef85 1034 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
92d7f7b0 1035 NLP_EVT_CMPL_PRLI);
dea3101e
JB		 1036 }
1037
1038out:
1039 lpfc_els_free_iocb(phba, cmdiocb);
1040 return;
1041}
1042
1043int
2e0fef85 1044lpfc_issue_els_prli(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
dea3101e
JB		 1045 uint8_t retry)
1046{
2e0fef85
JS		 1047 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1048 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 1049 PRLI *npr;
1050 IOCB_t *icmd;
1051 struct lpfc_iocbq *elsiocb;
1052 struct lpfc_sli_ring *pring;
1053 struct lpfc_sli *psli;
1054 uint8_t *pcmd;
1055 uint16_t cmdsize;
1056
1057 psli = &phba->sli;
1058 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1059
92d7f7b0 1060 cmdsize = (sizeof(uint32_t) + sizeof(PRLI));
2e0fef85
JS		 1061 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1062 ndlp->nlp_DID, ELS_CMD_PRLI);
488d1469 1063 if (!elsiocb)
c9f8735b 1064 return 1;
dea3101e
JB		 1065
1066 icmd = &elsiocb->iocb;
1067 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1068
1069 /* For PRLI request, remainder of payload is service parameters */
92d7f7b0 1070 memset(pcmd, 0, (sizeof(PRLI) + sizeof(uint32_t)));
dea3101e 1071 *((uint32_t *) (pcmd)) = ELS_CMD_PRLI;
92d7f7b0 1072 pcmd += sizeof(uint32_t);
dea3101e
JB		 1073
1074 /* For PRLI, remainder of payload is PRLI parameter page */
1075 npr = (PRLI *) pcmd;
1076 /*
1077 * If our firmware version is 3.20 or later,
1078 * set the following bits for FC-TAPE support.
1079 */
1080 if (phba->vpd.rev.feaLevelHigh >= 0x02) {
1081 npr->ConfmComplAllowed = 1;
1082 npr->Retry = 1;
1083 npr->TaskRetryIdReq = 1;
1084 }
1085 npr->estabImagePair = 1;
1086 npr->readXferRdyDis = 1;
1087
1088 /* For FCP support */
1089 npr->prliType = PRLI_FCP_TYPE;
1090 npr->initiatorFunc = 1;
1091
858c9f6c
JS		 1092 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1093 "Issue PRLI: did:x%x",
1094 ndlp->nlp_DID, 0, 0);
1095
dea3101e
JB		 1096 phba->fc_stat.elsXmitPRLI++;
1097 elsiocb->iocb_cmpl = lpfc_cmpl_els_prli;
2e0fef85 1098 spin_lock_irq(shost->host_lock);
dea3101e 1099 ndlp->nlp_flag |= NLP_PRLI_SND;
2e0fef85 1100 spin_unlock_irq(shost->host_lock);
dea3101e 1101 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2e0fef85 1102 spin_lock_irq(shost->host_lock);
dea3101e 1103 ndlp->nlp_flag &= ~NLP_PRLI_SND;
2e0fef85 1104 spin_unlock_irq(shost->host_lock);
dea3101e 1105 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 1106 return 1;
dea3101e 1107 }
2e0fef85 1108 vport->fc_prli_sent++;
c9f8735b 1109 return 0;
dea3101e
JB		 1110}
1111
1112static void
2e0fef85 1113lpfc_more_adisc(struct lpfc_vport *vport)
dea3101e
JB		 1114{
1115 int sentadisc;
1116
2e0fef85
JS		 1117 if (vport->num_disc_nodes)
1118 vport->num_disc_nodes--;
dea3101e 1119 /* Continue discovery with <num_disc_nodes> ADISCs to go */
e8b62011
JS		 1120 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1121 "0210 Continue discovery with %d ADISCs to go "
1122 "Data: x%x x%x x%x\n",
1123 vport->num_disc_nodes, vport->fc_adisc_cnt,
1124 vport->fc_flag, vport->port_state);
dea3101e 1125 /* Check to see if there are more ADISCs to be sent */
2e0fef85
JS		 1126 if (vport->fc_flag & FC_NLP_MORE) {
1127 lpfc_set_disctmo(vport);
1128 /* go thru NPR nodes and issue any remaining ELS ADISCs */
1129 sentadisc = lpfc_els_disc_adisc(vport);
dea3101e
JB		 1130 }
1131 return;
1132}
1133
1134static void
2e0fef85 1135lpfc_rscn_disc(struct lpfc_vport *vport)
dea3101e 1136{
2e0fef85
JS		 1137 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1138
858c9f6c
JS		 1139 lpfc_can_disctmo(vport);
1140
dea3101e 1141 /* RSCN discovery */
2e0fef85
JS		 1142 /* go thru NPR nodes and issue ELS PLOGIs */
1143 if (vport->fc_npr_cnt)
1144 if (lpfc_els_disc_plogi(vport))
dea3101e 1145 return;
2e0fef85
JS		 1146
1147 if (vport->fc_flag & FC_RSCN_MODE) {
dea3101e
JB		 1148 /* Check to see if more RSCNs came in while we were
1149 * processing this one.
1150 */
2e0fef85
JS		 1151 if ((vport->fc_rscn_id_cnt == 0) &&
1152 (!(vport->fc_flag & FC_RSCN_DISCOVERY))) {
1153 spin_lock_irq(shost->host_lock);
1154 vport->fc_flag &= ~FC_RSCN_MODE;
1155 spin_unlock_irq(shost->host_lock);
dea3101e 1156 } else {
2e0fef85 1157 lpfc_els_handle_rscn(vport);
dea3101e
JB		 1158 }
1159 }
1160}
1161
1162static void
2e0fef85
JS		 1163lpfc_cmpl_els_adisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1164 struct lpfc_iocbq *rspiocb)
dea3101e 1165{
2e0fef85
JS		 1166 struct lpfc_vport *vport = cmdiocb->vport;
1167 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e 1168 IOCB_t *irsp;
dea3101e 1169 struct lpfc_nodelist *ndlp;
2e0fef85 1170 int disc;
dea3101e
JB		 1171
1172 /* we pass cmdiocb to state machine which needs rspiocb as well */
1173 cmdiocb->context_un.rsp_iocb = rspiocb;
1174
1175 irsp = &(rspiocb->iocb);
1176 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
dea3101e 1177
858c9f6c
JS		 1178 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1179 "ADISC cmpl: status:x%x/x%x did:x%x",
1180 irsp->ulpStatus, irsp->un.ulpWord[4],
1181 ndlp->nlp_DID);
1182
dea3101e
JB		 1183 /* Since ndlp can be freed in the disc state machine, note if this node
1184 * is being used during discovery.
1185 */
2e0fef85 1186 spin_lock_irq(shost->host_lock);
dea3101e 1187 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
c9f8735b 1188 ndlp->nlp_flag &= ~(NLP_ADISC_SND | NLP_NPR_2B_DISC);
2e0fef85 1189 spin_unlock_irq(shost->host_lock);
dea3101e 1190 /* ADISC completes to NPort <nlp_DID> */
e8b62011
JS		 1191 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1192 "0104 ADISC completes to NPort x%x "
1193 "Data: x%x x%x x%x x%x x%x\n",
1194 ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
1195 irsp->ulpTimeout, disc, vport->num_disc_nodes);
dea3101e 1196 /* Check to see if link went down during discovery */
2e0fef85
JS		 1197 if (lpfc_els_chk_latt(vport)) {
1198 spin_lock_irq(shost->host_lock);
dea3101e 1199 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2e0fef85 1200 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 1201 goto out;
1202 }
1203
1204 if (irsp->ulpStatus) {
1205 /* Check for retry */
1206 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1207 /* ELS command is being retried */
1208 if (disc) {
2e0fef85 1209 spin_lock_irq(shost->host_lock);
dea3101e 1210 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2e0fef85
JS		 1211 spin_unlock_irq(shost->host_lock);
1212 lpfc_set_disctmo(vport);
dea3101e
JB		 1213 }
1214 goto out;
1215 }
1216 /* ADISC failed */
1217 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
858c9f6c 1218 if (!lpfc_error_lost_link(irsp)) {
2e0fef85 1219 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
858c9f6c 1220 NLP_EVT_CMPL_ADISC);
dea3101e
JB		 1221 }
1222 } else {
1223 /* Good status, call state machine */
2e0fef85 1224 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
dea3101e
JB		 1225 NLP_EVT_CMPL_ADISC);
1226 }
1227
2e0fef85 1228 if (disc && vport->num_disc_nodes) {
dea3101e 1229 /* Check to see if there are more ADISCs to be sent */
2e0fef85 1230 lpfc_more_adisc(vport);
dea3101e
JB		 1231
1232 /* Check to see if we are done with ADISC authentication */
2e0fef85 1233 if (vport->num_disc_nodes == 0) {
92d7f7b0
JS		 1234 /* If we get here, there is nothing left to ADISC */
1235 /*
1236 * For NPIV, cmpl_reg_vpi will set port_state to READY,
1237 * and continue discovery.
1238 */
1239 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
1240 !(vport->fc_flag & FC_RSCN_MODE)) {
1241 lpfc_issue_reg_vpi(phba, vport);
1242 goto out;
1243 }
1244 /*
1245 * For SLI2, we need to set port_state to READY
1246 * and continue discovery.
1247 */
1248 if (vport->port_state < LPFC_VPORT_READY) {
1249 /* If we get here, there is nothing to ADISC */
ed957684 1250 if (vport->port_type == LPFC_PHYSICAL_PORT)
2e0fef85 1251 lpfc_issue_clear_la(phba, vport);
92d7f7b0
JS		 1252
1253 if (!(vport->fc_flag & FC_ABORT_DISCOVERY)) {
1254 vport->num_disc_nodes = 0;
1255 /* go thru NPR list, issue ELS PLOGIs */
1256 if (vport->fc_npr_cnt)
1257 lpfc_els_disc_plogi(vport);
1258
1259 if (!vport->num_disc_nodes) {
1260 spin_lock_irq(shost->host_lock);
1261 vport->fc_flag &=
1262 ~FC_NDISC_ACTIVE;
1263 spin_unlock_irq(
1264 shost->host_lock);
1265 lpfc_can_disctmo(vport);
1266 }
1267 }
1268 vport->port_state = LPFC_VPORT_READY;
dea3101e 1269 } else {
2e0fef85 1270 lpfc_rscn_disc(vport);
dea3101e
JB		 1271 }
1272 }
1273 }
dea3101e
JB		 1274out:
1275 lpfc_els_free_iocb(phba, cmdiocb);
1276 return;
1277}
1278
1279int
2e0fef85 1280lpfc_issue_els_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
dea3101e
JB		 1281 uint8_t retry)
1282{
2e0fef85
JS		 1283 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1284 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 1285 ADISC *ap;
1286 IOCB_t *icmd;
1287 struct lpfc_iocbq *elsiocb;
2e0fef85
JS		 1288 struct lpfc_sli *psli = &phba->sli;
1289 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
dea3101e
JB		 1290 uint8_t *pcmd;
1291 uint16_t cmdsize;
1292
92d7f7b0 1293 cmdsize = (sizeof(uint32_t) + sizeof(ADISC));
2e0fef85
JS		 1294 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1295 ndlp->nlp_DID, ELS_CMD_ADISC);
488d1469 1296 if (!elsiocb)
c9f8735b 1297 return 1;
dea3101e
JB		 1298
1299 icmd = &elsiocb->iocb;
1300 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1301
1302 /* For ADISC request, remainder of payload is service parameters */
1303 *((uint32_t *) (pcmd)) = ELS_CMD_ADISC;
92d7f7b0 1304 pcmd += sizeof(uint32_t);
dea3101e
JB		 1305
1306 /* Fill in ADISC payload */
1307 ap = (ADISC *) pcmd;
1308 ap->hardAL_PA = phba->fc_pref_ALPA;
92d7f7b0
JS		 1309 memcpy(&ap->portName, &vport->fc_portname, sizeof(struct lpfc_name));
1310 memcpy(&ap->nodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
2e0fef85 1311 ap->DID = be32_to_cpu(vport->fc_myDID);
dea3101e 1312
858c9f6c
JS		 1313 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1314 "Issue ADISC: did:x%x",
1315 ndlp->nlp_DID, 0, 0);
1316
dea3101e
JB		 1317 phba->fc_stat.elsXmitADISC++;
1318 elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc;
2e0fef85 1319 spin_lock_irq(shost->host_lock);
dea3101e 1320 ndlp->nlp_flag |= NLP_ADISC_SND;
2e0fef85 1321 spin_unlock_irq(shost->host_lock);
dea3101e 1322 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2e0fef85 1323 spin_lock_irq(shost->host_lock);
dea3101e 1324 ndlp->nlp_flag &= ~NLP_ADISC_SND;
2e0fef85 1325 spin_unlock_irq(shost->host_lock);
dea3101e 1326 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 1327 return 1;
dea3101e 1328 }
c9f8735b 1329 return 0;
dea3101e
JB		 1330}
1331
1332static void
2e0fef85
JS		 1333lpfc_cmpl_els_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1334 struct lpfc_iocbq *rspiocb)
dea3101e 1335{
2e0fef85
JS		 1336 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1337 struct lpfc_vport *vport = ndlp->vport;
1338 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e
JB		 1339 IOCB_t *irsp;
1340 struct lpfc_sli *psli;
dea3101e
JB		 1341
1342 psli = &phba->sli;
1343 /* we pass cmdiocb to state machine which needs rspiocb as well */
1344 cmdiocb->context_un.rsp_iocb = rspiocb;
1345
1346 irsp = &(rspiocb->iocb);
2e0fef85 1347 spin_lock_irq(shost->host_lock);
dea3101e 1348 ndlp->nlp_flag &= ~NLP_LOGO_SND;
2e0fef85 1349 spin_unlock_irq(shost->host_lock);
dea3101e 1350
858c9f6c
JS		 1351 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1352 "LOGO cmpl: status:x%x/x%x did:x%x",
1353 irsp->ulpStatus, irsp->un.ulpWord[4],
1354 ndlp->nlp_DID);
dea3101e 1355 /* LOGO completes to NPort <nlp_DID> */
e8b62011
JS		 1356 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1357 "0105 LOGO completes to NPort x%x "
1358 "Data: x%x x%x x%x x%x\n",
1359 ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
1360 irsp->ulpTimeout, vport->num_disc_nodes);
dea3101e 1361 /* Check to see if link went down during discovery */
2e0fef85 1362 if (lpfc_els_chk_latt(vport))
dea3101e
JB		 1363 goto out;
1364
92d7f7b0
JS		 1365 if (ndlp->nlp_flag & NLP_TARGET_REMOVE) {
1366 /* NLP_EVT_DEVICE_RM should unregister the RPI
1367 * which should abort all outstanding IOs.
1368 */
1369 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1370 NLP_EVT_DEVICE_RM);
1371 goto out;
1372 }
1373
dea3101e
JB		 1374 if (irsp->ulpStatus) {
1375 /* Check for retry */
2e0fef85 1376 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
dea3101e
JB		 1377 /* ELS command is being retried */
1378 goto out;
dea3101e
JB		 1379 /* LOGO failed */
1380 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
858c9f6c 1381 if (lpfc_error_lost_link(irsp))
dea3101e 1382 goto out;
858c9f6c 1383 else
2e0fef85 1384 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
92d7f7b0 1385 NLP_EVT_CMPL_LOGO);
dea3101e 1386 } else {
5024ab17
JW		 1387 /* Good status, call state machine.
1388 * This will unregister the rpi if needed.
1389 */
2e0fef85 1390 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
92d7f7b0 1391 NLP_EVT_CMPL_LOGO);
dea3101e
JB		 1392 }
1393
1394out:
1395 lpfc_els_free_iocb(phba, cmdiocb);
1396 return;
1397}
1398
1399int
2e0fef85 1400lpfc_issue_els_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
dea3101e
JB		 1401 uint8_t retry)
1402{
2e0fef85
JS		 1403 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1404 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 1405 IOCB_t *icmd;
1406 struct lpfc_iocbq *elsiocb;
1407 struct lpfc_sli_ring *pring;
1408 struct lpfc_sli *psli;
1409 uint8_t *pcmd;
1410 uint16_t cmdsize;
92d7f7b0 1411 int rc;
dea3101e
JB		 1412
1413 psli = &phba->sli;
1414 pring = &psli->ring[LPFC_ELS_RING];
1415
92d7f7b0 1416 cmdsize = (2 * sizeof(uint32_t)) + sizeof(struct lpfc_name);
2e0fef85
JS		 1417 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1418 ndlp->nlp_DID, ELS_CMD_LOGO);
488d1469 1419 if (!elsiocb)
c9f8735b 1420 return 1;
dea3101e
JB		 1421
1422 icmd = &elsiocb->iocb;
1423 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1424 *((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
92d7f7b0 1425 pcmd += sizeof(uint32_t);
dea3101e
JB		 1426
1427 /* Fill in LOGO payload */
2e0fef85 1428 *((uint32_t *) (pcmd)) = be32_to_cpu(vport->fc_myDID);
92d7f7b0
JS		 1429 pcmd += sizeof(uint32_t);
1430 memcpy(pcmd, &vport->fc_portname, sizeof(struct lpfc_name));
dea3101e 1431
858c9f6c
JS		 1432 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1433 "Issue LOGO: did:x%x",
1434 ndlp->nlp_DID, 0, 0);
1435
dea3101e
JB		 1436 phba->fc_stat.elsXmitLOGO++;
1437 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo;
2e0fef85 1438 spin_lock_irq(shost->host_lock);
dea3101e 1439 ndlp->nlp_flag |= NLP_LOGO_SND;
2e0fef85 1440 spin_unlock_irq(shost->host_lock);
92d7f7b0
JS		 1441 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
1442
1443 if (rc == IOCB_ERROR) {
2e0fef85 1444 spin_lock_irq(shost->host_lock);
dea3101e 1445 ndlp->nlp_flag &= ~NLP_LOGO_SND;
2e0fef85 1446 spin_unlock_irq(shost->host_lock);
dea3101e 1447 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 1448 return 1;
dea3101e 1449 }
c9f8735b 1450 return 0;
dea3101e
JB		 1451}
1452
1453static void
2e0fef85
JS		 1454lpfc_cmpl_els_cmd(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1455 struct lpfc_iocbq *rspiocb)
dea3101e 1456{
2e0fef85 1457 struct lpfc_vport *vport = cmdiocb->vport;
dea3101e
JB		 1458 IOCB_t *irsp;
1459
1460 irsp = &rspiocb->iocb;
1461
858c9f6c
JS		 1462 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1463 "ELS cmd cmpl: status:x%x/x%x did:x%x",
1464 irsp->ulpStatus, irsp->un.ulpWord[4],
1465 irsp->un.elsreq64.remoteID);
dea3101e 1466 /* ELS cmd tag <ulpIoTag> completes */
e8b62011
JS		 1467 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1468 "0106 ELS cmd tag x%x completes Data: x%x x%x x%x\n",
1469 irsp->ulpIoTag, irsp->ulpStatus,
1470 irsp->un.ulpWord[4], irsp->ulpTimeout);
dea3101e 1471 /* Check to see if link went down during discovery */
2e0fef85 1472 lpfc_els_chk_latt(vport);
dea3101e
JB		 1473 lpfc_els_free_iocb(phba, cmdiocb);
1474 return;
1475}
1476
1477int
2e0fef85 1478lpfc_issue_els_scr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
dea3101e 1479{
2e0fef85 1480 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 1481 IOCB_t *icmd;
1482 struct lpfc_iocbq *elsiocb;
1483 struct lpfc_sli_ring *pring;
1484 struct lpfc_sli *psli;
1485 uint8_t *pcmd;
1486 uint16_t cmdsize;
1487 struct lpfc_nodelist *ndlp;
1488
1489 psli = &phba->sli;
1490 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
92d7f7b0 1491 cmdsize = (sizeof(uint32_t) + sizeof(SCR));
c9f8735b
JW		 1492 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1493 if (!ndlp)
1494 return 1;
dea3101e 1495
2e0fef85
JS		 1496 lpfc_nlp_init(vport, ndlp, nportid);
1497
1498 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1499 ndlp->nlp_DID, ELS_CMD_SCR);
dea3101e 1500
488d1469 1501 if (!elsiocb) {
329f9bc7 1502 lpfc_nlp_put(ndlp);
c9f8735b 1503 return 1;
dea3101e
JB		 1504 }
1505
1506 icmd = &elsiocb->iocb;
1507 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1508
1509 *((uint32_t *) (pcmd)) = ELS_CMD_SCR;
92d7f7b0 1510 pcmd += sizeof(uint32_t);
dea3101e
JB		 1511
1512 /* For SCR, remainder of payload is SCR parameter page */
92d7f7b0 1513 memset(pcmd, 0, sizeof(SCR));
dea3101e
JB		 1514 ((SCR *) pcmd)->Function = SCR_FUNC_FULL;
1515
858c9f6c
JS		 1516 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1517 "Issue SCR: did:x%x",
1518 ndlp->nlp_DID, 0, 0);
1519
dea3101e
JB		 1520 phba->fc_stat.elsXmitSCR++;
1521 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
dea3101e 1522 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
329f9bc7 1523 lpfc_nlp_put(ndlp);
dea3101e 1524 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 1525 return 1;
dea3101e 1526 }
329f9bc7 1527 lpfc_nlp_put(ndlp);
c9f8735b 1528 return 0;
dea3101e
JB		 1529}
1530
1531static int
2e0fef85 1532lpfc_issue_els_farpr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
dea3101e 1533{
2e0fef85 1534 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 1535 IOCB_t *icmd;
1536 struct lpfc_iocbq *elsiocb;
1537 struct lpfc_sli_ring *pring;
1538 struct lpfc_sli *psli;
1539 FARP *fp;
1540 uint8_t *pcmd;
1541 uint32_t *lp;
1542 uint16_t cmdsize;
1543 struct lpfc_nodelist *ondlp;
1544 struct lpfc_nodelist *ndlp;
1545
1546 psli = &phba->sli;
1547 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
92d7f7b0 1548 cmdsize = (sizeof(uint32_t) + sizeof(FARP));
c9f8735b
JW		 1549 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1550 if (!ndlp)
1551 return 1;
dea3101e 1552
2e0fef85
JS		 1553 lpfc_nlp_init(vport, ndlp, nportid);
1554
1555 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1556 ndlp->nlp_DID, ELS_CMD_RNID);
488d1469 1557 if (!elsiocb) {
329f9bc7 1558 lpfc_nlp_put(ndlp);
c9f8735b 1559 return 1;
dea3101e
JB		 1560 }
1561
1562 icmd = &elsiocb->iocb;
1563 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1564
1565 *((uint32_t *) (pcmd)) = ELS_CMD_FARPR;
92d7f7b0 1566 pcmd += sizeof(uint32_t);
dea3101e
JB		 1567
1568 /* Fill in FARPR payload */
1569 fp = (FARP *) (pcmd);
92d7f7b0 1570 memset(fp, 0, sizeof(FARP));
dea3101e
JB		 1571 lp = (uint32_t *) pcmd;
1572 *lp++ = be32_to_cpu(nportid);
2e0fef85 1573 *lp++ = be32_to_cpu(vport->fc_myDID);
dea3101e
JB		 1574 fp->Rflags = 0;
1575 fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE);
1576
92d7f7b0
JS		 1577 memcpy(&fp->RportName, &vport->fc_portname, sizeof(struct lpfc_name));
1578 memcpy(&fp->RnodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
2e0fef85
JS		 1579 ondlp = lpfc_findnode_did(vport, nportid);
1580 if (ondlp) {
dea3101e 1581 memcpy(&fp->OportName, &ondlp->nlp_portname,
92d7f7b0 1582 sizeof(struct lpfc_name));
dea3101e 1583 memcpy(&fp->OnodeName, &ondlp->nlp_nodename,
92d7f7b0 1584 sizeof(struct lpfc_name));
dea3101e
JB		 1585 }
1586
858c9f6c
JS		 1587 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1588 "Issue FARPR: did:x%x",
1589 ndlp->nlp_DID, 0, 0);
1590
dea3101e
JB		 1591 phba->fc_stat.elsXmitFARPR++;
1592 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
dea3101e 1593 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
329f9bc7 1594 lpfc_nlp_put(ndlp);
dea3101e 1595 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 1596 return 1;
dea3101e 1597 }
329f9bc7 1598 lpfc_nlp_put(ndlp);
c9f8735b 1599 return 0;
dea3101e
JB		 1600}
1601
ed957684
JS		 1602static void
1603lpfc_end_rscn(struct lpfc_vport *vport)
1604{
1605 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1606
1607 if (vport->fc_flag & FC_RSCN_MODE) {
1608 /*
1609 * Check to see if more RSCNs came in while we were
1610 * processing this one.
1611 */
1612 if (vport->fc_rscn_id_cnt ||
1613 (vport->fc_flag & FC_RSCN_DISCOVERY) != 0)
1614 lpfc_els_handle_rscn(vport);
1615 else {
1616 spin_lock_irq(shost->host_lock);
1617 vport->fc_flag &= ~FC_RSCN_MODE;
1618 spin_unlock_irq(shost->host_lock);
1619 }
1620 }
1621}
1622
fdcebe28 1623void
2e0fef85 1624lpfc_cancel_retry_delay_tmo(struct lpfc_vport *vport, struct lpfc_nodelist *nlp)
fdcebe28 1625{
2e0fef85
JS		 1626 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1627
1628 spin_lock_irq(shost->host_lock);
fdcebe28 1629 nlp->nlp_flag &= ~NLP_DELAY_TMO;
2e0fef85 1630 spin_unlock_irq(shost->host_lock);
fdcebe28
JS		 1631 del_timer_sync(&nlp->nlp_delayfunc);
1632 nlp->nlp_last_elscmd = 0;
1633
1634 if (!list_empty(&nlp->els_retry_evt.evt_listp))
1635 list_del_init(&nlp->els_retry_evt.evt_listp);
1636
1637 if (nlp->nlp_flag & NLP_NPR_2B_DISC) {
2e0fef85 1638 spin_lock_irq(shost->host_lock);
fdcebe28 1639 nlp->nlp_flag &= ~NLP_NPR_2B_DISC;
2e0fef85
JS		 1640 spin_unlock_irq(shost->host_lock);
1641 if (vport->num_disc_nodes) {
fdcebe28
JS		 1642 /* Check to see if there are more
1643 * PLOGIs to be sent
1644 */
2e0fef85
JS		 1645 lpfc_more_plogi(vport);
1646
1647 if (vport->num_disc_nodes == 0) {
1648 spin_lock_irq(shost->host_lock);
1649 vport->fc_flag &= ~FC_NDISC_ACTIVE;
1650 spin_unlock_irq(shost->host_lock);
1651 lpfc_can_disctmo(vport);
ed957684 1652 lpfc_end_rscn(vport);
fdcebe28
JS		 1653 }
1654 }
1655 }
1656 return;
1657}
1658
dea3101e
JB		 1659void
1660lpfc_els_retry_delay(unsigned long ptr)
1661{
2e0fef85
JS		 1662 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) ptr;
1663 struct lpfc_vport *vport = ndlp->vport;
2e0fef85 1664 struct lpfc_hba *phba = vport->phba;
92d7f7b0 1665 unsigned long flags;
2e0fef85 1666 struct lpfc_work_evt *evtp = &ndlp->els_retry_evt;
dea3101e 1667
2e0fef85
JS		 1668 ndlp = (struct lpfc_nodelist *) ptr;
1669 phba = ndlp->vport->phba;
dea3101e
JB		 1670 evtp = &ndlp->els_retry_evt;
1671
92d7f7b0 1672 spin_lock_irqsave(&phba->hbalock, flags);
dea3101e 1673 if (!list_empty(&evtp->evt_listp)) {
92d7f7b0 1674 spin_unlock_irqrestore(&phba->hbalock, flags);
dea3101e
JB		 1675 return;
1676 }
1677
1678 evtp->evt_arg1 = ndlp;
1679 evtp->evt = LPFC_EVT_ELS_RETRY;
1680 list_add_tail(&evtp->evt_listp, &phba->work_list);
1681 if (phba->work_wait)
92d7f7b0 1682 lpfc_worker_wake_up(phba);
dea3101e 1683
92d7f7b0 1684 spin_unlock_irqrestore(&phba->hbalock, flags);
dea3101e
JB		 1685 return;
1686}
1687
1688void
1689lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
1690{
2e0fef85
JS		 1691 struct lpfc_vport *vport = ndlp->vport;
1692 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1693 uint32_t cmd, did, retry;
dea3101e 1694
2e0fef85 1695 spin_lock_irq(shost->host_lock);
5024ab17
JW		 1696 did = ndlp->nlp_DID;
1697 cmd = ndlp->nlp_last_elscmd;
1698 ndlp->nlp_last_elscmd = 0;
dea3101e
JB		 1699
1700 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
2e0fef85 1701 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 1702 return;
1703 }
1704
1705 ndlp->nlp_flag &= ~NLP_DELAY_TMO;
2e0fef85 1706 spin_unlock_irq(shost->host_lock);
1a169689
JS		 1707 /*
1708 * If a discovery event readded nlp_delayfunc after timer
1709 * firing and before processing the timer, cancel the
1710 * nlp_delayfunc.
1711 */
1712 del_timer_sync(&ndlp->nlp_delayfunc);
dea3101e
JB		 1713 retry = ndlp->nlp_retry;
1714
1715 switch (cmd) {
1716 case ELS_CMD_FLOGI:
2e0fef85 1717 lpfc_issue_els_flogi(vport, ndlp, retry);
dea3101e
JB		 1718 break;
1719 case ELS_CMD_PLOGI:
2e0fef85 1720 if (!lpfc_issue_els_plogi(vport, ndlp->nlp_DID, retry)) {
5024ab17 1721 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1722 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
6ad42535 1723 }
dea3101e
JB		 1724 break;
1725 case ELS_CMD_ADISC:
2e0fef85 1726 if (!lpfc_issue_els_adisc(vport, ndlp, retry)) {
5024ab17 1727 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1728 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
6ad42535 1729 }
dea3101e
JB		 1730 break;
1731 case ELS_CMD_PRLI:
2e0fef85 1732 if (!lpfc_issue_els_prli(vport, ndlp, retry)) {
5024ab17 1733 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1734 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
6ad42535 1735 }
dea3101e
JB		 1736 break;
1737 case ELS_CMD_LOGO:
2e0fef85 1738 if (!lpfc_issue_els_logo(vport, ndlp, retry)) {
5024ab17 1739 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1740 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
6ad42535 1741 }
dea3101e 1742 break;
92d7f7b0
JS		 1743 case ELS_CMD_FDISC:
1744 lpfc_issue_els_fdisc(vport, ndlp, retry);
1745 break;
dea3101e
JB		 1746 }
1747 return;
1748}
1749
1750static int
2e0fef85
JS		 1751lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1752 struct lpfc_iocbq *rspiocb)
dea3101e 1753{
2e0fef85
JS		 1754 struct lpfc_vport *vport = cmdiocb->vport;
1755 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1756 IOCB_t *irsp = &rspiocb->iocb;
1757 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1758 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
dea3101e
JB		 1759 uint32_t *elscmd;
1760 struct ls_rjt stat;
2e0fef85
JS		 1761 int retry = 0, maxretry = lpfc_max_els_tries, delay = 0;
1762 uint32_t cmd = 0;
488d1469 1763 uint32_t did;
dea3101e 1764
488d1469 1765
dea3101e
JB		 1766 /* Note: context2 may be 0 for internal driver abort
1767 * of delays ELS command.
1768 */
1769
1770 if (pcmd && pcmd->virt) {
1771 elscmd = (uint32_t *) (pcmd->virt);
1772 cmd = *elscmd++;
1773 }
1774
329f9bc7 1775 if (ndlp)
488d1469
JS		 1776 did = ndlp->nlp_DID;
1777 else {
1778 /* We should only hit this case for retrying PLOGI */
1779 did = irsp->un.elsreq64.remoteID;
2e0fef85 1780 ndlp = lpfc_findnode_did(vport, did);
488d1469
JS		 1781 if (!ndlp && (cmd != ELS_CMD_PLOGI))
1782 return 1;
1783 }
1784
858c9f6c
JS		 1785 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1786 "Retry ELS: wd7:x%x wd4:x%x did:x%x",
1787 *(((uint32_t *) irsp) + 7), irsp->un.ulpWord[4], ndlp->nlp_DID);
1788
dea3101e
JB		 1789 switch (irsp->ulpStatus) {
1790 case IOSTAT_FCP_RSP_ERROR:
1791 case IOSTAT_REMOTE_STOP:
1792 break;
1793
1794 case IOSTAT_LOCAL_REJECT:
1795 switch ((irsp->un.ulpWord[4] & 0xff)) {
1796 case IOERR_LOOP_OPEN_FAILURE:
2e0fef85 1797 if (cmd == ELS_CMD_PLOGI && cmdiocb->retry == 0)
92d7f7b0 1798 delay = 1000;
dea3101e
JB		 1799 retry = 1;
1800 break;
1801
92d7f7b0
JS		 1802 case IOERR_ILLEGAL_COMMAND:
1803 if ((phba->sli3_options & LPFC_SLI3_VPORT_TEARDOWN) &&
1804 (cmd == ELS_CMD_FDISC)) {
e8b62011
JS		 1805 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1806 "0124 FDISC failed (3/6) "
1807 "retrying...\n");
92d7f7b0
JS		 1808 lpfc_mbx_unreg_vpi(vport);
1809 retry = 1;
51ef4c26
JS		 1810 /* FDISC retry policy */
1811 maxretry = 48;
1812 if (cmdiocb->retry >= 32)
1813 delay = 1000;
92d7f7b0
JS		 1814 }
1815 break;
1816
dea3101e 1817 case IOERR_NO_RESOURCES:
858c9f6c
JS		 1818 retry = 1;
1819 if (cmdiocb->retry > 100)
1820 delay = 100;
1821 maxretry = 250;
1822 break;
1823
1824 case IOERR_ILLEGAL_FRAME:
92d7f7b0 1825 delay = 100;
dea3101e
JB		 1826 retry = 1;
1827 break;
1828
858c9f6c 1829 case IOERR_SEQUENCE_TIMEOUT:
dea3101e
JB		 1830 case IOERR_INVALID_RPI:
1831 retry = 1;
1832 break;
1833 }
1834 break;
1835
1836 case IOSTAT_NPORT_RJT:
1837 case IOSTAT_FABRIC_RJT:
1838 if (irsp->un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
1839 retry = 1;
1840 break;
1841 }
1842 break;
1843
1844 case IOSTAT_NPORT_BSY:
1845 case IOSTAT_FABRIC_BSY:
1846 retry = 1;
1847 break;
1848
1849 case IOSTAT_LS_RJT:
1850 stat.un.lsRjtError = be32_to_cpu(irsp->un.ulpWord[4]);
1851 /* Added for Vendor specifc support
1852 * Just keep retrying for these Rsn / Exp codes
1853 */
1854 switch (stat.un.b.lsRjtRsnCode) {
1855 case LSRJT_UNABLE_TPC:
1856 if (stat.un.b.lsRjtRsnCodeExp ==
1857 LSEXP_CMD_IN_PROGRESS) {
1858 if (cmd == ELS_CMD_PLOGI) {
92d7f7b0 1859 delay = 1000;
dea3101e
JB		 1860 maxretry = 48;
1861 }
1862 retry = 1;
1863 break;
1864 }
1865 if (cmd == ELS_CMD_PLOGI) {
92d7f7b0 1866 delay = 1000;
dea3101e
JB		 1867 maxretry = lpfc_max_els_tries + 1;
1868 retry = 1;
1869 break;
1870 }
92d7f7b0
JS		 1871 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
1872 (cmd == ELS_CMD_FDISC) &&
1873 (stat.un.b.lsRjtRsnCodeExp == LSEXP_OUT_OF_RESOURCE)){
e8b62011
JS		 1874 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1875 "0125 FDISC Failed (x%x). "
1876 "Fabric out of resources\n",
1877 stat.un.lsRjtError);
92d7f7b0
JS		 1878 lpfc_vport_set_state(vport,
1879 FC_VPORT_NO_FABRIC_RSCS);
1880 }
dea3101e
JB		 1881 break;
1882
1883 case LSRJT_LOGICAL_BSY:
858c9f6c
JS		 1884 if ((cmd == ELS_CMD_PLOGI) ||
1885 (cmd == ELS_CMD_PRLI)) {
92d7f7b0 1886 delay = 1000;
dea3101e 1887 maxretry = 48;
92d7f7b0 1888 } else if (cmd == ELS_CMD_FDISC) {
51ef4c26
JS		 1889 /* FDISC retry policy */
1890 maxretry = 48;
1891 if (cmdiocb->retry >= 32)
1892 delay = 1000;
dea3101e
JB		 1893 }
1894 retry = 1;
1895 break;
92d7f7b0
JS		 1896
1897 case LSRJT_LOGICAL_ERR:
1898 case LSRJT_PROTOCOL_ERR:
1899 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
1900 (cmd == ELS_CMD_FDISC) &&
1901 ((stat.un.b.lsRjtRsnCodeExp == LSEXP_INVALID_PNAME) ||
1902 (stat.un.b.lsRjtRsnCodeExp == LSEXP_INVALID_NPORT_ID))
1903 ) {
e8b62011
JS		 1904 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1905 "0123 FDISC Failed (x%x). "
1906 "Fabric Detected Bad WWN\n",
1907 stat.un.lsRjtError);
92d7f7b0
JS		 1908 lpfc_vport_set_state(vport,
1909 FC_VPORT_FABRIC_REJ_WWN);
1910 }
1911 break;
dea3101e
JB		 1912 }
1913 break;
1914
1915 case IOSTAT_INTERMED_RSP:
1916 case IOSTAT_BA_RJT:
1917 break;
1918
1919 default:
1920 break;
1921 }
1922
488d1469 1923 if (did == FDMI_DID)
dea3101e 1924 retry = 1;
dea3101e
JB		 1925
1926 if ((++cmdiocb->retry) >= maxretry) {
1927 phba->fc_stat.elsRetryExceeded++;
1928 retry = 0;
1929 }
1930
ed957684
JS		 1931 if ((vport->load_flag & FC_UNLOADING) != 0)
1932 retry = 0;
1933
dea3101e
JB		 1934 if (retry) {
1935
1936 /* Retry ELS command <elsCmd> to remote NPORT <did> */
e8b62011
JS		 1937 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1938 "0107 Retry ELS command x%x to remote "
1939 "NPORT x%x Data: x%x x%x\n",
1940 cmd, did, cmdiocb->retry, delay);
dea3101e 1941
858c9f6c
JS		 1942 if (((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) &&
1943 ((irsp->ulpStatus != IOSTAT_LOCAL_REJECT) ||
1944 ((irsp->un.ulpWord[4] & 0xff) != IOERR_NO_RESOURCES))) {
1945 /* Don't reset timer for no resources */
1946
dea3101e 1947 /* If discovery / RSCN timer is running, reset it */
2e0fef85 1948 if (timer_pending(&vport->fc_disctmo) ||
92d7f7b0 1949 (vport->fc_flag & FC_RSCN_MODE))
2e0fef85 1950 lpfc_set_disctmo(vport);
dea3101e
JB		 1951 }
1952
1953 phba->fc_stat.elsXmitRetry++;
488d1469 1954 if (ndlp && delay) {
dea3101e
JB		 1955 phba->fc_stat.elsDelayRetry++;
1956 ndlp->nlp_retry = cmdiocb->retry;
1957
92d7f7b0
JS		 1958 /* delay is specified in milliseconds */
1959 mod_timer(&ndlp->nlp_delayfunc,
1960 jiffies + msecs_to_jiffies(delay));
2e0fef85 1961 spin_lock_irq(shost->host_lock);
dea3101e 1962 ndlp->nlp_flag |= NLP_DELAY_TMO;
2e0fef85 1963 spin_unlock_irq(shost->host_lock);
dea3101e 1964
5024ab17 1965 ndlp->nlp_prev_state = ndlp->nlp_state;
858c9f6c
JS		 1966 if (cmd == ELS_CMD_PRLI)
1967 lpfc_nlp_set_state(vport, ndlp,
1968 NLP_STE_REG_LOGIN_ISSUE);
1969 else
1970 lpfc_nlp_set_state(vport, ndlp,
1971 NLP_STE_NPR_NODE);
dea3101e
JB		 1972 ndlp->nlp_last_elscmd = cmd;
1973
c9f8735b 1974 return 1;
dea3101e
JB		 1975 }
1976 switch (cmd) {
1977 case ELS_CMD_FLOGI:
2e0fef85 1978 lpfc_issue_els_flogi(vport, ndlp, cmdiocb->retry);
c9f8735b 1979 return 1;
92d7f7b0
JS		 1980 case ELS_CMD_FDISC:
1981 lpfc_issue_els_fdisc(vport, ndlp, cmdiocb->retry);
1982 return 1;
dea3101e 1983 case ELS_CMD_PLOGI:
488d1469
JS		 1984 if (ndlp) {
1985 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1986 lpfc_nlp_set_state(vport, ndlp,
de0c5b32 1987 NLP_STE_PLOGI_ISSUE);
488d1469 1988 }
2e0fef85 1989 lpfc_issue_els_plogi(vport, did, cmdiocb->retry);
c9f8735b 1990 return 1;
dea3101e 1991 case ELS_CMD_ADISC:
5024ab17 1992 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 1993 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
1994 lpfc_issue_els_adisc(vport, ndlp, cmdiocb->retry);
c9f8735b 1995 return 1;
dea3101e 1996 case ELS_CMD_PRLI:
5024ab17 1997 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 1998 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
1999 lpfc_issue_els_prli(vport, ndlp, cmdiocb->retry);
c9f8735b 2000 return 1;
dea3101e 2001 case ELS_CMD_LOGO:
5024ab17 2002 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 2003 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
2004 lpfc_issue_els_logo(vport, ndlp, cmdiocb->retry);
c9f8735b 2005 return 1;
dea3101e
JB		 2006 }
2007 }
dea3101e 2008 /* No retry ELS command <elsCmd> to remote NPORT <did> */
a58cbd52
JS		 2009 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
2010 "0108 No retry ELS command x%x to remote "
2011 "NPORT x%x Retried:%d Error:x%x/%x\n",
2012 cmd, did, cmdiocb->retry, irsp->ulpStatus,
2013 irsp->un.ulpWord[4]);
c9f8735b 2014 return 0;
dea3101e
JB		 2015}
2016
2017int
329f9bc7 2018lpfc_els_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *elsiocb)
dea3101e
JB		 2019{
2020 struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
2021
329f9bc7
JS		 2022 if (elsiocb->context1) {
2023 lpfc_nlp_put(elsiocb->context1);
2024 elsiocb->context1 = NULL;
2025 }
dea3101e
JB		 2026 /* context2 = cmd, context2->next = rsp, context3 = bpl */
2027 if (elsiocb->context2) {
2028 buf_ptr1 = (struct lpfc_dmabuf *) elsiocb->context2;
2029 /* Free the response before processing the command. */
2030 if (!list_empty(&buf_ptr1->list)) {
2031 list_remove_head(&buf_ptr1->list, buf_ptr,
2032 struct lpfc_dmabuf,
2033 list);
2034 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
2035 kfree(buf_ptr);
2036 }
2037 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
2038 kfree(buf_ptr1);
2039 }
2040
2041 if (elsiocb->context3) {
2042 buf_ptr = (struct lpfc_dmabuf *) elsiocb->context3;
2043 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
2044 kfree(buf_ptr);
2045 }
604a3e30 2046 lpfc_sli_release_iocbq(phba, elsiocb);
dea3101e
JB		 2047 return 0;
2048}
2049
2050static void
2e0fef85
JS		 2051lpfc_cmpl_els_logo_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2052 struct lpfc_iocbq *rspiocb)
dea3101e 2053{
2e0fef85
JS		 2054 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
2055 struct lpfc_vport *vport = cmdiocb->vport;
858c9f6c
JS		 2056 IOCB_t *irsp;
2057
2058 irsp = &rspiocb->iocb;
2059 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2060 "ACC LOGO cmpl: status:x%x/x%x did:x%x",
2061 irsp->ulpStatus, irsp->un.ulpWord[4], ndlp->nlp_DID);
dea3101e 2062 /* ACC to LOGO completes to NPort <nlp_DID> */
e8b62011
JS		 2063 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2064 "0109 ACC to LOGO completes to NPort x%x "
2065 "Data: x%x x%x x%x\n",
2066 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2067 ndlp->nlp_rpi);
dea3101e
JB		 2068 switch (ndlp->nlp_state) {
2069 case NLP_STE_UNUSED_NODE: /* node is just allocated */
2e0fef85 2070 lpfc_drop_node(vport, ndlp);
dea3101e
JB		 2071 break;
2072 case NLP_STE_NPR_NODE: /* NPort Recovery mode */
2e0fef85 2073 lpfc_unreg_rpi(vport, ndlp);
dea3101e
JB		 2074 break;
2075 default:
2076 break;
2077 }
2078 lpfc_els_free_iocb(phba, cmdiocb);
2079 return;
2080}
2081
858c9f6c
JS		 2082void
2083lpfc_mbx_cmpl_dflt_rpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2084{
2085 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
2086 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
2087
2088 pmb->context1 = NULL;
2089 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2090 kfree(mp);
2091 mempool_free(pmb, phba->mbox_mem_pool);
2092 lpfc_nlp_put(ndlp);
2093 return;
2094}
2095
dea3101e 2096static void
858c9f6c 2097lpfc_cmpl_els_rsp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
329f9bc7 2098 struct lpfc_iocbq *rspiocb)
dea3101e 2099{
2e0fef85
JS		 2100 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
2101 struct lpfc_vport *vport = ndlp ? ndlp->vport : NULL;
2102 struct Scsi_Host *shost = vport ? lpfc_shost_from_vport(vport) : NULL;
33ccf8d1 2103 IOCB_t *irsp;
dea3101e 2104 LPFC_MBOXQ_t *mbox = NULL;
2e0fef85 2105 struct lpfc_dmabuf *mp = NULL;
dea3101e 2106
33ccf8d1
JS		 2107 irsp = &rspiocb->iocb;
2108
dea3101e
JB		 2109 if (cmdiocb->context_un.mbox)
2110 mbox = cmdiocb->context_un.mbox;
2111
dea3101e 2112 /* Check to see if link went down during discovery */
2e0fef85 2113 if (!ndlp || lpfc_els_chk_latt(vport)) {
dea3101e 2114 if (mbox) {
14691150
JS		 2115 mp = (struct lpfc_dmabuf *) mbox->context1;
2116 if (mp) {
2117 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2118 kfree(mp);
2119 }
329f9bc7 2120 mempool_free(mbox, phba->mbox_mem_pool);
dea3101e
JB		 2121 }
2122 goto out;
2123 }
2124
858c9f6c 2125 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
51ef4c26 2126 "ELS rsp cmpl: status:x%x/x%x did:x%x",
858c9f6c 2127 irsp->ulpStatus, irsp->un.ulpWord[4],
51ef4c26 2128 cmdiocb->iocb.un.elsreq64.remoteID);
dea3101e 2129 /* ELS response tag <ulpIoTag> completes */
e8b62011
JS		 2130 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2131 "0110 ELS response tag x%x completes "
2132 "Data: x%x x%x x%x x%x x%x x%x x%x\n",
2133 cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus,
2134 rspiocb->iocb.un.ulpWord[4], rspiocb->iocb.ulpTimeout,
2135 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2136 ndlp->nlp_rpi);
dea3101e
JB		 2137 if (mbox) {
2138 if ((rspiocb->iocb.ulpStatus == 0)
2139 && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) {
2e0fef85 2140 lpfc_unreg_rpi(vport, ndlp);
329f9bc7 2141 mbox->context2 = lpfc_nlp_get(ndlp);
2e0fef85 2142 mbox->vport = vport;
858c9f6c
JS		 2143 if (ndlp->nlp_flag & NLP_RM_DFLT_RPI) {
2144 mbox->mbox_flag |= LPFC_MBX_IMED_UNREG;
2145 mbox->mbox_cmpl = lpfc_mbx_cmpl_dflt_rpi;
2146 }
2147 else {
2148 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
2149 ndlp->nlp_prev_state = ndlp->nlp_state;
2150 lpfc_nlp_set_state(vport, ndlp,
2e0fef85 2151 NLP_STE_REG_LOGIN_ISSUE);
858c9f6c 2152 }
dea3101e
JB		 2153 if (lpfc_sli_issue_mbox(phba, mbox,
2154 (MBX_NOWAIT | MBX_STOP_IOCB))
2155 != MBX_NOT_FINISHED) {
2156 goto out;
2157 }
329f9bc7 2158 lpfc_nlp_put(ndlp);
dea3101e
JB		 2159 /* NOTE: we should have messages for unsuccessful
2160 reglogin */
dea3101e 2161 } else {
858c9f6c
JS		 2162 /* Do not drop node for lpfc_els_abort'ed ELS cmds */
2163 if (!lpfc_error_lost_link(irsp) &&
2164 ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
2165 lpfc_drop_node(vport, ndlp);
2166 ndlp = NULL;
dea3101e
JB		 2167 }
2168 }
14691150
JS		 2169 mp = (struct lpfc_dmabuf *) mbox->context1;
2170 if (mp) {
2171 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2172 kfree(mp);
2173 }
2174 mempool_free(mbox, phba->mbox_mem_pool);
dea3101e
JB		 2175 }
2176out:
2177 if (ndlp) {
2e0fef85 2178 spin_lock_irq(shost->host_lock);
858c9f6c 2179 ndlp->nlp_flag &= ~(NLP_ACC_REGLOGIN | NLP_RM_DFLT_RPI);
2e0fef85 2180 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 2181 }
2182 lpfc_els_free_iocb(phba, cmdiocb);
2183 return;
2184}
2185
2186int
2e0fef85
JS		 2187lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
2188 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp,
51ef4c26 2189 LPFC_MBOXQ_t *mbox)
dea3101e 2190{
2e0fef85
JS		 2191 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2192 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2193 IOCB_t *icmd;
2194 IOCB_t *oldcmd;
2195 struct lpfc_iocbq *elsiocb;
2196 struct lpfc_sli_ring *pring;
2197 struct lpfc_sli *psli;
2198 uint8_t *pcmd;
2199 uint16_t cmdsize;
2200 int rc;
82d9a2a2 2201 ELS_PKT *els_pkt_ptr;
dea3101e
JB		 2202
2203 psli = &phba->sli;
2204 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2205 oldcmd = &oldiocb->iocb;
2206
2207 switch (flag) {
2208 case ELS_CMD_ACC:
92d7f7b0 2209 cmdsize = sizeof(uint32_t);
2e0fef85
JS		 2210 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
2211 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
488d1469 2212 if (!elsiocb) {
2e0fef85 2213 spin_lock_irq(shost->host_lock);
5024ab17 2214 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
2e0fef85 2215 spin_unlock_irq(shost->host_lock);
c9f8735b 2216 return 1;
dea3101e 2217 }
2e0fef85 2218
dea3101e
JB		 2219 icmd = &elsiocb->iocb;
2220 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2221 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2222 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
92d7f7b0 2223 pcmd += sizeof(uint32_t);
858c9f6c
JS		 2224
2225 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2226 "Issue ACC: did:x%x flg:x%x",
2227 ndlp->nlp_DID, ndlp->nlp_flag, 0);
dea3101e
JB		 2228 break;
2229 case ELS_CMD_PLOGI:
92d7f7b0 2230 cmdsize = (sizeof(struct serv_parm) + sizeof(uint32_t));
2e0fef85
JS		 2231 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
2232 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
488d1469 2233 if (!elsiocb)
c9f8735b 2234 return 1;
488d1469 2235
dea3101e
JB		 2236 icmd = &elsiocb->iocb;
2237 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2238 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2239
2240 if (mbox)
2241 elsiocb->context_un.mbox = mbox;
2242
2243 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
92d7f7b0
JS		 2244 pcmd += sizeof(uint32_t);
2245 memcpy(pcmd, &vport->fc_sparam, sizeof(struct serv_parm));
858c9f6c
JS		 2246
2247 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2248 "Issue ACC PLOGI: did:x%x flg:x%x",
2249 ndlp->nlp_DID, ndlp->nlp_flag, 0);
dea3101e 2250 break;
82d9a2a2 2251 case ELS_CMD_PRLO:
92d7f7b0 2252 cmdsize = sizeof(uint32_t) + sizeof(PRLO);
2e0fef85 2253 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
82d9a2a2
JS		 2254 ndlp, ndlp->nlp_DID, ELS_CMD_PRLO);
2255 if (!elsiocb)
2256 return 1;
2257
2258 icmd = &elsiocb->iocb;
2259 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2260 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2261
2262 memcpy(pcmd, ((struct lpfc_dmabuf *) oldiocb->context2)->virt,
92d7f7b0 2263 sizeof(uint32_t) + sizeof(PRLO));
82d9a2a2
JS		 2264 *((uint32_t *) (pcmd)) = ELS_CMD_PRLO_ACC;
2265 els_pkt_ptr = (ELS_PKT *) pcmd;
2266 els_pkt_ptr->un.prlo.acceptRspCode = PRLO_REQ_EXECUTED;
858c9f6c
JS		 2267
2268 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2269 "Issue ACC PRLO: did:x%x flg:x%x",
2270 ndlp->nlp_DID, ndlp->nlp_flag, 0);
82d9a2a2 2271 break;
dea3101e 2272 default:
c9f8735b 2273 return 1;
dea3101e 2274 }
dea3101e 2275 /* Xmit ELS ACC response tag <ulpIoTag> */
e8b62011
JS		 2276 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2277 "0128 Xmit ELS ACC response tag x%x, XRI: x%x, "
2278 "DID: x%x, nlp_flag: x%x nlp_state: x%x RPI: x%x\n",
2279 elsiocb->iotag, elsiocb->iocb.ulpContext,
2280 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2281 ndlp->nlp_rpi);
dea3101e 2282 if (ndlp->nlp_flag & NLP_LOGO_ACC) {
2e0fef85 2283 spin_lock_irq(shost->host_lock);
c9f8735b 2284 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
2e0fef85 2285 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 2286 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc;
2287 } else {
858c9f6c 2288 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
dea3101e
JB		 2289 }
2290
2291 phba->fc_stat.elsXmitACC++;
dea3101e 2292 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
dea3101e
JB		 2293 if (rc == IOCB_ERROR) {
2294 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 2295 return 1;
dea3101e 2296 }
c9f8735b 2297 return 0;
dea3101e
JB		 2298}
2299
2300int
2e0fef85 2301lpfc_els_rsp_reject(struct lpfc_vport *vport, uint32_t rejectError,
858c9f6c
JS		 2302 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp,
2303 LPFC_MBOXQ_t *mbox)
dea3101e 2304{
2e0fef85 2305 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2306 IOCB_t *icmd;
2307 IOCB_t *oldcmd;
2308 struct lpfc_iocbq *elsiocb;
2309 struct lpfc_sli_ring *pring;
2310 struct lpfc_sli *psli;
2311 uint8_t *pcmd;
2312 uint16_t cmdsize;
2313 int rc;
2314
2315 psli = &phba->sli;
2316 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2317
92d7f7b0 2318 cmdsize = 2 * sizeof(uint32_t);
2e0fef85
JS		 2319 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2320 ndlp->nlp_DID, ELS_CMD_LS_RJT);
488d1469 2321 if (!elsiocb)
c9f8735b 2322 return 1;
dea3101e
JB		 2323
2324 icmd = &elsiocb->iocb;
2325 oldcmd = &oldiocb->iocb;
2326 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2327 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2328
2329 *((uint32_t *) (pcmd)) = ELS_CMD_LS_RJT;
92d7f7b0 2330 pcmd += sizeof(uint32_t);
dea3101e
JB		 2331 *((uint32_t *) (pcmd)) = rejectError;
2332
51ef4c26 2333 if (mbox)
858c9f6c 2334 elsiocb->context_un.mbox = mbox;
858c9f6c 2335
dea3101e 2336 /* Xmit ELS RJT <err> response tag <ulpIoTag> */
e8b62011
JS		 2337 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2338 "0129 Xmit ELS RJT x%x response tag x%x "
2339 "xri x%x, did x%x, nlp_flag x%x, nlp_state x%x, "
2340 "rpi x%x\n",
2341 rejectError, elsiocb->iotag,
2342 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2343 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
858c9f6c
JS		 2344 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2345 "Issue LS_RJT: did:x%x flg:x%x err:x%x",
2346 ndlp->nlp_DID, ndlp->nlp_flag, rejectError);
2347
dea3101e 2348 phba->fc_stat.elsXmitLSRJT++;
858c9f6c 2349 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
dea3101e 2350 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
51ef4c26
JS		 2351
2352 /* If the node is in the UNUSED state, and we are sending
2353 * a reject, we are done with it. Release driver reference
2354 * count here. The outstanding els will release its reference on
2355 * completion and the node can be freed then.
2356 */
2357 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
2358 lpfc_nlp_put(ndlp);
2359
dea3101e
JB		 2360 if (rc == IOCB_ERROR) {
2361 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 2362 return 1;
dea3101e 2363 }
c9f8735b 2364 return 0;
dea3101e
JB		 2365}
2366
2367int
2e0fef85
JS		 2368lpfc_els_rsp_adisc_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
2369 struct lpfc_nodelist *ndlp)
dea3101e 2370{
2e0fef85
JS		 2371 struct lpfc_hba *phba = vport->phba;
2372 struct lpfc_sli *psli = &phba->sli;
2373 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
dea3101e 2374 ADISC *ap;
2e0fef85 2375 IOCB_t *icmd, *oldcmd;
dea3101e 2376 struct lpfc_iocbq *elsiocb;
dea3101e
JB		 2377 uint8_t *pcmd;
2378 uint16_t cmdsize;
2379 int rc;
2380
92d7f7b0 2381 cmdsize = sizeof(uint32_t) + sizeof(ADISC);
2e0fef85
JS		 2382 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2383 ndlp->nlp_DID, ELS_CMD_ACC);
488d1469 2384 if (!elsiocb)
c9f8735b 2385 return 1;
dea3101e 2386
5b8bd0c9
JS		 2387 icmd = &elsiocb->iocb;
2388 oldcmd = &oldiocb->iocb;
2389 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2390
dea3101e 2391 /* Xmit ADISC ACC response tag <ulpIoTag> */
e8b62011
JS		 2392 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2393 "0130 Xmit ADISC ACC response iotag x%x xri: "
2394 "x%x, did x%x, nlp_flag x%x, nlp_state x%x rpi x%x\n",
2395 elsiocb->iotag, elsiocb->iocb.ulpContext,
2396 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2397 ndlp->nlp_rpi);
dea3101e
JB		 2398 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2399
2400 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
92d7f7b0 2401 pcmd += sizeof(uint32_t);
dea3101e
JB		 2402
2403 ap = (ADISC *) (pcmd);
2404 ap->hardAL_PA = phba->fc_pref_ALPA;
92d7f7b0
JS		 2405 memcpy(&ap->portName, &vport->fc_portname, sizeof(struct lpfc_name));
2406 memcpy(&ap->nodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
2e0fef85 2407 ap->DID = be32_to_cpu(vport->fc_myDID);
dea3101e 2408
858c9f6c
JS		 2409 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2410 "Issue ACC ADISC: did:x%x flg:x%x",
2411 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2412
dea3101e 2413 phba->fc_stat.elsXmitACC++;
858c9f6c 2414 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
dea3101e 2415 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
dea3101e
JB		 2416 if (rc == IOCB_ERROR) {
2417 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 2418 return 1;
dea3101e 2419 }
c9f8735b 2420 return 0;
dea3101e
JB		 2421}
2422
2423int
2e0fef85 2424lpfc_els_rsp_prli_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
5b8bd0c9 2425 struct lpfc_nodelist *ndlp)
dea3101e 2426{
2e0fef85 2427 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2428 PRLI *npr;
2429 lpfc_vpd_t *vpd;
2430 IOCB_t *icmd;
2431 IOCB_t *oldcmd;
2432 struct lpfc_iocbq *elsiocb;
2433 struct lpfc_sli_ring *pring;
2434 struct lpfc_sli *psli;
2435 uint8_t *pcmd;
2436 uint16_t cmdsize;
2437 int rc;
2438
2439 psli = &phba->sli;
2440 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2441
92d7f7b0 2442 cmdsize = sizeof(uint32_t) + sizeof(PRLI);
2e0fef85 2443 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
92d7f7b0 2444 ndlp->nlp_DID, (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK)));
c9f8735b
JW		 2445 if (!elsiocb)
2446 return 1;
dea3101e 2447
5b8bd0c9
JS		 2448 icmd = &elsiocb->iocb;
2449 oldcmd = &oldiocb->iocb;
2450 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
dea3101e 2451 /* Xmit PRLI ACC response tag <ulpIoTag> */
e8b62011
JS		 2452 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2453 "0131 Xmit PRLI ACC response tag x%x xri x%x, "
2454 "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
2455 elsiocb->iotag, elsiocb->iocb.ulpContext,
2456 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2457 ndlp->nlp_rpi);
dea3101e
JB		 2458 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2459
2460 *((uint32_t *) (pcmd)) = (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK));
92d7f7b0 2461 pcmd += sizeof(uint32_t);
dea3101e
JB		 2462
2463 /* For PRLI, remainder of payload is PRLI parameter page */
92d7f7b0 2464 memset(pcmd, 0, sizeof(PRLI));
dea3101e
JB		 2465
2466 npr = (PRLI *) pcmd;
2467 vpd = &phba->vpd;
2468 /*
2469 * If our firmware version is 3.20 or later,
2470 * set the following bits for FC-TAPE support.
2471 */
2472 if (vpd->rev.feaLevelHigh >= 0x02) {
2473 npr->ConfmComplAllowed = 1;
2474 npr->Retry = 1;
2475 npr->TaskRetryIdReq = 1;
2476 }
2477
2478 npr->acceptRspCode = PRLI_REQ_EXECUTED;
2479 npr->estabImagePair = 1;
2480 npr->readXferRdyDis = 1;
2481 npr->ConfmComplAllowed = 1;
2482
2483 npr->prliType = PRLI_FCP_TYPE;
2484 npr->initiatorFunc = 1;
2485
858c9f6c
JS		 2486 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2487 "Issue ACC PRLI: did:x%x flg:x%x",
2488 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2489
dea3101e 2490 phba->fc_stat.elsXmitACC++;
858c9f6c 2491 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
dea3101e 2492
dea3101e 2493 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
dea3101e
JB		 2494 if (rc == IOCB_ERROR) {
2495 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 2496 return 1;
dea3101e 2497 }
c9f8735b 2498 return 0;
dea3101e
JB		 2499}
2500
2501static int
2e0fef85 2502lpfc_els_rsp_rnid_acc(struct lpfc_vport *vport, uint8_t format,
329f9bc7 2503 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
dea3101e 2504{
2e0fef85 2505 struct lpfc_hba *phba = vport->phba;
dea3101e 2506 RNID *rn;
2e0fef85 2507 IOCB_t *icmd, *oldcmd;
dea3101e
JB		 2508 struct lpfc_iocbq *elsiocb;
2509 struct lpfc_sli_ring *pring;
2510 struct lpfc_sli *psli;
2511 uint8_t *pcmd;
2512 uint16_t cmdsize;
2513 int rc;
2514
2515 psli = &phba->sli;
2516 pring = &psli->ring[LPFC_ELS_RING];
2517
92d7f7b0
JS		 2518 cmdsize = sizeof(uint32_t) + sizeof(uint32_t)
2519 + (2 * sizeof(struct lpfc_name));
dea3101e 2520 if (format)
92d7f7b0 2521 cmdsize += sizeof(RNID_TOP_DISC);
dea3101e 2522
2e0fef85
JS		 2523 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2524 ndlp->nlp_DID, ELS_CMD_ACC);
488d1469 2525 if (!elsiocb)
c9f8735b 2526 return 1;
dea3101e 2527
5b8bd0c9
JS		 2528 icmd = &elsiocb->iocb;
2529 oldcmd = &oldiocb->iocb;
2530 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
dea3101e 2531 /* Xmit RNID ACC response tag <ulpIoTag> */
e8b62011
JS		 2532 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2533 "0132 Xmit RNID ACC response tag x%x xri x%x\n",
2534 elsiocb->iotag, elsiocb->iocb.ulpContext);
dea3101e 2535 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
dea3101e 2536 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
92d7f7b0 2537 pcmd += sizeof(uint32_t);
dea3101e 2538
92d7f7b0 2539 memset(pcmd, 0, sizeof(RNID));
dea3101e
JB		 2540 rn = (RNID *) (pcmd);
2541 rn->Format = format;
92d7f7b0
JS		 2542 rn->CommonLen = (2 * sizeof(struct lpfc_name));
2543 memcpy(&rn->portName, &vport->fc_portname, sizeof(struct lpfc_name));
2544 memcpy(&rn->nodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
dea3101e
JB		 2545 switch (format) {
2546 case 0:
2547 rn->SpecificLen = 0;
2548 break;
2549 case RNID_TOPOLOGY_DISC:
92d7f7b0 2550 rn->SpecificLen = sizeof(RNID_TOP_DISC);
dea3101e 2551 memcpy(&rn->un.topologyDisc.portName,
92d7f7b0 2552 &vport->fc_portname, sizeof(struct lpfc_name));
dea3101e
JB		 2553 rn->un.topologyDisc.unitType = RNID_HBA;
2554 rn->un.topologyDisc.physPort = 0;
2555 rn->un.topologyDisc.attachedNodes = 0;
2556 break;
2557 default:
2558 rn->CommonLen = 0;
2559 rn->SpecificLen = 0;
2560 break;
2561 }
2562
858c9f6c
JS		 2563 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2564 "Issue ACC RNID: did:x%x flg:x%x",
2565 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2566
dea3101e 2567 phba->fc_stat.elsXmitACC++;
858c9f6c 2568 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
329f9bc7 2569 lpfc_nlp_put(ndlp);
dea3101e
JB		 2570 elsiocb->context1 = NULL; /* Don't need ndlp for cmpl,
2571 * it could be freed */
2572
dea3101e 2573 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
dea3101e
JB		 2574 if (rc == IOCB_ERROR) {
2575 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 2576 return 1;
dea3101e 2577 }
c9f8735b 2578 return 0;
dea3101e
JB		 2579}
2580
2581int
2e0fef85 2582lpfc_els_disc_adisc(struct lpfc_vport *vport)
dea3101e 2583{
2e0fef85 2584 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e 2585 struct lpfc_nodelist *ndlp, *next_ndlp;
2e0fef85 2586 int sentadisc = 0;
dea3101e 2587
685f0bf7 2588 /* go thru NPR nodes and issue any remaining ELS ADISCs */
2e0fef85 2589 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
685f0bf7
JS		 2590 if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
2591 (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
2592 (ndlp->nlp_flag & NLP_NPR_ADISC) != 0) {
2e0fef85 2593 spin_lock_irq(shost->host_lock);
685f0bf7 2594 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2e0fef85 2595 spin_unlock_irq(shost->host_lock);
685f0bf7 2596 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 2597 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
2598 lpfc_issue_els_adisc(vport, ndlp, 0);
685f0bf7 2599 sentadisc++;
2e0fef85
JS		 2600 vport->num_disc_nodes++;
2601 if (vport->num_disc_nodes >=
3de2a653 2602 vport->cfg_discovery_threads) {
2e0fef85
JS		 2603 spin_lock_irq(shost->host_lock);
2604 vport->fc_flag |= FC_NLP_MORE;
2605 spin_unlock_irq(shost->host_lock);
685f0bf7 2606 break;
dea3101e
JB		 2607 }
2608 }
2609 }
2610 if (sentadisc == 0) {
2e0fef85
JS		 2611 spin_lock_irq(shost->host_lock);
2612 vport->fc_flag &= ~FC_NLP_MORE;
2613 spin_unlock_irq(shost->host_lock);
dea3101e 2614 }
2fe165b6 2615 return sentadisc;
dea3101e
JB		 2616}
2617
2618int
2e0fef85 2619lpfc_els_disc_plogi(struct lpfc_vport *vport)
dea3101e 2620{
2e0fef85 2621 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e 2622 struct lpfc_nodelist *ndlp, *next_ndlp;
2e0fef85 2623 int sentplogi = 0;
dea3101e 2624
2e0fef85
JS		 2625 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
2626 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
685f0bf7
JS		 2627 if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
2628 (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
2629 (ndlp->nlp_flag & NLP_DELAY_TMO) == 0 &&
2630 (ndlp->nlp_flag & NLP_NPR_ADISC) == 0) {
2631 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 2632 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2633 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
685f0bf7 2634 sentplogi++;
2e0fef85
JS		 2635 vport->num_disc_nodes++;
2636 if (vport->num_disc_nodes >=
3de2a653 2637 vport->cfg_discovery_threads) {
2e0fef85
JS		 2638 spin_lock_irq(shost->host_lock);
2639 vport->fc_flag |= FC_NLP_MORE;
2640 spin_unlock_irq(shost->host_lock);
685f0bf7 2641 break;
dea3101e
JB		 2642 }
2643 }
2644 }
2645 if (sentplogi == 0) {
2e0fef85
JS		 2646 spin_lock_irq(shost->host_lock);
2647 vport->fc_flag &= ~FC_NLP_MORE;
2648 spin_unlock_irq(shost->host_lock);
dea3101e 2649 }
2fe165b6 2650 return sentplogi;
dea3101e
JB		 2651}
2652
92d7f7b0 2653void
2e0fef85 2654lpfc_els_flush_rscn(struct lpfc_vport *vport)
dea3101e 2655{
2e0fef85
JS		 2656 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2657 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2658 int i;
2659
2e0fef85 2660 for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
92d7f7b0 2661 lpfc_in_buf_free(phba, vport->fc_rscn_id_list[i]);
2e0fef85 2662 vport->fc_rscn_id_list[i] = NULL;
dea3101e 2663 }
2e0fef85
JS		 2664 spin_lock_irq(shost->host_lock);
2665 vport->fc_rscn_id_cnt = 0;
2666 vport->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY);
2667 spin_unlock_irq(shost->host_lock);
2668 lpfc_can_disctmo(vport);
dea3101e
JB		 2669}
2670
2671int
2e0fef85 2672lpfc_rscn_payload_check(struct lpfc_vport *vport, uint32_t did)
dea3101e
JB		 2673{
2674 D_ID ns_did;
2675 D_ID rscn_did;
dea3101e 2676 uint32_t *lp;
92d7f7b0 2677 uint32_t payload_len, i;
dea3101e
JB		 2678
2679 ns_did.un.word = did;
dea3101e
JB		 2680
2681 /* Never match fabric nodes for RSCNs */
2682 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
2e0fef85 2683 return 0;
dea3101e
JB		 2684
2685 /* If we are doing a FULL RSCN rediscovery, match everything */
2e0fef85 2686 if (vport->fc_flag & FC_RSCN_DISCOVERY)
c9f8735b 2687 return did;
dea3101e 2688
2e0fef85 2689 for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
92d7f7b0
JS		 2690 lp = vport->fc_rscn_id_list[i]->virt;
2691 payload_len = be32_to_cpu(*lp++ & ~ELS_CMD_MASK);
2692 payload_len -= sizeof(uint32_t); /* take off word 0 */
dea3101e 2693 while (payload_len) {
92d7f7b0
JS		 2694 rscn_did.un.word = be32_to_cpu(*lp++);
2695 payload_len -= sizeof(uint32_t);
dea3101e
JB		 2696 switch (rscn_did.un.b.resv) {
2697 case 0: /* Single N_Port ID effected */
2e0fef85 2698 if (ns_did.un.word == rscn_did.un.word)
92d7f7b0 2699 return did;
dea3101e
JB		 2700 break;
2701 case 1: /* Whole N_Port Area effected */
2702 if ((ns_did.un.b.domain == rscn_did.un.b.domain)
2703 && (ns_did.un.b.area == rscn_did.un.b.area))
92d7f7b0 2704 return did;
dea3101e
JB		 2705 break;
2706 case 2: /* Whole N_Port Domain effected */
2707 if (ns_did.un.b.domain == rscn_did.un.b.domain)
92d7f7b0 2708 return did;
dea3101e
JB		 2709 break;
2710 default:
2e0fef85 2711 /* Unknown Identifier in RSCN node */
e8b62011
JS		 2712 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2713 "0217 Unknown Identifier in "
2714 "RSCN payload Data: x%x\n",
2715 rscn_did.un.word);
92d7f7b0
JS		 2716 case 3: /* Whole Fabric effected */
2717 return did;
dea3101e
JB		 2718 }
2719 }
92d7f7b0
JS		 2720 }
2721 return 0;
dea3101e
JB		 2722}
2723
2724static int
2e0fef85 2725lpfc_rscn_recovery_check(struct lpfc_vport *vport)
dea3101e 2726{
685f0bf7 2727 struct lpfc_nodelist *ndlp = NULL;
dea3101e
JB		 2728
2729 /* Look at all nodes effected by pending RSCNs and move
685f0bf7 2730 * them to NPR state.
dea3101e 2731 */
dea3101e 2732
2e0fef85 2733 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
685f0bf7 2734 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE ||
2e0fef85 2735 lpfc_rscn_payload_check(vport, ndlp->nlp_DID) == 0)
685f0bf7 2736 continue;
dea3101e 2737
2e0fef85 2738 lpfc_disc_state_machine(vport, ndlp, NULL,
92d7f7b0 2739 NLP_EVT_DEVICE_RECOVERY);
5024ab17 2740
685f0bf7
JS		 2741 /*
2742 * Make sure NLP_DELAY_TMO is NOT running after a device
2743 * recovery event.
2744 */
2745 if (ndlp->nlp_flag & NLP_DELAY_TMO)
2e0fef85 2746 lpfc_cancel_retry_delay_tmo(vport, ndlp);
dea3101e 2747 }
685f0bf7 2748
c9f8735b 2749 return 0;
dea3101e
JB		 2750}
2751
2752static int
2e0fef85 2753lpfc_els_rcv_rscn(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
51ef4c26 2754 struct lpfc_nodelist *ndlp)
dea3101e 2755{
2e0fef85
JS		 2756 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2757 struct lpfc_hba *phba = vport->phba;
dea3101e 2758 struct lpfc_dmabuf *pcmd;
92d7f7b0 2759 uint32_t *lp, *datap;
dea3101e 2760 IOCB_t *icmd;
92d7f7b0
JS		 2761 uint32_t payload_len, length, nportid, *cmd;
2762 int rscn_cnt = vport->fc_rscn_id_cnt;
2763 int rscn_id = 0, hba_id = 0;
d2873e4c 2764 int i;
dea3101e
JB		 2765
2766 icmd = &cmdiocb->iocb;
2767 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2768 lp = (uint32_t *) pcmd->virt;
2769
92d7f7b0
JS		 2770 payload_len = be32_to_cpu(*lp++ & ~ELS_CMD_MASK);
2771 payload_len -= sizeof(uint32_t); /* take off word 0 */
dea3101e 2772 /* RSCN received */
e8b62011
JS		 2773 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2774 "0214 RSCN received Data: x%x x%x x%x x%x\n",
2775 vport->fc_flag, payload_len, *lp, rscn_cnt);
d2873e4c 2776 for (i = 0; i < payload_len/sizeof(uint32_t); i++)
2e0fef85 2777 fc_host_post_event(shost, fc_get_event_number(),
d2873e4c
JS		 2778 FCH_EVT_RSCN, lp[i]);
2779
dea3101e
JB		 2780 /* If we are about to begin discovery, just ACC the RSCN.
2781 * Discovery processing will satisfy it.
2782 */
2e0fef85 2783 if (vport->port_state <= LPFC_NS_QRY) {
858c9f6c
JS		 2784 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
2785 "RCV RSCN ignore: did:x%x/ste:x%x flg:x%x",
2786 ndlp->nlp_DID, vport->port_state, ndlp->nlp_flag);
2787
51ef4c26 2788 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
c9f8735b 2789 return 0;
dea3101e
JB		 2790 }
2791
92d7f7b0
JS		 2792 /* If this RSCN just contains NPortIDs for other vports on this HBA,
2793 * just ACC and ignore it.
2794 */
2795 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
3de2a653 2796 !(vport->cfg_peer_port_login)) {
92d7f7b0
JS		 2797 i = payload_len;
2798 datap = lp;
2799 while (i > 0) {
2800 nportid = *datap++;
2801 nportid = ((be32_to_cpu(nportid)) & Mask_DID);
2802 i -= sizeof(uint32_t);
2803 rscn_id++;
549e55cd
JS		 2804 if (lpfc_find_vport_by_did(phba, nportid))
2805 hba_id++;
92d7f7b0
JS		 2806 }
2807 if (rscn_id == hba_id) {
2808 /* ALL NPortIDs in RSCN are on HBA */
e8b62011
JS		 2809 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2810 "0214 Ignore RSCN "
2811 "Data: x%x x%x x%x x%x\n",
2812 vport->fc_flag, payload_len,
2813 *lp, rscn_cnt);
858c9f6c
JS		 2814 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
2815 "RCV RSCN vport: did:x%x/ste:x%x flg:x%x",
2816 ndlp->nlp_DID, vport->port_state,
2817 ndlp->nlp_flag);
2818
92d7f7b0 2819 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb,
51ef4c26 2820 ndlp, NULL);
92d7f7b0
JS		 2821 return 0;
2822 }
2823 }
2824
dea3101e
JB		 2825 /* If we are already processing an RSCN, save the received
2826 * RSCN payload buffer, cmdiocb->context2 to process later.
2827 */
2e0fef85 2828 if (vport->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) {
858c9f6c
JS		 2829 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
2830 "RCV RSCN defer: did:x%x/ste:x%x flg:x%x",
2831 ndlp->nlp_DID, vport->port_state, ndlp->nlp_flag);
2832
92d7f7b0
JS		 2833 vport->fc_flag |= FC_RSCN_DEFERRED;
2834 if ((rscn_cnt < FC_MAX_HOLD_RSCN) &&
2e0fef85
JS		 2835 !(vport->fc_flag & FC_RSCN_DISCOVERY)) {
2836 spin_lock_irq(shost->host_lock);
2837 vport->fc_flag |= FC_RSCN_MODE;
2838 spin_unlock_irq(shost->host_lock);
92d7f7b0
JS		 2839 if (rscn_cnt) {
2840 cmd = vport->fc_rscn_id_list[rscn_cnt-1]->virt;
2841 length = be32_to_cpu(*cmd & ~ELS_CMD_MASK);
2842 }
2843 if ((rscn_cnt) &&
2844 (payload_len + length <= LPFC_BPL_SIZE)) {
2845 *cmd &= ELS_CMD_MASK;
2846 *cmd |= be32_to_cpu(payload_len + length);
2847 memcpy(((uint8_t *)cmd) + length, lp,
2848 payload_len);
2849 } else {
2850 vport->fc_rscn_id_list[rscn_cnt] = pcmd;
2851 vport->fc_rscn_id_cnt++;
2852 /* If we zero, cmdiocb->context2, the calling
2853 * routine will not try to free it.
2854 */
2855 cmdiocb->context2 = NULL;
2856 }
dea3101e
JB		 2857
2858 /* Deferred RSCN */
e8b62011
JS		 2859 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2860 "0235 Deferred RSCN "
2861 "Data: x%x x%x x%x\n",
2862 vport->fc_rscn_id_cnt, vport->fc_flag,
2863 vport->port_state);
dea3101e 2864 } else {
2e0fef85
JS		 2865 spin_lock_irq(shost->host_lock);
2866 vport->fc_flag |= FC_RSCN_DISCOVERY;
2867 spin_unlock_irq(shost->host_lock);
dea3101e 2868 /* ReDiscovery RSCN */
e8b62011
JS		 2869 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2870 "0234 ReDiscovery RSCN "
2871 "Data: x%x x%x x%x\n",
2872 vport->fc_rscn_id_cnt, vport->fc_flag,
2873 vport->port_state);
dea3101e
JB		 2874 }
2875 /* Send back ACC */
51ef4c26 2876 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
dea3101e
JB		 2877
2878 /* send RECOVERY event for ALL nodes that match RSCN payload */
2e0fef85 2879 lpfc_rscn_recovery_check(vport);
92d7f7b0 2880 vport->fc_flag &= ~FC_RSCN_DEFERRED;
c9f8735b 2881 return 0;
dea3101e
JB		 2882 }
2883
858c9f6c
JS		 2884 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
2885 "RCV RSCN: did:x%x/ste:x%x flg:x%x",
2886 ndlp->nlp_DID, vport->port_state, ndlp->nlp_flag);
2887
2e0fef85
JS		 2888 spin_lock_irq(shost->host_lock);
2889 vport->fc_flag |= FC_RSCN_MODE;
2890 spin_unlock_irq(shost->host_lock);
2891 vport->fc_rscn_id_list[vport->fc_rscn_id_cnt++] = pcmd;
dea3101e
JB		 2892 /*
2893 * If we zero, cmdiocb->context2, the calling routine will
2894 * not try to free it.
2895 */
2896 cmdiocb->context2 = NULL;
2897
2e0fef85 2898 lpfc_set_disctmo(vport);
dea3101e
JB		 2899
2900 /* Send back ACC */
51ef4c26 2901 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
dea3101e
JB		 2902
2903 /* send RECOVERY event for ALL nodes that match RSCN payload */
2e0fef85 2904 lpfc_rscn_recovery_check(vport);
dea3101e 2905
2e0fef85 2906 return lpfc_els_handle_rscn(vport);
dea3101e
JB		 2907}
2908
2909int
2e0fef85 2910lpfc_els_handle_rscn(struct lpfc_vport *vport)
dea3101e
JB		 2911{
2912 struct lpfc_nodelist *ndlp;
2e0fef85 2913 struct lpfc_hba *phba = vport->phba;
dea3101e 2914
92d7f7b0
JS		 2915 /* Ignore RSCN if the port is being torn down. */
2916 if (vport->load_flag & FC_UNLOADING) {
2917 lpfc_els_flush_rscn(vport);
2918 return 0;
2919 }
2920
dea3101e 2921 /* Start timer for RSCN processing */
2e0fef85 2922 lpfc_set_disctmo(vport);
dea3101e
JB		 2923
2924 /* RSCN processed */
e8b62011
JS		 2925 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2926 "0215 RSCN processed Data: x%x x%x x%x x%x\n",
2927 vport->fc_flag, 0, vport->fc_rscn_id_cnt,
2928 vport->port_state);
dea3101e
JB		 2929
2930 /* To process RSCN, first compare RSCN data with NameServer */
2e0fef85
JS		 2931 vport->fc_ns_retry = 0;
2932 ndlp = lpfc_findnode_did(vport, NameServer_DID);
685f0bf7 2933 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
dea3101e 2934 /* Good ndlp, issue CT Request to NameServer */
92d7f7b0 2935 if (lpfc_ns_cmd(vport, SLI_CTNS_GID_FT, 0, 0) == 0)
dea3101e
JB		 2936 /* Wait for NameServer query cmpl before we can
2937 continue */
c9f8735b 2938 return 1;
dea3101e
JB		 2939 } else {
2940 /* If login to NameServer does not exist, issue one */
2941 /* Good status, issue PLOGI to NameServer */
2e0fef85
JS		 2942 ndlp = lpfc_findnode_did(vport, NameServer_DID);
2943 if (ndlp)
dea3101e
JB		 2944 /* Wait for NameServer login cmpl before we can
2945 continue */
c9f8735b 2946 return 1;
2e0fef85 2947
c9f8735b
JW		 2948 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
2949 if (!ndlp) {
2e0fef85 2950 lpfc_els_flush_rscn(vport);
c9f8735b 2951 return 0;
dea3101e 2952 } else {
2e0fef85 2953 lpfc_nlp_init(vport, ndlp, NameServer_DID);
dea3101e 2954 ndlp->nlp_type |= NLP_FABRIC;
5024ab17 2955 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 2956 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2957 lpfc_issue_els_plogi(vport, NameServer_DID, 0);
dea3101e
JB		 2958 /* Wait for NameServer login cmpl before we can
2959 continue */
c9f8735b 2960 return 1;
dea3101e
JB		 2961 }
2962 }
2963
2e0fef85 2964 lpfc_els_flush_rscn(vport);
c9f8735b 2965 return 0;
dea3101e
JB		 2966}
2967
2968static int
2e0fef85 2969lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
51ef4c26 2970 struct lpfc_nodelist *ndlp)
dea3101e 2971{
2e0fef85
JS		 2972 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2973 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2974 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2975 uint32_t *lp = (uint32_t *) pcmd->virt;
2976 IOCB_t *icmd = &cmdiocb->iocb;
2977 struct serv_parm *sp;
2978 LPFC_MBOXQ_t *mbox;
2979 struct ls_rjt stat;
2980 uint32_t cmd, did;
2981 int rc;
2982
2983 cmd = *lp++;
2984 sp = (struct serv_parm *) lp;
2985
2986 /* FLOGI received */
2987
2e0fef85 2988 lpfc_set_disctmo(vport);
dea3101e
JB		 2989
2990 if (phba->fc_topology == TOPOLOGY_LOOP) {
2991 /* We should never receive a FLOGI in loop mode, ignore it */
2992 did = icmd->un.elsreq64.remoteID;
2993
2994 /* An FLOGI ELS command <elsCmd> was received from DID <did> in
2995 Loop Mode */
e8b62011
JS		 2996 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
2997 "0113 An FLOGI ELS command x%x was "
2998 "received from DID x%x in Loop Mode\n",
2999 cmd, did);
c9f8735b 3000 return 1;
dea3101e
JB		 3001 }
3002
3003 did = Fabric_DID;
3004
2e0fef85 3005 if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3))) {
dea3101e
JB		 3006 /* For a FLOGI we accept, then if our portname is greater
3007 * then the remote portname we initiate Nport login.
3008 */
3009
2e0fef85 3010 rc = memcmp(&vport->fc_portname, &sp->portName,
92d7f7b0 3011 sizeof(struct lpfc_name));
dea3101e
JB		 3012
3013 if (!rc) {
2e0fef85
JS		 3014 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3015 if (!mbox)
c9f8735b 3016 return 1;
2e0fef85 3017
dea3101e
JB		 3018 lpfc_linkdown(phba);
3019 lpfc_init_link(phba, mbox,
3020 phba->cfg_topology,
3021 phba->cfg_link_speed);
3022 mbox->mb.un.varInitLnk.lipsr_AL_PA = 0;
3023 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
ed957684 3024 mbox->vport = vport;
dea3101e
JB		 3025 rc = lpfc_sli_issue_mbox
3026 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB));
5b8bd0c9 3027 lpfc_set_loopback_flag(phba);
dea3101e 3028 if (rc == MBX_NOT_FINISHED) {
329f9bc7 3029 mempool_free(mbox, phba->mbox_mem_pool);
dea3101e 3030 }
c9f8735b 3031 return 1;
2fe165b6 3032 } else if (rc > 0) { /* greater than */
2e0fef85
JS		 3033 spin_lock_irq(shost->host_lock);
3034 vport->fc_flag |= FC_PT2PT_PLOGI;
3035 spin_unlock_irq(shost->host_lock);
dea3101e 3036 }
2e0fef85
JS		 3037 spin_lock_irq(shost->host_lock);
3038 vport->fc_flag |= FC_PT2PT;
3039 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
3040 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 3041 } else {
3042 /* Reject this request because invalid parameters */
3043 stat.un.b.lsRjtRsvd0 = 0;
3044 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3045 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
3046 stat.un.b.vendorUnique = 0;
858c9f6c
JS		 3047 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3048 NULL);
c9f8735b 3049 return 1;
dea3101e
JB		 3050 }
3051
3052 /* Send back ACC */
51ef4c26 3053 lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL);
dea3101e 3054
c9f8735b 3055 return 0;
dea3101e
JB		 3056}
3057
3058static int
2e0fef85
JS		 3059lpfc_els_rcv_rnid(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3060 struct lpfc_nodelist *ndlp)
dea3101e
JB		 3061{
3062 struct lpfc_dmabuf *pcmd;
3063 uint32_t *lp;
3064 IOCB_t *icmd;
3065 RNID *rn;
3066 struct ls_rjt stat;
3067 uint32_t cmd, did;
3068
3069 icmd = &cmdiocb->iocb;
3070 did = icmd->un.elsreq64.remoteID;
3071 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3072 lp = (uint32_t *) pcmd->virt;
3073
3074 cmd = *lp++;
3075 rn = (RNID *) lp;
3076
3077 /* RNID received */
3078
3079 switch (rn->Format) {
3080 case 0:
3081 case RNID_TOPOLOGY_DISC:
3082 /* Send back ACC */
2e0fef85 3083 lpfc_els_rsp_rnid_acc(vport, rn->Format, cmdiocb, ndlp);
dea3101e
JB		 3084 break;
3085 default:
3086 /* Reject this request because format not supported */
3087 stat.un.b.lsRjtRsvd0 = 0;
3088 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3089 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3090 stat.un.b.vendorUnique = 0;
858c9f6c
JS		 3091 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3092 NULL);
dea3101e 3093 }
c9f8735b 3094 return 0;
dea3101e
JB		 3095}
3096
3097static int
2e0fef85
JS		 3098lpfc_els_rcv_lirr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3099 struct lpfc_nodelist *ndlp)
7bb3b137
JW		 3100{
3101 struct ls_rjt stat;
3102
3103 /* For now, unconditionally reject this command */
3104 stat.un.b.lsRjtRsvd0 = 0;
3105 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3106 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3107 stat.un.b.vendorUnique = 0;
858c9f6c 3108 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
7bb3b137
JW		 3109 return 0;
3110}
3111
082c0266 3112static void
329f9bc7 3113lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
7bb3b137 3114{
2e0fef85
JS		 3115 struct lpfc_sli *psli = &phba->sli;
3116 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
7bb3b137
JW		 3117 MAILBOX_t *mb;
3118 IOCB_t *icmd;
3119 RPS_RSP *rps_rsp;
3120 uint8_t *pcmd;
3121 struct lpfc_iocbq *elsiocb;
3122 struct lpfc_nodelist *ndlp;
3123 uint16_t xri, status;
3124 uint32_t cmdsize;
3125
7bb3b137
JW		 3126 mb = &pmb->mb;
3127
3128 ndlp = (struct lpfc_nodelist *) pmb->context2;
3129 xri = (uint16_t) ((unsigned long)(pmb->context1));
041976fb
RD		 3130 pmb->context1 = NULL;
3131 pmb->context2 = NULL;
7bb3b137
JW		 3132
3133 if (mb->mbxStatus) {
329f9bc7 3134 mempool_free(pmb, phba->mbox_mem_pool);
7bb3b137
JW		 3135 return;
3136 }
3137
3138 cmdsize = sizeof(RPS_RSP) + sizeof(uint32_t);
329f9bc7 3139 mempool_free(pmb, phba->mbox_mem_pool);
2e0fef85
JS		 3140 elsiocb = lpfc_prep_els_iocb(phba->pport, 0, cmdsize,
3141 lpfc_max_els_tries, ndlp,
3142 ndlp->nlp_DID, ELS_CMD_ACC);
329f9bc7 3143 lpfc_nlp_put(ndlp);
c9f8735b 3144 if (!elsiocb)
7bb3b137 3145 return;
7bb3b137
JW		 3146
3147 icmd = &elsiocb->iocb;
3148 icmd->ulpContext = xri;
3149
3150 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
3151 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
92d7f7b0 3152 pcmd += sizeof(uint32_t); /* Skip past command */
7bb3b137
JW		 3153 rps_rsp = (RPS_RSP *)pcmd;
3154
3155 if (phba->fc_topology != TOPOLOGY_LOOP)
3156 status = 0x10;
3157 else
3158 status = 0x8;
2e0fef85 3159 if (phba->pport->fc_flag & FC_FABRIC)
7bb3b137
JW		 3160 status |= 0x4;
3161
3162 rps_rsp->rsvd1 = 0;
3163 rps_rsp->portStatus = be16_to_cpu(status);
3164 rps_rsp->linkFailureCnt = be32_to_cpu(mb->un.varRdLnk.linkFailureCnt);
3165 rps_rsp->lossSyncCnt = be32_to_cpu(mb->un.varRdLnk.lossSyncCnt);
3166 rps_rsp->lossSignalCnt = be32_to_cpu(mb->un.varRdLnk.lossSignalCnt);
3167 rps_rsp->primSeqErrCnt = be32_to_cpu(mb->un.varRdLnk.primSeqErrCnt);
3168 rps_rsp->invalidXmitWord = be32_to_cpu(mb->un.varRdLnk.invalidXmitWord);
3169 rps_rsp->crcCnt = be32_to_cpu(mb->un.varRdLnk.crcCnt);
7bb3b137 3170 /* Xmit ELS RPS ACC response tag <ulpIoTag> */
e8b62011
JS		 3171 lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_ELS,
3172 "0118 Xmit ELS RPS ACC response tag x%x xri x%x, "
3173 "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
3174 elsiocb->iotag, elsiocb->iocb.ulpContext,
3175 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
3176 ndlp->nlp_rpi);
858c9f6c 3177 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
7bb3b137 3178 phba->fc_stat.elsXmitACC++;
ed957684 3179 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR)
7bb3b137 3180 lpfc_els_free_iocb(phba, elsiocb);
7bb3b137
JW		 3181 return;
3182}
3183
3184static int
2e0fef85
JS		 3185lpfc_els_rcv_rps(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3186 struct lpfc_nodelist *ndlp)
dea3101e 3187{
2e0fef85 3188 struct lpfc_hba *phba = vport->phba;
dea3101e 3189 uint32_t *lp;
7bb3b137
JW		 3190 uint8_t flag;
3191 LPFC_MBOXQ_t *mbox;
3192 struct lpfc_dmabuf *pcmd;
3193 RPS *rps;
3194 struct ls_rjt stat;
3195
2fe165b6
JW		 3196 if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
3197 (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
7bb3b137
JW		 3198 stat.un.b.lsRjtRsvd0 = 0;
3199 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3200 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3201 stat.un.b.vendorUnique = 0;
858c9f6c
JS		 3202 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3203 NULL);
7bb3b137
JW		 3204 }
3205
3206 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3207 lp = (uint32_t *) pcmd->virt;
3208 flag = (be32_to_cpu(*lp++) & 0xf);
3209 rps = (RPS *) lp;
3210
3211 if ((flag == 0) ||
3212 ((flag == 1) && (be32_to_cpu(rps->un.portNum) == 0)) ||
2e0fef85 3213 ((flag == 2) && (memcmp(&rps->un.portName, &vport->fc_portname,
92d7f7b0 3214 sizeof(struct lpfc_name)) == 0))) {
2e0fef85 3215
92d7f7b0
JS		 3216 printk("Fix me....\n");
3217 dump_stack();
2e0fef85
JS		 3218 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC);
3219 if (mbox) {
7bb3b137
JW		 3220 lpfc_read_lnk_stat(phba, mbox);
3221 mbox->context1 =
92d7f7b0 3222 (void *)((unsigned long) cmdiocb->iocb.ulpContext);
329f9bc7 3223 mbox->context2 = lpfc_nlp_get(ndlp);
92d7f7b0 3224 mbox->vport = vport;
7bb3b137
JW		 3225 mbox->mbox_cmpl = lpfc_els_rsp_rps_acc;
3226 if (lpfc_sli_issue_mbox (phba, mbox,
2e0fef85 3227 (MBX_NOWAIT | MBX_STOP_IOCB)) != MBX_NOT_FINISHED)
7bb3b137
JW		 3228 /* Mbox completion will send ELS Response */
3229 return 0;
2e0fef85 3230
329f9bc7 3231 lpfc_nlp_put(ndlp);
7bb3b137
JW		 3232 mempool_free(mbox, phba->mbox_mem_pool);
3233 }
3234 }
3235 stat.un.b.lsRjtRsvd0 = 0;
3236 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3237 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3238 stat.un.b.vendorUnique = 0;
858c9f6c 3239 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
7bb3b137
JW		 3240 return 0;
3241}
3242
082c0266 3243static int
2e0fef85
JS		 3244lpfc_els_rsp_rpl_acc(struct lpfc_vport *vport, uint16_t cmdsize,
3245 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
7bb3b137 3246{
2e0fef85
JS		 3247 struct lpfc_hba *phba = vport->phba;
3248 IOCB_t *icmd, *oldcmd;
7bb3b137
JW		 3249 RPL_RSP rpl_rsp;
3250 struct lpfc_iocbq *elsiocb;
2e0fef85
JS		 3251 struct lpfc_sli *psli = &phba->sli;
3252 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
7bb3b137 3253 uint8_t *pcmd;
dea3101e 3254
2e0fef85
JS		 3255 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
3256 ndlp->nlp_DID, ELS_CMD_ACC);
7bb3b137 3257
488d1469 3258 if (!elsiocb)
7bb3b137 3259 return 1;
488d1469 3260
7bb3b137
JW		 3261 icmd = &elsiocb->iocb;
3262 oldcmd = &oldiocb->iocb;
3263 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
3264
3265 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
3266 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
92d7f7b0 3267 pcmd += sizeof(uint16_t);
7bb3b137
JW		 3268 *((uint16_t *)(pcmd)) = be16_to_cpu(cmdsize);
3269 pcmd += sizeof(uint16_t);
3270
3271 /* Setup the RPL ACC payload */
3272 rpl_rsp.listLen = be32_to_cpu(1);
3273 rpl_rsp.index = 0;
3274 rpl_rsp.port_num_blk.portNum = 0;
2e0fef85
JS		 3275 rpl_rsp.port_num_blk.portID = be32_to_cpu(vport->fc_myDID);
3276 memcpy(&rpl_rsp.port_num_blk.portName, &vport->fc_portname,
7bb3b137 3277 sizeof(struct lpfc_name));
7bb3b137 3278 memcpy(pcmd, &rpl_rsp, cmdsize - sizeof(uint32_t));
7bb3b137 3279 /* Xmit ELS RPL ACC response tag <ulpIoTag> */
e8b62011
JS		 3280 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3281 "0120 Xmit ELS RPL ACC response tag x%x "
3282 "xri x%x, did x%x, nlp_flag x%x, nlp_state x%x, "
3283 "rpi x%x\n",
3284 elsiocb->iotag, elsiocb->iocb.ulpContext,
3285 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
3286 ndlp->nlp_rpi);
858c9f6c 3287 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
7bb3b137
JW		 3288 phba->fc_stat.elsXmitACC++;
3289 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
3290 lpfc_els_free_iocb(phba, elsiocb);
3291 return 1;
3292 }
3293 return 0;
3294}
3295
3296static int
2e0fef85
JS		 3297lpfc_els_rcv_rpl(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3298 struct lpfc_nodelist *ndlp)
7bb3b137
JW		 3299{
3300 struct lpfc_dmabuf *pcmd;
3301 uint32_t *lp;
3302 uint32_t maxsize;
3303 uint16_t cmdsize;
3304 RPL *rpl;
3305 struct ls_rjt stat;
3306
2fe165b6
JW		 3307 if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
3308 (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
7bb3b137
JW		 3309 stat.un.b.lsRjtRsvd0 = 0;
3310 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3311 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3312 stat.un.b.vendorUnique = 0;
858c9f6c
JS		 3313 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3314 NULL);
7bb3b137
JW		 3315 }
3316
dea3101e
JB		 3317 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3318 lp = (uint32_t *) pcmd->virt;
7bb3b137 3319 rpl = (RPL *) (lp + 1);
dea3101e 3320
7bb3b137 3321 maxsize = be32_to_cpu(rpl->maxsize);
dea3101e 3322
7bb3b137
JW		 3323 /* We support only one port */
3324 if ((rpl->index == 0) &&
3325 ((maxsize == 0) ||
3326 ((maxsize * sizeof(uint32_t)) >= sizeof(RPL_RSP)))) {
3327 cmdsize = sizeof(uint32_t) + sizeof(RPL_RSP);
2fe165b6 3328 } else {
7bb3b137
JW		 3329 cmdsize = sizeof(uint32_t) + maxsize * sizeof(uint32_t);
3330 }
2e0fef85 3331 lpfc_els_rsp_rpl_acc(vport, cmdsize, cmdiocb, ndlp);
dea3101e
JB		 3332
3333 return 0;
3334}
3335
3336static int
2e0fef85
JS		 3337lpfc_els_rcv_farp(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3338 struct lpfc_nodelist *ndlp)
dea3101e
JB		 3339{
3340 struct lpfc_dmabuf *pcmd;
3341 uint32_t *lp;
3342 IOCB_t *icmd;
3343 FARP *fp;
3344 uint32_t cmd, cnt, did;
3345
3346 icmd = &cmdiocb->iocb;
3347 did = icmd->un.elsreq64.remoteID;
3348 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3349 lp = (uint32_t *) pcmd->virt;
3350
3351 cmd = *lp++;
3352 fp = (FARP *) lp;
dea3101e 3353 /* FARP-REQ received from DID <did> */
e8b62011
JS		 3354 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3355 "0601 FARP-REQ received from DID x%x\n", did);
dea3101e
JB		 3356 /* We will only support match on WWPN or WWNN */
3357 if (fp->Mflags & ~(FARP_MATCH_NODE | FARP_MATCH_PORT)) {
c9f8735b 3358 return 0;
dea3101e
JB		 3359 }
3360
3361 cnt = 0;
3362 /* If this FARP command is searching for my portname */
3363 if (fp->Mflags & FARP_MATCH_PORT) {
2e0fef85 3364 if (memcmp(&fp->RportName, &vport->fc_portname,
92d7f7b0 3365 sizeof(struct lpfc_name)) == 0)
dea3101e
JB		 3366 cnt = 1;
3367 }
3368
3369 /* If this FARP command is searching for my nodename */
3370 if (fp->Mflags & FARP_MATCH_NODE) {
2e0fef85 3371 if (memcmp(&fp->RnodeName, &vport->fc_nodename,
92d7f7b0 3372 sizeof(struct lpfc_name)) == 0)
dea3101e
JB		 3373 cnt = 1;
3374 }
3375
3376 if (cnt) {
3377 if ((ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) ||
3378 (ndlp->nlp_state == NLP_STE_MAPPED_NODE)) {
3379 /* Log back into the node before sending the FARP. */
3380 if (fp->Rflags & FARP_REQUEST_PLOGI) {
5024ab17 3381 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 3382 lpfc_nlp_set_state(vport, ndlp,
de0c5b32 3383 NLP_STE_PLOGI_ISSUE);
2e0fef85 3384 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
dea3101e
JB		 3385 }
3386
3387 /* Send a FARP response to that node */
2e0fef85
JS		 3388 if (fp->Rflags & FARP_REQUEST_FARPR)
3389 lpfc_issue_els_farpr(vport, did, 0);
dea3101e
JB		 3390 }
3391 }
c9f8735b 3392 return 0;
dea3101e
JB		 3393}
3394
3395static int
2e0fef85
JS		 3396lpfc_els_rcv_farpr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3397 struct lpfc_nodelist *ndlp)
dea3101e
JB		 3398{
3399 struct lpfc_dmabuf *pcmd;
3400 uint32_t *lp;
3401 IOCB_t *icmd;
3402 uint32_t cmd, did;
3403
3404 icmd = &cmdiocb->iocb;
3405 did = icmd->un.elsreq64.remoteID;
3406 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3407 lp = (uint32_t *) pcmd->virt;
3408
3409 cmd = *lp++;
3410 /* FARP-RSP received from DID <did> */
e8b62011
JS		 3411 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3412 "0600 FARP-RSP received from DID x%x\n", did);
dea3101e 3413 /* ACCEPT the Farp resp request */
51ef4c26 3414 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
dea3101e
JB		 3415
3416 return 0;
3417}
3418
3419static int
2e0fef85
JS		 3420lpfc_els_rcv_fan(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3421 struct lpfc_nodelist *fan_ndlp)
dea3101e
JB		 3422{
3423 struct lpfc_dmabuf *pcmd;
3424 uint32_t *lp;
3425 IOCB_t *icmd;
dea3101e 3426 uint32_t cmd, did;
5024ab17
JW		 3427 FAN *fp;
3428 struct lpfc_nodelist *ndlp, *next_ndlp;
2e0fef85 3429 struct lpfc_hba *phba = vport->phba;
5024ab17
JW		 3430
3431 /* FAN received */
e8b62011
JS		 3432 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3433 "0265 FAN received\n");
dea3101e
JB		 3434 icmd = &cmdiocb->iocb;
3435 did = icmd->un.elsreq64.remoteID;
5024ab17
JW		 3436 pcmd = (struct lpfc_dmabuf *)cmdiocb->context2;
3437 lp = (uint32_t *)pcmd->virt;
dea3101e
JB		 3438
3439 cmd = *lp++;
92d7f7b0 3440 fp = (FAN *) lp;
dea3101e 3441
5024ab17 3442 /* FAN received; Fan does not have a reply sequence */
dea3101e 3443
2e0fef85 3444 if (phba->pport->port_state == LPFC_LOCAL_CFG_LINK) {
5024ab17
JW		 3445 if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName,
3446 sizeof(struct lpfc_name)) != 0) ||
3447 (memcmp(&phba->fc_fabparam.portName, &fp->FportName,
3448 sizeof(struct lpfc_name)) != 0)) {
3449 /*
3450 * This node has switched fabrics. FLOGI is required
3451 * Clean up the old rpi's
dea3101e 3452 */
5024ab17
JW		 3453
3454 list_for_each_entry_safe(ndlp, next_ndlp,
2e0fef85 3455 &vport->fc_nodes, nlp_listp) {
685f0bf7
JS		 3456 if (ndlp->nlp_state != NLP_STE_NPR_NODE)
3457 continue;
5024ab17
JW		 3458 if (ndlp->nlp_type & NLP_FABRIC) {
3459 /*
3460 * Clean up old Fabric, Nameserver and
3461 * other NLP_FABRIC logins
3462 */
2e0fef85 3463 lpfc_drop_node(vport, ndlp);
2fe165b6 3464 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
5024ab17
JW		 3465 /* Fail outstanding I/O now since this
3466 * device is marked for PLOGI
3467 */
2e0fef85 3468 lpfc_unreg_rpi(vport, ndlp);
5024ab17
JW		 3469 }
3470 }
3471
2e0fef85
JS		 3472 vport->port_state = LPFC_FLOGI;
3473 lpfc_set_disctmo(vport);
3474 lpfc_initial_flogi(vport);
c9f8735b 3475 return 0;
dea3101e 3476 }
5024ab17
JW		 3477 /* Discovery not needed,
3478 * move the nodes to their original state.
3479 */
2e0fef85 3480 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes,
685f0bf7
JS		 3481 nlp_listp) {
3482 if (ndlp->nlp_state != NLP_STE_NPR_NODE)
3483 continue;
dea3101e 3484
5024ab17
JW		 3485 switch (ndlp->nlp_prev_state) {
3486 case NLP_STE_UNMAPPED_NODE:
3487 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
2e0fef85 3488 lpfc_nlp_set_state(vport, ndlp,
de0c5b32 3489 NLP_STE_UNMAPPED_NODE);
5024ab17
JW		 3490 break;
3491
3492 case NLP_STE_MAPPED_NODE:
3493 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
2e0fef85 3494 lpfc_nlp_set_state(vport, ndlp,
de0c5b32 3495 NLP_STE_MAPPED_NODE);
5024ab17
JW		 3496 break;
3497
3498 default:
3499 break;
3500 }
3501 }
3502
3503 /* Start discovery - this should just do CLEAR_LA */
2e0fef85 3504 lpfc_disc_start(vport);
dea3101e 3505 }
c9f8735b 3506 return 0;
dea3101e
JB		 3507}
3508
3509void
3510lpfc_els_timeout(unsigned long ptr)
3511{
2e0fef85
JS		 3512 struct lpfc_vport *vport = (struct lpfc_vport *) ptr;
3513 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 3514 unsigned long iflag;
3515
2e0fef85
JS		 3516 spin_lock_irqsave(&vport->work_port_lock, iflag);
3517 if ((vport->work_port_events & WORKER_ELS_TMO) == 0) {
3518 vport->work_port_events |= WORKER_ELS_TMO;
92d7f7b0
JS		 3519 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
3520
3521 spin_lock_irqsave(&phba->hbalock, iflag);
dea3101e 3522 if (phba->work_wait)
92d7f7b0
JS		 3523 lpfc_worker_wake_up(phba);
3524 spin_unlock_irqrestore(&phba->hbalock, iflag);
dea3101e 3525 }
92d7f7b0
JS		 3526 else
3527 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
dea3101e
JB		 3528 return;
3529}
3530
3531void
2e0fef85 3532lpfc_els_timeout_handler(struct lpfc_vport *vport)
dea3101e 3533{
2e0fef85 3534 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 3535 struct lpfc_sli_ring *pring;
3536 struct lpfc_iocbq *tmp_iocb, *piocb;
3537 IOCB_t *cmd = NULL;
3538 struct lpfc_dmabuf *pcmd;
2e0fef85 3539 uint32_t els_command = 0;
dea3101e 3540 uint32_t timeout;
2e0fef85 3541 uint32_t remote_ID = 0xffffffff;
dea3101e 3542
dea3101e 3543 /* If the timer is already canceled do nothing */
2e0fef85 3544 if ((vport->work_port_events & WORKER_ELS_TMO) == 0) {
dea3101e
JB		 3545 return;
3546 }
2e0fef85 3547 spin_lock_irq(&phba->hbalock);
dea3101e
JB		 3548 timeout = (uint32_t)(phba->fc_ratov << 1);
3549
3550 pring = &phba->sli.ring[LPFC_ELS_RING];
dea3101e
JB		 3551
3552 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3553 cmd = &piocb->iocb;
3554
2e0fef85
JS		 3555 if ((piocb->iocb_flag & LPFC_IO_LIBDFC) != 0 ||
3556 piocb->iocb.ulpCommand == CMD_ABORT_XRI_CN ||
3557 piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)
dea3101e 3558 continue;
2e0fef85
JS		 3559
3560 if (piocb->vport != vport)
3561 continue;
3562
dea3101e 3563 pcmd = (struct lpfc_dmabuf *) piocb->context2;
2e0fef85
JS		 3564 if (pcmd)
3565 els_command = *(uint32_t *) (pcmd->virt);
dea3101e 3566
92d7f7b0
JS		 3567 if (els_command == ELS_CMD_FARP ||
3568 els_command == ELS_CMD_FARPR ||
3569 els_command == ELS_CMD_FDISC)
3570 continue;
3571
3572 if (vport != piocb->vport)
dea3101e 3573 continue;
dea3101e
JB		 3574
3575 if (piocb->drvrTimeout > 0) {
92d7f7b0 3576 if (piocb->drvrTimeout >= timeout)
dea3101e 3577 piocb->drvrTimeout -= timeout;
92d7f7b0 3578 else
dea3101e 3579 piocb->drvrTimeout = 0;
dea3101e
JB		 3580 continue;
3581 }
3582
2e0fef85
JS		 3583 remote_ID = 0xffffffff;
3584 if (cmd->ulpCommand != CMD_GEN_REQUEST64_CR)
dea3101e 3585 remote_ID = cmd->un.elsreq64.remoteID;
2e0fef85
JS		 3586 else {
3587 struct lpfc_nodelist *ndlp;
3588 ndlp = __lpfc_findnode_rpi(vport, cmd->ulpContext);
3589 if (ndlp)
3590 remote_ID = ndlp->nlp_DID;
dea3101e 3591 }
e8b62011
JS		 3592 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
3593 "0127 ELS timeout Data: x%x x%x x%x "
3594 "x%x\n", els_command,
3595 remote_ID, cmd->ulpCommand, cmd->ulpIoTag);
07951076 3596 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
dea3101e 3597 }
2e0fef85 3598 spin_unlock_irq(&phba->hbalock);
5a0e326d 3599
2e0fef85
JS		 3600 if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt)
3601 mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
dea3101e
JB		 3602}
3603
3604void
2e0fef85 3605lpfc_els_flush_cmd(struct lpfc_vport *vport)
dea3101e 3606{
2534ba75 3607 LIST_HEAD(completions);
2e0fef85 3608 struct lpfc_hba *phba = vport->phba;
329f9bc7 3609 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
dea3101e
JB		 3610 struct lpfc_iocbq *tmp_iocb, *piocb;
3611 IOCB_t *cmd = NULL;
92d7f7b0
JS		 3612
3613 lpfc_fabric_abort_vport(vport);
dea3101e 3614
2e0fef85 3615 spin_lock_irq(&phba->hbalock);
dea3101e
JB		 3616 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
3617 cmd = &piocb->iocb;
3618
3619 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3620 continue;
3621 }
3622
3623 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
329f9bc7
JS		 3624 if (cmd->ulpCommand == CMD_QUE_RING_BUF_CN ||
3625 cmd->ulpCommand == CMD_QUE_RING_BUF64_CN ||
3626 cmd->ulpCommand == CMD_CLOSE_XRI_CN ||
3627 cmd->ulpCommand == CMD_ABORT_XRI_CN)
dea3101e 3628 continue;
dea3101e 3629
2e0fef85
JS		 3630 if (piocb->vport != vport)
3631 continue;
3632
2534ba75 3633 list_move_tail(&piocb->list, &completions);
1dcb58e5 3634 pring->txq_cnt--;
dea3101e
JB		 3635 }
3636
3637 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
dea3101e
JB		 3638 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3639 continue;
3640 }
dea3101e 3641
2e0fef85
JS		 3642 if (piocb->vport != vport)
3643 continue;
3644
07951076 3645 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
dea3101e 3646 }
2e0fef85 3647 spin_unlock_irq(&phba->hbalock);
2534ba75 3648
2e0fef85 3649 while (!list_empty(&completions)) {
2534ba75
JS		 3650 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
3651 cmd = &piocb->iocb;
92d7f7b0 3652 list_del_init(&piocb->list);
2534ba75 3653
2e0fef85
JS		 3654 if (!piocb->iocb_cmpl)
3655 lpfc_sli_release_iocbq(phba, piocb);
3656 else {
2534ba75
JS		 3657 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3658 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3659 (piocb->iocb_cmpl) (phba, piocb, piocb);
2e0fef85 3660 }
2534ba75
JS		 3661 }
3662
dea3101e
JB		 3663 return;
3664}
3665
549e55cd
JS		 3666void
3667lpfc_els_flush_all_cmd(struct lpfc_hba *phba)
3668{
3669 LIST_HEAD(completions);
3670 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
3671 struct lpfc_iocbq *tmp_iocb, *piocb;
3672 IOCB_t *cmd = NULL;
3673
3674 lpfc_fabric_abort_hba(phba);
3675 spin_lock_irq(&phba->hbalock);
3676 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
3677 cmd = &piocb->iocb;
3678 if (piocb->iocb_flag & LPFC_IO_LIBDFC)
3679 continue;
3680 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
3681 if (cmd->ulpCommand == CMD_QUE_RING_BUF_CN ||
3682 cmd->ulpCommand == CMD_QUE_RING_BUF64_CN ||
3683 cmd->ulpCommand == CMD_CLOSE_XRI_CN ||
3684 cmd->ulpCommand == CMD_ABORT_XRI_CN)
3685 continue;
3686 list_move_tail(&piocb->list, &completions);
3687 pring->txq_cnt--;
3688 }
3689 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3690 if (piocb->iocb_flag & LPFC_IO_LIBDFC)
3691 continue;
3692 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3693 }
3694 spin_unlock_irq(&phba->hbalock);
3695 while (!list_empty(&completions)) {
3696 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
3697 cmd = &piocb->iocb;
3698 list_del_init(&piocb->list);
3699 if (!piocb->iocb_cmpl)
3700 lpfc_sli_release_iocbq(phba, piocb);
3701 else {
3702 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3703 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3704 (piocb->iocb_cmpl) (phba, piocb, piocb);
3705 }
3706 }
3707 return;
3708}
3709
ed957684
JS		 3710static void
3711lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
92d7f7b0 3712 struct lpfc_vport *vport, struct lpfc_iocbq *elsiocb)
dea3101e 3713{
dea3101e 3714 struct lpfc_nodelist *ndlp;
dea3101e 3715 struct ls_rjt stat;
92d7f7b0 3716 uint32_t *payload;
2e0fef85 3717 uint32_t cmd, did, newnode, rjt_err = 0;
ed957684 3718 IOCB_t *icmd = &elsiocb->iocb;
dea3101e 3719
92d7f7b0 3720 if (vport == NULL || elsiocb->context2 == NULL)
dea3101e 3721 goto dropit;
2e0fef85 3722
dea3101e 3723 newnode = 0;
92d7f7b0
JS		 3724 payload = ((struct lpfc_dmabuf *)elsiocb->context2)->virt;
3725 cmd = *payload;
ed957684
JS		 3726 if ((phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) == 0)
3727 lpfc_post_buffer(phba, pring, 1, 1);
dea3101e 3728
858c9f6c
JS		 3729 did = icmd->un.rcvels.remoteID;
3730 if (icmd->ulpStatus) {
3731 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3732 "RCV Unsol ELS: status:x%x/x%x did:x%x",
3733 icmd->ulpStatus, icmd->un.ulpWord[4], did);
dea3101e 3734 goto dropit;
858c9f6c 3735 }
dea3101e
JB		 3736
3737 /* Check to see if link went down during discovery */
ed957684 3738 if (lpfc_els_chk_latt(vport))
dea3101e 3739 goto dropit;
dea3101e 3740
92d7f7b0
JS		 3741 /* Ignore traffic recevied during vport shutdown. */
3742 if (vport->load_flag & FC_UNLOADING)
3743 goto dropit;
3744
2e0fef85 3745 ndlp = lpfc_findnode_did(vport, did);
c9f8735b 3746 if (!ndlp) {
dea3101e 3747 /* Cannot find existing Fabric ndlp, so allocate a new one */
c9f8735b 3748 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
ed957684 3749 if (!ndlp)
dea3101e 3750 goto dropit;
dea3101e 3751
2e0fef85 3752 lpfc_nlp_init(vport, ndlp, did);
dea3101e
JB		 3753 newnode = 1;
3754 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) {
3755 ndlp->nlp_type |= NLP_FABRIC;
3756 }
2e0fef85 3757 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNUSED_NODE);
dea3101e
JB		 3758 }
3759
3760 phba->fc_stat.elsRcvFrame++;
329f9bc7
JS		 3761 if (elsiocb->context1)
3762 lpfc_nlp_put(elsiocb->context1);
3763 elsiocb->context1 = lpfc_nlp_get(ndlp);
2e0fef85 3764 elsiocb->vport = vport;
dea3101e
JB		 3765
3766 if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) {
3767 cmd &= ELS_CMD_MASK;
3768 }
3769 /* ELS command <elsCmd> received from NPORT <did> */
e8b62011
JS		 3770 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3771 "0112 ELS command x%x received from NPORT x%x "
3772 "Data: x%x\n", cmd, did, vport->port_state);
dea3101e
JB		 3773 switch (cmd) {
3774 case ELS_CMD_PLOGI:
858c9f6c
JS		 3775 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3776 "RCV PLOGI: did:x%x/ste:x%x flg:x%x",
3777 did, vport->port_state, ndlp->nlp_flag);
3778
dea3101e 3779 phba->fc_stat.elsRcvPLOGI++;
858c9f6c
JS		 3780 ndlp = lpfc_plogi_confirm_nport(phba, payload, ndlp);
3781
3782 if (vport->port_state < LPFC_DISC_AUTH) {
3783 rjt_err = LSRJT_UNABLE_TPC;
dea3101e
JB		 3784 break;
3785 }
2e0fef85
JS		 3786 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3787 NLP_EVT_RCV_PLOGI);
858c9f6c 3788
dea3101e
JB		 3789 break;
3790 case ELS_CMD_FLOGI:
858c9f6c
JS		 3791 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3792 "RCV FLOGI: did:x%x/ste:x%x flg:x%x",
3793 did, vport->port_state, ndlp->nlp_flag);
3794
dea3101e 3795 phba->fc_stat.elsRcvFLOGI++;
51ef4c26 3796 lpfc_els_rcv_flogi(vport, elsiocb, ndlp);
de0c5b32 3797 if (newnode)
2e0fef85 3798 lpfc_drop_node(vport, ndlp);
dea3101e
JB		 3799 break;
3800 case ELS_CMD_LOGO:
858c9f6c
JS		 3801 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3802 "RCV LOGO: did:x%x/ste:x%x flg:x%x",
3803 did, vport->port_state, ndlp->nlp_flag);
3804
dea3101e 3805 phba->fc_stat.elsRcvLOGO++;
2e0fef85 3806 if (vport->port_state < LPFC_DISC_AUTH) {
858c9f6c 3807 rjt_err = LSRJT_UNABLE_TPC;
dea3101e
JB		 3808 break;
3809 }
2e0fef85 3810 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_LOGO);
dea3101e
JB		 3811 break;
3812 case ELS_CMD_PRLO:
858c9f6c
JS		 3813 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3814 "RCV PRLO: did:x%x/ste:x%x flg:x%x",
3815 did, vport->port_state, ndlp->nlp_flag);
3816
dea3101e 3817 phba->fc_stat.elsRcvPRLO++;
2e0fef85 3818 if (vport->port_state < LPFC_DISC_AUTH) {
858c9f6c 3819 rjt_err = LSRJT_UNABLE_TPC;
dea3101e
JB		 3820 break;
3821 }
2e0fef85 3822 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_PRLO);
dea3101e
JB		 3823 break;
3824 case ELS_CMD_RSCN:
3825 phba->fc_stat.elsRcvRSCN++;
51ef4c26 3826 lpfc_els_rcv_rscn(vport, elsiocb, ndlp);
de0c5b32 3827 if (newnode)
2e0fef85 3828 lpfc_drop_node(vport, ndlp);
dea3101e
JB		 3829 break;
3830 case ELS_CMD_ADISC:
858c9f6c
JS		 3831 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3832 "RCV ADISC: did:x%x/ste:x%x flg:x%x",
3833 did, vport->port_state, ndlp->nlp_flag);
3834
dea3101e 3835 phba->fc_stat.elsRcvADISC++;
2e0fef85 3836 if (vport->port_state < LPFC_DISC_AUTH) {
858c9f6c 3837 rjt_err = LSRJT_UNABLE_TPC;
dea3101e
JB		 3838 break;
3839 }
2e0fef85
JS		 3840 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3841 NLP_EVT_RCV_ADISC);
dea3101e
JB		 3842 break;
3843 case ELS_CMD_PDISC:
858c9f6c
JS		 3844 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3845 "RCV PDISC: did:x%x/ste:x%x flg:x%x",
3846 did, vport->port_state, ndlp->nlp_flag);
3847
dea3101e 3848 phba->fc_stat.elsRcvPDISC++;
2e0fef85 3849 if (vport->port_state < LPFC_DISC_AUTH) {
858c9f6c 3850 rjt_err = LSRJT_UNABLE_TPC;
dea3101e
JB		 3851 break;
3852 }
2e0fef85
JS		 3853 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3854 NLP_EVT_RCV_PDISC);
dea3101e
JB		 3855 break;
3856 case ELS_CMD_FARPR:
858c9f6c
JS		 3857 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3858 "RCV FARPR: did:x%x/ste:x%x flg:x%x",
3859 did, vport->port_state, ndlp->nlp_flag);
3860
dea3101e 3861 phba->fc_stat.elsRcvFARPR++;
2e0fef85 3862 lpfc_els_rcv_farpr(vport, elsiocb, ndlp);
dea3101e
JB		 3863 break;
3864 case ELS_CMD_FARP:
858c9f6c
JS		 3865 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3866 "RCV FARP: did:x%x/ste:x%x flg:x%x",
3867 did, vport->port_state, ndlp->nlp_flag);
3868
dea3101e 3869 phba->fc_stat.elsRcvFARP++;
2e0fef85 3870 lpfc_els_rcv_farp(vport, elsiocb, ndlp);
dea3101e
JB		 3871 break;
3872 case ELS_CMD_FAN:
858c9f6c
JS		 3873 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3874 "RCV FAN: did:x%x/ste:x%x flg:x%x",
3875 did, vport->port_state, ndlp->nlp_flag);
3876
dea3101e 3877 phba->fc_stat.elsRcvFAN++;
2e0fef85 3878 lpfc_els_rcv_fan(vport, elsiocb, ndlp);
dea3101e 3879 break;
dea3101e 3880 case ELS_CMD_PRLI:
858c9f6c
JS		 3881 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3882 "RCV PRLI: did:x%x/ste:x%x flg:x%x",
3883 did, vport->port_state, ndlp->nlp_flag);
3884
dea3101e 3885 phba->fc_stat.elsRcvPRLI++;
2e0fef85 3886 if (vport->port_state < LPFC_DISC_AUTH) {
858c9f6c 3887 rjt_err = LSRJT_UNABLE_TPC;
dea3101e
JB		 3888 break;
3889 }
2e0fef85 3890 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_PRLI);
dea3101e 3891 break;
7bb3b137 3892 case ELS_CMD_LIRR:
858c9f6c
JS		 3893 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3894 "RCV LIRR: did:x%x/ste:x%x flg:x%x",
3895 did, vport->port_state, ndlp->nlp_flag);
3896
7bb3b137 3897 phba->fc_stat.elsRcvLIRR++;
2e0fef85 3898 lpfc_els_rcv_lirr(vport, elsiocb, ndlp);
de0c5b32 3899 if (newnode)
2e0fef85 3900 lpfc_drop_node(vport, ndlp);
7bb3b137
JW		 3901 break;
3902 case ELS_CMD_RPS:
858c9f6c
JS		 3903 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3904 "RCV RPS: did:x%x/ste:x%x flg:x%x",
3905 did, vport->port_state, ndlp->nlp_flag);
3906
7bb3b137 3907 phba->fc_stat.elsRcvRPS++;
2e0fef85 3908 lpfc_els_rcv_rps(vport, elsiocb, ndlp);
de0c5b32 3909 if (newnode)
2e0fef85 3910 lpfc_drop_node(vport, ndlp);
7bb3b137
JW		 3911 break;
3912 case ELS_CMD_RPL:
858c9f6c
JS		 3913 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3914 "RCV RPL: did:x%x/ste:x%x flg:x%x",
3915 did, vport->port_state, ndlp->nlp_flag);
3916
7bb3b137 3917 phba->fc_stat.elsRcvRPL++;
2e0fef85 3918 lpfc_els_rcv_rpl(vport, elsiocb, ndlp);
de0c5b32 3919 if (newnode)
2e0fef85 3920 lpfc_drop_node(vport, ndlp);
7bb3b137 3921 break;
dea3101e 3922 case ELS_CMD_RNID:
858c9f6c
JS		 3923 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3924 "RCV RNID: did:x%x/ste:x%x flg:x%x",
3925 did, vport->port_state, ndlp->nlp_flag);
3926
dea3101e 3927 phba->fc_stat.elsRcvRNID++;
2e0fef85 3928 lpfc_els_rcv_rnid(vport, elsiocb, ndlp);
de0c5b32 3929 if (newnode)
2e0fef85 3930 lpfc_drop_node(vport, ndlp);
dea3101e
JB		 3931 break;
3932 default:
858c9f6c
JS		 3933 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3934 "RCV ELS cmd: cmd:x%x did:x%x/ste:x%x",
3935 cmd, did, vport->port_state);
3936
dea3101e 3937 /* Unsupported ELS command, reject */
858c9f6c 3938 rjt_err = LSRJT_INVALID_CMD;
dea3101e
JB		 3939
3940 /* Unknown ELS command <elsCmd> received from NPORT <did> */
e8b62011
JS		 3941 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
3942 "0115 Unknown ELS command x%x "
3943 "received from NPORT x%x\n", cmd, did);
de0c5b32 3944 if (newnode)
2e0fef85 3945 lpfc_drop_node(vport, ndlp);
dea3101e
JB		 3946 break;
3947 }
3948
3949 /* check if need to LS_RJT received ELS cmd */
3950 if (rjt_err) {
92d7f7b0 3951 memset(&stat, 0, sizeof(stat));
858c9f6c 3952 stat.un.b.lsRjtRsnCode = rjt_err;
1f679caf 3953 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
858c9f6c
JS		 3954 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, elsiocb, ndlp,
3955 NULL);
dea3101e
JB		 3956 }
3957
ed957684
JS		 3958 return;
3959
3960dropit:
3961 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
e8b62011 3962 "(%d):0111 Dropping received ELS cmd "
ed957684 3963 "Data: x%x x%x x%x\n",
e8b62011
JS		 3964 vport ? vport->vpi : 0xffff, icmd->ulpStatus,
3965 icmd->un.ulpWord[4], icmd->ulpTimeout);
ed957684
JS		 3966 phba->fc_stat.elsRcvDrop++;
3967}
3968
92d7f7b0
JS		 3969static struct lpfc_vport *
3970lpfc_find_vport_by_vpid(struct lpfc_hba *phba, uint16_t vpi)
3971{
3972 struct lpfc_vport *vport;
549e55cd 3973 unsigned long flags;
92d7f7b0 3974
549e55cd 3975 spin_lock_irqsave(&phba->hbalock, flags);
92d7f7b0 3976 list_for_each_entry(vport, &phba->port_list, listentry) {
549e55cd
JS		 3977 if (vport->vpi == vpi) {
3978 spin_unlock_irqrestore(&phba->hbalock, flags);
92d7f7b0 3979 return vport;
549e55cd 3980 }
92d7f7b0 3981 }
549e55cd 3982 spin_unlock_irqrestore(&phba->hbalock, flags);
92d7f7b0
JS		 3983 return NULL;
3984}
ed957684
JS		 3985
3986void
3987lpfc_els_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3988 struct lpfc_iocbq *elsiocb)
3989{
3990 struct lpfc_vport *vport = phba->pport;
ed957684 3991 IOCB_t *icmd = &elsiocb->iocb;
ed957684 3992 dma_addr_t paddr;
92d7f7b0
JS		 3993 struct lpfc_dmabuf *bdeBuf1 = elsiocb->context2;
3994 struct lpfc_dmabuf *bdeBuf2 = elsiocb->context3;
3995
3996 elsiocb->context2 = NULL;
3997 elsiocb->context3 = NULL;
ed957684 3998
92d7f7b0
JS		 3999 if (icmd->ulpStatus == IOSTAT_NEED_BUFFER) {
4000 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
4001 } else if (icmd->ulpStatus == IOSTAT_LOCAL_REJECT &&
4002 (icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING) {
ed957684
JS		 4003 phba->fc_stat.NoRcvBuf++;
4004 /* Not enough posted buffers; Try posting more buffers */
92d7f7b0 4005 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
ed957684
JS		 4006 lpfc_post_buffer(phba, pring, 0, 1);
4007 return;
4008 }
4009
92d7f7b0
JS		 4010 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
4011 (icmd->ulpCommand == CMD_IOCB_RCV_ELS64_CX ||
4012 icmd->ulpCommand == CMD_IOCB_RCV_SEQ64_CX)) {
4013 if (icmd->unsli3.rcvsli3.vpi == 0xffff)
4014 vport = phba->pport;
4015 else {
4016 uint16_t vpi = icmd->unsli3.rcvsli3.vpi;
4017 vport = lpfc_find_vport_by_vpid(phba, vpi);
4018 }
4019 }
4020 /* If there are no BDEs associated
4021 * with this IOCB, there is nothing to do.
4022 */
ed957684
JS		 4023 if (icmd->ulpBdeCount == 0)
4024 return;
4025
92d7f7b0
JS		 4026 /* type of ELS cmd is first 32bit word
4027 * in packet
4028 */
ed957684 4029 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
92d7f7b0 4030 elsiocb->context2 = bdeBuf1;
ed957684
JS		 4031 } else {
4032 paddr = getPaddr(icmd->un.cont64[0].addrHigh,
4033 icmd->un.cont64[0].addrLow);
92d7f7b0
JS		 4034 elsiocb->context2 = lpfc_sli_ringpostbuf_get(phba, pring,
4035 paddr);
ed957684
JS		 4036 }
4037
92d7f7b0
JS		 4038 lpfc_els_unsol_buffer(phba, pring, vport, elsiocb);
4039 /*
4040 * The different unsolicited event handlers would tell us
4041 * if they are done with "mp" by setting context2 to NULL.
4042 */
329f9bc7
JS		 4043 lpfc_nlp_put(elsiocb->context1);
4044 elsiocb->context1 = NULL;
dea3101e 4045 if (elsiocb->context2) {
92d7f7b0
JS		 4046 lpfc_in_buf_free(phba, (struct lpfc_dmabuf *)elsiocb->context2);
4047 elsiocb->context2 = NULL;
dea3101e 4048 }
ed957684
JS		 4049
4050 /* RCV_ELS64_CX provide for 2 BDEs - process 2nd if included */
92d7f7b0 4051 if ((phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) &&
ed957684 4052 icmd->ulpBdeCount == 2) {
92d7f7b0
JS		 4053 elsiocb->context2 = bdeBuf2;
4054 lpfc_els_unsol_buffer(phba, pring, vport, elsiocb);
ed957684
JS		 4055 /* free mp if we are done with it */
4056 if (elsiocb->context2) {
92d7f7b0
JS		 4057 lpfc_in_buf_free(phba, elsiocb->context2);
4058 elsiocb->context2 = NULL;
4059 }
4060 }
4061}
4062
4063void
4064lpfc_do_scr_ns_plogi(struct lpfc_hba *phba, struct lpfc_vport *vport)
4065{
4066 struct lpfc_nodelist *ndlp, *ndlp_fdmi;
4067
4068 ndlp = lpfc_findnode_did(vport, NameServer_DID);
4069 if (!ndlp) {
4070 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
4071 if (!ndlp) {
4072 if (phba->fc_topology == TOPOLOGY_LOOP) {
4073 lpfc_disc_start(vport);
4074 return;
4075 }
4076 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
e8b62011
JS		 4077 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4078 "0251 NameServer login: no memory\n");
92d7f7b0
JS		 4079 return;
4080 }
4081 lpfc_nlp_init(vport, ndlp, NameServer_DID);
4082 ndlp->nlp_type |= NLP_FABRIC;
4083 }
4084
4085 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
4086
4087 if (lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0)) {
4088 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
e8b62011
JS		 4089 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4090 "0252 Cannot issue NameServer login\n");
92d7f7b0
JS		 4091 return;
4092 }
4093
3de2a653 4094 if (vport->cfg_fdmi_on) {
92d7f7b0
JS		 4095 ndlp_fdmi = mempool_alloc(phba->nlp_mem_pool,
4096 GFP_KERNEL);
4097 if (ndlp_fdmi) {
4098 lpfc_nlp_init(vport, ndlp_fdmi, FDMI_DID);
4099 ndlp_fdmi->nlp_type |= NLP_FABRIC;
4100 ndlp_fdmi->nlp_state =
4101 NLP_STE_PLOGI_ISSUE;
4102 lpfc_issue_els_plogi(vport, ndlp_fdmi->nlp_DID,
4103 0);
4104 }
4105 }
4106 return;
4107}
4108
4109static void
4110lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
4111{
4112 struct lpfc_vport *vport = pmb->vport;
4113 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4114 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
4115 MAILBOX_t *mb = &pmb->mb;
4116
4117 vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
4118 lpfc_nlp_put(ndlp);
4119
4120 if (mb->mbxStatus) {
e8b62011
JS		 4121 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
4122 "0915 Register VPI failed: 0x%x\n",
4123 mb->mbxStatus);
92d7f7b0
JS		 4124
4125 switch (mb->mbxStatus) {
4126 case 0x11: /* unsupported feature */
4127 case 0x9603: /* max_vpi exceeded */
4128 /* giving up on vport registration */
4129 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4130 spin_lock_irq(shost->host_lock);
4131 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
4132 spin_unlock_irq(shost->host_lock);
4133 lpfc_can_disctmo(vport);
4134 break;
4135 default:
4136 /* Try to recover from this error */
4137 lpfc_mbx_unreg_vpi(vport);
4138 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
4139 lpfc_initial_fdisc(vport);
4140 break;
4141 }
4142
4143 } else {
4144 if (vport == phba->pport)
4145 lpfc_issue_fabric_reglogin(vport);
4146 else
4147 lpfc_do_scr_ns_plogi(phba, vport);
4148 }
4149 mempool_free(pmb, phba->mbox_mem_pool);
4150 return;
4151}
4152
4153void
4154lpfc_register_new_vport(struct lpfc_hba *phba, struct lpfc_vport *vport,
4155 struct lpfc_nodelist *ndlp)
4156{
4157 LPFC_MBOXQ_t *mbox;
4158
4159 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4160 if (mbox) {
4161 lpfc_reg_vpi(phba, vport->vpi, vport->fc_myDID, mbox);
4162 mbox->vport = vport;
4163 mbox->context2 = lpfc_nlp_get(ndlp);
4164 mbox->mbox_cmpl = lpfc_cmpl_reg_new_vport;
4165 if (lpfc_sli_issue_mbox(phba, mbox,
4166 MBX_NOWAIT | MBX_STOP_IOCB)
4167 == MBX_NOT_FINISHED) {
4168 mempool_free(mbox, phba->mbox_mem_pool);
4169 vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
4170
4171 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
e8b62011
JS		 4172 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
4173 "0253 Register VPI: Can't send mbox\n");
92d7f7b0
JS		 4174 }
4175 } else {
4176 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4177
e8b62011
JS		 4178 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
4179 "0254 Register VPI: no memory\n");
92d7f7b0
JS		 4180
4181 vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
4182 lpfc_nlp_put(ndlp);
4183 }
4184}
4185
4186static void
4187lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4188 struct lpfc_iocbq *rspiocb)
4189{
4190 struct lpfc_vport *vport = cmdiocb->vport;
4191 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4192 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
4193 struct lpfc_nodelist *np;
4194 struct lpfc_nodelist *next_np;
4195 IOCB_t *irsp = &rspiocb->iocb;
4196 struct lpfc_iocbq *piocb;
4197
e8b62011
JS		 4198 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
4199 "0123 FDISC completes. x%x/x%x prevDID: x%x\n",
4200 irsp->ulpStatus, irsp->un.ulpWord[4],
4201 vport->fc_prevDID);
92d7f7b0
JS		 4202 /* Since all FDISCs are being single threaded, we
4203 * must reset the discovery timer for ALL vports
4204 * waiting to send FDISC when one completes.
4205 */
4206 list_for_each_entry(piocb, &phba->fabric_iocb_list, list) {
4207 lpfc_set_disctmo(piocb->vport);
4208 }
4209
858c9f6c
JS		 4210 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4211 "FDISC cmpl: status:x%x/x%x prevdid:x%x",
4212 irsp->ulpStatus, irsp->un.ulpWord[4], vport->fc_prevDID);
4213
92d7f7b0
JS		 4214 if (irsp->ulpStatus) {
4215 /* Check for retry */
4216 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
4217 goto out;
92d7f7b0 4218 /* FDISC failed */
e8b62011
JS		 4219 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4220 "0124 FDISC failed. (%d/%d)\n",
4221 irsp->ulpStatus, irsp->un.ulpWord[4]);
92d7f7b0
JS		 4222 if (vport->fc_vport->vport_state == FC_VPORT_INITIALIZING)
4223 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4224
4225 lpfc_nlp_put(ndlp);
4226 /* giving up on FDISC. Cancel discovery timer */
4227 lpfc_can_disctmo(vport);
4228 } else {
4229 spin_lock_irq(shost->host_lock);
4230 vport->fc_flag |= FC_FABRIC;
4231 if (vport->phba->fc_topology == TOPOLOGY_LOOP)
4232 vport->fc_flag |= FC_PUBLIC_LOOP;
4233 spin_unlock_irq(shost->host_lock);
4234
4235 vport->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
4236 lpfc_vport_set_state(vport, FC_VPORT_ACTIVE);
4237 if ((vport->fc_prevDID != vport->fc_myDID) &&
4238 !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) {
4239 /* If our NportID changed, we need to ensure all
4240 * remaining NPORTs get unreg_login'ed so we can
4241 * issue unreg_vpi.
4242 */
4243 list_for_each_entry_safe(np, next_np,
4244 &vport->fc_nodes, nlp_listp) {
4245 if (np->nlp_state != NLP_STE_NPR_NODE
4246 || !(np->nlp_flag & NLP_NPR_ADISC))
4247 continue;
4248 spin_lock_irq(shost->host_lock);
4249 np->nlp_flag &= ~NLP_NPR_ADISC;
4250 spin_unlock_irq(shost->host_lock);
4251 lpfc_unreg_rpi(vport, np);
4252 }
4253 lpfc_mbx_unreg_vpi(vport);
4254 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
4255 }
4256
4257 if (vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)
4258 lpfc_register_new_vport(phba, vport, ndlp);
4259 else
4260 lpfc_do_scr_ns_plogi(phba, vport);
4261
4262 lpfc_nlp_put(ndlp); /* Free Fabric ndlp for vports */
4263 }
4264
4265out:
4266 lpfc_els_free_iocb(phba, cmdiocb);
4267}
4268
4269int
4270lpfc_issue_els_fdisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
4271 uint8_t retry)
4272{
4273 struct lpfc_hba *phba = vport->phba;
4274 IOCB_t *icmd;
4275 struct lpfc_iocbq *elsiocb;
4276 struct serv_parm *sp;
4277 uint8_t *pcmd;
4278 uint16_t cmdsize;
4279 int did = ndlp->nlp_DID;
4280 int rc;
92d7f7b0
JS		 4281
4282 cmdsize = (sizeof(uint32_t) + sizeof(struct serv_parm));
4283 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp, did,
4284 ELS_CMD_FDISC);
4285 if (!elsiocb) {
92d7f7b0 4286 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
e8b62011
JS		 4287 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4288 "0255 Issue FDISC: no IOCB\n");
92d7f7b0
JS		 4289 return 1;
4290 }
4291
4292 icmd = &elsiocb->iocb;
4293 icmd->un.elsreq64.myID = 0;
4294 icmd->un.elsreq64.fl = 1;
4295
4296 /* For FDISC, Let FDISC rsp set the NPortID for this VPI */
4297 icmd->ulpCt_h = 1;
4298 icmd->ulpCt_l = 0;
4299
4300 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
4301 *((uint32_t *) (pcmd)) = ELS_CMD_FDISC;
4302 pcmd += sizeof(uint32_t); /* CSP Word 1 */
4303 memcpy(pcmd, &vport->phba->pport->fc_sparam, sizeof(struct serv_parm));
4304 sp = (struct serv_parm *) pcmd;
4305 /* Setup CSPs accordingly for Fabric */
4306 sp->cmn.e_d_tov = 0;
4307 sp->cmn.w2.r_a_tov = 0;
4308 sp->cls1.classValid = 0;
4309 sp->cls2.seqDelivery = 1;
4310 sp->cls3.seqDelivery = 1;
4311
4312 pcmd += sizeof(uint32_t); /* CSP Word 2 */
4313 pcmd += sizeof(uint32_t); /* CSP Word 3 */
4314 pcmd += sizeof(uint32_t); /* CSP Word 4 */
4315 pcmd += sizeof(uint32_t); /* Port Name */
4316 memcpy(pcmd, &vport->fc_portname, 8);
4317 pcmd += sizeof(uint32_t); /* Node Name */
4318 pcmd += sizeof(uint32_t); /* Node Name */
4319 memcpy(pcmd, &vport->fc_nodename, 8);
4320
4321 lpfc_set_disctmo(vport);
4322
4323 phba->fc_stat.elsXmitFDISC++;
4324 elsiocb->iocb_cmpl = lpfc_cmpl_els_fdisc;
4325
858c9f6c
JS		 4326 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4327 "Issue FDISC: did:x%x",
4328 did, 0, 0);
4329
92d7f7b0
JS		 4330 rc = lpfc_issue_fabric_iocb(phba, elsiocb);
4331 if (rc == IOCB_ERROR) {
4332 lpfc_els_free_iocb(phba, elsiocb);
92d7f7b0 4333 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
e8b62011
JS		 4334 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4335 "0256 Issue FDISC: Cannot send IOCB\n");
92d7f7b0
JS		 4336 return 1;
4337 }
4338 lpfc_vport_set_state(vport, FC_VPORT_INITIALIZING);
4339 vport->port_state = LPFC_FDISC;
4340 return 0;
4341}
4342
4343static void
4344lpfc_cmpl_els_npiv_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4345 struct lpfc_iocbq *rspiocb)
4346{
4347 struct lpfc_vport *vport = cmdiocb->vport;
858c9f6c
JS		 4348 IOCB_t *irsp;
4349
4350 irsp = &rspiocb->iocb;
4351 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4352 "LOGO npiv cmpl: status:x%x/x%x did:x%x",
4353 irsp->ulpStatus, irsp->un.ulpWord[4], irsp->un.rcvels.remoteID);
92d7f7b0
JS		 4354
4355 lpfc_els_free_iocb(phba, cmdiocb);
4356 vport->unreg_vpi_cmpl = VPORT_ERROR;
4357}
4358
4359int
4360lpfc_issue_els_npiv_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
4361{
4362 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4363 struct lpfc_hba *phba = vport->phba;
4364 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4365 IOCB_t *icmd;
4366 struct lpfc_iocbq *elsiocb;
4367 uint8_t *pcmd;
4368 uint16_t cmdsize;
4369
4370 cmdsize = 2 * sizeof(uint32_t) + sizeof(struct lpfc_name);
4371 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, 0, ndlp, ndlp->nlp_DID,
4372 ELS_CMD_LOGO);
4373 if (!elsiocb)
4374 return 1;
4375
4376 icmd = &elsiocb->iocb;
4377 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
4378 *((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
4379 pcmd += sizeof(uint32_t);
4380
4381 /* Fill in LOGO payload */
4382 *((uint32_t *) (pcmd)) = be32_to_cpu(vport->fc_myDID);
4383 pcmd += sizeof(uint32_t);
4384 memcpy(pcmd, &vport->fc_portname, sizeof(struct lpfc_name));
4385
858c9f6c
JS		 4386 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4387 "Issue LOGO npiv did:x%x flg:x%x",
4388 ndlp->nlp_DID, ndlp->nlp_flag, 0);
4389
92d7f7b0
JS		 4390 elsiocb->iocb_cmpl = lpfc_cmpl_els_npiv_logo;
4391 spin_lock_irq(shost->host_lock);
4392 ndlp->nlp_flag |= NLP_LOGO_SND;
4393 spin_unlock_irq(shost->host_lock);
4394 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
4395 spin_lock_irq(shost->host_lock);
4396 ndlp->nlp_flag &= ~NLP_LOGO_SND;
4397 spin_unlock_irq(shost->host_lock);
4398 lpfc_els_free_iocb(phba, elsiocb);
4399 return 1;
4400 }
4401 return 0;
4402}
4403
4404void
4405lpfc_fabric_block_timeout(unsigned long ptr)
4406{
4407 struct lpfc_hba *phba = (struct lpfc_hba *) ptr;
4408 unsigned long iflags;
4409 uint32_t tmo_posted;
4410 spin_lock_irqsave(&phba->pport->work_port_lock, iflags);
4411 tmo_posted = phba->pport->work_port_events & WORKER_FABRIC_BLOCK_TMO;
4412 if (!tmo_posted)
4413 phba->pport->work_port_events |= WORKER_FABRIC_BLOCK_TMO;
4414 spin_unlock_irqrestore(&phba->pport->work_port_lock, iflags);
4415
4416 if (!tmo_posted) {
4417 spin_lock_irqsave(&phba->hbalock, iflags);
4418 if (phba->work_wait)
4419 lpfc_worker_wake_up(phba);
4420 spin_unlock_irqrestore(&phba->hbalock, iflags);
4421 }
4422}
4423
4424static void
4425lpfc_resume_fabric_iocbs(struct lpfc_hba *phba)
4426{
4427 struct lpfc_iocbq *iocb;
4428 unsigned long iflags;
4429 int ret;
4430 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4431 IOCB_t *cmd;
4432
4433repeat:
4434 iocb = NULL;
4435 spin_lock_irqsave(&phba->hbalock, iflags);
4436 /* Post any pending iocb to the SLI layer */
4437 if (atomic_read(&phba->fabric_iocb_count) == 0) {
4438 list_remove_head(&phba->fabric_iocb_list, iocb, typeof(*iocb),
4439 list);
4440 if (iocb)
4441 atomic_inc(&phba->fabric_iocb_count);
4442 }
4443 spin_unlock_irqrestore(&phba->hbalock, iflags);
4444 if (iocb) {
4445 iocb->fabric_iocb_cmpl = iocb->iocb_cmpl;
4446 iocb->iocb_cmpl = lpfc_cmpl_fabric_iocb;
4447 iocb->iocb_flag |= LPFC_IO_FABRIC;
4448
858c9f6c
JS		 4449 lpfc_debugfs_disc_trc(iocb->vport, LPFC_DISC_TRC_ELS_CMD,
4450 "Fabric sched1: ste:x%x",
4451 iocb->vport->port_state, 0, 0);
4452
92d7f7b0
JS		 4453 ret = lpfc_sli_issue_iocb(phba, pring, iocb, 0);
4454
4455 if (ret == IOCB_ERROR) {
4456 iocb->iocb_cmpl = iocb->fabric_iocb_cmpl;
4457 iocb->fabric_iocb_cmpl = NULL;
4458 iocb->iocb_flag &= ~LPFC_IO_FABRIC;
4459 cmd = &iocb->iocb;
4460 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4461 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4462 iocb->iocb_cmpl(phba, iocb, iocb);
4463
4464 atomic_dec(&phba->fabric_iocb_count);
4465 goto repeat;
4466 }
4467 }
4468
4469 return;
4470}
4471
4472void
4473lpfc_unblock_fabric_iocbs(struct lpfc_hba *phba)
4474{
4475 clear_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
4476
4477 lpfc_resume_fabric_iocbs(phba);
4478 return;
4479}
4480
4481static void
4482lpfc_block_fabric_iocbs(struct lpfc_hba *phba)
4483{
4484 int blocked;
4485
4486 blocked = test_and_set_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
4487 /* Start a timer to unblock fabric
4488 * iocbs after 100ms
4489 */
4490 if (!blocked)
4491 mod_timer(&phba->fabric_block_timer, jiffies + HZ/10 );
4492
4493 return;
4494}
4495
4496static void
4497lpfc_cmpl_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4498 struct lpfc_iocbq *rspiocb)
4499{
4500 struct ls_rjt stat;
4501
4502 if ((cmdiocb->iocb_flag & LPFC_IO_FABRIC) != LPFC_IO_FABRIC)
4503 BUG();
4504
4505 switch (rspiocb->iocb.ulpStatus) {
4506 case IOSTAT_NPORT_RJT:
4507 case IOSTAT_FABRIC_RJT:
4508 if (rspiocb->iocb.un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
4509 lpfc_block_fabric_iocbs(phba);
ed957684 4510 }
92d7f7b0
JS		 4511 break;
4512
4513 case IOSTAT_NPORT_BSY:
4514 case IOSTAT_FABRIC_BSY:
4515 lpfc_block_fabric_iocbs(phba);
4516 break;
4517
4518 case IOSTAT_LS_RJT:
4519 stat.un.lsRjtError =
4520 be32_to_cpu(rspiocb->iocb.un.ulpWord[4]);
4521 if ((stat.un.b.lsRjtRsnCode == LSRJT_UNABLE_TPC) ||
4522 (stat.un.b.lsRjtRsnCode == LSRJT_LOGICAL_BSY))
4523 lpfc_block_fabric_iocbs(phba);
4524 break;
4525 }
4526
4527 if (atomic_read(&phba->fabric_iocb_count) == 0)
4528 BUG();
4529
4530 cmdiocb->iocb_cmpl = cmdiocb->fabric_iocb_cmpl;
4531 cmdiocb->fabric_iocb_cmpl = NULL;
4532 cmdiocb->iocb_flag &= ~LPFC_IO_FABRIC;
4533 cmdiocb->iocb_cmpl(phba, cmdiocb, rspiocb);
4534
4535 atomic_dec(&phba->fabric_iocb_count);
4536 if (!test_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags)) {
4537 /* Post any pending iocbs to HBA */
4538 lpfc_resume_fabric_iocbs(phba);
4539 }
4540}
4541
4542int
4543lpfc_issue_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *iocb)
4544{
4545 unsigned long iflags;
4546 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4547 int ready;
4548 int ret;
4549
4550 if (atomic_read(&phba->fabric_iocb_count) > 1)
4551 BUG();
4552
4553 spin_lock_irqsave(&phba->hbalock, iflags);
4554 ready = atomic_read(&phba->fabric_iocb_count) == 0 &&
4555 !test_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
4556
4557 spin_unlock_irqrestore(&phba->hbalock, iflags);
4558 if (ready) {
4559 iocb->fabric_iocb_cmpl = iocb->iocb_cmpl;
4560 iocb->iocb_cmpl = lpfc_cmpl_fabric_iocb;
4561 iocb->iocb_flag |= LPFC_IO_FABRIC;
4562
858c9f6c
JS		 4563 lpfc_debugfs_disc_trc(iocb->vport, LPFC_DISC_TRC_ELS_CMD,
4564 "Fabric sched2: ste:x%x",
4565 iocb->vport->port_state, 0, 0);
4566
92d7f7b0
JS		 4567 atomic_inc(&phba->fabric_iocb_count);
4568 ret = lpfc_sli_issue_iocb(phba, pring, iocb, 0);
4569
4570 if (ret == IOCB_ERROR) {
4571 iocb->iocb_cmpl = iocb->fabric_iocb_cmpl;
4572 iocb->fabric_iocb_cmpl = NULL;
4573 iocb->iocb_flag &= ~LPFC_IO_FABRIC;
4574 atomic_dec(&phba->fabric_iocb_count);
4575 }
4576 } else {
4577 spin_lock_irqsave(&phba->hbalock, iflags);
4578 list_add_tail(&iocb->list, &phba->fabric_iocb_list);
4579 spin_unlock_irqrestore(&phba->hbalock, iflags);
4580 ret = IOCB_SUCCESS;
4581 }
4582 return ret;
4583}
4584
4585
4586void lpfc_fabric_abort_vport(struct lpfc_vport *vport)
4587{
4588 LIST_HEAD(completions);
4589 struct lpfc_hba *phba = vport->phba;
4590 struct lpfc_iocbq *tmp_iocb, *piocb;
4591 IOCB_t *cmd;
4592
4593 spin_lock_irq(&phba->hbalock);
4594 list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list,
4595 list) {
4596
4597 if (piocb->vport != vport)
4598 continue;
4599
4600 list_move_tail(&piocb->list, &completions);
4601 }
4602 spin_unlock_irq(&phba->hbalock);
4603
4604 while (!list_empty(&completions)) {
4605 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
4606 list_del_init(&piocb->list);
4607
4608 cmd = &piocb->iocb;
4609 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4610 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4611 (piocb->iocb_cmpl) (phba, piocb, piocb);
4612 }
4613}
4614
4615void lpfc_fabric_abort_nport(struct lpfc_nodelist *ndlp)
4616{
4617 LIST_HEAD(completions);
4618 struct lpfc_hba *phba = ndlp->vport->phba;
4619 struct lpfc_iocbq *tmp_iocb, *piocb;
4620 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4621 IOCB_t *cmd;
4622
4623 spin_lock_irq(&phba->hbalock);
4624 list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list,
4625 list) {
4626 if ((lpfc_check_sli_ndlp(phba, pring, piocb, ndlp))) {
4627
4628 list_move_tail(&piocb->list, &completions);
ed957684 4629 }
dea3101e 4630 }
92d7f7b0
JS		 4631 spin_unlock_irq(&phba->hbalock);
4632
4633 while (!list_empty(&completions)) {
4634 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
4635 list_del_init(&piocb->list);
4636
4637 cmd = &piocb->iocb;
4638 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4639 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4640 (piocb->iocb_cmpl) (phba, piocb, piocb);
4641 }
4642}
4643
4644void lpfc_fabric_abort_hba(struct lpfc_hba *phba)
4645{
4646 LIST_HEAD(completions);
4647 struct lpfc_iocbq *piocb;
4648 IOCB_t *cmd;
4649
4650 spin_lock_irq(&phba->hbalock);
4651 list_splice_init(&phba->fabric_iocb_list, &completions);
4652 spin_unlock_irq(&phba->hbalock);
4653
4654 while (!list_empty(&completions)) {
4655 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
4656 list_del_init(&piocb->list);
4657
4658 cmd = &piocb->iocb;
4659 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4660 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4661 (piocb->iocb_cmpl) (phba, piocb, piocb);
4662 }
dea3101e 4663}
92d7f7b0
JS		 4664
4665
4666void lpfc_fabric_abort_flogi(struct lpfc_hba *phba)
4667{
4668 LIST_HEAD(completions);
4669 struct lpfc_iocbq *tmp_iocb, *piocb;
4670 IOCB_t *cmd;
4671 struct lpfc_nodelist *ndlp;
4672
4673 spin_lock_irq(&phba->hbalock);
4674 list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list,
4675 list) {
4676
4677 cmd = &piocb->iocb;
4678 ndlp = (struct lpfc_nodelist *) piocb->context1;
4679 if (cmd->ulpCommand == CMD_ELS_REQUEST64_CR &&
4680 ndlp != NULL &&
4681 ndlp->nlp_DID == Fabric_DID)
4682 list_move_tail(&piocb->list, &completions);
4683 }
4684 spin_unlock_irq(&phba->hbalock);
4685
4686 while (!list_empty(&completions)) {
4687 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
4688 list_del_init(&piocb->list);
4689
4690 cmd = &piocb->iocb;
4691 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4692 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4693 (piocb->iocb_cmpl) (phba, piocb, piocb);
4694 }
4695}
4696
4697
Clone of davem's net-next-2.6 tree