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