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