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