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