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