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