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