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