]> 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: NPIV: split ports
[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"
38
39static int lpfc_els_retry(struct lpfc_hba *, struct lpfc_iocbq *,
40 struct lpfc_iocbq *);
41static int lpfc_max_els_tries = 3;
42
43static int
2e0fef85 44lpfc_els_chk_latt(struct lpfc_vport *vport)
dea3101e 45{
2e0fef85
JS		 46 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
47 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 48 LPFC_MBOXQ_t *mbox;
49 uint32_t ha_copy;
50 int rc;
51
2e0fef85
JS		 52 if (vport->port_state >= LPFC_VPORT_READY ||
53 phba->link_state == LPFC_LINK_DOWN)
dea3101e
JB		 54 return 0;
55
56 /* Read the HBA Host Attention Register */
dea3101e 57 ha_copy = readl(phba->HAregaddr);
dea3101e
JB		 58
59 if (!(ha_copy & HA_LATT))
60 return 0;
61
62 /* Pending Link Event during Discovery */
63 lpfc_printf_log(phba, KERN_WARNING, LOG_DISCOVERY,
64 "%d:0237 Pending Link Event during "
65 "Discovery: State x%x\n",
2e0fef85 66 phba->brd_no, phba->pport->port_state);
dea3101e
JB		 67
68 /* CLEAR_LA should re-enable link attention events and
69 * we should then imediately take a LATT event. The
70 * LATT processing should call lpfc_linkdown() which
71 * will cleanup any left over in-progress discovery
72 * events.
73 */
2e0fef85
JS		 74 spin_lock_irq(shost->host_lock);
75 vport->fc_flag |= FC_ABORT_DISCOVERY;
76 spin_unlock_irq(shost->host_lock);
dea3101e 77
2e0fef85 78 if (phba->link_state != LPFC_CLEAR_LA) {
dea3101e 79 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) {
2e0fef85 80 phba->link_state = LPFC_CLEAR_LA;
dea3101e
JB		 81 lpfc_clear_la(phba, mbox);
82 mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la;
2e0fef85
JS		 83 mbox->vport = vport;
84 printk(KERN_ERR "%s (%d): do clear_la\n",
85 __FUNCTION__, __LINE__);
86 rc = lpfc_sli_issue_mbox(phba, mbox,
87 (MBX_NOWAIT | MBX_STOP_IOCB));
dea3101e
JB		 88 if (rc == MBX_NOT_FINISHED) {
89 mempool_free(mbox, phba->mbox_mem_pool);
2e0fef85 90 phba->link_state = LPFC_HBA_ERROR;
dea3101e
JB		 91 }
92 }
93 }
94
c9f8735b 95 return 1;
dea3101e
JB		 96
97}
98
99static struct lpfc_iocbq *
2e0fef85
JS		 100lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
101 uint16_t cmdSize, uint8_t retry,
102 struct lpfc_nodelist *ndlp, uint32_t did,
103 uint32_t elscmd)
dea3101e 104{
2e0fef85 105 struct lpfc_hba *phba = vport->phba;
0bd4ca25 106 struct lpfc_iocbq *elsiocb;
dea3101e
JB		 107 struct lpfc_dmabuf *pcmd, *prsp, *pbuflist;
108 struct ulp_bde64 *bpl;
109 IOCB_t *icmd;
110
dea3101e 111
2e0fef85
JS		 112 if (!lpfc_is_link_up(phba))
113 return NULL;
dea3101e 114
dea3101e 115 /* Allocate buffer for command iocb */
0bd4ca25 116 elsiocb = lpfc_sli_get_iocbq(phba);
dea3101e
JB		 117
118 if (elsiocb == NULL)
119 return NULL;
dea3101e
JB		 120 icmd = &elsiocb->iocb;
121
122 /* fill in BDEs for command */
123 /* Allocate buffer for command payload */
124 if (((pcmd = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL)) == 0) ||
125 ((pcmd->virt = lpfc_mbuf_alloc(phba,
126 MEM_PRI, &(pcmd->phys))) == 0)) {
c9475cb0 127 kfree(pcmd);
dea3101e 128
604a3e30 129 lpfc_sli_release_iocbq(phba, elsiocb);
dea3101e
JB		 130 return NULL;
131 }
132
133 INIT_LIST_HEAD(&pcmd->list);
134
135 /* Allocate buffer for response payload */
136 if (expectRsp) {
137 prsp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
138 if (prsp)
139 prsp->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
140 &prsp->phys);
141 if (prsp == 0 || prsp->virt == 0) {
c9475cb0 142 kfree(prsp);
dea3101e
JB		 143 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
144 kfree(pcmd);
604a3e30 145 lpfc_sli_release_iocbq(phba, elsiocb);
dea3101e
JB		 146 return NULL;
147 }
148 INIT_LIST_HEAD(&prsp->list);
149 } else {
150 prsp = NULL;
151 }
152
153 /* Allocate buffer for Buffer ptr list */
154 pbuflist = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
155 if (pbuflist)
156 pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
157 &pbuflist->phys);
158 if (pbuflist == 0 || pbuflist->virt == 0) {
604a3e30 159 lpfc_sli_release_iocbq(phba, elsiocb);
dea3101e
JB		 160 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
161 lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
162 kfree(pcmd);
163 kfree(prsp);
c9475cb0 164 kfree(pbuflist);
dea3101e
JB		 165 return NULL;
166 }
167
168 INIT_LIST_HEAD(&pbuflist->list);
169
170 icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
171 icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
172 icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BDL;
2e0fef85 173 icmd->un.elsreq64.remoteID = did; /* DID */
dea3101e
JB		 174 if (expectRsp) {
175 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof (struct ulp_bde64));
dea3101e 176 icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
2680eeaa 177 icmd->ulpTimeout = phba->fc_ratov * 2;
dea3101e
JB		 178 } else {
179 icmd->un.elsreq64.bdl.bdeSize = sizeof (struct ulp_bde64);
180 icmd->ulpCommand = CMD_XMIT_ELS_RSP64_CX;
181 }
182
183 icmd->ulpBdeCount = 1;
184 icmd->ulpLe = 1;
185 icmd->ulpClass = CLASS3;
186
187 bpl = (struct ulp_bde64 *) pbuflist->virt;
188 bpl->addrLow = le32_to_cpu(putPaddrLow(pcmd->phys));
189 bpl->addrHigh = le32_to_cpu(putPaddrHigh(pcmd->phys));
190 bpl->tus.f.bdeSize = cmdSize;
191 bpl->tus.f.bdeFlags = 0;
192 bpl->tus.w = le32_to_cpu(bpl->tus.w);
193
194 if (expectRsp) {
195 bpl++;
196 bpl->addrLow = le32_to_cpu(putPaddrLow(prsp->phys));
197 bpl->addrHigh = le32_to_cpu(putPaddrHigh(prsp->phys));
198 bpl->tus.f.bdeSize = FCELSSIZE;
199 bpl->tus.f.bdeFlags = BUFF_USE_RCV;
200 bpl->tus.w = le32_to_cpu(bpl->tus.w);
201 }
202
203 /* Save for completion so we can release these resources */
329f9bc7
JS		 204 elsiocb->context1 = lpfc_nlp_get(ndlp);
205 elsiocb->context2 = pcmd;
206 elsiocb->context3 = pbuflist;
dea3101e 207 elsiocb->retry = retry;
2e0fef85 208 elsiocb->vport = vport;
dea3101e
JB		 209 elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
210
211 if (prsp) {
212 list_add(&prsp->list, &pcmd->list);
213 }
214
215 if (expectRsp) {
216 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
217 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
218 "%d:0116 Xmit ELS command x%x to remote "
2e0fef85
JS		 219 "NPORT x%x I/O tag: x%x, port state: x%x\n",
220 phba->brd_no, elscmd, did,
221 elsiocb->iotag, vport->port_state);
dea3101e
JB		 222 } else {
223 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
224 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
225 "%d:0117 Xmit ELS response x%x to remote "
1dcb58e5 226 "NPORT x%x I/O tag: x%x, size: x%x\n",
dea3101e 227 phba->brd_no, elscmd,
1dcb58e5 228 ndlp->nlp_DID, elsiocb->iotag, cmdSize);
dea3101e
JB		 229 }
230
c9f8735b 231 return elsiocb;
dea3101e
JB		 232}
233
234
235static int
2e0fef85
JS		 236lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
237 struct serv_parm *sp, IOCB_t *irsp)
dea3101e 238{
2e0fef85
JS		 239 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
240 struct lpfc_hba *phba = vport->phba;
dea3101e 241 LPFC_MBOXQ_t *mbox;
14691150 242 struct lpfc_dmabuf *mp;
dea3101e
JB		 243 int rc;
244
2e0fef85
JS		 245 spin_lock_irq(shost->host_lock);
246 vport->fc_flag |= FC_FABRIC;
247 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 248
249 phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov);
250 if (sp->cmn.edtovResolution) /* E_D_TOV ticks are in nanoseconds */
251 phba->fc_edtov = (phba->fc_edtov + 999999) / 1000000;
252
253 phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
254
255 if (phba->fc_topology == TOPOLOGY_LOOP) {
2e0fef85
JS		 256 spin_lock_irq(shost->host_lock);
257 vport->fc_flag |= FC_PUBLIC_LOOP;
258 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 259 } else {
260 /*
261 * If we are a N-port connected to a Fabric, fixup sparam's so
262 * logins to devices on remote loops work.
263 */
2e0fef85 264 vport->fc_sparam.cmn.altBbCredit = 1;
dea3101e
JB		 265 }
266
2e0fef85 267 vport->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
dea3101e
JB		 268 memcpy(&ndlp->nlp_portname, &sp->portName, sizeof(struct lpfc_name));
269 memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof (struct lpfc_name));
270 ndlp->nlp_class_sup = 0;
271 if (sp->cls1.classValid)
272 ndlp->nlp_class_sup |= FC_COS_CLASS1;
273 if (sp->cls2.classValid)
274 ndlp->nlp_class_sup |= FC_COS_CLASS2;
275 if (sp->cls3.classValid)
276 ndlp->nlp_class_sup |= FC_COS_CLASS3;
277 if (sp->cls4.classValid)
278 ndlp->nlp_class_sup |= FC_COS_CLASS4;
279 ndlp->nlp_maxframe = ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) |
280 sp->cmn.bbRcvSizeLsb;
281 memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
282
2e0fef85
JS		 283 ndlp->nlp_sid = irsp->un.ulpWord[4] & Mask_DID;
284
dea3101e
JB		 285 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
286 if (!mbox)
287 goto fail;
288
2e0fef85 289 vport->port_state = LPFC_FABRIC_CFG_LINK;
dea3101e
JB		 290 lpfc_config_link(phba, mbox);
291 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
292
293 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
294 if (rc == MBX_NOT_FINISHED)
295 goto fail_free_mbox;
296
297 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
298 if (!mbox)
299 goto fail;
2e0fef85
JS		 300 rc = lpfc_reg_login(phba, Fabric_DID, (uint8_t *) sp, mbox, 0);
301 if (rc)
dea3101e
JB		 302 goto fail_free_mbox;
303
dea3101e 304 mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login;
2e0fef85 305 mbox->vport = vport;
329f9bc7 306 mbox->context2 = lpfc_nlp_get(ndlp);
dea3101e
JB		 307
308 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT | MBX_STOP_IOCB);
309 if (rc == MBX_NOT_FINISHED)
14691150 310 goto fail_issue_reg_login;
dea3101e
JB		 311
312 return 0;
313
14691150 314 fail_issue_reg_login:
329f9bc7 315 lpfc_nlp_put(ndlp);
14691150
JS		 316 mp = (struct lpfc_dmabuf *) mbox->context1;
317 lpfc_mbuf_free(phba, mp->virt, mp->phys);
318 kfree(mp);
dea3101e
JB		 319 fail_free_mbox:
320 mempool_free(mbox, phba->mbox_mem_pool);
321 fail:
322 return -ENXIO;
323}
324
325/*
326 * We FLOGIed into an NPort, initiate pt2pt protocol
327 */
328static int
2e0fef85
JS		 329lpfc_cmpl_els_flogi_nport(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
330 struct serv_parm *sp)
dea3101e 331{
2e0fef85
JS		 332 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
333 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 334 LPFC_MBOXQ_t *mbox;
335 int rc;
336
2e0fef85
JS		 337 spin_lock_irq(shost->host_lock);
338 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
339 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 340
341 phba->fc_edtov = FF_DEF_EDTOV;
342 phba->fc_ratov = FF_DEF_RATOV;
2e0fef85 343 rc = memcmp(&vport->fc_portname, &sp->portName,
dea3101e
JB		 344 sizeof(struct lpfc_name));
345 if (rc >= 0) {
346 /* This side will initiate the PLOGI */
2e0fef85
JS		 347 spin_lock_irq(shost->host_lock);
348 vport->fc_flag |= FC_PT2PT_PLOGI;
349 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 350
351 /*
352 * N_Port ID cannot be 0, set our to LocalID the other
353 * side will be RemoteID.
354 */
355
356 /* not equal */
357 if (rc)
2e0fef85 358 vport->fc_myDID = PT2PT_LocalID;
dea3101e
JB		 359
360 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
361 if (!mbox)
362 goto fail;
363
364 lpfc_config_link(phba, mbox);
365
366 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
367 rc = lpfc_sli_issue_mbox(phba, mbox,
368 MBX_NOWAIT | MBX_STOP_IOCB);
369 if (rc == MBX_NOT_FINISHED) {
370 mempool_free(mbox, phba->mbox_mem_pool);
371 goto fail;
372 }
329f9bc7 373 lpfc_nlp_put(ndlp);
dea3101e 374
2e0fef85 375 ndlp = lpfc_findnode_did(vport, PT2PT_RemoteID);
dea3101e
JB		 376 if (!ndlp) {
377 /*
378 * Cannot find existing Fabric ndlp, so allocate a
379 * new one
380 */
381 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
382 if (!ndlp)
383 goto fail;
384
2e0fef85 385 lpfc_nlp_init(vport, ndlp, PT2PT_RemoteID);
dea3101e
JB		 386 }
387
388 memcpy(&ndlp->nlp_portname, &sp->portName,
2e0fef85 389 sizeof(struct lpfc_name));
dea3101e 390 memcpy(&ndlp->nlp_nodename, &sp->nodeName,
2e0fef85
JS		 391 sizeof(struct lpfc_name));
392 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
393 spin_lock_irq(shost->host_lock);
dea3101e 394 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2e0fef85 395 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 396 } else {
397 /* This side will wait for the PLOGI */
329f9bc7 398 lpfc_nlp_put(ndlp);
dea3101e
JB		 399 }
400
2e0fef85
JS		 401 spin_lock_irq(shost->host_lock);
402 vport->fc_flag |= FC_PT2PT;
403 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 404
405 /* Start discovery - this should just do CLEAR_LA */
2e0fef85 406 lpfc_disc_start(vport);
dea3101e
JB		 407 return 0;
408 fail:
409 return -ENXIO;
410}
411
412static void
329f9bc7
JS		 413lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
414 struct lpfc_iocbq *rspiocb)
dea3101e 415{
2e0fef85
JS		 416 struct lpfc_vport *vport = cmdiocb->vport;
417 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e
JB		 418 IOCB_t *irsp = &rspiocb->iocb;
419 struct lpfc_nodelist *ndlp = cmdiocb->context1;
420 struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
421 struct serv_parm *sp;
422 int rc;
423
424 /* Check to see if link went down during discovery */
2e0fef85 425 if (lpfc_els_chk_latt(vport)) {
329f9bc7 426 lpfc_nlp_put(ndlp);
dea3101e
JB		 427 goto out;
428 }
429
430 if (irsp->ulpStatus) {
431 /* Check for retry */
2e0fef85 432 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
dea3101e 433 goto out;
2e0fef85 434
dea3101e 435 /* FLOGI failed, so there is no fabric */
2e0fef85
JS		 436 spin_lock_irq(shost->host_lock);
437 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
438 spin_unlock_irq(shost->host_lock);
dea3101e 439
329f9bc7 440 /* If private loop, then allow max outstanding els to be
dea3101e
JB		 441 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
442 * alpa map would take too long otherwise.
443 */
444 if (phba->alpa_map[0] == 0) {
329f9bc7 445 phba->cfg_discovery_threads = LPFC_MAX_DISC_THREADS;
dea3101e
JB		 446 }
447
448 /* FLOGI failure */
449 lpfc_printf_log(phba,
450 KERN_INFO,
451 LOG_ELS,
c9f8735b 452 "%d:0100 FLOGI failure Data: x%x x%x x%x\n",
dea3101e 453 phba->brd_no,
c9f8735b
JW		 454 irsp->ulpStatus, irsp->un.ulpWord[4],
455 irsp->ulpTimeout);
dea3101e
JB		 456 goto flogifail;
457 }
458
459 /*
460 * The FLogI succeeded. Sync the data for the CPU before
461 * accessing it.
462 */
463 prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list);
464
465 sp = prsp->virt + sizeof(uint32_t);
466
467 /* FLOGI completes successfully */
468 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
469 "%d:0101 FLOGI completes sucessfully "
470 "Data: x%x x%x x%x x%x\n",
471 phba->brd_no,
472 irsp->un.ulpWord[4], sp->cmn.e_d_tov,
473 sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
474
2e0fef85 475 if (vport->port_state == LPFC_FLOGI) {
dea3101e
JB		 476 /*
477 * If Common Service Parameters indicate Nport
478 * we are point to point, if Fport we are Fabric.
479 */
480 if (sp->cmn.fPort)
2e0fef85 481 rc = lpfc_cmpl_els_flogi_fabric(vport, ndlp, sp, irsp);
dea3101e 482 else
2e0fef85 483 rc = lpfc_cmpl_els_flogi_nport(vport, ndlp, sp);
dea3101e
JB		 484
485 if (!rc)
486 goto out;
487 }
488
489flogifail:
329f9bc7 490 lpfc_nlp_put(ndlp);
dea3101e
JB		 491
492 if (irsp->ulpStatus != IOSTAT_LOCAL_REJECT ||
493 (irsp->un.ulpWord[4] != IOERR_SLI_ABORTED &&
494 irsp->un.ulpWord[4] != IOERR_SLI_DOWN)) {
495 /* FLOGI failed, so just use loop map to make discovery list */
2e0fef85 496 lpfc_disc_list_loopmap(vport);
dea3101e
JB		 497
498 /* Start discovery */
2e0fef85 499 lpfc_disc_start(vport);
dea3101e
JB		 500 }
501
502out:
503 lpfc_els_free_iocb(phba, cmdiocb);
504}
505
506static int
2e0fef85 507lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
dea3101e
JB		 508 uint8_t retry)
509{
2e0fef85 510 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 511 struct serv_parm *sp;
512 IOCB_t *icmd;
513 struct lpfc_iocbq *elsiocb;
514 struct lpfc_sli_ring *pring;
515 uint8_t *pcmd;
516 uint16_t cmdsize;
517 uint32_t tmo;
518 int rc;
519
520 pring = &phba->sli.ring[LPFC_ELS_RING];
521
522 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
2e0fef85
JS		 523 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
524 ndlp->nlp_DID, ELS_CMD_FLOGI);
488d1469 525 if (!elsiocb)
c9f8735b 526 return 1;
dea3101e
JB		 527
528 icmd = &elsiocb->iocb;
529 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
530
531 /* For FLOGI request, remainder of payload is service parameters */
532 *((uint32_t *) (pcmd)) = ELS_CMD_FLOGI;
533 pcmd += sizeof (uint32_t);
2e0fef85 534 memcpy(pcmd, &vport->fc_sparam, sizeof (struct serv_parm));
dea3101e
JB		 535 sp = (struct serv_parm *) pcmd;
536
537 /* Setup CSPs accordingly for Fabric */
538 sp->cmn.e_d_tov = 0;
539 sp->cmn.w2.r_a_tov = 0;
540 sp->cls1.classValid = 0;
541 sp->cls2.seqDelivery = 1;
542 sp->cls3.seqDelivery = 1;
543 if (sp->cmn.fcphLow < FC_PH3)
544 sp->cmn.fcphLow = FC_PH3;
545 if (sp->cmn.fcphHigh < FC_PH3)
546 sp->cmn.fcphHigh = FC_PH3;
547
548 tmo = phba->fc_ratov;
549 phba->fc_ratov = LPFC_DISC_FLOGI_TMO;
2e0fef85 550 lpfc_set_disctmo(vport);
dea3101e
JB		 551 phba->fc_ratov = tmo;
552
553 phba->fc_stat.elsXmitFLOGI++;
554 elsiocb->iocb_cmpl = lpfc_cmpl_els_flogi;
dea3101e 555 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
dea3101e
JB		 556 if (rc == IOCB_ERROR) {
557 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 558 return 1;
dea3101e 559 }
c9f8735b 560 return 0;
dea3101e
JB		 561}
562
563int
2e0fef85 564lpfc_els_abort_flogi(struct lpfc_hba *phba)
dea3101e
JB		 565{
566 struct lpfc_sli_ring *pring;
567 struct lpfc_iocbq *iocb, *next_iocb;
568 struct lpfc_nodelist *ndlp;
569 IOCB_t *icmd;
570
571 /* Abort outstanding I/O on NPort <nlp_DID> */
572 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
573 "%d:0201 Abort outstanding I/O on NPort x%x\n",
574 phba->brd_no, Fabric_DID);
575
576 pring = &phba->sli.ring[LPFC_ELS_RING];
577
578 /*
579 * Check the txcmplq for an iocb that matches the nport the driver is
580 * searching for.
581 */
2e0fef85 582 spin_lock_irq(&phba->hbalock);
dea3101e
JB		 583 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
584 icmd = &iocb->iocb;
2e0fef85
JS		 585 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR &&
586 icmd->un.elsreq64.bdl.ulpIoTag32) {
dea3101e 587 ndlp = (struct lpfc_nodelist *)(iocb->context1);
07951076
JS		 588 if (ndlp && (ndlp->nlp_DID == Fabric_DID))
589 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
dea3101e
JB		 590 }
591 }
2e0fef85 592 spin_unlock_irq(&phba->hbalock);
dea3101e
JB		 593
594 return 0;
595}
596
597int
2e0fef85 598lpfc_initial_flogi(struct lpfc_vport *vport)
dea3101e 599{
2e0fef85 600 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 601 struct lpfc_nodelist *ndlp;
602
c9f8735b 603 /* First look for the Fabric ndlp */
2e0fef85 604 ndlp = lpfc_findnode_did(vport, Fabric_DID);
c9f8735b 605 if (!ndlp) {
dea3101e 606 /* Cannot find existing Fabric ndlp, so allocate a new one */
c9f8735b
JW		 607 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
608 if (!ndlp)
609 return 0;
2e0fef85 610 lpfc_nlp_init(vport, ndlp, Fabric_DID);
c9f8735b 611 } else {
2e0fef85 612 lpfc_dequeue_node(vport, ndlp);
dea3101e 613 }
2e0fef85 614 if (lpfc_issue_els_flogi(vport, ndlp, 0)) {
329f9bc7 615 lpfc_nlp_put(ndlp);
dea3101e 616 }
c9f8735b 617 return 1;
dea3101e
JB		 618}
619
620static void
2e0fef85 621lpfc_more_plogi(struct lpfc_vport *vport)
dea3101e
JB		 622{
623 int sentplogi;
2e0fef85 624 struct lpfc_hba *phba = vport->phba;
dea3101e 625
2e0fef85
JS		 626 if (vport->num_disc_nodes)
627 vport->num_disc_nodes--;
dea3101e
JB		 628
629 /* Continue discovery with <num_disc_nodes> PLOGIs to go */
630 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
631 "%d:0232 Continue discovery with %d PLOGIs to go "
632 "Data: x%x x%x x%x\n",
2e0fef85
JS		 633 phba->brd_no, vport->num_disc_nodes,
634 vport->fc_plogi_cnt, vport->fc_flag, vport->port_state);
dea3101e
JB		 635
636 /* Check to see if there are more PLOGIs to be sent */
2e0fef85
JS		 637 if (vport->fc_flag & FC_NLP_MORE)
638 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
639 sentplogi = lpfc_els_disc_plogi(vport);
640
dea3101e
JB		 641 return;
642}
643
488d1469 644static struct lpfc_nodelist *
685f0bf7 645lpfc_plogi_confirm_nport(struct lpfc_hba *phba, struct lpfc_dmabuf *prsp,
488d1469
JS		 646 struct lpfc_nodelist *ndlp)
647{
2e0fef85 648 struct lpfc_vport *vport = ndlp->vport;
488d1469 649 struct lpfc_nodelist *new_ndlp;
488d1469
JS		 650 uint32_t *lp;
651 struct serv_parm *sp;
652 uint8_t name[sizeof (struct lpfc_name)];
653 uint32_t rc;
654
2fb9bd8b
JS		 655 /* Fabric nodes can have the same WWPN so we don't bother searching
656 * by WWPN. Just return the ndlp that was given to us.
657 */
658 if (ndlp->nlp_type & NLP_FABRIC)
659 return ndlp;
660
488d1469
JS		 661 lp = (uint32_t *) prsp->virt;
662 sp = (struct serv_parm *) ((uint8_t *) lp + sizeof (uint32_t));
685f0bf7 663 memset(name, 0, sizeof(struct lpfc_name));
488d1469 664
685f0bf7 665 /* Now we find out if the NPort we are logging into, matches the WWPN
488d1469
JS		 666 * we have for that ndlp. If not, we have some work to do.
667 */
2e0fef85 668 new_ndlp = lpfc_findnode_wwpn(vport, &sp->portName);
488d1469 669
92795650 670 if (new_ndlp == ndlp)
488d1469 671 return ndlp;
488d1469
JS		 672
673 if (!new_ndlp) {
2e0fef85
JS		 674 rc = memcmp(&ndlp->nlp_portname, name,
675 sizeof(struct lpfc_name));
92795650
JS		 676 if (!rc)
677 return ndlp;
488d1469
JS		 678 new_ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_ATOMIC);
679 if (!new_ndlp)
680 return ndlp;
681
2e0fef85 682 lpfc_nlp_init(vport, new_ndlp, ndlp->nlp_DID);
488d1469
JS		 683 }
684
2e0fef85 685 lpfc_unreg_rpi(vport, new_ndlp);
488d1469 686 new_ndlp->nlp_DID = ndlp->nlp_DID;
92795650 687 new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
2e0fef85 688 lpfc_nlp_set_state(vport, new_ndlp, ndlp->nlp_state);
488d1469 689
2e0fef85 690 /* Move this back to NPR state */
de0c5b32 691 if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0)
2e0fef85 692 lpfc_drop_node(vport, ndlp);
92795650 693 else {
2e0fef85 694 lpfc_unreg_rpi(vport, ndlp);
92795650 695 ndlp->nlp_DID = 0; /* Two ndlps cannot have the same did */
2e0fef85 696 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
92795650 697 }
488d1469
JS		 698 return new_ndlp;
699}
700
dea3101e 701static void
2e0fef85
JS		 702lpfc_cmpl_els_plogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
703 struct lpfc_iocbq *rspiocb)
dea3101e 704{
2e0fef85
JS		 705 struct lpfc_vport *vport = cmdiocb->vport;
706 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e 707 IOCB_t *irsp;
dea3101e 708 struct lpfc_nodelist *ndlp;
92795650 709 struct lpfc_dmabuf *prsp;
dea3101e
JB		 710 int disc, rc, did, type;
711
dea3101e
JB		 712 /* we pass cmdiocb to state machine which needs rspiocb as well */
713 cmdiocb->context_un.rsp_iocb = rspiocb;
714
715 irsp = &rspiocb->iocb;
2e0fef85 716 ndlp = lpfc_findnode_did(vport, irsp->un.elsreq64.remoteID);
488d1469
JS		 717 if (!ndlp)
718 goto out;
dea3101e
JB		 719
720 /* Since ndlp can be freed in the disc state machine, note if this node
721 * is being used during discovery.
722 */
2e0fef85 723 spin_lock_irq(shost->host_lock);
dea3101e 724 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
488d1469 725 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
2e0fef85 726 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 727 rc = 0;
728
729 /* PLOGI completes to NPort <nlp_DID> */
730 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
731 "%d:0102 PLOGI completes to NPort x%x "
c9f8735b 732 "Data: x%x x%x x%x x%x x%x\n",
dea3101e 733 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
c9f8735b 734 irsp->un.ulpWord[4], irsp->ulpTimeout, disc,
2e0fef85 735 vport->num_disc_nodes);
dea3101e
JB		 736
737 /* Check to see if link went down during discovery */
2e0fef85
JS		 738 if (lpfc_els_chk_latt(vport)) {
739 spin_lock_irq(shost->host_lock);
dea3101e 740 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2e0fef85 741 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 742 goto out;
743 }
744
745 /* ndlp could be freed in DSM, save these values now */
746 type = ndlp->nlp_type;
747 did = ndlp->nlp_DID;
748
749 if (irsp->ulpStatus) {
750 /* Check for retry */
751 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
752 /* ELS command is being retried */
753 if (disc) {
2e0fef85 754 spin_lock_irq(shost->host_lock);
dea3101e 755 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2e0fef85 756 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 757 }
758 goto out;
759 }
760
761 /* PLOGI failed */
762 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
763 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
764 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
6281bfe0 765 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
dea3101e 766 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
c9f8735b 767 rc = NLP_STE_FREED_NODE;
2fe165b6 768 } else {
2e0fef85 769 rc = lpfc_disc_state_machine(vport, ndlp, cmdiocb,
dea3101e
JB		 770 NLP_EVT_CMPL_PLOGI);
771 }
772 } else {
773 /* Good status, call state machine */
92795650
JS		 774 prsp = list_entry(((struct lpfc_dmabuf *)
775 cmdiocb->context2)->list.next,
776 struct lpfc_dmabuf, list);
777 ndlp = lpfc_plogi_confirm_nport(phba, prsp, ndlp);
2e0fef85 778 rc = lpfc_disc_state_machine(vport, ndlp, cmdiocb,
dea3101e
JB		 779 NLP_EVT_CMPL_PLOGI);
780 }
781
2e0fef85 782 if (disc && vport->num_disc_nodes) {
dea3101e 783 /* Check to see if there are more PLOGIs to be sent */
2e0fef85 784 lpfc_more_plogi(vport);
dea3101e 785
2e0fef85
JS		 786 if (vport->num_disc_nodes == 0) {
787 spin_lock_irq(shost->host_lock);
788 vport->fc_flag &= ~FC_NDISC_ACTIVE;
789 spin_unlock_irq(shost->host_lock);
dea3101e 790
2e0fef85
JS		 791 lpfc_can_disctmo(vport);
792 if (vport->fc_flag & FC_RSCN_MODE) {
10d4e957
JS		 793 /*
794 * Check to see if more RSCNs came in while
795 * we were processing this one.
796 */
2e0fef85
JS		 797 if ((vport->fc_rscn_id_cnt == 0) &&
798 (!(vport->fc_flag & FC_RSCN_DISCOVERY))) {
799 spin_lock_irq(shost->host_lock);
800 vport->fc_flag &= ~FC_RSCN_MODE;
801 spin_unlock_irq(shost->host_lock);
10d4e957 802 } else {
2e0fef85 803 lpfc_els_handle_rscn(vport);
10d4e957 804 }
dea3101e
JB		 805 }
806 }
807 }
808
809out:
810 lpfc_els_free_iocb(phba, cmdiocb);
811 return;
812}
813
814int
2e0fef85 815lpfc_issue_els_plogi(struct lpfc_vport *vport, uint32_t did, uint8_t retry)
dea3101e 816{
2e0fef85 817 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 818 struct serv_parm *sp;
819 IOCB_t *icmd;
820 struct lpfc_iocbq *elsiocb;
821 struct lpfc_sli_ring *pring;
822 struct lpfc_sli *psli;
823 uint8_t *pcmd;
824 uint16_t cmdsize;
825
826 psli = &phba->sli;
827 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
828
829 cmdsize = (sizeof (uint32_t) + sizeof (struct serv_parm));
2e0fef85
JS		 830 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, NULL, did,
831 ELS_CMD_PLOGI);
c9f8735b
JW		 832 if (!elsiocb)
833 return 1;
dea3101e
JB		 834
835 icmd = &elsiocb->iocb;
836 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
837
838 /* For PLOGI request, remainder of payload is service parameters */
839 *((uint32_t *) (pcmd)) = ELS_CMD_PLOGI;
840 pcmd += sizeof (uint32_t);
2e0fef85 841 memcpy(pcmd, &vport->fc_sparam, sizeof (struct serv_parm));
dea3101e
JB		 842 sp = (struct serv_parm *) pcmd;
843
844 if (sp->cmn.fcphLow < FC_PH_4_3)
845 sp->cmn.fcphLow = FC_PH_4_3;
846
847 if (sp->cmn.fcphHigh < FC_PH3)
848 sp->cmn.fcphHigh = FC_PH3;
849
850 phba->fc_stat.elsXmitPLOGI++;
851 elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi;
dea3101e 852 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
dea3101e 853 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 854 return 1;
dea3101e 855 }
c9f8735b 856 return 0;
dea3101e
JB		 857}
858
859static void
2e0fef85
JS		 860lpfc_cmpl_els_prli(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
861 struct lpfc_iocbq *rspiocb)
dea3101e 862{
2e0fef85
JS		 863 struct lpfc_vport *vport = cmdiocb->vport;
864 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e
JB		 865 IOCB_t *irsp;
866 struct lpfc_sli *psli;
867 struct lpfc_nodelist *ndlp;
868
869 psli = &phba->sli;
870 /* we pass cmdiocb to state machine which needs rspiocb as well */
871 cmdiocb->context_un.rsp_iocb = rspiocb;
872
873 irsp = &(rspiocb->iocb);
874 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
2e0fef85 875 spin_lock_irq(shost->host_lock);
dea3101e 876 ndlp->nlp_flag &= ~NLP_PRLI_SND;
2e0fef85 877 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 878
879 /* PRLI completes to NPort <nlp_DID> */
880 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
881 "%d:0103 PRLI completes to NPort x%x "
c9f8735b 882 "Data: x%x x%x x%x x%x\n",
dea3101e 883 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
c9f8735b 884 irsp->un.ulpWord[4], irsp->ulpTimeout,
2e0fef85 885 vport->num_disc_nodes);
dea3101e 886
2e0fef85 887 vport->fc_prli_sent--;
dea3101e 888 /* Check to see if link went down during discovery */
2e0fef85 889 if (lpfc_els_chk_latt(vport))
dea3101e
JB		 890 goto out;
891
892 if (irsp->ulpStatus) {
893 /* Check for retry */
894 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
895 /* ELS command is being retried */
896 goto out;
897 }
898 /* PRLI failed */
899 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
900 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
901 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
6281bfe0 902 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
dea3101e
JB		 903 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
904 goto out;
2fe165b6 905 } else {
2e0fef85 906 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
dea3101e
JB		 907 NLP_EVT_CMPL_PRLI);
908 }
909 } else {
910 /* Good status, call state machine */
2e0fef85
JS		 911 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
912 NLP_EVT_CMPL_PRLI);
dea3101e
JB		 913 }
914
915out:
916 lpfc_els_free_iocb(phba, cmdiocb);
917 return;
918}
919
920int
2e0fef85 921lpfc_issue_els_prli(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
dea3101e
JB		 922 uint8_t retry)
923{
2e0fef85
JS		 924 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
925 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 926 PRLI *npr;
927 IOCB_t *icmd;
928 struct lpfc_iocbq *elsiocb;
929 struct lpfc_sli_ring *pring;
930 struct lpfc_sli *psli;
931 uint8_t *pcmd;
932 uint16_t cmdsize;
933
934 psli = &phba->sli;
935 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
936
937 cmdsize = (sizeof (uint32_t) + sizeof (PRLI));
2e0fef85
JS		 938 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
939 ndlp->nlp_DID, ELS_CMD_PRLI);
488d1469 940 if (!elsiocb)
c9f8735b 941 return 1;
dea3101e
JB		 942
943 icmd = &elsiocb->iocb;
944 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
945
946 /* For PRLI request, remainder of payload is service parameters */
947 memset(pcmd, 0, (sizeof (PRLI) + sizeof (uint32_t)));
948 *((uint32_t *) (pcmd)) = ELS_CMD_PRLI;
949 pcmd += sizeof (uint32_t);
950
951 /* For PRLI, remainder of payload is PRLI parameter page */
952 npr = (PRLI *) pcmd;
953 /*
954 * If our firmware version is 3.20 or later,
955 * set the following bits for FC-TAPE support.
956 */
957 if (phba->vpd.rev.feaLevelHigh >= 0x02) {
958 npr->ConfmComplAllowed = 1;
959 npr->Retry = 1;
960 npr->TaskRetryIdReq = 1;
961 }
962 npr->estabImagePair = 1;
963 npr->readXferRdyDis = 1;
964
965 /* For FCP support */
966 npr->prliType = PRLI_FCP_TYPE;
967 npr->initiatorFunc = 1;
968
969 phba->fc_stat.elsXmitPRLI++;
970 elsiocb->iocb_cmpl = lpfc_cmpl_els_prli;
2e0fef85 971 spin_lock_irq(shost->host_lock);
dea3101e 972 ndlp->nlp_flag |= NLP_PRLI_SND;
2e0fef85 973 spin_unlock_irq(shost->host_lock);
dea3101e 974 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2e0fef85 975 spin_lock_irq(shost->host_lock);
dea3101e 976 ndlp->nlp_flag &= ~NLP_PRLI_SND;
2e0fef85 977 spin_unlock_irq(shost->host_lock);
dea3101e 978 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 979 return 1;
dea3101e 980 }
2e0fef85 981 vport->fc_prli_sent++;
c9f8735b 982 return 0;
dea3101e
JB		 983}
984
985static void
2e0fef85 986lpfc_more_adisc(struct lpfc_vport *vport)
dea3101e
JB		 987{
988 int sentadisc;
2e0fef85 989 struct lpfc_hba *phba = vport->phba;
dea3101e 990
2e0fef85
JS		 991 if (vport->num_disc_nodes)
992 vport->num_disc_nodes--;
dea3101e
JB		 993
994 /* Continue discovery with <num_disc_nodes> ADISCs to go */
995 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
996 "%d:0210 Continue discovery with %d ADISCs to go "
997 "Data: x%x x%x x%x\n",
2e0fef85
JS		 998 phba->brd_no, vport->num_disc_nodes,
999 vport->fc_adisc_cnt, vport->fc_flag, vport->port_state);
dea3101e
JB		 1000
1001 /* Check to see if there are more ADISCs to be sent */
2e0fef85
JS		 1002 if (vport->fc_flag & FC_NLP_MORE) {
1003 lpfc_set_disctmo(vport);
1004 /* go thru NPR nodes and issue any remaining ELS ADISCs */
1005 sentadisc = lpfc_els_disc_adisc(vport);
dea3101e
JB		 1006 }
1007 return;
1008}
1009
1010static void
2e0fef85 1011lpfc_rscn_disc(struct lpfc_vport *vport)
dea3101e 1012{
2e0fef85
JS		 1013 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1014
dea3101e 1015 /* RSCN discovery */
2e0fef85
JS		 1016 /* go thru NPR nodes and issue ELS PLOGIs */
1017 if (vport->fc_npr_cnt)
1018 if (lpfc_els_disc_plogi(vport))
dea3101e 1019 return;
2e0fef85
JS		 1020
1021 if (vport->fc_flag & FC_RSCN_MODE) {
dea3101e
JB		 1022 /* Check to see if more RSCNs came in while we were
1023 * processing this one.
1024 */
2e0fef85
JS		 1025 if ((vport->fc_rscn_id_cnt == 0) &&
1026 (!(vport->fc_flag & FC_RSCN_DISCOVERY))) {
1027 spin_lock_irq(shost->host_lock);
1028 vport->fc_flag &= ~FC_RSCN_MODE;
1029 spin_unlock_irq(shost->host_lock);
dea3101e 1030 } else {
2e0fef85 1031 lpfc_els_handle_rscn(vport);
dea3101e
JB		 1032 }
1033 }
1034}
1035
1036static void
2e0fef85
JS		 1037lpfc_cmpl_els_adisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1038 struct lpfc_iocbq *rspiocb)
dea3101e 1039{
2e0fef85
JS		 1040 struct lpfc_vport *vport = cmdiocb->vport;
1041 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e 1042 IOCB_t *irsp;
dea3101e 1043 struct lpfc_nodelist *ndlp;
2e0fef85 1044 int disc;
dea3101e
JB		 1045
1046 /* we pass cmdiocb to state machine which needs rspiocb as well */
1047 cmdiocb->context_un.rsp_iocb = rspiocb;
1048
1049 irsp = &(rspiocb->iocb);
1050 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
dea3101e
JB		 1051
1052 /* Since ndlp can be freed in the disc state machine, note if this node
1053 * is being used during discovery.
1054 */
2e0fef85 1055 spin_lock_irq(shost->host_lock);
dea3101e 1056 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
c9f8735b 1057 ndlp->nlp_flag &= ~(NLP_ADISC_SND | NLP_NPR_2B_DISC);
2e0fef85 1058 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 1059
1060 /* ADISC completes to NPort <nlp_DID> */
1061 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1062 "%d:0104 ADISC completes to NPort x%x "
c9f8735b 1063 "Data: x%x x%x x%x x%x x%x\n",
dea3101e 1064 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
c9f8735b 1065 irsp->un.ulpWord[4], irsp->ulpTimeout, disc,
2e0fef85 1066 vport->num_disc_nodes);
dea3101e
JB		 1067
1068 /* Check to see if link went down during discovery */
2e0fef85
JS		 1069 if (lpfc_els_chk_latt(vport)) {
1070 spin_lock_irq(shost->host_lock);
dea3101e 1071 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2e0fef85 1072 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 1073 goto out;
1074 }
1075
1076 if (irsp->ulpStatus) {
1077 /* Check for retry */
1078 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1079 /* ELS command is being retried */
1080 if (disc) {
2e0fef85 1081 spin_lock_irq(shost->host_lock);
dea3101e 1082 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2e0fef85
JS		 1083 spin_unlock_irq(shost->host_lock);
1084 lpfc_set_disctmo(vport);
dea3101e
JB		 1085 }
1086 goto out;
1087 }
1088 /* ADISC failed */
1089 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
c9f8735b
JW		 1090 if ((irsp->ulpStatus != IOSTAT_LOCAL_REJECT) ||
1091 ((irsp->un.ulpWord[4] != IOERR_SLI_ABORTED) &&
1092 (irsp->un.ulpWord[4] != IOERR_LINK_DOWN) &&
1093 (irsp->un.ulpWord[4] != IOERR_SLI_DOWN))) {
2e0fef85 1094 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
dea3101e
JB		 1095 NLP_EVT_CMPL_ADISC);
1096 }
1097 } else {
1098 /* Good status, call state machine */
2e0fef85 1099 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
dea3101e
JB		 1100 NLP_EVT_CMPL_ADISC);
1101 }
1102
2e0fef85 1103 if (disc && vport->num_disc_nodes) {
dea3101e 1104 /* Check to see if there are more ADISCs to be sent */
2e0fef85 1105 lpfc_more_adisc(vport);
dea3101e
JB		 1106
1107 /* Check to see if we are done with ADISC authentication */
2e0fef85
JS		 1108 if (vport->num_disc_nodes == 0) {
1109 lpfc_can_disctmo(vport);
dea3101e 1110 /* If we get here, there is nothing left to wait for */
2e0fef85
JS		 1111 if (vport->port_state < LPFC_VPORT_READY &&
1112 phba->link_state != LPFC_CLEAR_LA) {
1113 if (vport->port_type == LPFC_PHYSICAL_PORT) {
1114 lpfc_issue_clear_la(phba, vport);
dea3101e
JB		 1115 }
1116 } else {
2e0fef85 1117 lpfc_rscn_disc(vport);
dea3101e
JB		 1118 }
1119 }
1120 }
dea3101e
JB		 1121out:
1122 lpfc_els_free_iocb(phba, cmdiocb);
1123 return;
1124}
1125
1126int
2e0fef85 1127lpfc_issue_els_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
dea3101e
JB		 1128 uint8_t retry)
1129{
2e0fef85
JS		 1130 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1131 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 1132 ADISC *ap;
1133 IOCB_t *icmd;
1134 struct lpfc_iocbq *elsiocb;
2e0fef85
JS		 1135 struct lpfc_sli *psli = &phba->sli;
1136 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
dea3101e
JB		 1137 uint8_t *pcmd;
1138 uint16_t cmdsize;
1139
dea3101e 1140 cmdsize = (sizeof (uint32_t) + sizeof (ADISC));
2e0fef85
JS		 1141 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1142 ndlp->nlp_DID, ELS_CMD_ADISC);
488d1469 1143 if (!elsiocb)
c9f8735b 1144 return 1;
dea3101e
JB		 1145
1146 icmd = &elsiocb->iocb;
1147 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1148
1149 /* For ADISC request, remainder of payload is service parameters */
1150 *((uint32_t *) (pcmd)) = ELS_CMD_ADISC;
1151 pcmd += sizeof (uint32_t);
1152
1153 /* Fill in ADISC payload */
1154 ap = (ADISC *) pcmd;
1155 ap->hardAL_PA = phba->fc_pref_ALPA;
2e0fef85
JS		 1156 memcpy(&ap->portName, &vport->fc_portname, sizeof (struct lpfc_name));
1157 memcpy(&ap->nodeName, &vport->fc_nodename, sizeof (struct lpfc_name));
1158 ap->DID = be32_to_cpu(vport->fc_myDID);
dea3101e
JB		 1159
1160 phba->fc_stat.elsXmitADISC++;
1161 elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc;
2e0fef85 1162 spin_lock_irq(shost->host_lock);
dea3101e 1163 ndlp->nlp_flag |= NLP_ADISC_SND;
2e0fef85 1164 spin_unlock_irq(shost->host_lock);
dea3101e 1165 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2e0fef85 1166 spin_lock_irq(shost->host_lock);
dea3101e 1167 ndlp->nlp_flag &= ~NLP_ADISC_SND;
2e0fef85 1168 spin_unlock_irq(shost->host_lock);
dea3101e 1169 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 1170 return 1;
dea3101e 1171 }
c9f8735b 1172 return 0;
dea3101e
JB		 1173}
1174
1175static void
2e0fef85
JS		 1176lpfc_cmpl_els_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1177 struct lpfc_iocbq *rspiocb)
dea3101e 1178{
2e0fef85
JS		 1179 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1180 struct lpfc_vport *vport = ndlp->vport;
1181 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e
JB		 1182 IOCB_t *irsp;
1183 struct lpfc_sli *psli;
dea3101e
JB		 1184
1185 psli = &phba->sli;
1186 /* we pass cmdiocb to state machine which needs rspiocb as well */
1187 cmdiocb->context_un.rsp_iocb = rspiocb;
1188
1189 irsp = &(rspiocb->iocb);
2e0fef85 1190 spin_lock_irq(shost->host_lock);
dea3101e 1191 ndlp->nlp_flag &= ~NLP_LOGO_SND;
2e0fef85 1192 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 1193
1194 /* LOGO completes to NPort <nlp_DID> */
1195 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1196 "%d:0105 LOGO completes to NPort x%x "
c9f8735b 1197 "Data: x%x x%x x%x x%x\n",
dea3101e 1198 phba->brd_no, ndlp->nlp_DID, irsp->ulpStatus,
c9f8735b 1199 irsp->un.ulpWord[4], irsp->ulpTimeout,
2e0fef85 1200 vport->num_disc_nodes);
dea3101e
JB		 1201
1202 /* Check to see if link went down during discovery */
2e0fef85 1203 if (lpfc_els_chk_latt(vport))
dea3101e
JB		 1204 goto out;
1205
1206 if (irsp->ulpStatus) {
1207 /* Check for retry */
2e0fef85 1208 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
dea3101e
JB		 1209 /* ELS command is being retried */
1210 goto out;
dea3101e
JB		 1211 /* LOGO failed */
1212 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1213 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1214 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
6281bfe0 1215 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
dea3101e
JB		 1216 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN))) {
1217 goto out;
2fe165b6 1218 } else {
2e0fef85 1219 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
dea3101e
JB		 1220 NLP_EVT_CMPL_LOGO);
1221 }
1222 } else {
5024ab17
JW		 1223 /* Good status, call state machine.
1224 * This will unregister the rpi if needed.
1225 */
2e0fef85
JS		 1226 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1227 NLP_EVT_CMPL_LOGO);
dea3101e
JB		 1228 }
1229
1230out:
1231 lpfc_els_free_iocb(phba, cmdiocb);
1232 return;
1233}
1234
1235int
2e0fef85 1236lpfc_issue_els_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
dea3101e
JB		 1237 uint8_t retry)
1238{
2e0fef85
JS		 1239 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1240 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 1241 IOCB_t *icmd;
1242 struct lpfc_iocbq *elsiocb;
1243 struct lpfc_sli_ring *pring;
1244 struct lpfc_sli *psli;
1245 uint8_t *pcmd;
1246 uint16_t cmdsize;
1247
1248 psli = &phba->sli;
1249 pring = &psli->ring[LPFC_ELS_RING];
1250
10d4e957 1251 cmdsize = (2 * sizeof (uint32_t)) + sizeof (struct lpfc_name);
2e0fef85
JS		 1252 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1253 ndlp->nlp_DID, ELS_CMD_LOGO);
488d1469 1254 if (!elsiocb)
c9f8735b 1255 return 1;
dea3101e
JB		 1256
1257 icmd = &elsiocb->iocb;
1258 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1259 *((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
1260 pcmd += sizeof (uint32_t);
1261
1262 /* Fill in LOGO payload */
2e0fef85 1263 *((uint32_t *) (pcmd)) = be32_to_cpu(vport->fc_myDID);
dea3101e 1264 pcmd += sizeof (uint32_t);
2e0fef85 1265 memcpy(pcmd, &vport->fc_portname, sizeof (struct lpfc_name));
dea3101e
JB		 1266
1267 phba->fc_stat.elsXmitLOGO++;
1268 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo;
2e0fef85 1269 spin_lock_irq(shost->host_lock);
dea3101e 1270 ndlp->nlp_flag |= NLP_LOGO_SND;
2e0fef85 1271 spin_unlock_irq(shost->host_lock);
dea3101e 1272 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2e0fef85 1273 spin_lock_irq(shost->host_lock);
dea3101e 1274 ndlp->nlp_flag &= ~NLP_LOGO_SND;
2e0fef85 1275 spin_unlock_irq(shost->host_lock);
dea3101e 1276 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 1277 return 1;
dea3101e 1278 }
c9f8735b 1279 return 0;
dea3101e
JB		 1280}
1281
1282static void
2e0fef85
JS		 1283lpfc_cmpl_els_cmd(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1284 struct lpfc_iocbq *rspiocb)
dea3101e 1285{
2e0fef85 1286 struct lpfc_vport *vport = cmdiocb->vport;
dea3101e
JB		 1287 IOCB_t *irsp;
1288
1289 irsp = &rspiocb->iocb;
1290
1291 /* ELS cmd tag <ulpIoTag> completes */
1292 lpfc_printf_log(phba,
1293 KERN_INFO,
1294 LOG_ELS,
c9f8735b 1295 "%d:0106 ELS cmd tag x%x completes Data: x%x x%x x%x\n",
dea3101e 1296 phba->brd_no,
c9f8735b
JW		 1297 irsp->ulpIoTag, irsp->ulpStatus,
1298 irsp->un.ulpWord[4], irsp->ulpTimeout);
dea3101e
JB		 1299
1300 /* Check to see if link went down during discovery */
2e0fef85 1301 lpfc_els_chk_latt(vport);
dea3101e
JB		 1302 lpfc_els_free_iocb(phba, cmdiocb);
1303 return;
1304}
1305
1306int
2e0fef85 1307lpfc_issue_els_scr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
dea3101e 1308{
2e0fef85 1309 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 1310 IOCB_t *icmd;
1311 struct lpfc_iocbq *elsiocb;
1312 struct lpfc_sli_ring *pring;
1313 struct lpfc_sli *psli;
1314 uint8_t *pcmd;
1315 uint16_t cmdsize;
1316 struct lpfc_nodelist *ndlp;
1317
1318 psli = &phba->sli;
1319 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1320 cmdsize = (sizeof (uint32_t) + sizeof (SCR));
c9f8735b
JW		 1321 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1322 if (!ndlp)
1323 return 1;
dea3101e 1324
2e0fef85
JS		 1325 lpfc_nlp_init(vport, ndlp, nportid);
1326
1327 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1328 ndlp->nlp_DID, ELS_CMD_SCR);
dea3101e 1329
488d1469 1330 if (!elsiocb) {
329f9bc7 1331 lpfc_nlp_put(ndlp);
c9f8735b 1332 return 1;
dea3101e
JB		 1333 }
1334
1335 icmd = &elsiocb->iocb;
1336 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1337
1338 *((uint32_t *) (pcmd)) = ELS_CMD_SCR;
1339 pcmd += sizeof (uint32_t);
1340
1341 /* For SCR, remainder of payload is SCR parameter page */
1342 memset(pcmd, 0, sizeof (SCR));
1343 ((SCR *) pcmd)->Function = SCR_FUNC_FULL;
1344
1345 phba->fc_stat.elsXmitSCR++;
1346 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
dea3101e 1347 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
329f9bc7 1348 lpfc_nlp_put(ndlp);
dea3101e 1349 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 1350 return 1;
dea3101e 1351 }
329f9bc7 1352 lpfc_nlp_put(ndlp);
c9f8735b 1353 return 0;
dea3101e
JB		 1354}
1355
1356static int
2e0fef85 1357lpfc_issue_els_farpr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
dea3101e 1358{
2e0fef85 1359 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 1360 IOCB_t *icmd;
1361 struct lpfc_iocbq *elsiocb;
1362 struct lpfc_sli_ring *pring;
1363 struct lpfc_sli *psli;
1364 FARP *fp;
1365 uint8_t *pcmd;
1366 uint32_t *lp;
1367 uint16_t cmdsize;
1368 struct lpfc_nodelist *ondlp;
1369 struct lpfc_nodelist *ndlp;
1370
1371 psli = &phba->sli;
1372 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1373 cmdsize = (sizeof (uint32_t) + sizeof (FARP));
c9f8735b
JW		 1374 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1375 if (!ndlp)
1376 return 1;
dea3101e 1377
2e0fef85
JS		 1378 lpfc_nlp_init(vport, ndlp, nportid);
1379
1380 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1381 ndlp->nlp_DID, ELS_CMD_RNID);
488d1469 1382 if (!elsiocb) {
329f9bc7 1383 lpfc_nlp_put(ndlp);
c9f8735b 1384 return 1;
dea3101e
JB		 1385 }
1386
1387 icmd = &elsiocb->iocb;
1388 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1389
1390 *((uint32_t *) (pcmd)) = ELS_CMD_FARPR;
1391 pcmd += sizeof (uint32_t);
1392
1393 /* Fill in FARPR payload */
1394 fp = (FARP *) (pcmd);
1395 memset(fp, 0, sizeof (FARP));
1396 lp = (uint32_t *) pcmd;
1397 *lp++ = be32_to_cpu(nportid);
2e0fef85 1398 *lp++ = be32_to_cpu(vport->fc_myDID);
dea3101e
JB		 1399 fp->Rflags = 0;
1400 fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE);
1401
2e0fef85
JS		 1402 memcpy(&fp->RportName, &vport->fc_portname, sizeof (struct lpfc_name));
1403 memcpy(&fp->RnodeName, &vport->fc_nodename, sizeof (struct lpfc_name));
1404 ondlp = lpfc_findnode_did(vport, nportid);
1405 if (ondlp) {
dea3101e
JB		 1406 memcpy(&fp->OportName, &ondlp->nlp_portname,
1407 sizeof (struct lpfc_name));
1408 memcpy(&fp->OnodeName, &ondlp->nlp_nodename,
1409 sizeof (struct lpfc_name));
1410 }
1411
1412 phba->fc_stat.elsXmitFARPR++;
1413 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
dea3101e 1414 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
329f9bc7 1415 lpfc_nlp_put(ndlp);
dea3101e 1416 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 1417 return 1;
dea3101e 1418 }
329f9bc7 1419 lpfc_nlp_put(ndlp);
c9f8735b 1420 return 0;
dea3101e
JB		 1421}
1422
fdcebe28 1423void
2e0fef85 1424lpfc_cancel_retry_delay_tmo(struct lpfc_vport *vport, struct lpfc_nodelist *nlp)
fdcebe28 1425{
2e0fef85
JS		 1426 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1427
1428 spin_lock_irq(shost->host_lock);
fdcebe28 1429 nlp->nlp_flag &= ~NLP_DELAY_TMO;
2e0fef85 1430 spin_unlock_irq(shost->host_lock);
fdcebe28
JS		 1431 del_timer_sync(&nlp->nlp_delayfunc);
1432 nlp->nlp_last_elscmd = 0;
1433
1434 if (!list_empty(&nlp->els_retry_evt.evt_listp))
1435 list_del_init(&nlp->els_retry_evt.evt_listp);
1436
1437 if (nlp->nlp_flag & NLP_NPR_2B_DISC) {
2e0fef85 1438 spin_lock_irq(shost->host_lock);
fdcebe28 1439 nlp->nlp_flag &= ~NLP_NPR_2B_DISC;
2e0fef85
JS		 1440 spin_unlock_irq(shost->host_lock);
1441 if (vport->num_disc_nodes) {
fdcebe28
JS		 1442 /* Check to see if there are more
1443 * PLOGIs to be sent
1444 */
2e0fef85
JS		 1445 lpfc_more_plogi(vport);
1446
1447 if (vport->num_disc_nodes == 0) {
1448 spin_lock_irq(shost->host_lock);
1449 vport->fc_flag &= ~FC_NDISC_ACTIVE;
1450 spin_unlock_irq(shost->host_lock);
1451 lpfc_can_disctmo(vport);
1452 if (vport->fc_flag & FC_RSCN_MODE) {
10d4e957
JS		 1453 /*
1454 * Check to see if more RSCNs
1455 * came in while we were
1456 * processing this one.
1457 */
2e0fef85
JS		 1458 if (!vport->fc_rscn_id_cnt &&
1459 !(vport->fc_flag &
1460 FC_RSCN_DISCOVERY)) {
1461 spin_lock_irq(shost->host_lock);
1462 vport->fc_flag &= ~FC_RSCN_MODE;
1463 spin_unlock_irq(
1464 shost->host_lock);
10d4e957
JS		 1465 }
1466 else {
2e0fef85 1467 lpfc_els_handle_rscn(vport);
10d4e957 1468 }
fdcebe28
JS		 1469 }
1470 }
1471 }
1472 }
1473 return;
1474}
1475
dea3101e
JB		 1476void
1477lpfc_els_retry_delay(unsigned long ptr)
1478{
2e0fef85
JS		 1479 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) ptr;
1480 struct lpfc_vport *vport = ndlp->vport;
1481 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1482 struct lpfc_hba *phba = vport->phba;
dea3101e 1483 unsigned long iflag;
2e0fef85 1484 struct lpfc_work_evt *evtp = &ndlp->els_retry_evt;
dea3101e 1485
2e0fef85
JS		 1486 ndlp = (struct lpfc_nodelist *) ptr;
1487 phba = ndlp->vport->phba;
dea3101e
JB		 1488 evtp = &ndlp->els_retry_evt;
1489
2e0fef85 1490 spin_lock_irqsave(shost->host_lock, iflag);
dea3101e 1491 if (!list_empty(&evtp->evt_listp)) {
2e0fef85 1492 spin_unlock_irqrestore(shost->host_lock, iflag);
dea3101e
JB		 1493 return;
1494 }
1495
1496 evtp->evt_arg1 = ndlp;
1497 evtp->evt = LPFC_EVT_ELS_RETRY;
1498 list_add_tail(&evtp->evt_listp, &phba->work_list);
1499 if (phba->work_wait)
1500 wake_up(phba->work_wait);
1501
2e0fef85 1502 spin_unlock_irqrestore(shost->host_lock, iflag);
dea3101e
JB		 1503 return;
1504}
1505
1506void
1507lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
1508{
2e0fef85
JS		 1509 struct lpfc_vport *vport = ndlp->vport;
1510 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1511 uint32_t cmd, did, retry;
dea3101e 1512
2e0fef85 1513 spin_lock_irq(shost->host_lock);
5024ab17
JW		 1514 did = ndlp->nlp_DID;
1515 cmd = ndlp->nlp_last_elscmd;
1516 ndlp->nlp_last_elscmd = 0;
dea3101e
JB		 1517
1518 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
2e0fef85 1519 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 1520 return;
1521 }
1522
1523 ndlp->nlp_flag &= ~NLP_DELAY_TMO;
2e0fef85 1524 spin_unlock_irq(shost->host_lock);
1a169689
JS		 1525 /*
1526 * If a discovery event readded nlp_delayfunc after timer
1527 * firing and before processing the timer, cancel the
1528 * nlp_delayfunc.
1529 */
1530 del_timer_sync(&ndlp->nlp_delayfunc);
dea3101e
JB		 1531 retry = ndlp->nlp_retry;
1532
1533 switch (cmd) {
1534 case ELS_CMD_FLOGI:
2e0fef85 1535 lpfc_issue_els_flogi(vport, ndlp, retry);
dea3101e
JB		 1536 break;
1537 case ELS_CMD_PLOGI:
2e0fef85 1538 if (!lpfc_issue_els_plogi(vport, ndlp->nlp_DID, retry)) {
5024ab17 1539 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1540 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
6ad42535 1541 }
dea3101e
JB		 1542 break;
1543 case ELS_CMD_ADISC:
2e0fef85 1544 if (!lpfc_issue_els_adisc(vport, ndlp, retry)) {
5024ab17 1545 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1546 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
6ad42535 1547 }
dea3101e
JB		 1548 break;
1549 case ELS_CMD_PRLI:
2e0fef85 1550 if (!lpfc_issue_els_prli(vport, ndlp, retry)) {
5024ab17 1551 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1552 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
6ad42535 1553 }
dea3101e
JB		 1554 break;
1555 case ELS_CMD_LOGO:
2e0fef85 1556 if (!lpfc_issue_els_logo(vport, ndlp, retry)) {
5024ab17 1557 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1558 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
6ad42535 1559 }
dea3101e
JB		 1560 break;
1561 }
1562 return;
1563}
1564
1565static int
2e0fef85
JS		 1566lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1567 struct lpfc_iocbq *rspiocb)
dea3101e 1568{
2e0fef85
JS		 1569 struct lpfc_vport *vport = cmdiocb->vport;
1570 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1571 IOCB_t *irsp = &rspiocb->iocb;
1572 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1573 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
dea3101e
JB		 1574 uint32_t *elscmd;
1575 struct ls_rjt stat;
2e0fef85
JS		 1576 int retry = 0, maxretry = lpfc_max_els_tries, delay = 0;
1577 uint32_t cmd = 0;
488d1469 1578 uint32_t did;
dea3101e 1579
488d1469 1580
dea3101e
JB		 1581 /* Note: context2 may be 0 for internal driver abort
1582 * of delays ELS command.
1583 */
1584
1585 if (pcmd && pcmd->virt) {
1586 elscmd = (uint32_t *) (pcmd->virt);
1587 cmd = *elscmd++;
1588 }
1589
329f9bc7 1590 if (ndlp)
488d1469
JS		 1591 did = ndlp->nlp_DID;
1592 else {
1593 /* We should only hit this case for retrying PLOGI */
1594 did = irsp->un.elsreq64.remoteID;
2e0fef85 1595 ndlp = lpfc_findnode_did(vport, did);
488d1469
JS		 1596 if (!ndlp && (cmd != ELS_CMD_PLOGI))
1597 return 1;
1598 }
1599
dea3101e
JB		 1600 switch (irsp->ulpStatus) {
1601 case IOSTAT_FCP_RSP_ERROR:
1602 case IOSTAT_REMOTE_STOP:
1603 break;
1604
1605 case IOSTAT_LOCAL_REJECT:
1606 switch ((irsp->un.ulpWord[4] & 0xff)) {
1607 case IOERR_LOOP_OPEN_FAILURE:
2e0fef85 1608 if (cmd == ELS_CMD_PLOGI && cmdiocb->retry == 0)
dea3101e 1609 delay = 1;
dea3101e
JB		 1610 retry = 1;
1611 break;
1612
1613 case IOERR_SEQUENCE_TIMEOUT:
1614 retry = 1;
dea3101e
JB		 1615 break;
1616
1617 case IOERR_NO_RESOURCES:
2e0fef85 1618 if (cmd == ELS_CMD_PLOGI)
dea3101e 1619 delay = 1;
dea3101e
JB		 1620 retry = 1;
1621 break;
1622
1623 case IOERR_INVALID_RPI:
1624 retry = 1;
1625 break;
1626 }
1627 break;
1628
1629 case IOSTAT_NPORT_RJT:
1630 case IOSTAT_FABRIC_RJT:
1631 if (irsp->un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
1632 retry = 1;
1633 break;
1634 }
1635 break;
1636
1637 case IOSTAT_NPORT_BSY:
1638 case IOSTAT_FABRIC_BSY:
1639 retry = 1;
1640 break;
1641
1642 case IOSTAT_LS_RJT:
1643 stat.un.lsRjtError = be32_to_cpu(irsp->un.ulpWord[4]);
1644 /* Added for Vendor specifc support
1645 * Just keep retrying for these Rsn / Exp codes
1646 */
1647 switch (stat.un.b.lsRjtRsnCode) {
1648 case LSRJT_UNABLE_TPC:
1649 if (stat.un.b.lsRjtRsnCodeExp ==
1650 LSEXP_CMD_IN_PROGRESS) {
1651 if (cmd == ELS_CMD_PLOGI) {
1652 delay = 1;
1653 maxretry = 48;
1654 }
1655 retry = 1;
1656 break;
1657 }
1658 if (cmd == ELS_CMD_PLOGI) {
1659 delay = 1;
1660 maxretry = lpfc_max_els_tries + 1;
1661 retry = 1;
1662 break;
1663 }
1664 break;
1665
1666 case LSRJT_LOGICAL_BSY:
1667 if (cmd == ELS_CMD_PLOGI) {
1668 delay = 1;
1669 maxretry = 48;
1670 }
1671 retry = 1;
1672 break;
1673 }
1674 break;
1675
1676 case IOSTAT_INTERMED_RSP:
1677 case IOSTAT_BA_RJT:
1678 break;
1679
1680 default:
1681 break;
1682 }
1683
488d1469 1684 if (did == FDMI_DID)
dea3101e 1685 retry = 1;
dea3101e
JB		 1686
1687 if ((++cmdiocb->retry) >= maxretry) {
1688 phba->fc_stat.elsRetryExceeded++;
1689 retry = 0;
1690 }
1691
1692 if (retry) {
1693
1694 /* Retry ELS command <elsCmd> to remote NPORT <did> */
1695 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1696 "%d:0107 Retry ELS command x%x to remote "
1697 "NPORT x%x Data: x%x x%x\n",
1698 phba->brd_no,
488d1469 1699 cmd, did, cmdiocb->retry, delay);
dea3101e
JB		 1700
1701 if ((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) {
1702 /* If discovery / RSCN timer is running, reset it */
2e0fef85
JS		 1703 if (timer_pending(&vport->fc_disctmo) ||
1704 (vport->fc_flag & FC_RSCN_MODE))
1705 lpfc_set_disctmo(vport);
dea3101e
JB		 1706 }
1707
1708 phba->fc_stat.elsXmitRetry++;
488d1469 1709 if (ndlp && delay) {
dea3101e
JB		 1710 phba->fc_stat.elsDelayRetry++;
1711 ndlp->nlp_retry = cmdiocb->retry;
1712
1713 mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
2e0fef85 1714 spin_lock_irq(shost->host_lock);
dea3101e 1715 ndlp->nlp_flag |= NLP_DELAY_TMO;
2e0fef85 1716 spin_unlock_irq(shost->host_lock);
dea3101e 1717
5024ab17 1718 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1719 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
dea3101e
JB		 1720 ndlp->nlp_last_elscmd = cmd;
1721
c9f8735b 1722 return 1;
dea3101e
JB		 1723 }
1724 switch (cmd) {
1725 case ELS_CMD_FLOGI:
2e0fef85 1726 lpfc_issue_els_flogi(vport, ndlp, cmdiocb->retry);
c9f8735b 1727 return 1;
dea3101e 1728 case ELS_CMD_PLOGI:
488d1469
JS		 1729 if (ndlp) {
1730 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 1731 lpfc_nlp_set_state(vport, ndlp,
de0c5b32 1732 NLP_STE_PLOGI_ISSUE);
488d1469 1733 }
2e0fef85 1734 lpfc_issue_els_plogi(vport, did, cmdiocb->retry);
c9f8735b 1735 return 1;
dea3101e 1736 case ELS_CMD_ADISC:
5024ab17 1737 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 1738 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
1739 lpfc_issue_els_adisc(vport, ndlp, cmdiocb->retry);
c9f8735b 1740 return 1;
dea3101e 1741 case ELS_CMD_PRLI:
5024ab17 1742 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 1743 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
1744 lpfc_issue_els_prli(vport, ndlp, cmdiocb->retry);
c9f8735b 1745 return 1;
dea3101e 1746 case ELS_CMD_LOGO:
5024ab17 1747 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 1748 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1749 lpfc_issue_els_logo(vport, ndlp, cmdiocb->retry);
c9f8735b 1750 return 1;
dea3101e
JB		 1751 }
1752 }
1753
1754 /* No retry ELS command <elsCmd> to remote NPORT <did> */
1755 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1756 "%d:0108 No retry ELS command x%x to remote NPORT x%x "
488d1469 1757 "Data: x%x\n",
dea3101e 1758 phba->brd_no,
488d1469 1759 cmd, did, cmdiocb->retry);
dea3101e 1760
c9f8735b 1761 return 0;
dea3101e
JB		 1762}
1763
1764int
329f9bc7 1765lpfc_els_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *elsiocb)
dea3101e
JB		 1766{
1767 struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
1768
329f9bc7
JS		 1769 if (elsiocb->context1) {
1770 lpfc_nlp_put(elsiocb->context1);
1771 elsiocb->context1 = NULL;
1772 }
dea3101e
JB		 1773 /* context2 = cmd, context2->next = rsp, context3 = bpl */
1774 if (elsiocb->context2) {
1775 buf_ptr1 = (struct lpfc_dmabuf *) elsiocb->context2;
1776 /* Free the response before processing the command. */
1777 if (!list_empty(&buf_ptr1->list)) {
1778 list_remove_head(&buf_ptr1->list, buf_ptr,
1779 struct lpfc_dmabuf,
1780 list);
1781 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1782 kfree(buf_ptr);
1783 }
1784 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
1785 kfree(buf_ptr1);
1786 }
1787
1788 if (elsiocb->context3) {
1789 buf_ptr = (struct lpfc_dmabuf *) elsiocb->context3;
1790 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1791 kfree(buf_ptr);
1792 }
604a3e30 1793 lpfc_sli_release_iocbq(phba, elsiocb);
dea3101e
JB		 1794 return 0;
1795}
1796
1797static void
2e0fef85
JS		 1798lpfc_cmpl_els_logo_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1799 struct lpfc_iocbq *rspiocb)
dea3101e 1800{
2e0fef85
JS		 1801 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1802 struct lpfc_vport *vport = cmdiocb->vport;
dea3101e
JB		 1803
1804 /* ACC to LOGO completes to NPort <nlp_DID> */
1805 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1806 "%d:0109 ACC to LOGO completes to NPort x%x "
1807 "Data: x%x x%x x%x\n",
1808 phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag,
1809 ndlp->nlp_state, ndlp->nlp_rpi);
1810
dea3101e
JB		 1811 switch (ndlp->nlp_state) {
1812 case NLP_STE_UNUSED_NODE: /* node is just allocated */
2e0fef85 1813 lpfc_drop_node(vport, ndlp);
dea3101e
JB		 1814 break;
1815 case NLP_STE_NPR_NODE: /* NPort Recovery mode */
2e0fef85 1816 lpfc_unreg_rpi(vport, ndlp);
dea3101e
JB		 1817 break;
1818 default:
1819 break;
1820 }
1821 lpfc_els_free_iocb(phba, cmdiocb);
1822 return;
1823}
1824
1825static void
329f9bc7
JS		 1826lpfc_cmpl_els_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1827 struct lpfc_iocbq *rspiocb)
dea3101e 1828{
2e0fef85
JS		 1829 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1830 struct lpfc_vport *vport = ndlp ? ndlp->vport : NULL;
1831 struct Scsi_Host *shost = vport ? lpfc_shost_from_vport(vport) : NULL;
33ccf8d1 1832 IOCB_t *irsp;
dea3101e 1833 LPFC_MBOXQ_t *mbox = NULL;
2e0fef85 1834 struct lpfc_dmabuf *mp = NULL;
dea3101e 1835
33ccf8d1
JS		 1836 irsp = &rspiocb->iocb;
1837
dea3101e
JB		 1838 if (cmdiocb->context_un.mbox)
1839 mbox = cmdiocb->context_un.mbox;
1840
dea3101e 1841 /* Check to see if link went down during discovery */
2e0fef85 1842 if (!ndlp || lpfc_els_chk_latt(vport)) {
dea3101e 1843 if (mbox) {
14691150
JS		 1844 mp = (struct lpfc_dmabuf *) mbox->context1;
1845 if (mp) {
1846 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1847 kfree(mp);
1848 }
329f9bc7 1849 mempool_free(mbox, phba->mbox_mem_pool);
dea3101e
JB		 1850 }
1851 goto out;
1852 }
1853
1854 /* ELS response tag <ulpIoTag> completes */
1855 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1856 "%d:0110 ELS response tag x%x completes "
c9f8735b 1857 "Data: x%x x%x x%x x%x x%x x%x x%x\n",
dea3101e
JB		 1858 phba->brd_no,
1859 cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus,
c9f8735b 1860 rspiocb->iocb.un.ulpWord[4], rspiocb->iocb.ulpTimeout,
2e0fef85 1861 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
c9f8735b 1862 ndlp->nlp_rpi);
dea3101e
JB		 1863
1864 if (mbox) {
1865 if ((rspiocb->iocb.ulpStatus == 0)
1866 && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) {
2e0fef85 1867 lpfc_unreg_rpi(vport, ndlp);
dea3101e 1868 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
329f9bc7 1869 mbox->context2 = lpfc_nlp_get(ndlp);
2e0fef85 1870 mbox->vport = vport;
5024ab17 1871 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 1872 lpfc_nlp_set_state(vport, ndlp,
1873 NLP_STE_REG_LOGIN_ISSUE);
dea3101e
JB		 1874 if (lpfc_sli_issue_mbox(phba, mbox,
1875 (MBX_NOWAIT | MBX_STOP_IOCB))
1876 != MBX_NOT_FINISHED) {
1877 goto out;
1878 }
329f9bc7 1879 lpfc_nlp_put(ndlp);
dea3101e
JB		 1880 /* NOTE: we should have messages for unsuccessful
1881 reglogin */
dea3101e 1882 } else {
33ccf8d1
JS		 1883 /* Do not call NO_LIST for lpfc_els_abort'ed ELS cmds */
1884 if (!((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1885 ((irsp->un.ulpWord[4] == IOERR_SLI_ABORTED) ||
1886 (irsp->un.ulpWord[4] == IOERR_LINK_DOWN) ||
1887 (irsp->un.ulpWord[4] == IOERR_SLI_DOWN)))) {
1888 if (ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
2e0fef85 1889 lpfc_drop_node(vport, ndlp);
33ccf8d1
JS		 1890 ndlp = NULL;
1891 }
dea3101e
JB		 1892 }
1893 }
14691150
JS		 1894 mp = (struct lpfc_dmabuf *) mbox->context1;
1895 if (mp) {
1896 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1897 kfree(mp);
1898 }
1899 mempool_free(mbox, phba->mbox_mem_pool);
dea3101e
JB		 1900 }
1901out:
1902 if (ndlp) {
2e0fef85 1903 spin_lock_irq(shost->host_lock);
dea3101e 1904 ndlp->nlp_flag &= ~NLP_ACC_REGLOGIN;
2e0fef85 1905 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 1906 }
1907 lpfc_els_free_iocb(phba, cmdiocb);
1908 return;
1909}
1910
1911int
2e0fef85
JS		 1912lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
1913 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp,
1914 LPFC_MBOXQ_t *mbox, uint8_t newnode)
dea3101e 1915{
2e0fef85
JS		 1916 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1917 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 1918 IOCB_t *icmd;
1919 IOCB_t *oldcmd;
1920 struct lpfc_iocbq *elsiocb;
1921 struct lpfc_sli_ring *pring;
1922 struct lpfc_sli *psli;
1923 uint8_t *pcmd;
1924 uint16_t cmdsize;
1925 int rc;
82d9a2a2 1926 ELS_PKT *els_pkt_ptr;
dea3101e
JB		 1927
1928 psli = &phba->sli;
1929 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1930 oldcmd = &oldiocb->iocb;
1931
1932 switch (flag) {
1933 case ELS_CMD_ACC:
1934 cmdsize = sizeof (uint32_t);
2e0fef85
JS		 1935 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
1936 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
488d1469 1937 if (!elsiocb) {
2e0fef85 1938 spin_lock_irq(shost->host_lock);
5024ab17 1939 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
2e0fef85 1940 spin_unlock_irq(shost->host_lock);
c9f8735b 1941 return 1;
dea3101e 1942 }
2e0fef85 1943
dea3101e
JB		 1944 icmd = &elsiocb->iocb;
1945 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1946 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1947 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
1948 pcmd += sizeof (uint32_t);
1949 break;
1950 case ELS_CMD_PLOGI:
1951 cmdsize = (sizeof (struct serv_parm) + sizeof (uint32_t));
2e0fef85
JS		 1952 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
1953 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
488d1469 1954 if (!elsiocb)
c9f8735b 1955 return 1;
488d1469 1956
dea3101e
JB		 1957 icmd = &elsiocb->iocb;
1958 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1959 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1960
1961 if (mbox)
1962 elsiocb->context_un.mbox = mbox;
1963
1964 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
1965 pcmd += sizeof (uint32_t);
2e0fef85 1966 memcpy(pcmd, &vport->fc_sparam, sizeof (struct serv_parm));
dea3101e 1967 break;
82d9a2a2
JS		 1968 case ELS_CMD_PRLO:
1969 cmdsize = sizeof (uint32_t) + sizeof (PRLO);
2e0fef85 1970 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
82d9a2a2
JS		 1971 ndlp, ndlp->nlp_DID, ELS_CMD_PRLO);
1972 if (!elsiocb)
1973 return 1;
1974
1975 icmd = &elsiocb->iocb;
1976 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
1977 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1978
1979 memcpy(pcmd, ((struct lpfc_dmabuf *) oldiocb->context2)->virt,
1980 sizeof (uint32_t) + sizeof (PRLO));
1981 *((uint32_t *) (pcmd)) = ELS_CMD_PRLO_ACC;
1982 els_pkt_ptr = (ELS_PKT *) pcmd;
1983 els_pkt_ptr->un.prlo.acceptRspCode = PRLO_REQ_EXECUTED;
1984 break;
dea3101e 1985 default:
c9f8735b 1986 return 1;
dea3101e
JB		 1987 }
1988
329f9bc7
JS		 1989 if (newnode) {
1990 lpfc_nlp_put(ndlp);
dea3101e 1991 elsiocb->context1 = NULL;
329f9bc7 1992 }
dea3101e
JB		 1993
1994 /* Xmit ELS ACC response tag <ulpIoTag> */
1995 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
1dcb58e5
JS		 1996 "%d:0128 Xmit ELS ACC response tag x%x, XRI: x%x, "
1997 "DID: x%x, nlp_flag: x%x nlp_state: x%x RPI: x%x\n",
1998 phba->brd_no, elsiocb->iotag,
dea3101e
JB		 1999 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2000 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2001
2002 if (ndlp->nlp_flag & NLP_LOGO_ACC) {
2e0fef85 2003 spin_lock_irq(shost->host_lock);
c9f8735b 2004 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
2e0fef85 2005 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 2006 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc;
2007 } else {
2008 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2009 }
2010
2011 phba->fc_stat.elsXmitACC++;
dea3101e 2012 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
dea3101e
JB		 2013 if (rc == IOCB_ERROR) {
2014 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 2015 return 1;
dea3101e 2016 }
c9f8735b 2017 return 0;
dea3101e
JB		 2018}
2019
2020int
2e0fef85
JS		 2021lpfc_els_rsp_reject(struct lpfc_vport *vport, uint32_t rejectError,
2022 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
dea3101e 2023{
2e0fef85 2024 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2025 IOCB_t *icmd;
2026 IOCB_t *oldcmd;
2027 struct lpfc_iocbq *elsiocb;
2028 struct lpfc_sli_ring *pring;
2029 struct lpfc_sli *psli;
2030 uint8_t *pcmd;
2031 uint16_t cmdsize;
2032 int rc;
2033
2034 psli = &phba->sli;
2035 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2036
2037 cmdsize = 2 * sizeof (uint32_t);
2e0fef85
JS		 2038 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2039 ndlp->nlp_DID, ELS_CMD_LS_RJT);
488d1469 2040 if (!elsiocb)
c9f8735b 2041 return 1;
dea3101e
JB		 2042
2043 icmd = &elsiocb->iocb;
2044 oldcmd = &oldiocb->iocb;
2045 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2046 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2047
2048 *((uint32_t *) (pcmd)) = ELS_CMD_LS_RJT;
2049 pcmd += sizeof (uint32_t);
2050 *((uint32_t *) (pcmd)) = rejectError;
2051
2052 /* Xmit ELS RJT <err> response tag <ulpIoTag> */
2053 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
5b8bd0c9
JS		 2054 "%d:0129 Xmit ELS RJT x%x response tag x%x xri x%x, "
2055 "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
2056 phba->brd_no, rejectError, elsiocb->iotag,
dea3101e
JB		 2057 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2058 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2059
2060 phba->fc_stat.elsXmitLSRJT++;
2061 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
dea3101e 2062 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
dea3101e
JB		 2063 if (rc == IOCB_ERROR) {
2064 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 2065 return 1;
dea3101e 2066 }
c9f8735b 2067 return 0;
dea3101e
JB		 2068}
2069
2070int
2e0fef85
JS		 2071lpfc_els_rsp_adisc_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
2072 struct lpfc_nodelist *ndlp)
dea3101e 2073{
2e0fef85
JS		 2074 struct lpfc_hba *phba = vport->phba;
2075 struct lpfc_sli *psli = &phba->sli;
2076 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
dea3101e 2077 ADISC *ap;
2e0fef85 2078 IOCB_t *icmd, *oldcmd;
dea3101e 2079 struct lpfc_iocbq *elsiocb;
dea3101e
JB		 2080 uint8_t *pcmd;
2081 uint16_t cmdsize;
2082 int rc;
2083
dea3101e 2084 cmdsize = sizeof (uint32_t) + sizeof (ADISC);
2e0fef85
JS		 2085 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2086 ndlp->nlp_DID, ELS_CMD_ACC);
488d1469 2087 if (!elsiocb)
c9f8735b 2088 return 1;
dea3101e 2089
5b8bd0c9
JS		 2090 icmd = &elsiocb->iocb;
2091 oldcmd = &oldiocb->iocb;
2092 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2093
dea3101e
JB		 2094 /* Xmit ADISC ACC response tag <ulpIoTag> */
2095 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
5b8bd0c9
JS		 2096 "%d:0130 Xmit ADISC ACC response iotag x%x xri: "
2097 "x%x, did x%x, nlp_flag x%x, nlp_state x%x rpi x%x\n",
2098 phba->brd_no, elsiocb->iotag,
dea3101e
JB		 2099 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2100 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2101
dea3101e
JB		 2102 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2103
2104 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2105 pcmd += sizeof (uint32_t);
2106
2107 ap = (ADISC *) (pcmd);
2108 ap->hardAL_PA = phba->fc_pref_ALPA;
2e0fef85
JS		 2109 memcpy(&ap->portName, &vport->fc_portname, sizeof (struct lpfc_name));
2110 memcpy(&ap->nodeName, &vport->fc_nodename, sizeof (struct lpfc_name));
2111 ap->DID = be32_to_cpu(vport->fc_myDID);
dea3101e
JB		 2112
2113 phba->fc_stat.elsXmitACC++;
2114 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
dea3101e 2115 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
dea3101e
JB		 2116 if (rc == IOCB_ERROR) {
2117 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 2118 return 1;
dea3101e 2119 }
c9f8735b 2120 return 0;
dea3101e
JB		 2121}
2122
2123int
2e0fef85 2124lpfc_els_rsp_prli_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
5b8bd0c9 2125 struct lpfc_nodelist *ndlp)
dea3101e 2126{
2e0fef85 2127 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2128 PRLI *npr;
2129 lpfc_vpd_t *vpd;
2130 IOCB_t *icmd;
2131 IOCB_t *oldcmd;
2132 struct lpfc_iocbq *elsiocb;
2133 struct lpfc_sli_ring *pring;
2134 struct lpfc_sli *psli;
2135 uint8_t *pcmd;
2136 uint16_t cmdsize;
2137 int rc;
2138
2139 psli = &phba->sli;
2140 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2141
2142 cmdsize = sizeof (uint32_t) + sizeof (PRLI);
2e0fef85
JS		 2143 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2144 ndlp->nlp_DID,
2145 (ELS_CMD_ACC |
2146 (ELS_CMD_PRLI & ~ELS_RSP_MASK)));
c9f8735b
JW		 2147 if (!elsiocb)
2148 return 1;
dea3101e 2149
5b8bd0c9
JS		 2150 icmd = &elsiocb->iocb;
2151 oldcmd = &oldiocb->iocb;
2152 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2153
dea3101e
JB		 2154 /* Xmit PRLI ACC response tag <ulpIoTag> */
2155 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
5b8bd0c9
JS		 2156 "%d:0131 Xmit PRLI ACC response tag x%x xri x%x, "
2157 "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
2158 phba->brd_no, elsiocb->iotag,
dea3101e
JB		 2159 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2160 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2161
dea3101e
JB		 2162 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2163
2164 *((uint32_t *) (pcmd)) = (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK));
2165 pcmd += sizeof (uint32_t);
2166
2167 /* For PRLI, remainder of payload is PRLI parameter page */
2168 memset(pcmd, 0, sizeof (PRLI));
2169
2170 npr = (PRLI *) pcmd;
2171 vpd = &phba->vpd;
2172 /*
2173 * If our firmware version is 3.20 or later,
2174 * set the following bits for FC-TAPE support.
2175 */
2176 if (vpd->rev.feaLevelHigh >= 0x02) {
2177 npr->ConfmComplAllowed = 1;
2178 npr->Retry = 1;
2179 npr->TaskRetryIdReq = 1;
2180 }
2181
2182 npr->acceptRspCode = PRLI_REQ_EXECUTED;
2183 npr->estabImagePair = 1;
2184 npr->readXferRdyDis = 1;
2185 npr->ConfmComplAllowed = 1;
2186
2187 npr->prliType = PRLI_FCP_TYPE;
2188 npr->initiatorFunc = 1;
2189
2190 phba->fc_stat.elsXmitACC++;
2191 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2192
dea3101e 2193 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
dea3101e
JB		 2194 if (rc == IOCB_ERROR) {
2195 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 2196 return 1;
dea3101e 2197 }
c9f8735b 2198 return 0;
dea3101e
JB		 2199}
2200
2201static int
2e0fef85 2202lpfc_els_rsp_rnid_acc(struct lpfc_vport *vport, uint8_t format,
329f9bc7 2203 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
dea3101e 2204{
2e0fef85 2205 struct lpfc_hba *phba = vport->phba;
dea3101e 2206 RNID *rn;
2e0fef85 2207 IOCB_t *icmd, *oldcmd;
dea3101e
JB		 2208 struct lpfc_iocbq *elsiocb;
2209 struct lpfc_sli_ring *pring;
2210 struct lpfc_sli *psli;
2211 uint8_t *pcmd;
2212 uint16_t cmdsize;
2213 int rc;
2214
2215 psli = &phba->sli;
2216 pring = &psli->ring[LPFC_ELS_RING];
2217
2218 cmdsize = sizeof (uint32_t) + sizeof (uint32_t)
2219 + (2 * sizeof (struct lpfc_name));
2220 if (format)
2221 cmdsize += sizeof (RNID_TOP_DISC);
2222
2e0fef85
JS		 2223 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2224 ndlp->nlp_DID, ELS_CMD_ACC);
488d1469 2225 if (!elsiocb)
c9f8735b 2226 return 1;
dea3101e 2227
5b8bd0c9
JS		 2228 icmd = &elsiocb->iocb;
2229 oldcmd = &oldiocb->iocb;
2230 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2231
dea3101e
JB		 2232 /* Xmit RNID ACC response tag <ulpIoTag> */
2233 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
2234 "%d:0132 Xmit RNID ACC response tag x%x "
5b8bd0c9
JS		 2235 "xri x%x\n",
2236 phba->brd_no, elsiocb->iotag,
dea3101e
JB		 2237 elsiocb->iocb.ulpContext);
2238
dea3101e
JB		 2239 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2240
2241 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2242 pcmd += sizeof (uint32_t);
2243
2244 memset(pcmd, 0, sizeof (RNID));
2245 rn = (RNID *) (pcmd);
2246 rn->Format = format;
2247 rn->CommonLen = (2 * sizeof (struct lpfc_name));
2e0fef85
JS		 2248 memcpy(&rn->portName, &vport->fc_portname, sizeof (struct lpfc_name));
2249 memcpy(&rn->nodeName, &vport->fc_nodename, sizeof (struct lpfc_name));
dea3101e
JB		 2250 switch (format) {
2251 case 0:
2252 rn->SpecificLen = 0;
2253 break;
2254 case RNID_TOPOLOGY_DISC:
2255 rn->SpecificLen = sizeof (RNID_TOP_DISC);
2256 memcpy(&rn->un.topologyDisc.portName,
2e0fef85 2257 &vport->fc_portname, sizeof (struct lpfc_name));
dea3101e
JB		 2258 rn->un.topologyDisc.unitType = RNID_HBA;
2259 rn->un.topologyDisc.physPort = 0;
2260 rn->un.topologyDisc.attachedNodes = 0;
2261 break;
2262 default:
2263 rn->CommonLen = 0;
2264 rn->SpecificLen = 0;
2265 break;
2266 }
2267
2268 phba->fc_stat.elsXmitACC++;
2269 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
329f9bc7 2270 lpfc_nlp_put(ndlp);
dea3101e
JB		 2271 elsiocb->context1 = NULL; /* Don't need ndlp for cmpl,
2272 * it could be freed */
2273
dea3101e 2274 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
dea3101e
JB		 2275 if (rc == IOCB_ERROR) {
2276 lpfc_els_free_iocb(phba, elsiocb);
c9f8735b 2277 return 1;
dea3101e 2278 }
c9f8735b 2279 return 0;
dea3101e
JB		 2280}
2281
2282int
2e0fef85 2283lpfc_els_disc_adisc(struct lpfc_vport *vport)
dea3101e 2284{
2e0fef85 2285 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e 2286 struct lpfc_nodelist *ndlp, *next_ndlp;
2e0fef85 2287 int sentadisc = 0;
dea3101e 2288
685f0bf7 2289 /* go thru NPR nodes and issue any remaining ELS ADISCs */
2e0fef85 2290 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
685f0bf7
JS		 2291 if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
2292 (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
2293 (ndlp->nlp_flag & NLP_NPR_ADISC) != 0) {
2e0fef85 2294 spin_lock_irq(shost->host_lock);
685f0bf7 2295 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2e0fef85 2296 spin_unlock_irq(shost->host_lock);
685f0bf7 2297 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 2298 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
2299 lpfc_issue_els_adisc(vport, ndlp, 0);
685f0bf7 2300 sentadisc++;
2e0fef85
JS		 2301 vport->num_disc_nodes++;
2302 if (vport->num_disc_nodes >=
2303 vport->phba->cfg_discovery_threads) {
2304 spin_lock_irq(shost->host_lock);
2305 vport->fc_flag |= FC_NLP_MORE;
2306 spin_unlock_irq(shost->host_lock);
685f0bf7 2307 break;
dea3101e
JB		 2308 }
2309 }
2310 }
2311 if (sentadisc == 0) {
2e0fef85
JS		 2312 spin_lock_irq(shost->host_lock);
2313 vport->fc_flag &= ~FC_NLP_MORE;
2314 spin_unlock_irq(shost->host_lock);
dea3101e 2315 }
2fe165b6 2316 return sentadisc;
dea3101e
JB		 2317}
2318
2319int
2e0fef85 2320lpfc_els_disc_plogi(struct lpfc_vport *vport)
dea3101e 2321{
2e0fef85 2322 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
dea3101e 2323 struct lpfc_nodelist *ndlp, *next_ndlp;
2e0fef85 2324 int sentplogi = 0;
dea3101e 2325
2e0fef85
JS		 2326 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
2327 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
685f0bf7
JS		 2328 if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
2329 (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
2330 (ndlp->nlp_flag & NLP_DELAY_TMO) == 0 &&
2331 (ndlp->nlp_flag & NLP_NPR_ADISC) == 0) {
2332 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 2333 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2334 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
685f0bf7 2335 sentplogi++;
2e0fef85
JS		 2336 vport->num_disc_nodes++;
2337 if (vport->num_disc_nodes >=
2338 vport->phba->cfg_discovery_threads) {
2339 spin_lock_irq(shost->host_lock);
2340 vport->fc_flag |= FC_NLP_MORE;
2341 spin_unlock_irq(shost->host_lock);
685f0bf7 2342 break;
dea3101e
JB		 2343 }
2344 }
2345 }
2346 if (sentplogi == 0) {
2e0fef85
JS		 2347 spin_lock_irq(shost->host_lock);
2348 vport->fc_flag &= ~FC_NLP_MORE;
2349 spin_unlock_irq(shost->host_lock);
dea3101e 2350 }
2fe165b6 2351 return sentplogi;
dea3101e
JB		 2352}
2353
2354int
2e0fef85 2355lpfc_els_flush_rscn(struct lpfc_vport *vport)
dea3101e 2356{
2e0fef85
JS		 2357 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2358 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2359 struct lpfc_dmabuf *mp;
2360 int i;
2361
2e0fef85
JS		 2362 for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
2363 mp = vport->fc_rscn_id_list[i];
dea3101e
JB		 2364 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2365 kfree(mp);
2e0fef85 2366 vport->fc_rscn_id_list[i] = NULL;
dea3101e 2367 }
2e0fef85
JS		 2368 spin_lock_irq(shost->host_lock);
2369 vport->fc_rscn_id_cnt = 0;
2370 vport->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY);
2371 spin_unlock_irq(shost->host_lock);
2372 lpfc_can_disctmo(vport);
c9f8735b 2373 return 0;
dea3101e
JB		 2374}
2375
2376int
2e0fef85 2377lpfc_rscn_payload_check(struct lpfc_vport *vport, uint32_t did)
dea3101e
JB		 2378{
2379 D_ID ns_did;
2380 D_ID rscn_did;
2381 struct lpfc_dmabuf *mp;
2382 uint32_t *lp;
2383 uint32_t payload_len, cmd, i, match;
2e0fef85 2384 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2385
2386 ns_did.un.word = did;
2387 match = 0;
2388
2389 /* Never match fabric nodes for RSCNs */
2390 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
2e0fef85 2391 return 0;
dea3101e
JB		 2392
2393 /* If we are doing a FULL RSCN rediscovery, match everything */
2e0fef85 2394 if (vport->fc_flag & FC_RSCN_DISCOVERY)
c9f8735b 2395 return did;
dea3101e 2396
2e0fef85
JS		 2397 for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
2398 mp = vport->fc_rscn_id_list[i];
dea3101e
JB		 2399 lp = (uint32_t *) mp->virt;
2400 cmd = *lp++;
2401 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */
2402 payload_len -= sizeof (uint32_t); /* take off word 0 */
2403 while (payload_len) {
2404 rscn_did.un.word = *lp++;
2405 rscn_did.un.word = be32_to_cpu(rscn_did.un.word);
2406 payload_len -= sizeof (uint32_t);
2407 switch (rscn_did.un.b.resv) {
2408 case 0: /* Single N_Port ID effected */
2e0fef85 2409 if (ns_did.un.word == rscn_did.un.word)
dea3101e 2410 match = did;
dea3101e
JB		 2411 break;
2412 case 1: /* Whole N_Port Area effected */
2413 if ((ns_did.un.b.domain == rscn_did.un.b.domain)
2414 && (ns_did.un.b.area == rscn_did.un.b.area))
dea3101e 2415 match = did;
dea3101e
JB		 2416 break;
2417 case 2: /* Whole N_Port Domain effected */
2418 if (ns_did.un.b.domain == rscn_did.un.b.domain)
dea3101e 2419 match = did;
dea3101e
JB		 2420 break;
2421 case 3: /* Whole Fabric effected */
2422 match = did;
2423 break;
2424 default:
2e0fef85 2425 /* Unknown Identifier in RSCN node */
dea3101e
JB		 2426 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
2427 "%d:0217 Unknown Identifier in "
2428 "RSCN payload Data: x%x\n",
2429 phba->brd_no, rscn_did.un.word);
2430 break;
2431 }
2e0fef85 2432 if (match)
dea3101e
JB		 2433 break;
2434 }
2435 }
c9f8735b 2436 return match;
dea3101e
JB		 2437}
2438
2439static int
2e0fef85 2440lpfc_rscn_recovery_check(struct lpfc_vport *vport)
dea3101e 2441{
685f0bf7 2442 struct lpfc_nodelist *ndlp = NULL;
dea3101e
JB		 2443
2444 /* Look at all nodes effected by pending RSCNs and move
685f0bf7 2445 * them to NPR state.
dea3101e 2446 */
dea3101e 2447
2e0fef85 2448 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
685f0bf7 2449 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE ||
2e0fef85 2450 lpfc_rscn_payload_check(vport, ndlp->nlp_DID) == 0)
685f0bf7 2451 continue;
dea3101e 2452
2e0fef85 2453 lpfc_disc_state_machine(vport, ndlp, NULL,
dea3101e 2454 NLP_EVT_DEVICE_RECOVERY);
5024ab17 2455
685f0bf7
JS		 2456 /*
2457 * Make sure NLP_DELAY_TMO is NOT running after a device
2458 * recovery event.
2459 */
2460 if (ndlp->nlp_flag & NLP_DELAY_TMO)
2e0fef85 2461 lpfc_cancel_retry_delay_tmo(vport, ndlp);
dea3101e 2462 }
685f0bf7 2463
c9f8735b 2464 return 0;
dea3101e
JB		 2465}
2466
2467static int
2e0fef85
JS		 2468lpfc_els_rcv_rscn(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2469 struct lpfc_nodelist *ndlp, uint8_t newnode)
dea3101e 2470{
2e0fef85
JS		 2471 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2472 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2473 struct lpfc_dmabuf *pcmd;
2474 uint32_t *lp;
2475 IOCB_t *icmd;
2476 uint32_t payload_len, cmd;
d2873e4c 2477 int i;
dea3101e
JB		 2478
2479 icmd = &cmdiocb->iocb;
2480 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2481 lp = (uint32_t *) pcmd->virt;
2482
2483 cmd = *lp++;
2484 payload_len = be32_to_cpu(cmd) & 0xffff; /* payload length */
2485 payload_len -= sizeof (uint32_t); /* take off word 0 */
2486 cmd &= ELS_CMD_MASK;
2487
2488 /* RSCN received */
2489 lpfc_printf_log(phba,
2490 KERN_INFO,
2491 LOG_DISCOVERY,
2492 "%d:0214 RSCN received Data: x%x x%x x%x x%x\n",
2e0fef85
JS		 2493 phba->brd_no, vport->fc_flag, payload_len, *lp,
2494 vport->fc_rscn_id_cnt);
dea3101e 2495
d2873e4c 2496 for (i = 0; i < payload_len/sizeof(uint32_t); i++)
2e0fef85 2497 fc_host_post_event(shost, fc_get_event_number(),
d2873e4c
JS		 2498 FCH_EVT_RSCN, lp[i]);
2499
dea3101e
JB		 2500 /* If we are about to begin discovery, just ACC the RSCN.
2501 * Discovery processing will satisfy it.
2502 */
2e0fef85
JS		 2503 if (vport->port_state <= LPFC_NS_QRY) {
2504 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
dea3101e 2505 newnode);
c9f8735b 2506 return 0;
dea3101e
JB		 2507 }
2508
2509 /* If we are already processing an RSCN, save the received
2510 * RSCN payload buffer, cmdiocb->context2 to process later.
2511 */
2e0fef85
JS		 2512 if (vport->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) {
2513 if ((vport->fc_rscn_id_cnt < FC_MAX_HOLD_RSCN) &&
2514 !(vport->fc_flag & FC_RSCN_DISCOVERY)) {
2515 spin_lock_irq(shost->host_lock);
2516 vport->fc_flag |= FC_RSCN_MODE;
2517 spin_unlock_irq(shost->host_lock);
2518 vport->fc_rscn_id_list[vport->fc_rscn_id_cnt++] = pcmd;
dea3101e
JB		 2519
2520 /* If we zero, cmdiocb->context2, the calling
2521 * routine will not try to free it.
2522 */
2523 cmdiocb->context2 = NULL;
2524
2525 /* Deferred RSCN */
2526 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2527 "%d:0235 Deferred RSCN "
2528 "Data: x%x x%x x%x\n",
2e0fef85
JS		 2529 phba->brd_no, vport->fc_rscn_id_cnt,
2530 vport->fc_flag,
2531 vport->port_state);
dea3101e 2532 } else {
2e0fef85
JS		 2533 spin_lock_irq(shost->host_lock);
2534 vport->fc_flag |= FC_RSCN_DISCOVERY;
2535 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 2536 /* ReDiscovery RSCN */
2537 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
2538 "%d:0234 ReDiscovery RSCN "
2539 "Data: x%x x%x x%x\n",
2e0fef85
JS		 2540 phba->brd_no, vport->fc_rscn_id_cnt,
2541 vport->fc_flag,
2542 vport->port_state);
dea3101e
JB		 2543 }
2544 /* Send back ACC */
2e0fef85 2545 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL,
dea3101e
JB		 2546 newnode);
2547
2548 /* send RECOVERY event for ALL nodes that match RSCN payload */
2e0fef85 2549 lpfc_rscn_recovery_check(vport);
c9f8735b 2550 return 0;
dea3101e
JB		 2551 }
2552
2e0fef85
JS		 2553 spin_lock_irq(shost->host_lock);
2554 vport->fc_flag |= FC_RSCN_MODE;
2555 spin_unlock_irq(shost->host_lock);
2556 vport->fc_rscn_id_list[vport->fc_rscn_id_cnt++] = pcmd;
dea3101e
JB		 2557 /*
2558 * If we zero, cmdiocb->context2, the calling routine will
2559 * not try to free it.
2560 */
2561 cmdiocb->context2 = NULL;
2562
2e0fef85 2563 lpfc_set_disctmo(vport);
dea3101e
JB		 2564
2565 /* Send back ACC */
2e0fef85 2566 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL, newnode);
dea3101e
JB		 2567
2568 /* send RECOVERY event for ALL nodes that match RSCN payload */
2e0fef85 2569 lpfc_rscn_recovery_check(vport);
dea3101e 2570
2e0fef85 2571 return lpfc_els_handle_rscn(vport);
dea3101e
JB		 2572}
2573
2574int
2e0fef85 2575lpfc_els_handle_rscn(struct lpfc_vport *vport)
dea3101e
JB		 2576{
2577 struct lpfc_nodelist *ndlp;
2e0fef85 2578 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2579
2580 /* Start timer for RSCN processing */
2e0fef85 2581 lpfc_set_disctmo(vport);
dea3101e
JB		 2582
2583 /* RSCN processed */
2584 lpfc_printf_log(phba,
2585 KERN_INFO,
2586 LOG_DISCOVERY,
2587 "%d:0215 RSCN processed Data: x%x x%x x%x x%x\n",
2588 phba->brd_no,
2e0fef85
JS		 2589 vport->fc_flag, 0, vport->fc_rscn_id_cnt,
2590 vport->port_state);
dea3101e
JB		 2591
2592 /* To process RSCN, first compare RSCN data with NameServer */
2e0fef85
JS		 2593 vport->fc_ns_retry = 0;
2594 ndlp = lpfc_findnode_did(vport, NameServer_DID);
685f0bf7 2595 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
dea3101e 2596 /* Good ndlp, issue CT Request to NameServer */
2e0fef85 2597 if (lpfc_ns_cmd(vport, ndlp, SLI_CTNS_GID_FT) == 0)
dea3101e
JB		 2598 /* Wait for NameServer query cmpl before we can
2599 continue */
c9f8735b 2600 return 1;
dea3101e
JB		 2601 } else {
2602 /* If login to NameServer does not exist, issue one */
2603 /* Good status, issue PLOGI to NameServer */
2e0fef85
JS		 2604 ndlp = lpfc_findnode_did(vport, NameServer_DID);
2605 if (ndlp)
dea3101e
JB		 2606 /* Wait for NameServer login cmpl before we can
2607 continue */
c9f8735b 2608 return 1;
2e0fef85 2609
c9f8735b
JW		 2610 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
2611 if (!ndlp) {
2e0fef85 2612 lpfc_els_flush_rscn(vport);
c9f8735b 2613 return 0;
dea3101e 2614 } else {
2e0fef85 2615 lpfc_nlp_init(vport, ndlp, NameServer_DID);
dea3101e 2616 ndlp->nlp_type |= NLP_FABRIC;
5024ab17 2617 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85
JS		 2618 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2619 lpfc_issue_els_plogi(vport, NameServer_DID, 0);
dea3101e
JB		 2620 /* Wait for NameServer login cmpl before we can
2621 continue */
c9f8735b 2622 return 1;
dea3101e
JB		 2623 }
2624 }
2625
2e0fef85 2626 lpfc_els_flush_rscn(vport);
c9f8735b 2627 return 0;
dea3101e
JB		 2628}
2629
2630static int
2e0fef85
JS		 2631lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2632 struct lpfc_nodelist *ndlp, uint8_t newnode)
dea3101e 2633{
2e0fef85
JS		 2634 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2635 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 2636 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2637 uint32_t *lp = (uint32_t *) pcmd->virt;
2638 IOCB_t *icmd = &cmdiocb->iocb;
2639 struct serv_parm *sp;
2640 LPFC_MBOXQ_t *mbox;
2641 struct ls_rjt stat;
2642 uint32_t cmd, did;
2643 int rc;
2644
2645 cmd = *lp++;
2646 sp = (struct serv_parm *) lp;
2647
2648 /* FLOGI received */
2649
2e0fef85 2650 lpfc_set_disctmo(vport);
dea3101e
JB		 2651
2652 if (phba->fc_topology == TOPOLOGY_LOOP) {
2653 /* We should never receive a FLOGI in loop mode, ignore it */
2654 did = icmd->un.elsreq64.remoteID;
2655
2656 /* An FLOGI ELS command <elsCmd> was received from DID <did> in
2657 Loop Mode */
2658 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
2659 "%d:0113 An FLOGI ELS command x%x was received "
2660 "from DID x%x in Loop Mode\n",
2661 phba->brd_no, cmd, did);
c9f8735b 2662 return 1;
dea3101e
JB		 2663 }
2664
2665 did = Fabric_DID;
2666
2e0fef85 2667 if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3))) {
dea3101e
JB		 2668 /* For a FLOGI we accept, then if our portname is greater
2669 * then the remote portname we initiate Nport login.
2670 */
2671
2e0fef85 2672 rc = memcmp(&vport->fc_portname, &sp->portName,
dea3101e
JB		 2673 sizeof (struct lpfc_name));
2674
2675 if (!rc) {
2e0fef85
JS		 2676 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2677 if (!mbox)
c9f8735b 2678 return 1;
2e0fef85 2679
dea3101e
JB		 2680 lpfc_linkdown(phba);
2681 lpfc_init_link(phba, mbox,
2682 phba->cfg_topology,
2683 phba->cfg_link_speed);
2684 mbox->mb.un.varInitLnk.lipsr_AL_PA = 0;
2685 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2686 rc = lpfc_sli_issue_mbox
2687 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB));
5b8bd0c9 2688 lpfc_set_loopback_flag(phba);
dea3101e 2689 if (rc == MBX_NOT_FINISHED) {
329f9bc7 2690 mempool_free(mbox, phba->mbox_mem_pool);
dea3101e 2691 }
c9f8735b 2692 return 1;
2fe165b6 2693 } else if (rc > 0) { /* greater than */
2e0fef85
JS		 2694 spin_lock_irq(shost->host_lock);
2695 vport->fc_flag |= FC_PT2PT_PLOGI;
2696 spin_unlock_irq(shost->host_lock);
dea3101e 2697 }
2e0fef85
JS		 2698 spin_lock_irq(shost->host_lock);
2699 vport->fc_flag |= FC_PT2PT;
2700 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
2701 spin_unlock_irq(shost->host_lock);
dea3101e
JB		 2702 } else {
2703 /* Reject this request because invalid parameters */
2704 stat.un.b.lsRjtRsvd0 = 0;
2705 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2706 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
2707 stat.un.b.vendorUnique = 0;
2e0fef85 2708 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
c9f8735b 2709 return 1;
dea3101e
JB		 2710 }
2711
2712 /* Send back ACC */
2e0fef85 2713 lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL, newnode);
dea3101e 2714
c9f8735b 2715 return 0;
dea3101e
JB		 2716}
2717
2718static int
2e0fef85
JS		 2719lpfc_els_rcv_rnid(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2720 struct lpfc_nodelist *ndlp)
dea3101e
JB		 2721{
2722 struct lpfc_dmabuf *pcmd;
2723 uint32_t *lp;
2724 IOCB_t *icmd;
2725 RNID *rn;
2726 struct ls_rjt stat;
2727 uint32_t cmd, did;
2728
2729 icmd = &cmdiocb->iocb;
2730 did = icmd->un.elsreq64.remoteID;
2731 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2732 lp = (uint32_t *) pcmd->virt;
2733
2734 cmd = *lp++;
2735 rn = (RNID *) lp;
2736
2737 /* RNID received */
2738
2739 switch (rn->Format) {
2740 case 0:
2741 case RNID_TOPOLOGY_DISC:
2742 /* Send back ACC */
2e0fef85 2743 lpfc_els_rsp_rnid_acc(vport, rn->Format, cmdiocb, ndlp);
dea3101e
JB		 2744 break;
2745 default:
2746 /* Reject this request because format not supported */
2747 stat.un.b.lsRjtRsvd0 = 0;
2748 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2749 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2750 stat.un.b.vendorUnique = 0;
2e0fef85 2751 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
dea3101e 2752 }
c9f8735b 2753 return 0;
dea3101e
JB		 2754}
2755
2756static int
2e0fef85
JS		 2757lpfc_els_rcv_lirr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2758 struct lpfc_nodelist *ndlp)
7bb3b137
JW		 2759{
2760 struct ls_rjt stat;
2761
2762 /* For now, unconditionally reject this command */
2763 stat.un.b.lsRjtRsvd0 = 0;
2764 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2765 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2766 stat.un.b.vendorUnique = 0;
2e0fef85 2767 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
7bb3b137
JW		 2768 return 0;
2769}
2770
082c0266 2771static void
329f9bc7 2772lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
7bb3b137 2773{
2e0fef85
JS		 2774 struct lpfc_sli *psli = &phba->sli;
2775 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
7bb3b137
JW		 2776 MAILBOX_t *mb;
2777 IOCB_t *icmd;
2778 RPS_RSP *rps_rsp;
2779 uint8_t *pcmd;
2780 struct lpfc_iocbq *elsiocb;
2781 struct lpfc_nodelist *ndlp;
2782 uint16_t xri, status;
2783 uint32_t cmdsize;
2784
7bb3b137
JW		 2785 mb = &pmb->mb;
2786
2787 ndlp = (struct lpfc_nodelist *) pmb->context2;
2788 xri = (uint16_t) ((unsigned long)(pmb->context1));
041976fb
RD		 2789 pmb->context1 = NULL;
2790 pmb->context2 = NULL;
7bb3b137
JW		 2791
2792 if (mb->mbxStatus) {
329f9bc7 2793 mempool_free(pmb, phba->mbox_mem_pool);
7bb3b137
JW		 2794 return;
2795 }
2796
2797 cmdsize = sizeof(RPS_RSP) + sizeof(uint32_t);
329f9bc7 2798 mempool_free(pmb, phba->mbox_mem_pool);
2e0fef85
JS		 2799 elsiocb = lpfc_prep_els_iocb(phba->pport, 0, cmdsize,
2800 lpfc_max_els_tries, ndlp,
2801 ndlp->nlp_DID, ELS_CMD_ACC);
329f9bc7 2802 lpfc_nlp_put(ndlp);
c9f8735b 2803 if (!elsiocb)
7bb3b137 2804 return;
7bb3b137
JW		 2805
2806 icmd = &elsiocb->iocb;
2807 icmd->ulpContext = xri;
2808
2809 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2810 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2811 pcmd += sizeof (uint32_t); /* Skip past command */
2812 rps_rsp = (RPS_RSP *)pcmd;
2813
2814 if (phba->fc_topology != TOPOLOGY_LOOP)
2815 status = 0x10;
2816 else
2817 status = 0x8;
2e0fef85 2818 if (phba->pport->fc_flag & FC_FABRIC)
7bb3b137
JW		 2819 status |= 0x4;
2820
2821 rps_rsp->rsvd1 = 0;
2822 rps_rsp->portStatus = be16_to_cpu(status);
2823 rps_rsp->linkFailureCnt = be32_to_cpu(mb->un.varRdLnk.linkFailureCnt);
2824 rps_rsp->lossSyncCnt = be32_to_cpu(mb->un.varRdLnk.lossSyncCnt);
2825 rps_rsp->lossSignalCnt = be32_to_cpu(mb->un.varRdLnk.lossSignalCnt);
2826 rps_rsp->primSeqErrCnt = be32_to_cpu(mb->un.varRdLnk.primSeqErrCnt);
2827 rps_rsp->invalidXmitWord = be32_to_cpu(mb->un.varRdLnk.invalidXmitWord);
2828 rps_rsp->crcCnt = be32_to_cpu(mb->un.varRdLnk.crcCnt);
2829
2830 /* Xmit ELS RPS ACC response tag <ulpIoTag> */
2831 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
5b8bd0c9
JS		 2832 "%d:0118 Xmit ELS RPS ACC response tag x%x xri x%x, "
2833 "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
2834 phba->brd_no, elsiocb->iotag,
7bb3b137
JW		 2835 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2836 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2837
2838 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2839 phba->fc_stat.elsXmitACC++;
685f0bf7 2840
7bb3b137
JW		 2841 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2842 lpfc_els_free_iocb(phba, elsiocb);
2843 }
2844 return;
2845}
2846
2847static int
2e0fef85
JS		 2848lpfc_els_rcv_rps(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2849 struct lpfc_nodelist *ndlp)
dea3101e 2850{
2e0fef85 2851 struct lpfc_hba *phba = vport->phba;
dea3101e 2852 uint32_t *lp;
7bb3b137
JW		 2853 uint8_t flag;
2854 LPFC_MBOXQ_t *mbox;
2855 struct lpfc_dmabuf *pcmd;
2856 RPS *rps;
2857 struct ls_rjt stat;
2858
2fe165b6
JW		 2859 if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
2860 (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
7bb3b137
JW		 2861 stat.un.b.lsRjtRsvd0 = 0;
2862 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2863 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2864 stat.un.b.vendorUnique = 0;
2e0fef85 2865 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
7bb3b137
JW		 2866 }
2867
2868 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2869 lp = (uint32_t *) pcmd->virt;
2870 flag = (be32_to_cpu(*lp++) & 0xf);
2871 rps = (RPS *) lp;
2872
2873 if ((flag == 0) ||
2874 ((flag == 1) && (be32_to_cpu(rps->un.portNum) == 0)) ||
2e0fef85 2875 ((flag == 2) && (memcmp(&rps->un.portName, &vport->fc_portname,
7bb3b137 2876 sizeof (struct lpfc_name)) == 0))) {
2e0fef85
JS		 2877
2878 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC);
2879 if (mbox) {
7bb3b137
JW		 2880 lpfc_read_lnk_stat(phba, mbox);
2881 mbox->context1 =
2882 (void *)((unsigned long)cmdiocb->iocb.ulpContext);
329f9bc7 2883 mbox->context2 = lpfc_nlp_get(ndlp);
7bb3b137
JW		 2884 mbox->mbox_cmpl = lpfc_els_rsp_rps_acc;
2885 if (lpfc_sli_issue_mbox (phba, mbox,
2e0fef85 2886 (MBX_NOWAIT | MBX_STOP_IOCB)) != MBX_NOT_FINISHED)
7bb3b137
JW		 2887 /* Mbox completion will send ELS Response */
2888 return 0;
2e0fef85 2889
329f9bc7 2890 lpfc_nlp_put(ndlp);
7bb3b137
JW		 2891 mempool_free(mbox, phba->mbox_mem_pool);
2892 }
2893 }
2894 stat.un.b.lsRjtRsvd0 = 0;
2895 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2896 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2897 stat.un.b.vendorUnique = 0;
2e0fef85 2898 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
7bb3b137
JW		 2899 return 0;
2900}
2901
082c0266 2902static int
2e0fef85
JS		 2903lpfc_els_rsp_rpl_acc(struct lpfc_vport *vport, uint16_t cmdsize,
2904 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
7bb3b137 2905{
2e0fef85
JS		 2906 struct lpfc_hba *phba = vport->phba;
2907 IOCB_t *icmd, *oldcmd;
7bb3b137
JW		 2908 RPL_RSP rpl_rsp;
2909 struct lpfc_iocbq *elsiocb;
2e0fef85
JS		 2910 struct lpfc_sli *psli = &phba->sli;
2911 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
7bb3b137 2912 uint8_t *pcmd;
dea3101e 2913
2e0fef85
JS		 2914 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2915 ndlp->nlp_DID, ELS_CMD_ACC);
7bb3b137 2916
488d1469 2917 if (!elsiocb)
7bb3b137 2918 return 1;
488d1469 2919
7bb3b137
JW		 2920 icmd = &elsiocb->iocb;
2921 oldcmd = &oldiocb->iocb;
2922 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2923
2924 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2925 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2926 pcmd += sizeof (uint16_t);
2927 *((uint16_t *)(pcmd)) = be16_to_cpu(cmdsize);
2928 pcmd += sizeof(uint16_t);
2929
2930 /* Setup the RPL ACC payload */
2931 rpl_rsp.listLen = be32_to_cpu(1);
2932 rpl_rsp.index = 0;
2933 rpl_rsp.port_num_blk.portNum = 0;
2e0fef85
JS		 2934 rpl_rsp.port_num_blk.portID = be32_to_cpu(vport->fc_myDID);
2935 memcpy(&rpl_rsp.port_num_blk.portName, &vport->fc_portname,
7bb3b137
JW		 2936 sizeof(struct lpfc_name));
2937
2938 memcpy(pcmd, &rpl_rsp, cmdsize - sizeof(uint32_t));
2939
2940
2941 /* Xmit ELS RPL ACC response tag <ulpIoTag> */
2942 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
5b8bd0c9
JS		 2943 "%d:0120 Xmit ELS RPL ACC response tag x%x xri x%x, "
2944 "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
2945 phba->brd_no, elsiocb->iotag,
7bb3b137
JW		 2946 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2947 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2948
2949 elsiocb->iocb_cmpl = lpfc_cmpl_els_acc;
2950
2951 phba->fc_stat.elsXmitACC++;
2952 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
2953 lpfc_els_free_iocb(phba, elsiocb);
2954 return 1;
2955 }
2956 return 0;
2957}
2958
2959static int
2e0fef85
JS		 2960lpfc_els_rcv_rpl(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
2961 struct lpfc_nodelist *ndlp)
7bb3b137
JW		 2962{
2963 struct lpfc_dmabuf *pcmd;
2964 uint32_t *lp;
2965 uint32_t maxsize;
2966 uint16_t cmdsize;
2967 RPL *rpl;
2968 struct ls_rjt stat;
2969
2fe165b6
JW		 2970 if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
2971 (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
7bb3b137
JW		 2972 stat.un.b.lsRjtRsvd0 = 0;
2973 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2974 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
2975 stat.un.b.vendorUnique = 0;
2e0fef85 2976 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp);
7bb3b137
JW		 2977 }
2978
dea3101e
JB		 2979 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
2980 lp = (uint32_t *) pcmd->virt;
7bb3b137 2981 rpl = (RPL *) (lp + 1);
dea3101e 2982
7bb3b137 2983 maxsize = be32_to_cpu(rpl->maxsize);
dea3101e 2984
7bb3b137
JW		 2985 /* We support only one port */
2986 if ((rpl->index == 0) &&
2987 ((maxsize == 0) ||
2988 ((maxsize * sizeof(uint32_t)) >= sizeof(RPL_RSP)))) {
2989 cmdsize = sizeof(uint32_t) + sizeof(RPL_RSP);
2fe165b6 2990 } else {
7bb3b137
JW		 2991 cmdsize = sizeof(uint32_t) + maxsize * sizeof(uint32_t);
2992 }
2e0fef85 2993 lpfc_els_rsp_rpl_acc(vport, cmdsize, cmdiocb, ndlp);
dea3101e
JB		 2994
2995 return 0;
2996}
2997
2998static int
2e0fef85
JS		 2999lpfc_els_rcv_farp(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3000 struct lpfc_nodelist *ndlp)
dea3101e 3001{
2e0fef85 3002 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 3003 struct lpfc_dmabuf *pcmd;
3004 uint32_t *lp;
3005 IOCB_t *icmd;
3006 FARP *fp;
3007 uint32_t cmd, cnt, did;
3008
3009 icmd = &cmdiocb->iocb;
3010 did = icmd->un.elsreq64.remoteID;
3011 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3012 lp = (uint32_t *) pcmd->virt;
3013
3014 cmd = *lp++;
3015 fp = (FARP *) lp;
3016
3017 /* FARP-REQ received from DID <did> */
3018 lpfc_printf_log(phba,
3019 KERN_INFO,
a4bc3379 3020 LOG_ELS,
dea3101e
JB		 3021 "%d:0601 FARP-REQ received from DID x%x\n",
3022 phba->brd_no, did);
3023
3024 /* We will only support match on WWPN or WWNN */
3025 if (fp->Mflags & ~(FARP_MATCH_NODE | FARP_MATCH_PORT)) {
c9f8735b 3026 return 0;
dea3101e
JB		 3027 }
3028
3029 cnt = 0;
3030 /* If this FARP command is searching for my portname */
3031 if (fp->Mflags & FARP_MATCH_PORT) {
2e0fef85 3032 if (memcmp(&fp->RportName, &vport->fc_portname,
dea3101e
JB		 3033 sizeof (struct lpfc_name)) == 0)
3034 cnt = 1;
3035 }
3036
3037 /* If this FARP command is searching for my nodename */
3038 if (fp->Mflags & FARP_MATCH_NODE) {
2e0fef85 3039 if (memcmp(&fp->RnodeName, &vport->fc_nodename,
dea3101e
JB		 3040 sizeof (struct lpfc_name)) == 0)
3041 cnt = 1;
3042 }
3043
3044 if (cnt) {
3045 if ((ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) ||
3046 (ndlp->nlp_state == NLP_STE_MAPPED_NODE)) {
3047 /* Log back into the node before sending the FARP. */
3048 if (fp->Rflags & FARP_REQUEST_PLOGI) {
5024ab17 3049 ndlp->nlp_prev_state = ndlp->nlp_state;
2e0fef85 3050 lpfc_nlp_set_state(vport, ndlp,
de0c5b32 3051 NLP_STE_PLOGI_ISSUE);
2e0fef85 3052 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
dea3101e
JB		 3053 }
3054
3055 /* Send a FARP response to that node */
2e0fef85
JS		 3056 if (fp->Rflags & FARP_REQUEST_FARPR)
3057 lpfc_issue_els_farpr(vport, did, 0);
dea3101e
JB		 3058 }
3059 }
c9f8735b 3060 return 0;
dea3101e
JB		 3061}
3062
3063static int
2e0fef85
JS		 3064lpfc_els_rcv_farpr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3065 struct lpfc_nodelist *ndlp)
dea3101e
JB		 3066{
3067 struct lpfc_dmabuf *pcmd;
3068 uint32_t *lp;
3069 IOCB_t *icmd;
3070 uint32_t cmd, did;
2e0fef85 3071 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 3072
3073 icmd = &cmdiocb->iocb;
3074 did = icmd->un.elsreq64.remoteID;
3075 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3076 lp = (uint32_t *) pcmd->virt;
3077
3078 cmd = *lp++;
3079 /* FARP-RSP received from DID <did> */
3080 lpfc_printf_log(phba,
3081 KERN_INFO,
a4bc3379 3082 LOG_ELS,
dea3101e
JB		 3083 "%d:0600 FARP-RSP received from DID x%x\n",
3084 phba->brd_no, did);
3085
3086 /* ACCEPT the Farp resp request */
2e0fef85 3087 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL, 0);
dea3101e
JB		 3088
3089 return 0;
3090}
3091
3092static int
2e0fef85
JS		 3093lpfc_els_rcv_fan(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3094 struct lpfc_nodelist *fan_ndlp)
dea3101e
JB		 3095{
3096 struct lpfc_dmabuf *pcmd;
3097 uint32_t *lp;
3098 IOCB_t *icmd;
dea3101e 3099 uint32_t cmd, did;
5024ab17
JW		 3100 FAN *fp;
3101 struct lpfc_nodelist *ndlp, *next_ndlp;
2e0fef85 3102 struct lpfc_hba *phba = vport->phba;
5024ab17
JW		 3103
3104 /* FAN received */
dca9479b 3105 lpfc_printf_log(phba, KERN_INFO, LOG_ELS, "%d:0265 FAN received\n",
5024ab17 3106 phba->brd_no);
dea3101e
JB		 3107
3108 icmd = &cmdiocb->iocb;
3109 did = icmd->un.elsreq64.remoteID;
5024ab17
JW		 3110 pcmd = (struct lpfc_dmabuf *)cmdiocb->context2;
3111 lp = (uint32_t *)pcmd->virt;
dea3101e
JB		 3112
3113 cmd = *lp++;
5024ab17 3114 fp = (FAN *)lp;
dea3101e 3115
5024ab17 3116 /* FAN received; Fan does not have a reply sequence */
dea3101e 3117
2e0fef85 3118 if (phba->pport->port_state == LPFC_LOCAL_CFG_LINK) {
5024ab17
JW		 3119 if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName,
3120 sizeof(struct lpfc_name)) != 0) ||
3121 (memcmp(&phba->fc_fabparam.portName, &fp->FportName,
3122 sizeof(struct lpfc_name)) != 0)) {
3123 /*
3124 * This node has switched fabrics. FLOGI is required
3125 * Clean up the old rpi's
dea3101e 3126 */
5024ab17
JW		 3127
3128 list_for_each_entry_safe(ndlp, next_ndlp,
2e0fef85 3129 &vport->fc_nodes, nlp_listp) {
685f0bf7
JS		 3130 if (ndlp->nlp_state != NLP_STE_NPR_NODE)
3131 continue;
5024ab17
JW		 3132 if (ndlp->nlp_type & NLP_FABRIC) {
3133 /*
3134 * Clean up old Fabric, Nameserver and
3135 * other NLP_FABRIC logins
3136 */
2e0fef85 3137 lpfc_drop_node(vport, ndlp);
2fe165b6 3138 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
5024ab17
JW		 3139 /* Fail outstanding I/O now since this
3140 * device is marked for PLOGI
3141 */
2e0fef85 3142 lpfc_unreg_rpi(vport, ndlp);
5024ab17
JW		 3143 }
3144 }
3145
2e0fef85
JS		 3146 vport->port_state = LPFC_FLOGI;
3147 lpfc_set_disctmo(vport);
3148 lpfc_initial_flogi(vport);
c9f8735b 3149 return 0;
dea3101e 3150 }
5024ab17
JW		 3151 /* Discovery not needed,
3152 * move the nodes to their original state.
3153 */
2e0fef85 3154 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes,
685f0bf7
JS		 3155 nlp_listp) {
3156 if (ndlp->nlp_state != NLP_STE_NPR_NODE)
3157 continue;
dea3101e 3158
5024ab17
JW		 3159 switch (ndlp->nlp_prev_state) {
3160 case NLP_STE_UNMAPPED_NODE:
3161 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
2e0fef85 3162 lpfc_nlp_set_state(vport, ndlp,
de0c5b32 3163 NLP_STE_UNMAPPED_NODE);
5024ab17
JW		 3164 break;
3165
3166 case NLP_STE_MAPPED_NODE:
3167 ndlp->nlp_prev_state = NLP_STE_NPR_NODE;
2e0fef85 3168 lpfc_nlp_set_state(vport, ndlp,
de0c5b32 3169 NLP_STE_MAPPED_NODE);
5024ab17
JW		 3170 break;
3171
3172 default:
3173 break;
3174 }
3175 }
3176
3177 /* Start discovery - this should just do CLEAR_LA */
2e0fef85 3178 lpfc_disc_start(vport);
dea3101e 3179 }
c9f8735b 3180 return 0;
dea3101e
JB		 3181}
3182
3183void
3184lpfc_els_timeout(unsigned long ptr)
3185{
2e0fef85
JS		 3186 struct lpfc_vport *vport = (struct lpfc_vport *) ptr;
3187 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 3188 unsigned long iflag;
3189
2e0fef85
JS		 3190 spin_lock_irqsave(&vport->work_port_lock, iflag);
3191 if ((vport->work_port_events & WORKER_ELS_TMO) == 0) {
3192 vport->work_port_events |= WORKER_ELS_TMO;
dea3101e
JB		 3193 if (phba->work_wait)
3194 wake_up(phba->work_wait);
3195 }
2e0fef85 3196 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
dea3101e
JB		 3197 return;
3198}
3199
3200void
2e0fef85 3201lpfc_els_timeout_handler(struct lpfc_vport *vport)
dea3101e 3202{
2e0fef85 3203 struct lpfc_hba *phba = vport->phba;
dea3101e
JB		 3204 struct lpfc_sli_ring *pring;
3205 struct lpfc_iocbq *tmp_iocb, *piocb;
3206 IOCB_t *cmd = NULL;
3207 struct lpfc_dmabuf *pcmd;
2e0fef85 3208 uint32_t els_command = 0;
dea3101e 3209 uint32_t timeout;
2e0fef85 3210 uint32_t remote_ID = 0xffffffff;
dea3101e 3211
dea3101e 3212 /* If the timer is already canceled do nothing */
2e0fef85 3213 if ((vport->work_port_events & WORKER_ELS_TMO) == 0) {
dea3101e
JB		 3214 return;
3215 }
2e0fef85 3216 spin_lock_irq(&phba->hbalock);
dea3101e
JB		 3217 timeout = (uint32_t)(phba->fc_ratov << 1);
3218
3219 pring = &phba->sli.ring[LPFC_ELS_RING];
dea3101e
JB		 3220
3221 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3222 cmd = &piocb->iocb;
3223
2e0fef85
JS		 3224 if ((piocb->iocb_flag & LPFC_IO_LIBDFC) != 0 ||
3225 piocb->iocb.ulpCommand == CMD_ABORT_XRI_CN ||
3226 piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)
dea3101e 3227 continue;
2e0fef85
JS		 3228
3229 if (piocb->vport != vport)
3230 continue;
3231
dea3101e 3232 pcmd = (struct lpfc_dmabuf *) piocb->context2;
2e0fef85
JS		 3233 if (pcmd)
3234 els_command = *(uint32_t *) (pcmd->virt);
dea3101e
JB		 3235
3236 if ((els_command == ELS_CMD_FARP)
3237 || (els_command == ELS_CMD_FARPR)) {
3238 continue;
3239 }
3240
3241 if (piocb->drvrTimeout > 0) {
3242 if (piocb->drvrTimeout >= timeout) {
3243 piocb->drvrTimeout -= timeout;
3244 } else {
3245 piocb->drvrTimeout = 0;
3246 }
3247 continue;
3248 }
3249
2e0fef85
JS		 3250 remote_ID = 0xffffffff;
3251 if (cmd->ulpCommand != CMD_GEN_REQUEST64_CR)
dea3101e 3252 remote_ID = cmd->un.elsreq64.remoteID;
2e0fef85
JS		 3253 else {
3254 struct lpfc_nodelist *ndlp;
3255 ndlp = __lpfc_findnode_rpi(vport, cmd->ulpContext);
3256 if (ndlp)
3257 remote_ID = ndlp->nlp_DID;
dea3101e
JB		 3258 }
3259
3260 lpfc_printf_log(phba,
3261 KERN_ERR,
3262 LOG_ELS,
3263 "%d:0127 ELS timeout Data: x%x x%x x%x x%x\n",
3264 phba->brd_no, els_command,
3265 remote_ID, cmd->ulpCommand, cmd->ulpIoTag);
3266
07951076 3267 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
dea3101e 3268 }
2e0fef85 3269 spin_unlock_irq(&phba->hbalock);
5a0e326d 3270
2e0fef85
JS		 3271 if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt)
3272 mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
dea3101e
JB		 3273}
3274
3275void
2e0fef85 3276lpfc_els_flush_cmd(struct lpfc_vport *vport)
dea3101e 3277{
2534ba75 3278 LIST_HEAD(completions);
2e0fef85 3279 struct lpfc_hba *phba = vport->phba;
329f9bc7 3280 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
dea3101e
JB		 3281 struct lpfc_iocbq *tmp_iocb, *piocb;
3282 IOCB_t *cmd = NULL;
dea3101e 3283
2e0fef85 3284 spin_lock_irq(&phba->hbalock);
dea3101e
JB		 3285 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
3286 cmd = &piocb->iocb;
3287
3288 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3289 continue;
3290 }
3291
3292 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
329f9bc7
JS		 3293 if (cmd->ulpCommand == CMD_QUE_RING_BUF_CN ||
3294 cmd->ulpCommand == CMD_QUE_RING_BUF64_CN ||
3295 cmd->ulpCommand == CMD_CLOSE_XRI_CN ||
3296 cmd->ulpCommand == CMD_ABORT_XRI_CN)
dea3101e 3297 continue;
dea3101e 3298
2e0fef85
JS		 3299 if (piocb->vport != vport)
3300 continue;
3301
2534ba75 3302 list_move_tail(&piocb->list, &completions);
1dcb58e5 3303 pring->txq_cnt--;
dea3101e
JB		 3304 }
3305
3306 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
dea3101e
JB		 3307 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3308 continue;
3309 }
dea3101e 3310
2e0fef85
JS		 3311 if (piocb->vport != vport)
3312 continue;
3313
07951076 3314 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
dea3101e 3315 }
2e0fef85 3316 spin_unlock_irq(&phba->hbalock);
2534ba75 3317
2e0fef85 3318 while (!list_empty(&completions)) {
2534ba75
JS		 3319 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
3320 cmd = &piocb->iocb;
3321 list_del(&piocb->list);
3322
2e0fef85
JS		 3323 if (!piocb->iocb_cmpl)
3324 lpfc_sli_release_iocbq(phba, piocb);
3325 else {
2534ba75
JS		 3326 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3327 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3328 (piocb->iocb_cmpl) (phba, piocb, piocb);
2e0fef85 3329 }
2534ba75
JS		 3330 }
3331
dea3101e
JB		 3332 return;
3333}
3334
3335void
2e0fef85
JS		 3336lpfc_els_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3337 struct lpfc_iocbq *elsiocb)
dea3101e
JB		 3338{
3339 struct lpfc_sli *psli;
3340 struct lpfc_nodelist *ndlp;
2e0fef85 3341 struct lpfc_dmabuf *mp = NULL;
dea3101e
JB		 3342 uint32_t *lp;
3343 IOCB_t *icmd;
3344 struct ls_rjt stat;
2e0fef85 3345 uint32_t cmd, did, newnode, rjt_err = 0;
dea3101e 3346 uint32_t drop_cmd = 0; /* by default do NOT drop received cmd */
2e0fef85 3347 struct lpfc_vport *vport = NULL;
dea3101e
JB		 3348
3349 psli = &phba->sli;
3350 icmd = &elsiocb->iocb;
3351
3352 if ((icmd->ulpStatus == IOSTAT_LOCAL_REJECT) &&
3353 ((icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING)) {
dea3101e 3354 phba->fc_stat.NoRcvBuf++;
2e0fef85 3355 /* Not enough posted buffers; Try posting more buffers */
dea3101e
JB		 3356 lpfc_post_buffer(phba, pring, 0, 1);
3357 return;
3358 }
3359
3360 /* If there are no BDEs associated with this IOCB,
3361 * there is nothing to do.
3362 */
3363 if (icmd->ulpBdeCount == 0)
3364 return;
3365
2e0fef85
JS		 3366 /* type of ELS cmd is first 32bit word in packet */
3367 mp = lpfc_sli_ringpostbuf_get(phba, pring,
3368 getPaddr(icmd->un.cont64[0].addrHigh,
3369 icmd->un.cont64[0].addrLow));
dea3101e
JB		 3370 if (mp == 0) {
3371 drop_cmd = 1;
3372 goto dropit;
3373 }
3374
2e0fef85
JS		 3375 vport = phba->pport;
3376
dea3101e
JB		 3377 newnode = 0;
3378 lp = (uint32_t *) mp->virt;
3379 cmd = *lp++;
3380 lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], 1, 1);
3381
3382 if (icmd->ulpStatus) {
3383 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3384 kfree(mp);
3385 drop_cmd = 1;
3386 goto dropit;
3387 }
3388
3389 /* Check to see if link went down during discovery */
2e0fef85 3390 if (lpfc_els_chk_latt(vport)) {
dea3101e
JB		 3391 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3392 kfree(mp);
3393 drop_cmd = 1;
3394 goto dropit;
3395 }
3396
3397 did = icmd->un.rcvels.remoteID;
2e0fef85 3398 ndlp = lpfc_findnode_did(vport, did);
c9f8735b 3399 if (!ndlp) {
dea3101e 3400 /* Cannot find existing Fabric ndlp, so allocate a new one */
c9f8735b
JW		 3401 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
3402 if (!ndlp) {
dea3101e
JB		 3403 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3404 kfree(mp);
3405 drop_cmd = 1;
3406 goto dropit;
3407 }
3408
2e0fef85 3409 lpfc_nlp_init(vport, ndlp, did);
dea3101e
JB		 3410 newnode = 1;
3411 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK) {
3412 ndlp->nlp_type |= NLP_FABRIC;
3413 }
2e0fef85 3414 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNUSED_NODE);
dea3101e
JB		 3415 }
3416
3417 phba->fc_stat.elsRcvFrame++;
329f9bc7
JS		 3418 if (elsiocb->context1)
3419 lpfc_nlp_put(elsiocb->context1);
3420 elsiocb->context1 = lpfc_nlp_get(ndlp);
dea3101e 3421 elsiocb->context2 = mp;
2e0fef85 3422 elsiocb->vport = vport;
dea3101e
JB		 3423
3424 if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) {
3425 cmd &= ELS_CMD_MASK;
3426 }
3427 /* ELS command <elsCmd> received from NPORT <did> */
3428 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
3429 "%d:0112 ELS command x%x received from NPORT x%x "
2e0fef85
JS		 3430 "Data: x%x\n", phba->brd_no, cmd, did,
3431 vport->port_state);
dea3101e
JB		 3432
3433 switch (cmd) {
3434 case ELS_CMD_PLOGI:
3435 phba->fc_stat.elsRcvPLOGI++;
2e0fef85 3436 if (vport->port_state < LPFC_DISC_AUTH) {
1f679caf 3437 rjt_err = 1;
dea3101e
JB		 3438 break;
3439 }
92795650 3440 ndlp = lpfc_plogi_confirm_nport(phba, mp, ndlp);
2e0fef85
JS		 3441 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3442 NLP_EVT_RCV_PLOGI);
dea3101e
JB		 3443 break;
3444 case ELS_CMD_FLOGI:
3445 phba->fc_stat.elsRcvFLOGI++;
2e0fef85 3446 lpfc_els_rcv_flogi(vport, elsiocb, ndlp, newnode);
de0c5b32 3447 if (newnode)
2e0fef85 3448 lpfc_drop_node(vport, ndlp);
dea3101e
JB		 3449 break;
3450 case ELS_CMD_LOGO:
3451 phba->fc_stat.elsRcvLOGO++;
2e0fef85 3452 if (vport->port_state < LPFC_DISC_AUTH) {
1f679caf 3453 rjt_err = 1;
dea3101e
JB		 3454 break;
3455 }
2e0fef85 3456 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_LOGO);
dea3101e
JB		 3457 break;
3458 case ELS_CMD_PRLO:
3459 phba->fc_stat.elsRcvPRLO++;
2e0fef85 3460 if (vport->port_state < LPFC_DISC_AUTH) {
1f679caf 3461 rjt_err = 1;
dea3101e
JB		 3462 break;
3463 }
2e0fef85 3464 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_PRLO);
dea3101e
JB		 3465 break;
3466 case ELS_CMD_RSCN:
3467 phba->fc_stat.elsRcvRSCN++;
2e0fef85 3468 lpfc_els_rcv_rscn(vport, elsiocb, ndlp, newnode);
de0c5b32 3469 if (newnode)
2e0fef85 3470 lpfc_drop_node(vport, ndlp);
dea3101e
JB		 3471 break;
3472 case ELS_CMD_ADISC:
3473 phba->fc_stat.elsRcvADISC++;
2e0fef85 3474 if (vport->port_state < LPFC_DISC_AUTH) {
1f679caf 3475 rjt_err = 1;
dea3101e
JB		 3476 break;
3477 }
2e0fef85
JS		 3478 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3479 NLP_EVT_RCV_ADISC);
dea3101e
JB		 3480 break;
3481 case ELS_CMD_PDISC:
3482 phba->fc_stat.elsRcvPDISC++;
2e0fef85 3483 if (vport->port_state < LPFC_DISC_AUTH) {
1f679caf 3484 rjt_err = 1;
dea3101e
JB		 3485 break;
3486 }
2e0fef85
JS		 3487 lpfc_disc_state_machine(vport, ndlp, elsiocb,
3488 NLP_EVT_RCV_PDISC);
dea3101e
JB		 3489 break;
3490 case ELS_CMD_FARPR:
3491 phba->fc_stat.elsRcvFARPR++;
2e0fef85 3492 lpfc_els_rcv_farpr(vport, elsiocb, ndlp);
dea3101e
JB		 3493 break;
3494 case ELS_CMD_FARP:
3495 phba->fc_stat.elsRcvFARP++;
2e0fef85 3496 lpfc_els_rcv_farp(vport, elsiocb, ndlp);
dea3101e
JB		 3497 break;
3498 case ELS_CMD_FAN:
3499 phba->fc_stat.elsRcvFAN++;
2e0fef85 3500 lpfc_els_rcv_fan(vport, elsiocb, ndlp);
dea3101e 3501 break;
dea3101e
JB		 3502 case ELS_CMD_PRLI:
3503 phba->fc_stat.elsRcvPRLI++;
2e0fef85 3504 if (vport->port_state < LPFC_DISC_AUTH) {
1f679caf 3505 rjt_err = 1;
dea3101e
JB		 3506 break;
3507 }
2e0fef85 3508 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_PRLI);
dea3101e 3509 break;
7bb3b137
JW		 3510 case ELS_CMD_LIRR:
3511 phba->fc_stat.elsRcvLIRR++;
2e0fef85 3512 lpfc_els_rcv_lirr(vport, elsiocb, ndlp);
de0c5b32 3513 if (newnode)
2e0fef85 3514 lpfc_drop_node(vport, ndlp);
7bb3b137
JW		 3515 break;
3516 case ELS_CMD_RPS:
3517 phba->fc_stat.elsRcvRPS++;
2e0fef85 3518 lpfc_els_rcv_rps(vport, elsiocb, ndlp);
de0c5b32 3519 if (newnode)
2e0fef85 3520 lpfc_drop_node(vport, ndlp);
7bb3b137
JW		 3521 break;
3522 case ELS_CMD_RPL:
3523 phba->fc_stat.elsRcvRPL++;
2e0fef85 3524 lpfc_els_rcv_rpl(vport, elsiocb, ndlp);
de0c5b32 3525 if (newnode)
2e0fef85 3526 lpfc_drop_node(vport, ndlp);
7bb3b137 3527 break;
dea3101e
JB		 3528 case ELS_CMD_RNID:
3529 phba->fc_stat.elsRcvRNID++;
2e0fef85 3530 lpfc_els_rcv_rnid(vport, elsiocb, ndlp);
de0c5b32 3531 if (newnode)
2e0fef85 3532 lpfc_drop_node(vport, ndlp);
dea3101e
JB		 3533 break;
3534 default:
3535 /* Unsupported ELS command, reject */
1f679caf 3536 rjt_err = 1;
dea3101e
JB		 3537
3538 /* Unknown ELS command <elsCmd> received from NPORT <did> */
3539 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3540 "%d:0115 Unknown ELS command x%x received from "
3541 "NPORT x%x\n", phba->brd_no, cmd, did);
de0c5b32 3542 if (newnode)
2e0fef85 3543 lpfc_drop_node(vport, ndlp);
dea3101e
JB		 3544 break;
3545 }
3546
3547 /* check if need to LS_RJT received ELS cmd */
3548 if (rjt_err) {
3549 stat.un.b.lsRjtRsvd0 = 0;
3550 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
1f679caf 3551 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
dea3101e 3552 stat.un.b.vendorUnique = 0;
2e0fef85 3553 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, elsiocb, ndlp);
dea3101e
JB		 3554 }
3555
329f9bc7
JS		 3556 lpfc_nlp_put(elsiocb->context1);
3557 elsiocb->context1 = NULL;
dea3101e
JB		 3558 if (elsiocb->context2) {
3559 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3560 kfree(mp);
3561 }
3562dropit:
3563 /* check if need to drop received ELS cmd */
3564 if (drop_cmd == 1) {
3565 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
3566 "%d:0111 Dropping received ELS cmd "
c9f8735b
JW		 3567 "Data: x%x x%x x%x\n", phba->brd_no,
3568 icmd->ulpStatus, icmd->un.ulpWord[4],
3569 icmd->ulpTimeout);
dea3101e
JB		 3570 phba->fc_stat.elsRcvDrop++;
3571 }
dea3101e 3572}
Clone of davem's net-next-2.6 tree