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