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