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