?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (8866): Add dummy FE to the Kconfig-file and fix it
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / scsi / lpfc / lpfc_els.c
blobf54e0f7eaee3222d5e8251f84d0ad09adbe34d53
1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2008 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
6 * www.emulex.com *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
8 * *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
21 /* See Fibre Channel protocol T11 FC-LS for details */
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
25
26 #include <scsi/scsi.h>
27 #include <scsi/scsi_device.h>
28 #include <scsi/scsi_host.h>
29 #include <scsi/scsi_transport_fc.h>
30
31 #include "lpfc_hw.h"
32 #include "lpfc_sli.h"
33 #include "lpfc_disc.h"
34 #include "lpfc_scsi.h"
35 #include "lpfc.h"
36 #include "lpfc_logmsg.h"
37 #include "lpfc_crtn.h"
38 #include "lpfc_vport.h"
39 #include "lpfc_debugfs.h"
40
41 static int lpfc_els_retry(struct lpfc_hba *, struct lpfc_iocbq *,
42 struct lpfc_iocbq *);
43 static void lpfc_cmpl_fabric_iocb(struct lpfc_hba *, struct lpfc_iocbq *,
44 struct lpfc_iocbq *);
45 static void lpfc_fabric_abort_vport(struct lpfc_vport *vport);
46 static int lpfc_issue_els_fdisc(struct lpfc_vport *vport,
47 struct lpfc_nodelist *ndlp, uint8_t retry);
48 static int lpfc_issue_fabric_iocb(struct lpfc_hba *phba,
49 struct lpfc_iocbq *iocb);
50 static void lpfc_register_new_vport(struct lpfc_hba *phba,
51 struct lpfc_vport *vport,
52 struct lpfc_nodelist *ndlp);
53
54 static int lpfc_max_els_tries = 3;
55
56 int
57 lpfc_els_chk_latt(struct lpfc_vport *vport)
58 {
59 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
60 struct lpfc_hba *phba = vport->phba;
61 uint32_t ha_copy;
62
63 if (vport->port_state >= LPFC_VPORT_READY ||
64 phba->link_state == LPFC_LINK_DOWN)
65 return 0;
66
67 /* Read the HBA Host Attention Register */
68 ha_copy = readl(phba->HAregaddr);
69
70 if (!(ha_copy & HA_LATT))
71 return 0;
72
73 /* Pending Link Event during Discovery */
74 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
75 "0237 Pending Link Event during "
76 "Discovery: State x%x\n",
77 phba->pport->port_state);
78
79 /* CLEAR_LA should re-enable link attention events and
80 * we should then imediately take a LATT event. The
81 * LATT processing should call lpfc_linkdown() which
82 * will cleanup any left over in-progress discovery
83 * events.
84 */
85 spin_lock_irq(shost->host_lock);
86 vport->fc_flag |= FC_ABORT_DISCOVERY;
87 spin_unlock_irq(shost->host_lock);
88
89 if (phba->link_state != LPFC_CLEAR_LA)
90 lpfc_issue_clear_la(phba, vport);
91
92 return 1;
93 }
94
95 static struct lpfc_iocbq *
96 lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
97 uint16_t cmdSize, uint8_t retry,
98 struct lpfc_nodelist *ndlp, uint32_t did,
99 uint32_t elscmd)
100 {
101 struct lpfc_hba *phba = vport->phba;
102 struct lpfc_iocbq *elsiocb;
103 struct lpfc_dmabuf *pcmd, *prsp, *pbuflist;
104 struct ulp_bde64 *bpl;
105 IOCB_t *icmd;
106
107
108 if (!lpfc_is_link_up(phba))
109 return NULL;
110
111 /* Allocate buffer for command iocb */
112 elsiocb = lpfc_sli_get_iocbq(phba);
113
114 if (elsiocb == NULL)
115 return NULL;
116
117 icmd = &elsiocb->iocb;
118
119 /* fill in BDEs for command */
120 /* Allocate buffer for command payload */
121 pcmd = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
122 if (pcmd)
123 pcmd->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &pcmd->phys);
124 if (!pcmd || !pcmd->virt)
125 goto els_iocb_free_pcmb_exit;
126
127 INIT_LIST_HEAD(&pcmd->list);
128
129 /* Allocate buffer for response payload */
130 if (expectRsp) {
131 prsp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
132 if (prsp)
133 prsp->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
134 &prsp->phys);
135 if (!prsp || !prsp->virt)
136 goto els_iocb_free_prsp_exit;
137 INIT_LIST_HEAD(&prsp->list);
138 } else
139 prsp = NULL;
140
141 /* Allocate buffer for Buffer ptr list */
142 pbuflist = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
143 if (pbuflist)
144 pbuflist->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
145 &pbuflist->phys);
146 if (!pbuflist || !pbuflist->virt)
147 goto els_iocb_free_pbuf_exit;
148
149 INIT_LIST_HEAD(&pbuflist->list);
150
151 icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
152 icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
153 icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BDL;
154 icmd->un.elsreq64.remoteID = did; /* DID */
155 if (expectRsp) {
156 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64));
157 icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
158 icmd->ulpTimeout = phba->fc_ratov * 2;
159 } else {
160 icmd->un.elsreq64.bdl.bdeSize = sizeof(struct ulp_bde64);
161 icmd->ulpCommand = CMD_XMIT_ELS_RSP64_CX;
162 }
163 icmd->ulpBdeCount = 1;
164 icmd->ulpLe = 1;
165 icmd->ulpClass = CLASS3;
166
167 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
168 icmd->un.elsreq64.myID = vport->fc_myDID;
169
170 /* For ELS_REQUEST64_CR, use the VPI by default */
171 icmd->ulpContext = vport->vpi;
172 icmd->ulpCt_h = 0;
173 icmd->ulpCt_l = 1;
174 }
175
176 bpl = (struct ulp_bde64 *) pbuflist->virt;
177 bpl->addrLow = le32_to_cpu(putPaddrLow(pcmd->phys));
178 bpl->addrHigh = le32_to_cpu(putPaddrHigh(pcmd->phys));
179 bpl->tus.f.bdeSize = cmdSize;
180 bpl->tus.f.bdeFlags = 0;
181 bpl->tus.w = le32_to_cpu(bpl->tus.w);
182
183 if (expectRsp) {
184 bpl++;
185 bpl->addrLow = le32_to_cpu(putPaddrLow(prsp->phys));
186 bpl->addrHigh = le32_to_cpu(putPaddrHigh(prsp->phys));
187 bpl->tus.f.bdeSize = FCELSSIZE;
188 bpl->tus.f.bdeFlags = BUFF_USE_RCV;
189 bpl->tus.w = le32_to_cpu(bpl->tus.w);
190 }
191
192 /* prevent preparing iocb with NULL ndlp reference */
193 elsiocb->context1 = lpfc_nlp_get(ndlp);
194 if (!elsiocb->context1)
195 goto els_iocb_free_pbuf_exit;
196 elsiocb->context2 = pcmd;
197 elsiocb->context3 = pbuflist;
198 elsiocb->retry = retry;
199 elsiocb->vport = vport;
200 elsiocb->drvrTimeout = (phba->fc_ratov << 1) + LPFC_DRVR_TIMEOUT;
201
202 if (prsp) {
203 list_add(&prsp->list, &pcmd->list);
204 }
205 if (expectRsp) {
206 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
207 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
208 "0116 Xmit ELS command x%x to remote "
209 "NPORT x%x I/O tag: x%x, port state: x%x\n",
210 elscmd, did, elsiocb->iotag,
211 vport->port_state);
212 } else {
213 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
214 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
215 "0117 Xmit ELS response x%x to remote "
216 "NPORT x%x I/O tag: x%x, size: x%x\n",
217 elscmd, ndlp->nlp_DID, elsiocb->iotag,
218 cmdSize);
219 }
220 return elsiocb;
221
222 els_iocb_free_pbuf_exit:
223 lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
224 kfree(pbuflist);
225
226 els_iocb_free_prsp_exit:
227 lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
228 kfree(prsp);
229
230 els_iocb_free_pcmb_exit:
231 kfree(pcmd);
232 lpfc_sli_release_iocbq(phba, elsiocb);
233 return NULL;
234 }
235
236 static int
237 lpfc_issue_fabric_reglogin(struct lpfc_vport *vport)
238 {
239 struct lpfc_hba *phba = vport->phba;
240 LPFC_MBOXQ_t *mbox;
241 struct lpfc_dmabuf *mp;
242 struct lpfc_nodelist *ndlp;
243 struct serv_parm *sp;
244 int rc;
245 int err = 0;
246
247 sp = &phba->fc_fabparam;
248 ndlp = lpfc_findnode_did(vport, Fabric_DID);
249 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
250 err = 1;
251 goto fail;
252 }
253
254 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
255 if (!mbox) {
256 err = 2;
257 goto fail;
258 }
259
260 vport->port_state = LPFC_FABRIC_CFG_LINK;
261 lpfc_config_link(phba, mbox);
262 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
263 mbox->vport = vport;
264
265 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
266 if (rc == MBX_NOT_FINISHED) {
267 err = 3;
268 goto fail_free_mbox;
269 }
270
271 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
272 if (!mbox) {
273 err = 4;
274 goto fail;
275 }
276 rc = lpfc_reg_login(phba, vport->vpi, Fabric_DID, (uint8_t *)sp, mbox,
277 0);
278 if (rc) {
279 err = 5;
280 goto fail_free_mbox;
281 }
282
283 mbox->mbox_cmpl = lpfc_mbx_cmpl_fabric_reg_login;
284 mbox->vport = vport;
285 /* increment the reference count on ndlp to hold reference
286 * for the callback routine.
287 */
288 mbox->context2 = lpfc_nlp_get(ndlp);
289
290 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
291 if (rc == MBX_NOT_FINISHED) {
292 err = 6;
293 goto fail_issue_reg_login;
294 }
295
296 return 0;
297
298 fail_issue_reg_login:
299 /* decrement the reference count on ndlp just incremented
300 * for the failed mbox command.
301 */
302 lpfc_nlp_put(ndlp);
303 mp = (struct lpfc_dmabuf *) mbox->context1;
304 lpfc_mbuf_free(phba, mp->virt, mp->phys);
305 kfree(mp);
306 fail_free_mbox:
307 mempool_free(mbox, phba->mbox_mem_pool);
308
309 fail:
310 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
311 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
312 "0249 Cannot issue Register Fabric login: Err %d\n", err);
313 return -ENXIO;
314 }
315
316 static int
317 lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
318 struct serv_parm *sp, IOCB_t *irsp)
319 {
320 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
321 struct lpfc_hba *phba = vport->phba;
322 struct lpfc_nodelist *np;
323 struct lpfc_nodelist *next_np;
324
325 spin_lock_irq(shost->host_lock);
326 vport->fc_flag |= FC_FABRIC;
327 spin_unlock_irq(shost->host_lock);
328
329 phba->fc_edtov = be32_to_cpu(sp->cmn.e_d_tov);
330 if (sp->cmn.edtovResolution) /* E_D_TOV ticks are in nanoseconds */
331 phba->fc_edtov = (phba->fc_edtov + 999999) / 1000000;
332
333 phba->fc_ratov = (be32_to_cpu(sp->cmn.w2.r_a_tov) + 999) / 1000;
334
335 if (phba->fc_topology == TOPOLOGY_LOOP) {
336 spin_lock_irq(shost->host_lock);
337 vport->fc_flag |= FC_PUBLIC_LOOP;
338 spin_unlock_irq(shost->host_lock);
339 } else {
340 /*
341 * If we are a N-port connected to a Fabric, fixup sparam's so
342 * logins to devices on remote loops work.
343 */
344 vport->fc_sparam.cmn.altBbCredit = 1;
345 }
346
347 vport->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
348 memcpy(&ndlp->nlp_portname, &sp->portName, sizeof(struct lpfc_name));
349 memcpy(&ndlp->nlp_nodename, &sp->nodeName, sizeof(struct lpfc_name));
350 ndlp->nlp_class_sup = 0;
351 if (sp->cls1.classValid)
352 ndlp->nlp_class_sup |= FC_COS_CLASS1;
353 if (sp->cls2.classValid)
354 ndlp->nlp_class_sup |= FC_COS_CLASS2;
355 if (sp->cls3.classValid)
356 ndlp->nlp_class_sup |= FC_COS_CLASS3;
357 if (sp->cls4.classValid)
358 ndlp->nlp_class_sup |= FC_COS_CLASS4;
359 ndlp->nlp_maxframe = ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) |
360 sp->cmn.bbRcvSizeLsb;
361 memcpy(&phba->fc_fabparam, sp, sizeof(struct serv_parm));
362
363 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
364 if (sp->cmn.response_multiple_NPort) {
365 lpfc_printf_vlog(vport, KERN_WARNING,
366 LOG_ELS | LOG_VPORT,
367 "1816 FLOGI NPIV supported, "
368 "response data 0x%x\n",
369 sp->cmn.response_multiple_NPort);
370 phba->link_flag |= LS_NPIV_FAB_SUPPORTED;
371 } else {
372 /* Because we asked f/w for NPIV it still expects us
373 to call reg_vnpid atleast for the physcial host */
374 lpfc_printf_vlog(vport, KERN_WARNING,
375 LOG_ELS | LOG_VPORT,
376 "1817 Fabric does not support NPIV "
377 "- configuring single port mode.\n");
378 phba->link_flag &= ~LS_NPIV_FAB_SUPPORTED;
379 }
380 }
381
382 if ((vport->fc_prevDID != vport->fc_myDID) &&
383 !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) {
384
385 /* If our NportID changed, we need to ensure all
386 * remaining NPORTs get unreg_login'ed.
387 */
388 list_for_each_entry_safe(np, next_np,
389 &vport->fc_nodes, nlp_listp) {
390 if (!NLP_CHK_NODE_ACT(ndlp))
391 continue;
392 if ((np->nlp_state != NLP_STE_NPR_NODE) ||
393 !(np->nlp_flag & NLP_NPR_ADISC))
394 continue;
395 spin_lock_irq(shost->host_lock);
396 np->nlp_flag &= ~NLP_NPR_ADISC;
397 spin_unlock_irq(shost->host_lock);
398 lpfc_unreg_rpi(vport, np);
399 }
400 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
401 lpfc_mbx_unreg_vpi(vport);
402 spin_lock_irq(shost->host_lock);
403 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
404 spin_unlock_irq(shost->host_lock);
405 }
406 }
407
408 lpfc_nlp_set_state(vport, ndlp, NLP_STE_REG_LOGIN_ISSUE);
409
410 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED &&
411 vport->fc_flag & FC_VPORT_NEEDS_REG_VPI) {
412 lpfc_register_new_vport(phba, vport, ndlp);
413 return 0;
414 }
415 lpfc_issue_fabric_reglogin(vport);
416 return 0;
417 }
418
419 /*
420 * We FLOGIed into an NPort, initiate pt2pt protocol
421 */
422 static int
423 lpfc_cmpl_els_flogi_nport(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
424 struct serv_parm *sp)
425 {
426 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
427 struct lpfc_hba *phba = vport->phba;
428 LPFC_MBOXQ_t *mbox;
429 int rc;
430
431 spin_lock_irq(shost->host_lock);
432 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
433 spin_unlock_irq(shost->host_lock);
434
435 phba->fc_edtov = FF_DEF_EDTOV;
436 phba->fc_ratov = FF_DEF_RATOV;
437 rc = memcmp(&vport->fc_portname, &sp->portName,
438 sizeof(vport->fc_portname));
439 if (rc >= 0) {
440 /* This side will initiate the PLOGI */
441 spin_lock_irq(shost->host_lock);
442 vport->fc_flag |= FC_PT2PT_PLOGI;
443 spin_unlock_irq(shost->host_lock);
444
445 /*
446 * N_Port ID cannot be 0, set our to LocalID the other
447 * side will be RemoteID.
448 */
449
450 /* not equal */
451 if (rc)
452 vport->fc_myDID = PT2PT_LocalID;
453
454 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
455 if (!mbox)
456 goto fail;
457
458 lpfc_config_link(phba, mbox);
459
460 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
461 mbox->vport = vport;
462 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
463 if (rc == MBX_NOT_FINISHED) {
464 mempool_free(mbox, phba->mbox_mem_pool);
465 goto fail;
466 }
467 /* Decrement ndlp reference count indicating that ndlp can be
468 * safely released when other references to it are done.
469 */
470 lpfc_nlp_put(ndlp);
471
472 ndlp = lpfc_findnode_did(vport, PT2PT_RemoteID);
473 if (!ndlp) {
474 /*
475 * Cannot find existing Fabric ndlp, so allocate a
476 * new one
477 */
478 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
479 if (!ndlp)
480 goto fail;
481 lpfc_nlp_init(vport, ndlp, PT2PT_RemoteID);
482 } else if (!NLP_CHK_NODE_ACT(ndlp)) {
483 ndlp = lpfc_enable_node(vport, ndlp,
484 NLP_STE_UNUSED_NODE);
485 if(!ndlp)
486 goto fail;
487 }
488
489 memcpy(&ndlp->nlp_portname, &sp->portName,
490 sizeof(struct lpfc_name));
491 memcpy(&ndlp->nlp_nodename, &sp->nodeName,
492 sizeof(struct lpfc_name));
493 /* Set state will put ndlp onto node list if not already done */
494 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
495 spin_lock_irq(shost->host_lock);
496 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
497 spin_unlock_irq(shost->host_lock);
498 } else
499 /* This side will wait for the PLOGI, decrement ndlp reference
500 * count indicating that ndlp can be released when other
501 * references to it are done.
502 */
503 lpfc_nlp_put(ndlp);
504
505 /* If we are pt2pt with another NPort, force NPIV off! */
506 phba->sli3_options &= ~LPFC_SLI3_NPIV_ENABLED;
507
508 spin_lock_irq(shost->host_lock);
509 vport->fc_flag |= FC_PT2PT;
510 spin_unlock_irq(shost->host_lock);
511
512 /* Start discovery - this should just do CLEAR_LA */
513 lpfc_disc_start(vport);
514 return 0;
515 fail:
516 return -ENXIO;
517 }
518
519 static void
520 lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
521 struct lpfc_iocbq *rspiocb)
522 {
523 struct lpfc_vport *vport = cmdiocb->vport;
524 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
525 IOCB_t *irsp = &rspiocb->iocb;
526 struct lpfc_nodelist *ndlp = cmdiocb->context1;
527 struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
528 struct serv_parm *sp;
529 int rc;
530
531 /* Check to see if link went down during discovery */
532 if (lpfc_els_chk_latt(vport)) {
533 /* One additional decrement on node reference count to
534 * trigger the release of the node
535 */
536 lpfc_nlp_put(ndlp);
537 goto out;
538 }
539
540 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
541 "FLOGI cmpl: status:x%x/x%x state:x%x",
542 irsp->ulpStatus, irsp->un.ulpWord[4],
543 vport->port_state);
544
545 if (irsp->ulpStatus) {
546 /* Check for retry */
547 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
548 goto out;
549
550 /* FLOGI failed, so there is no fabric */
551 spin_lock_irq(shost->host_lock);
552 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
553 spin_unlock_irq(shost->host_lock);
554
555 /* If private loop, then allow max outstanding els to be
556 * LPFC_MAX_DISC_THREADS (32). Scanning in the case of no
557 * alpa map would take too long otherwise.
558 */
559 if (phba->alpa_map[0] == 0) {
560 vport->cfg_discovery_threads = LPFC_MAX_DISC_THREADS;
561 }
562
563 /* FLOGI failure */
564 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
565 "0100 FLOGI failure Data: x%x x%x "
566 "x%x\n",
567 irsp->ulpStatus, irsp->un.ulpWord[4],
568 irsp->ulpTimeout);
569 goto flogifail;
570 }
571
572 /*
573 * The FLogI succeeded. Sync the data for the CPU before
574 * accessing it.
575 */
576 prsp = list_get_first(&pcmd->list, struct lpfc_dmabuf, list);
577
578 sp = prsp->virt + sizeof(uint32_t);
579
580 /* FLOGI completes successfully */
581 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
582 "0101 FLOGI completes sucessfully "
583 "Data: x%x x%x x%x x%x\n",
584 irsp->un.ulpWord[4], sp->cmn.e_d_tov,
585 sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
586
587 if (vport->port_state == LPFC_FLOGI) {
588 /*
589 * If Common Service Parameters indicate Nport
590 * we are point to point, if Fport we are Fabric.
591 */
592 if (sp->cmn.fPort)
593 rc = lpfc_cmpl_els_flogi_fabric(vport, ndlp, sp, irsp);
594 else
595 rc = lpfc_cmpl_els_flogi_nport(vport, ndlp, sp);
596
597 if (!rc)
598 goto out;
599 }
600
601 flogifail:
602 lpfc_nlp_put(ndlp);
603
604 if (!lpfc_error_lost_link(irsp)) {
605 /* FLOGI failed, so just use loop map to make discovery list */
606 lpfc_disc_list_loopmap(vport);
607
608 /* Start discovery */
609 lpfc_disc_start(vport);
610 } else if (((irsp->ulpStatus != IOSTAT_LOCAL_REJECT) ||
611 ((irsp->un.ulpWord[4] != IOERR_SLI_ABORTED) &&
612 (irsp->un.ulpWord[4] != IOERR_SLI_DOWN))) &&
613 (phba->link_state != LPFC_CLEAR_LA)) {
614 /* If FLOGI failed enable link interrupt. */
615 lpfc_issue_clear_la(phba, vport);
616 }
617 out:
618 lpfc_els_free_iocb(phba, cmdiocb);
619 }
620
621 static int
622 lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
623 uint8_t retry)
624 {
625 struct lpfc_hba *phba = vport->phba;
626 struct serv_parm *sp;
627 IOCB_t *icmd;
628 struct lpfc_iocbq *elsiocb;
629 struct lpfc_sli_ring *pring;
630 uint8_t *pcmd;
631 uint16_t cmdsize;
632 uint32_t tmo;
633 int rc;
634
635 pring = &phba->sli.ring[LPFC_ELS_RING];
636
637 cmdsize = (sizeof(uint32_t) + sizeof(struct serv_parm));
638 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
639 ndlp->nlp_DID, ELS_CMD_FLOGI);
640
641 if (!elsiocb)
642 return 1;
643
644 icmd = &elsiocb->iocb;
645 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
646
647 /* For FLOGI request, remainder of payload is service parameters */
648 *((uint32_t *) (pcmd)) = ELS_CMD_FLOGI;
649 pcmd += sizeof(uint32_t);
650 memcpy(pcmd, &vport->fc_sparam, sizeof(struct serv_parm));
651 sp = (struct serv_parm *) pcmd;
652
653 /* Setup CSPs accordingly for Fabric */
654 sp->cmn.e_d_tov = 0;
655 sp->cmn.w2.r_a_tov = 0;
656 sp->cls1.classValid = 0;
657 sp->cls2.seqDelivery = 1;
658 sp->cls3.seqDelivery = 1;
659 if (sp->cmn.fcphLow < FC_PH3)
660 sp->cmn.fcphLow = FC_PH3;
661 if (sp->cmn.fcphHigh < FC_PH3)
662 sp->cmn.fcphHigh = FC_PH3;
663
664 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
665 sp->cmn.request_multiple_Nport = 1;
666
667 /* For FLOGI, Let FLOGI rsp set the NPortID for VPI 0 */
668 icmd->ulpCt_h = 1;
669 icmd->ulpCt_l = 0;
670 }
671
672 if (phba->fc_topology != TOPOLOGY_LOOP) {
673 icmd->un.elsreq64.myID = 0;
674 icmd->un.elsreq64.fl = 1;
675 }
676
677 tmo = phba->fc_ratov;
678 phba->fc_ratov = LPFC_DISC_FLOGI_TMO;
679 lpfc_set_disctmo(vport);
680 phba->fc_ratov = tmo;
681
682 phba->fc_stat.elsXmitFLOGI++;
683 elsiocb->iocb_cmpl = lpfc_cmpl_els_flogi;
684
685 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
686 "Issue FLOGI: opt:x%x",
687 phba->sli3_options, 0, 0);
688
689 rc = lpfc_issue_fabric_iocb(phba, elsiocb);
690 if (rc == IOCB_ERROR) {
691 lpfc_els_free_iocb(phba, elsiocb);
692 return 1;
693 }
694 return 0;
695 }
696
697 int
698 lpfc_els_abort_flogi(struct lpfc_hba *phba)
699 {
700 struct lpfc_sli_ring *pring;
701 struct lpfc_iocbq *iocb, *next_iocb;
702 struct lpfc_nodelist *ndlp;
703 IOCB_t *icmd;
704
705 /* Abort outstanding I/O on NPort <nlp_DID> */
706 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY,
707 "0201 Abort outstanding I/O on NPort x%x\n",
708 Fabric_DID);
709
710 pring = &phba->sli.ring[LPFC_ELS_RING];
711
712 /*
713 * Check the txcmplq for an iocb that matches the nport the driver is
714 * searching for.
715 */
716 spin_lock_irq(&phba->hbalock);
717 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
718 icmd = &iocb->iocb;
719 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR &&
720 icmd->un.elsreq64.bdl.ulpIoTag32) {
721 ndlp = (struct lpfc_nodelist *)(iocb->context1);
722 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
723 (ndlp->nlp_DID == Fabric_DID))
724 lpfc_sli_issue_abort_iotag(phba, pring, iocb);
725 }
726 }
727 spin_unlock_irq(&phba->hbalock);
728
729 return 0;
730 }
731
732 int
733 lpfc_initial_flogi(struct lpfc_vport *vport)
734 {
735 struct lpfc_hba *phba = vport->phba;
736 struct lpfc_nodelist *ndlp;
737
738 vport->port_state = LPFC_FLOGI;
739 lpfc_set_disctmo(vport);
740
741 /* First look for the Fabric ndlp */
742 ndlp = lpfc_findnode_did(vport, Fabric_DID);
743 if (!ndlp) {
744 /* Cannot find existing Fabric ndlp, so allocate a new one */
745 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
746 if (!ndlp)
747 return 0;
748 lpfc_nlp_init(vport, ndlp, Fabric_DID);
749 /* Put ndlp onto node list */
750 lpfc_enqueue_node(vport, ndlp);
751 } else if (!NLP_CHK_NODE_ACT(ndlp)) {
752 /* re-setup ndlp without removing from node list */
753 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
754 if (!ndlp)
755 return 0;
756 }
757
758 if (lpfc_issue_els_flogi(vport, ndlp, 0))
759 /* This decrement of reference count to node shall kick off
760 * the release of the node.
761 */
762 lpfc_nlp_put(ndlp);
763
764 return 1;
765 }
766
767 int
768 lpfc_initial_fdisc(struct lpfc_vport *vport)
769 {
770 struct lpfc_hba *phba = vport->phba;
771 struct lpfc_nodelist *ndlp;
772
773 /* First look for the Fabric ndlp */
774 ndlp = lpfc_findnode_did(vport, Fabric_DID);
775 if (!ndlp) {
776 /* Cannot find existing Fabric ndlp, so allocate a new one */
777 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
778 if (!ndlp)
779 return 0;
780 lpfc_nlp_init(vport, ndlp, Fabric_DID);
781 /* Put ndlp onto node list */
782 lpfc_enqueue_node(vport, ndlp);
783 } else if (!NLP_CHK_NODE_ACT(ndlp)) {
784 /* re-setup ndlp without removing from node list */
785 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
786 if (!ndlp)
787 return 0;
788 }
789
790 if (lpfc_issue_els_fdisc(vport, ndlp, 0)) {
791 /* decrement node reference count to trigger the release of
792 * the node.
793 */
794 lpfc_nlp_put(ndlp);
795 return 0;
796 }
797 return 1;
798 }
799
800 void
801 lpfc_more_plogi(struct lpfc_vport *vport)
802 {
803 int sentplogi;
804
805 if (vport->num_disc_nodes)
806 vport->num_disc_nodes--;
807
808 /* Continue discovery with <num_disc_nodes> PLOGIs to go */
809 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
810 "0232 Continue discovery with %d PLOGIs to go "
811 "Data: x%x x%x x%x\n",
812 vport->num_disc_nodes, vport->fc_plogi_cnt,
813 vport->fc_flag, vport->port_state);
814 /* Check to see if there are more PLOGIs to be sent */
815 if (vport->fc_flag & FC_NLP_MORE)
816 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
817 sentplogi = lpfc_els_disc_plogi(vport);
818
819 return;
820 }
821
822 static struct lpfc_nodelist *
823 lpfc_plogi_confirm_nport(struct lpfc_hba *phba, uint32_t *prsp,
824 struct lpfc_nodelist *ndlp)
825 {
826 struct lpfc_vport *vport = ndlp->vport;
827 struct lpfc_nodelist *new_ndlp;
828 struct lpfc_rport_data *rdata;
829 struct fc_rport *rport;
830 struct serv_parm *sp;
831 uint8_t name[sizeof(struct lpfc_name)];
832 uint32_t rc, keepDID = 0;
833
834 /* Fabric nodes can have the same WWPN so we don't bother searching
835 * by WWPN. Just return the ndlp that was given to us.
836 */
837 if (ndlp->nlp_type & NLP_FABRIC)
838 return ndlp;
839
840 sp = (struct serv_parm *) ((uint8_t *) prsp + sizeof(uint32_t));
841 memset(name, 0, sizeof(struct lpfc_name));
842
843 /* Now we find out if the NPort we are logging into, matches the WWPN
844 * we have for that ndlp. If not, we have some work to do.
845 */
846 new_ndlp = lpfc_findnode_wwpn(vport, &sp->portName);
847
848 if (new_ndlp == ndlp && NLP_CHK_NODE_ACT(new_ndlp))
849 return ndlp;
850
851 if (!new_ndlp) {
852 rc = memcmp(&ndlp->nlp_portname, name,
853 sizeof(struct lpfc_name));
854 if (!rc)
855 return ndlp;
856 new_ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_ATOMIC);
857 if (!new_ndlp)
858 return ndlp;
859 lpfc_nlp_init(vport, new_ndlp, ndlp->nlp_DID);
860 } else if (!NLP_CHK_NODE_ACT(new_ndlp)) {
861 rc = memcmp(&ndlp->nlp_portname, name,
862 sizeof(struct lpfc_name));
863 if (!rc)
864 return ndlp;
865 new_ndlp = lpfc_enable_node(vport, new_ndlp,
866 NLP_STE_UNUSED_NODE);
867 if (!new_ndlp)
868 return ndlp;
869 keepDID = new_ndlp->nlp_DID;
870 } else
871 keepDID = new_ndlp->nlp_DID;
872
873 lpfc_unreg_rpi(vport, new_ndlp);
874 new_ndlp->nlp_DID = ndlp->nlp_DID;
875 new_ndlp->nlp_prev_state = ndlp->nlp_prev_state;
876
877 if (ndlp->nlp_flag & NLP_NPR_2B_DISC)
878 new_ndlp->nlp_flag |= NLP_NPR_2B_DISC;
879 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
880
881 /* Set state will put new_ndlp on to node list if not already done */
882 lpfc_nlp_set_state(vport, new_ndlp, ndlp->nlp_state);
883
884 /* Move this back to NPR state */
885 if (memcmp(&ndlp->nlp_portname, name, sizeof(struct lpfc_name)) == 0) {
886 /* The new_ndlp is replacing ndlp totally, so we need
887 * to put ndlp on UNUSED list and try to free it.
888 */
889
890 /* Fix up the rport accordingly */
891 rport = ndlp->rport;
892 if (rport) {
893 rdata = rport->dd_data;
894 if (rdata->pnode == ndlp) {
895 lpfc_nlp_put(ndlp);
896 ndlp->rport = NULL;
897 rdata->pnode = lpfc_nlp_get(new_ndlp);
898 new_ndlp->rport = rport;
899 }
900 new_ndlp->nlp_type = ndlp->nlp_type;
901 }
902 /* We shall actually free the ndlp with both nlp_DID and
903 * nlp_portname fields equals 0 to avoid any ndlp on the
904 * nodelist never to be used.
905 */
906 if (ndlp->nlp_DID == 0) {
907 spin_lock_irq(&phba->ndlp_lock);
908 NLP_SET_FREE_REQ(ndlp);
909 spin_unlock_irq(&phba->ndlp_lock);
910 }
911
912 /* Two ndlps cannot have the same did on the nodelist */
913 ndlp->nlp_DID = keepDID;
914 lpfc_drop_node(vport, ndlp);
915 }
916 else {
917 lpfc_unreg_rpi(vport, ndlp);
918 /* Two ndlps cannot have the same did */
919 ndlp->nlp_DID = keepDID;
920 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
921 }
922 return new_ndlp;
923 }
924
925 void
926 lpfc_end_rscn(struct lpfc_vport *vport)
927 {
928 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
929
930 if (vport->fc_flag & FC_RSCN_MODE) {
931 /*
932 * Check to see if more RSCNs came in while we were
933 * processing this one.
934 */
935 if (vport->fc_rscn_id_cnt ||
936 (vport->fc_flag & FC_RSCN_DISCOVERY) != 0)
937 lpfc_els_handle_rscn(vport);
938 else {
939 spin_lock_irq(shost->host_lock);
940 vport->fc_flag &= ~FC_RSCN_MODE;
941 spin_unlock_irq(shost->host_lock);
942 }
943 }
944 }
945
946 static void
947 lpfc_cmpl_els_plogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
948 struct lpfc_iocbq *rspiocb)
949 {
950 struct lpfc_vport *vport = cmdiocb->vport;
951 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
952 IOCB_t *irsp;
953 struct lpfc_nodelist *ndlp;
954 struct lpfc_dmabuf *prsp;
955 int disc, rc, did, type;
956
957 /* we pass cmdiocb to state machine which needs rspiocb as well */
958 cmdiocb->context_un.rsp_iocb = rspiocb;
959
960 irsp = &rspiocb->iocb;
961 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
962 "PLOGI cmpl: status:x%x/x%x did:x%x",
963 irsp->ulpStatus, irsp->un.ulpWord[4],
964 irsp->un.elsreq64.remoteID);
965
966 ndlp = lpfc_findnode_did(vport, irsp->un.elsreq64.remoteID);
967 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
968 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
969 "0136 PLOGI completes to NPort x%x "
970 "with no ndlp. Data: x%x x%x x%x\n",
971 irsp->un.elsreq64.remoteID,
972 irsp->ulpStatus, irsp->un.ulpWord[4],
973 irsp->ulpIoTag);
974 goto out;
975 }
976
977 /* Since ndlp can be freed in the disc state machine, note if this node
978 * is being used during discovery.
979 */
980 spin_lock_irq(shost->host_lock);
981 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
982 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
983 spin_unlock_irq(shost->host_lock);
984 rc = 0;
985
986 /* PLOGI completes to NPort <nlp_DID> */
987 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
988 "0102 PLOGI completes to NPort x%x "
989 "Data: x%x x%x x%x x%x x%x\n",
990 ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
991 irsp->ulpTimeout, disc, vport->num_disc_nodes);
992 /* Check to see if link went down during discovery */
993 if (lpfc_els_chk_latt(vport)) {
994 spin_lock_irq(shost->host_lock);
995 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
996 spin_unlock_irq(shost->host_lock);
997 goto out;
998 }
999
1000 /* ndlp could be freed in DSM, save these values now */
1001 type = ndlp->nlp_type;
1002 did = ndlp->nlp_DID;
1003
1004 if (irsp->ulpStatus) {
1005 /* Check for retry */
1006 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1007 /* ELS command is being retried */
1008 if (disc) {
1009 spin_lock_irq(shost->host_lock);
1010 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1011 spin_unlock_irq(shost->host_lock);
1012 }
1013 goto out;
1014 }
1015 /* PLOGI failed */
1016 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1017 if (lpfc_error_lost_link(irsp))
1018 rc = NLP_STE_FREED_NODE;
1019 else
1020 rc = lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1021 NLP_EVT_CMPL_PLOGI);
1022 } else {
1023 /* Good status, call state machine */
1024 prsp = list_entry(((struct lpfc_dmabuf *)
1025 cmdiocb->context2)->list.next,
1026 struct lpfc_dmabuf, list);
1027 ndlp = lpfc_plogi_confirm_nport(phba, prsp->virt, ndlp);
1028 rc = lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1029 NLP_EVT_CMPL_PLOGI);
1030 }
1031
1032 if (disc && vport->num_disc_nodes) {
1033 /* Check to see if there are more PLOGIs to be sent */
1034 lpfc_more_plogi(vport);
1035
1036 if (vport->num_disc_nodes == 0) {
1037 spin_lock_irq(shost->host_lock);
1038 vport->fc_flag &= ~FC_NDISC_ACTIVE;
1039 spin_unlock_irq(shost->host_lock);
1040
1041 lpfc_can_disctmo(vport);
1042 lpfc_end_rscn(vport);
1043 }
1044 }
1045
1046 out:
1047 lpfc_els_free_iocb(phba, cmdiocb);
1048 return;
1049 }
1050
1051 int
1052 lpfc_issue_els_plogi(struct lpfc_vport *vport, uint32_t did, uint8_t retry)
1053 {
1054 struct lpfc_hba *phba = vport->phba;
1055 struct serv_parm *sp;
1056 IOCB_t *icmd;
1057 struct lpfc_nodelist *ndlp;
1058 struct lpfc_iocbq *elsiocb;
1059 struct lpfc_sli_ring *pring;
1060 struct lpfc_sli *psli;
1061 uint8_t *pcmd;
1062 uint16_t cmdsize;
1063 int ret;
1064
1065 psli = &phba->sli;
1066 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1067
1068 ndlp = lpfc_findnode_did(vport, did);
1069 if (ndlp && !NLP_CHK_NODE_ACT(ndlp))
1070 ndlp = NULL;
1071
1072 /* If ndlp is not NULL, we will bump the reference count on it */
1073 cmdsize = (sizeof(uint32_t) + sizeof(struct serv_parm));
1074 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp, did,
1075 ELS_CMD_PLOGI);
1076 if (!elsiocb)
1077 return 1;
1078
1079 icmd = &elsiocb->iocb;
1080 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1081
1082 /* For PLOGI request, remainder of payload is service parameters */
1083 *((uint32_t *) (pcmd)) = ELS_CMD_PLOGI;
1084 pcmd += sizeof(uint32_t);
1085 memcpy(pcmd, &vport->fc_sparam, sizeof(struct serv_parm));
1086 sp = (struct serv_parm *) pcmd;
1087
1088 if (sp->cmn.fcphLow < FC_PH_4_3)
1089 sp->cmn.fcphLow = FC_PH_4_3;
1090
1091 if (sp->cmn.fcphHigh < FC_PH3)
1092 sp->cmn.fcphHigh = FC_PH3;
1093
1094 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1095 "Issue PLOGI: did:x%x",
1096 did, 0, 0);
1097
1098 phba->fc_stat.elsXmitPLOGI++;
1099 elsiocb->iocb_cmpl = lpfc_cmpl_els_plogi;
1100 ret = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
1101
1102 if (ret == IOCB_ERROR) {
1103 lpfc_els_free_iocb(phba, elsiocb);
1104 return 1;
1105 }
1106 return 0;
1107 }
1108
1109 static void
1110 lpfc_cmpl_els_prli(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1111 struct lpfc_iocbq *rspiocb)
1112 {
1113 struct lpfc_vport *vport = cmdiocb->vport;
1114 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1115 IOCB_t *irsp;
1116 struct lpfc_sli *psli;
1117 struct lpfc_nodelist *ndlp;
1118
1119 psli = &phba->sli;
1120 /* we pass cmdiocb to state machine which needs rspiocb as well */
1121 cmdiocb->context_un.rsp_iocb = rspiocb;
1122
1123 irsp = &(rspiocb->iocb);
1124 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1125 spin_lock_irq(shost->host_lock);
1126 ndlp->nlp_flag &= ~NLP_PRLI_SND;
1127 spin_unlock_irq(shost->host_lock);
1128
1129 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1130 "PRLI cmpl: status:x%x/x%x did:x%x",
1131 irsp->ulpStatus, irsp->un.ulpWord[4],
1132 ndlp->nlp_DID);
1133 /* PRLI completes to NPort <nlp_DID> */
1134 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1135 "0103 PRLI completes to NPort x%x "
1136 "Data: x%x x%x x%x x%x\n",
1137 ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
1138 irsp->ulpTimeout, vport->num_disc_nodes);
1139
1140 vport->fc_prli_sent--;
1141 /* Check to see if link went down during discovery */
1142 if (lpfc_els_chk_latt(vport))
1143 goto out;
1144
1145 if (irsp->ulpStatus) {
1146 /* Check for retry */
1147 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1148 /* ELS command is being retried */
1149 goto out;
1150 }
1151 /* PRLI failed */
1152 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1153 if (lpfc_error_lost_link(irsp))
1154 goto out;
1155 else
1156 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1157 NLP_EVT_CMPL_PRLI);
1158 } else
1159 /* Good status, call state machine */
1160 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1161 NLP_EVT_CMPL_PRLI);
1162 out:
1163 lpfc_els_free_iocb(phba, cmdiocb);
1164 return;
1165 }
1166
1167 int
1168 lpfc_issue_els_prli(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1169 uint8_t retry)
1170 {
1171 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1172 struct lpfc_hba *phba = vport->phba;
1173 PRLI *npr;
1174 IOCB_t *icmd;
1175 struct lpfc_iocbq *elsiocb;
1176 struct lpfc_sli_ring *pring;
1177 struct lpfc_sli *psli;
1178 uint8_t *pcmd;
1179 uint16_t cmdsize;
1180
1181 psli = &phba->sli;
1182 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1183
1184 cmdsize = (sizeof(uint32_t) + sizeof(PRLI));
1185 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1186 ndlp->nlp_DID, ELS_CMD_PRLI);
1187 if (!elsiocb)
1188 return 1;
1189
1190 icmd = &elsiocb->iocb;
1191 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1192
1193 /* For PRLI request, remainder of payload is service parameters */
1194 memset(pcmd, 0, (sizeof(PRLI) + sizeof(uint32_t)));
1195 *((uint32_t *) (pcmd)) = ELS_CMD_PRLI;
1196 pcmd += sizeof(uint32_t);
1197
1198 /* For PRLI, remainder of payload is PRLI parameter page */
1199 npr = (PRLI *) pcmd;
1200 /*
1201 * If our firmware version is 3.20 or later,
1202 * set the following bits for FC-TAPE support.
1203 */
1204 if (phba->vpd.rev.feaLevelHigh >= 0x02) {
1205 npr->ConfmComplAllowed = 1;
1206 npr->Retry = 1;
1207 npr->TaskRetryIdReq = 1;
1208 }
1209 npr->estabImagePair = 1;
1210 npr->readXferRdyDis = 1;
1211
1212 /* For FCP support */
1213 npr->prliType = PRLI_FCP_TYPE;
1214 npr->initiatorFunc = 1;
1215
1216 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1217 "Issue PRLI: did:x%x",
1218 ndlp->nlp_DID, 0, 0);
1219
1220 phba->fc_stat.elsXmitPRLI++;
1221 elsiocb->iocb_cmpl = lpfc_cmpl_els_prli;
1222 spin_lock_irq(shost->host_lock);
1223 ndlp->nlp_flag |= NLP_PRLI_SND;
1224 spin_unlock_irq(shost->host_lock);
1225 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1226 spin_lock_irq(shost->host_lock);
1227 ndlp->nlp_flag &= ~NLP_PRLI_SND;
1228 spin_unlock_irq(shost->host_lock);
1229 lpfc_els_free_iocb(phba, elsiocb);
1230 return 1;
1231 }
1232 vport->fc_prli_sent++;
1233 return 0;
1234 }
1235
1236 void
1237 lpfc_more_adisc(struct lpfc_vport *vport)
1238 {
1239 int sentadisc;
1240
1241 if (vport->num_disc_nodes)
1242 vport->num_disc_nodes--;
1243 /* Continue discovery with <num_disc_nodes> ADISCs to go */
1244 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1245 "0210 Continue discovery with %d ADISCs to go "
1246 "Data: x%x x%x x%x\n",
1247 vport->num_disc_nodes, vport->fc_adisc_cnt,
1248 vport->fc_flag, vport->port_state);
1249 /* Check to see if there are more ADISCs to be sent */
1250 if (vport->fc_flag & FC_NLP_MORE) {
1251 lpfc_set_disctmo(vport);
1252 /* go thru NPR nodes and issue any remaining ELS ADISCs */
1253 sentadisc = lpfc_els_disc_adisc(vport);
1254 }
1255 return;
1256 }
1257
1258 static void
1259 lpfc_rscn_disc(struct lpfc_vport *vport)
1260 {
1261 lpfc_can_disctmo(vport);
1262
1263 /* RSCN discovery */
1264 /* go thru NPR nodes and issue ELS PLOGIs */
1265 if (vport->fc_npr_cnt)
1266 if (lpfc_els_disc_plogi(vport))
1267 return;
1268
1269 lpfc_end_rscn(vport);
1270 }
1271
1272 static void
1273 lpfc_cmpl_els_adisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1274 struct lpfc_iocbq *rspiocb)
1275 {
1276 struct lpfc_vport *vport = cmdiocb->vport;
1277 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1278 IOCB_t *irsp;
1279 struct lpfc_nodelist *ndlp;
1280 int disc;
1281
1282 /* we pass cmdiocb to state machine which needs rspiocb as well */
1283 cmdiocb->context_un.rsp_iocb = rspiocb;
1284
1285 irsp = &(rspiocb->iocb);
1286 ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1287
1288 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1289 "ADISC cmpl: status:x%x/x%x did:x%x",
1290 irsp->ulpStatus, irsp->un.ulpWord[4],
1291 ndlp->nlp_DID);
1292
1293 /* Since ndlp can be freed in the disc state machine, note if this node
1294 * is being used during discovery.
1295 */
1296 spin_lock_irq(shost->host_lock);
1297 disc = (ndlp->nlp_flag & NLP_NPR_2B_DISC);
1298 ndlp->nlp_flag &= ~(NLP_ADISC_SND | NLP_NPR_2B_DISC);
1299 spin_unlock_irq(shost->host_lock);
1300 /* ADISC completes to NPort <nlp_DID> */
1301 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1302 "0104 ADISC completes to NPort x%x "
1303 "Data: x%x x%x x%x x%x x%x\n",
1304 ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
1305 irsp->ulpTimeout, disc, vport->num_disc_nodes);
1306 /* Check to see if link went down during discovery */
1307 if (lpfc_els_chk_latt(vport)) {
1308 spin_lock_irq(shost->host_lock);
1309 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1310 spin_unlock_irq(shost->host_lock);
1311 goto out;
1312 }
1313
1314 if (irsp->ulpStatus) {
1315 /* Check for retry */
1316 if (lpfc_els_retry(phba, cmdiocb, rspiocb)) {
1317 /* ELS command is being retried */
1318 if (disc) {
1319 spin_lock_irq(shost->host_lock);
1320 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
1321 spin_unlock_irq(shost->host_lock);
1322 lpfc_set_disctmo(vport);
1323 }
1324 goto out;
1325 }
1326 /* ADISC failed */
1327 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1328 if (!lpfc_error_lost_link(irsp))
1329 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1330 NLP_EVT_CMPL_ADISC);
1331 } else
1332 /* Good status, call state machine */
1333 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1334 NLP_EVT_CMPL_ADISC);
1335
1336 if (disc && vport->num_disc_nodes) {
1337 /* Check to see if there are more ADISCs to be sent */
1338 lpfc_more_adisc(vport);
1339
1340 /* Check to see if we are done with ADISC authentication */
1341 if (vport->num_disc_nodes == 0) {
1342 /* If we get here, there is nothing left to ADISC */
1343 /*
1344 * For NPIV, cmpl_reg_vpi will set port_state to READY,
1345 * and continue discovery.
1346 */
1347 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
1348 !(vport->fc_flag & FC_RSCN_MODE)) {
1349 lpfc_issue_reg_vpi(phba, vport);
1350 goto out;
1351 }
1352 /*
1353 * For SLI2, we need to set port_state to READY
1354 * and continue discovery.
1355 */
1356 if (vport->port_state < LPFC_VPORT_READY) {
1357 /* If we get here, there is nothing to ADISC */
1358 if (vport->port_type == LPFC_PHYSICAL_PORT)
1359 lpfc_issue_clear_la(phba, vport);
1360
1361 if (!(vport->fc_flag & FC_ABORT_DISCOVERY)) {
1362 vport->num_disc_nodes = 0;
1363 /* go thru NPR list, issue ELS PLOGIs */
1364 if (vport->fc_npr_cnt)
1365 lpfc_els_disc_plogi(vport);
1366
1367 if (!vport->num_disc_nodes) {
1368 spin_lock_irq(shost->host_lock);
1369 vport->fc_flag &=
1370 ~FC_NDISC_ACTIVE;
1371 spin_unlock_irq(
1372 shost->host_lock);
1373 lpfc_can_disctmo(vport);
1374 }
1375 }
1376 vport->port_state = LPFC_VPORT_READY;
1377 } else {
1378 lpfc_rscn_disc(vport);
1379 }
1380 }
1381 }
1382 out:
1383 lpfc_els_free_iocb(phba, cmdiocb);
1384 return;
1385 }
1386
1387 int
1388 lpfc_issue_els_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1389 uint8_t retry)
1390 {
1391 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1392 struct lpfc_hba *phba = vport->phba;
1393 ADISC *ap;
1394 IOCB_t *icmd;
1395 struct lpfc_iocbq *elsiocb;
1396 struct lpfc_sli *psli = &phba->sli;
1397 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
1398 uint8_t *pcmd;
1399 uint16_t cmdsize;
1400
1401 cmdsize = (sizeof(uint32_t) + sizeof(ADISC));
1402 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1403 ndlp->nlp_DID, ELS_CMD_ADISC);
1404 if (!elsiocb)
1405 return 1;
1406
1407 icmd = &elsiocb->iocb;
1408 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1409
1410 /* For ADISC request, remainder of payload is service parameters */
1411 *((uint32_t *) (pcmd)) = ELS_CMD_ADISC;
1412 pcmd += sizeof(uint32_t);
1413
1414 /* Fill in ADISC payload */
1415 ap = (ADISC *) pcmd;
1416 ap->hardAL_PA = phba->fc_pref_ALPA;
1417 memcpy(&ap->portName, &vport->fc_portname, sizeof(struct lpfc_name));
1418 memcpy(&ap->nodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
1419 ap->DID = be32_to_cpu(vport->fc_myDID);
1420
1421 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1422 "Issue ADISC: did:x%x",
1423 ndlp->nlp_DID, 0, 0);
1424
1425 phba->fc_stat.elsXmitADISC++;
1426 elsiocb->iocb_cmpl = lpfc_cmpl_els_adisc;
1427 spin_lock_irq(shost->host_lock);
1428 ndlp->nlp_flag |= NLP_ADISC_SND;
1429 spin_unlock_irq(shost->host_lock);
1430 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1431 spin_lock_irq(shost->host_lock);
1432 ndlp->nlp_flag &= ~NLP_ADISC_SND;
1433 spin_unlock_irq(shost->host_lock);
1434 lpfc_els_free_iocb(phba, elsiocb);
1435 return 1;
1436 }
1437 return 0;
1438 }
1439
1440 static void
1441 lpfc_cmpl_els_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1442 struct lpfc_iocbq *rspiocb)
1443 {
1444 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1445 struct lpfc_vport *vport = ndlp->vport;
1446 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1447 IOCB_t *irsp;
1448 struct lpfc_sli *psli;
1449
1450 psli = &phba->sli;
1451 /* we pass cmdiocb to state machine which needs rspiocb as well */
1452 cmdiocb->context_un.rsp_iocb = rspiocb;
1453
1454 irsp = &(rspiocb->iocb);
1455 spin_lock_irq(shost->host_lock);
1456 ndlp->nlp_flag &= ~NLP_LOGO_SND;
1457 spin_unlock_irq(shost->host_lock);
1458
1459 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1460 "LOGO cmpl: status:x%x/x%x did:x%x",
1461 irsp->ulpStatus, irsp->un.ulpWord[4],
1462 ndlp->nlp_DID);
1463 /* LOGO completes to NPort <nlp_DID> */
1464 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1465 "0105 LOGO completes to NPort x%x "
1466 "Data: x%x x%x x%x x%x\n",
1467 ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
1468 irsp->ulpTimeout, vport->num_disc_nodes);
1469 /* Check to see if link went down during discovery */
1470 if (lpfc_els_chk_latt(vport))
1471 goto out;
1472
1473 if (ndlp->nlp_flag & NLP_TARGET_REMOVE) {
1474 /* NLP_EVT_DEVICE_RM should unregister the RPI
1475 * which should abort all outstanding IOs.
1476 */
1477 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1478 NLP_EVT_DEVICE_RM);
1479 goto out;
1480 }
1481
1482 if (irsp->ulpStatus) {
1483 /* Check for retry */
1484 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
1485 /* ELS command is being retried */
1486 goto out;
1487 /* LOGO failed */
1488 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
1489 if (lpfc_error_lost_link(irsp))
1490 goto out;
1491 else
1492 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1493 NLP_EVT_CMPL_LOGO);
1494 } else
1495 /* Good status, call state machine.
1496 * This will unregister the rpi if needed.
1497 */
1498 lpfc_disc_state_machine(vport, ndlp, cmdiocb,
1499 NLP_EVT_CMPL_LOGO);
1500 out:
1501 lpfc_els_free_iocb(phba, cmdiocb);
1502 return;
1503 }
1504
1505 int
1506 lpfc_issue_els_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1507 uint8_t retry)
1508 {
1509 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1510 struct lpfc_hba *phba = vport->phba;
1511 IOCB_t *icmd;
1512 struct lpfc_iocbq *elsiocb;
1513 struct lpfc_sli_ring *pring;
1514 struct lpfc_sli *psli;
1515 uint8_t *pcmd;
1516 uint16_t cmdsize;
1517 int rc;
1518
1519 psli = &phba->sli;
1520 pring = &psli->ring[LPFC_ELS_RING];
1521
1522 spin_lock_irq(shost->host_lock);
1523 if (ndlp->nlp_flag & NLP_LOGO_SND) {
1524 spin_unlock_irq(shost->host_lock);
1525 return 0;
1526 }
1527 spin_unlock_irq(shost->host_lock);
1528
1529 cmdsize = (2 * sizeof(uint32_t)) + sizeof(struct lpfc_name);
1530 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1531 ndlp->nlp_DID, ELS_CMD_LOGO);
1532 if (!elsiocb)
1533 return 1;
1534
1535 icmd = &elsiocb->iocb;
1536 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1537 *((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
1538 pcmd += sizeof(uint32_t);
1539
1540 /* Fill in LOGO payload */
1541 *((uint32_t *) (pcmd)) = be32_to_cpu(vport->fc_myDID);
1542 pcmd += sizeof(uint32_t);
1543 memcpy(pcmd, &vport->fc_portname, sizeof(struct lpfc_name));
1544
1545 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1546 "Issue LOGO: did:x%x",
1547 ndlp->nlp_DID, 0, 0);
1548
1549 phba->fc_stat.elsXmitLOGO++;
1550 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo;
1551 spin_lock_irq(shost->host_lock);
1552 ndlp->nlp_flag |= NLP_LOGO_SND;
1553 spin_unlock_irq(shost->host_lock);
1554 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
1555
1556 if (rc == IOCB_ERROR) {
1557 spin_lock_irq(shost->host_lock);
1558 ndlp->nlp_flag &= ~NLP_LOGO_SND;
1559 spin_unlock_irq(shost->host_lock);
1560 lpfc_els_free_iocb(phba, elsiocb);
1561 return 1;
1562 }
1563 return 0;
1564 }
1565
1566 static void
1567 lpfc_cmpl_els_cmd(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1568 struct lpfc_iocbq *rspiocb)
1569 {
1570 struct lpfc_vport *vport = cmdiocb->vport;
1571 IOCB_t *irsp;
1572
1573 irsp = &rspiocb->iocb;
1574
1575 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1576 "ELS cmd cmpl: status:x%x/x%x did:x%x",
1577 irsp->ulpStatus, irsp->un.ulpWord[4],
1578 irsp->un.elsreq64.remoteID);
1579 /* ELS cmd tag <ulpIoTag> completes */
1580 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
1581 "0106 ELS cmd tag x%x completes Data: x%x x%x x%x\n",
1582 irsp->ulpIoTag, irsp->ulpStatus,
1583 irsp->un.ulpWord[4], irsp->ulpTimeout);
1584 /* Check to see if link went down during discovery */
1585 lpfc_els_chk_latt(vport);
1586 lpfc_els_free_iocb(phba, cmdiocb);
1587 return;
1588 }
1589
1590 int
1591 lpfc_issue_els_scr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
1592 {
1593 struct lpfc_hba *phba = vport->phba;
1594 IOCB_t *icmd;
1595 struct lpfc_iocbq *elsiocb;
1596 struct lpfc_sli_ring *pring;
1597 struct lpfc_sli *psli;
1598 uint8_t *pcmd;
1599 uint16_t cmdsize;
1600 struct lpfc_nodelist *ndlp;
1601
1602 psli = &phba->sli;
1603 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1604 cmdsize = (sizeof(uint32_t) + sizeof(SCR));
1605
1606 ndlp = lpfc_findnode_did(vport, nportid);
1607 if (!ndlp) {
1608 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1609 if (!ndlp)
1610 return 1;
1611 lpfc_nlp_init(vport, ndlp, nportid);
1612 lpfc_enqueue_node(vport, ndlp);
1613 } else if (!NLP_CHK_NODE_ACT(ndlp)) {
1614 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
1615 if (!ndlp)
1616 return 1;
1617 }
1618
1619 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1620 ndlp->nlp_DID, ELS_CMD_SCR);
1621
1622 if (!elsiocb) {
1623 /* This will trigger the release of the node just
1624 * allocated
1625 */
1626 lpfc_nlp_put(ndlp);
1627 return 1;
1628 }
1629
1630 icmd = &elsiocb->iocb;
1631 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1632
1633 *((uint32_t *) (pcmd)) = ELS_CMD_SCR;
1634 pcmd += sizeof(uint32_t);
1635
1636 /* For SCR, remainder of payload is SCR parameter page */
1637 memset(pcmd, 0, sizeof(SCR));
1638 ((SCR *) pcmd)->Function = SCR_FUNC_FULL;
1639
1640 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1641 "Issue SCR: did:x%x",
1642 ndlp->nlp_DID, 0, 0);
1643
1644 phba->fc_stat.elsXmitSCR++;
1645 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1646 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1647 /* The additional lpfc_nlp_put will cause the following
1648 * lpfc_els_free_iocb routine to trigger the rlease of
1649 * the node.
1650 */
1651 lpfc_nlp_put(ndlp);
1652 lpfc_els_free_iocb(phba, elsiocb);
1653 return 1;
1654 }
1655 /* This will cause the callback-function lpfc_cmpl_els_cmd to
1656 * trigger the release of node.
1657 */
1658 lpfc_nlp_put(ndlp);
1659 return 0;
1660 }
1661
1662 static int
1663 lpfc_issue_els_farpr(struct lpfc_vport *vport, uint32_t nportid, uint8_t retry)
1664 {
1665 struct lpfc_hba *phba = vport->phba;
1666 IOCB_t *icmd;
1667 struct lpfc_iocbq *elsiocb;
1668 struct lpfc_sli_ring *pring;
1669 struct lpfc_sli *psli;
1670 FARP *fp;
1671 uint8_t *pcmd;
1672 uint32_t *lp;
1673 uint16_t cmdsize;
1674 struct lpfc_nodelist *ondlp;
1675 struct lpfc_nodelist *ndlp;
1676
1677 psli = &phba->sli;
1678 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
1679 cmdsize = (sizeof(uint32_t) + sizeof(FARP));
1680
1681 ndlp = lpfc_findnode_did(vport, nportid);
1682 if (!ndlp) {
1683 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
1684 if (!ndlp)
1685 return 1;
1686 lpfc_nlp_init(vport, ndlp, nportid);
1687 lpfc_enqueue_node(vport, ndlp);
1688 } else if (!NLP_CHK_NODE_ACT(ndlp)) {
1689 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
1690 if (!ndlp)
1691 return 1;
1692 }
1693
1694 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp,
1695 ndlp->nlp_DID, ELS_CMD_RNID);
1696 if (!elsiocb) {
1697 /* This will trigger the release of the node just
1698 * allocated
1699 */
1700 lpfc_nlp_put(ndlp);
1701 return 1;
1702 }
1703
1704 icmd = &elsiocb->iocb;
1705 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
1706
1707 *((uint32_t *) (pcmd)) = ELS_CMD_FARPR;
1708 pcmd += sizeof(uint32_t);
1709
1710 /* Fill in FARPR payload */
1711 fp = (FARP *) (pcmd);
1712 memset(fp, 0, sizeof(FARP));
1713 lp = (uint32_t *) pcmd;
1714 *lp++ = be32_to_cpu(nportid);
1715 *lp++ = be32_to_cpu(vport->fc_myDID);
1716 fp->Rflags = 0;
1717 fp->Mflags = (FARP_MATCH_PORT | FARP_MATCH_NODE);
1718
1719 memcpy(&fp->RportName, &vport->fc_portname, sizeof(struct lpfc_name));
1720 memcpy(&fp->RnodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
1721 ondlp = lpfc_findnode_did(vport, nportid);
1722 if (ondlp && NLP_CHK_NODE_ACT(ondlp)) {
1723 memcpy(&fp->OportName, &ondlp->nlp_portname,
1724 sizeof(struct lpfc_name));
1725 memcpy(&fp->OnodeName, &ondlp->nlp_nodename,
1726 sizeof(struct lpfc_name));
1727 }
1728
1729 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1730 "Issue FARPR: did:x%x",
1731 ndlp->nlp_DID, 0, 0);
1732
1733 phba->fc_stat.elsXmitFARPR++;
1734 elsiocb->iocb_cmpl = lpfc_cmpl_els_cmd;
1735 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
1736 /* The additional lpfc_nlp_put will cause the following
1737 * lpfc_els_free_iocb routine to trigger the release of
1738 * the node.
1739 */
1740 lpfc_nlp_put(ndlp);
1741 lpfc_els_free_iocb(phba, elsiocb);
1742 return 1;
1743 }
1744 /* This will cause the callback-function lpfc_cmpl_els_cmd to
1745 * trigger the release of the node.
1746 */
1747 lpfc_nlp_put(ndlp);
1748 return 0;
1749 }
1750
1751 void
1752 lpfc_cancel_retry_delay_tmo(struct lpfc_vport *vport, struct lpfc_nodelist *nlp)
1753 {
1754 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1755 struct lpfc_work_evt *evtp;
1756
1757 if (!(nlp->nlp_flag & NLP_DELAY_TMO))
1758 return;
1759 spin_lock_irq(shost->host_lock);
1760 nlp->nlp_flag &= ~NLP_DELAY_TMO;
1761 spin_unlock_irq(shost->host_lock);
1762 del_timer_sync(&nlp->nlp_delayfunc);
1763 nlp->nlp_last_elscmd = 0;
1764 if (!list_empty(&nlp->els_retry_evt.evt_listp)) {
1765 list_del_init(&nlp->els_retry_evt.evt_listp);
1766 /* Decrement nlp reference count held for the delayed retry */
1767 evtp = &nlp->els_retry_evt;
1768 lpfc_nlp_put((struct lpfc_nodelist *)evtp->evt_arg1);
1769 }
1770 if (nlp->nlp_flag & NLP_NPR_2B_DISC) {
1771 spin_lock_irq(shost->host_lock);
1772 nlp->nlp_flag &= ~NLP_NPR_2B_DISC;
1773 spin_unlock_irq(shost->host_lock);
1774 if (vport->num_disc_nodes) {
1775 if (vport->port_state < LPFC_VPORT_READY) {
1776 /* Check if there are more ADISCs to be sent */
1777 lpfc_more_adisc(vport);
1778 if ((vport->num_disc_nodes == 0) &&
1779 (vport->fc_npr_cnt))
1780 lpfc_els_disc_plogi(vport);
1781 } else {
1782 /* Check if there are more PLOGIs to be sent */
1783 lpfc_more_plogi(vport);
1784 }
1785 if (vport->num_disc_nodes == 0) {
1786 spin_lock_irq(shost->host_lock);
1787 vport->fc_flag &= ~FC_NDISC_ACTIVE;
1788 spin_unlock_irq(shost->host_lock);
1789 lpfc_can_disctmo(vport);
1790 lpfc_end_rscn(vport);
1791 }
1792 }
1793 }
1794 return;
1795 }
1796
1797 void
1798 lpfc_els_retry_delay(unsigned long ptr)
1799 {
1800 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) ptr;
1801 struct lpfc_vport *vport = ndlp->vport;
1802 struct lpfc_hba *phba = vport->phba;
1803 unsigned long flags;
1804 struct lpfc_work_evt *evtp = &ndlp->els_retry_evt;
1805
1806 spin_lock_irqsave(&phba->hbalock, flags);
1807 if (!list_empty(&evtp->evt_listp)) {
1808 spin_unlock_irqrestore(&phba->hbalock, flags);
1809 return;
1810 }
1811
1812 /* We need to hold the node by incrementing the reference
1813 * count until the queued work is done
1814 */
1815 evtp->evt_arg1 = lpfc_nlp_get(ndlp);
1816 if (evtp->evt_arg1) {
1817 evtp->evt = LPFC_EVT_ELS_RETRY;
1818 list_add_tail(&evtp->evt_listp, &phba->work_list);
1819 lpfc_worker_wake_up(phba);
1820 }
1821 spin_unlock_irqrestore(&phba->hbalock, flags);
1822 return;
1823 }
1824
1825 void
1826 lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
1827 {
1828 struct lpfc_vport *vport = ndlp->vport;
1829 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1830 uint32_t cmd, did, retry;
1831
1832 spin_lock_irq(shost->host_lock);
1833 did = ndlp->nlp_DID;
1834 cmd = ndlp->nlp_last_elscmd;
1835 ndlp->nlp_last_elscmd = 0;
1836
1837 if (!(ndlp->nlp_flag & NLP_DELAY_TMO)) {
1838 spin_unlock_irq(shost->host_lock);
1839 return;
1840 }
1841
1842 ndlp->nlp_flag &= ~NLP_DELAY_TMO;
1843 spin_unlock_irq(shost->host_lock);
1844 /*
1845 * If a discovery event readded nlp_delayfunc after timer
1846 * firing and before processing the timer, cancel the
1847 * nlp_delayfunc.
1848 */
1849 del_timer_sync(&ndlp->nlp_delayfunc);
1850 retry = ndlp->nlp_retry;
1851
1852 switch (cmd) {
1853 case ELS_CMD_FLOGI:
1854 lpfc_issue_els_flogi(vport, ndlp, retry);
1855 break;
1856 case ELS_CMD_PLOGI:
1857 if (!lpfc_issue_els_plogi(vport, ndlp->nlp_DID, retry)) {
1858 ndlp->nlp_prev_state = ndlp->nlp_state;
1859 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
1860 }
1861 break;
1862 case ELS_CMD_ADISC:
1863 if (!lpfc_issue_els_adisc(vport, ndlp, retry)) {
1864 ndlp->nlp_prev_state = ndlp->nlp_state;
1865 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
1866 }
1867 break;
1868 case ELS_CMD_PRLI:
1869 if (!lpfc_issue_els_prli(vport, ndlp, retry)) {
1870 ndlp->nlp_prev_state = ndlp->nlp_state;
1871 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
1872 }
1873 break;
1874 case ELS_CMD_LOGO:
1875 if (!lpfc_issue_els_logo(vport, ndlp, retry)) {
1876 ndlp->nlp_prev_state = ndlp->nlp_state;
1877 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
1878 }
1879 break;
1880 case ELS_CMD_FDISC:
1881 lpfc_issue_els_fdisc(vport, ndlp, retry);
1882 break;
1883 }
1884 return;
1885 }
1886
1887 static int
1888 lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1889 struct lpfc_iocbq *rspiocb)
1890 {
1891 struct lpfc_vport *vport = cmdiocb->vport;
1892 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1893 IOCB_t *irsp = &rspiocb->iocb;
1894 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
1895 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
1896 uint32_t *elscmd;
1897 struct ls_rjt stat;
1898 int retry = 0, maxretry = lpfc_max_els_tries, delay = 0;
1899 int logerr = 0;
1900 uint32_t cmd = 0;
1901 uint32_t did;
1902
1903
1904 /* Note: context2 may be 0 for internal driver abort
1905 * of delays ELS command.
1906 */
1907
1908 if (pcmd && pcmd->virt) {
1909 elscmd = (uint32_t *) (pcmd->virt);
1910 cmd = *elscmd++;
1911 }
1912
1913 if (ndlp && NLP_CHK_NODE_ACT(ndlp))
1914 did = ndlp->nlp_DID;
1915 else {
1916 /* We should only hit this case for retrying PLOGI */
1917 did = irsp->un.elsreq64.remoteID;
1918 ndlp = lpfc_findnode_did(vport, did);
1919 if ((!ndlp || !NLP_CHK_NODE_ACT(ndlp))
1920 && (cmd != ELS_CMD_PLOGI))
1921 return 1;
1922 }
1923
1924 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1925 "Retry ELS: wd7:x%x wd4:x%x did:x%x",
1926 *(((uint32_t *) irsp) + 7), irsp->un.ulpWord[4], ndlp->nlp_DID);
1927
1928 switch (irsp->ulpStatus) {
1929 case IOSTAT_FCP_RSP_ERROR:
1930 case IOSTAT_REMOTE_STOP:
1931 break;
1932
1933 case IOSTAT_LOCAL_REJECT:
1934 switch ((irsp->un.ulpWord[4] & 0xff)) {
1935 case IOERR_LOOP_OPEN_FAILURE:
1936 if (cmd == ELS_CMD_PLOGI && cmdiocb->retry == 0)
1937 delay = 1000;
1938 retry = 1;
1939 break;
1940
1941 case IOERR_ILLEGAL_COMMAND:
1942 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1943 "0124 Retry illegal cmd x%x "
1944 "retry:x%x delay:x%x\n",
1945 cmd, cmdiocb->retry, delay);
1946 retry = 1;
1947 /* All command's retry policy */
1948 maxretry = 8;
1949 if (cmdiocb->retry > 2)
1950 delay = 1000;
1951 break;
1952
1953 case IOERR_NO_RESOURCES:
1954 logerr = 1; /* HBA out of resources */
1955 retry = 1;
1956 if (cmdiocb->retry > 100)
1957 delay = 100;
1958 maxretry = 250;
1959 break;
1960
1961 case IOERR_ILLEGAL_FRAME:
1962 delay = 100;
1963 retry = 1;
1964 break;
1965
1966 case IOERR_SEQUENCE_TIMEOUT:
1967 case IOERR_INVALID_RPI:
1968 retry = 1;
1969 break;
1970 }
1971 break;
1972
1973 case IOSTAT_NPORT_RJT:
1974 case IOSTAT_FABRIC_RJT:
1975 if (irsp->un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
1976 retry = 1;
1977 break;
1978 }
1979 break;
1980
1981 case IOSTAT_NPORT_BSY:
1982 case IOSTAT_FABRIC_BSY:
1983 logerr = 1; /* Fabric / Remote NPort out of resources */
1984 retry = 1;
1985 break;
1986
1987 case IOSTAT_LS_RJT:
1988 stat.un.lsRjtError = be32_to_cpu(irsp->un.ulpWord[4]);
1989 /* Added for Vendor specifc support
1990 * Just keep retrying for these Rsn / Exp codes
1991 */
1992 switch (stat.un.b.lsRjtRsnCode) {
1993 case LSRJT_UNABLE_TPC:
1994 if (stat.un.b.lsRjtRsnCodeExp ==
1995 LSEXP_CMD_IN_PROGRESS) {
1996 if (cmd == ELS_CMD_PLOGI) {
1997 delay = 1000;
1998 maxretry = 48;
1999 }
2000 retry = 1;
2001 break;
2002 }
2003 if (cmd == ELS_CMD_PLOGI) {
2004 delay = 1000;
2005 maxretry = lpfc_max_els_tries + 1;
2006 retry = 1;
2007 break;
2008 }
2009 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
2010 (cmd == ELS_CMD_FDISC) &&
2011 (stat.un.b.lsRjtRsnCodeExp == LSEXP_OUT_OF_RESOURCE)){
2012 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
2013 "0125 FDISC Failed (x%x). "
2014 "Fabric out of resources\n",
2015 stat.un.lsRjtError);
2016 lpfc_vport_set_state(vport,
2017 FC_VPORT_NO_FABRIC_RSCS);
2018 }
2019 break;
2020
2021 case LSRJT_LOGICAL_BSY:
2022 if ((cmd == ELS_CMD_PLOGI) ||
2023 (cmd == ELS_CMD_PRLI)) {
2024 delay = 1000;
2025 maxretry = 48;
2026 } else if (cmd == ELS_CMD_FDISC) {
2027 /* FDISC retry policy */
2028 maxretry = 48;
2029 if (cmdiocb->retry >= 32)
2030 delay = 1000;
2031 }
2032 retry = 1;
2033 break;
2034
2035 case LSRJT_LOGICAL_ERR:
2036 /* There are some cases where switches return this
2037 * error when they are not ready and should be returning
2038 * Logical Busy. We should delay every time.
2039 */
2040 if (cmd == ELS_CMD_FDISC &&
2041 stat.un.b.lsRjtRsnCodeExp == LSEXP_PORT_LOGIN_REQ) {
2042 maxretry = 3;
2043 delay = 1000;
2044 retry = 1;
2045 break;
2046 }
2047 case LSRJT_PROTOCOL_ERR:
2048 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
2049 (cmd == ELS_CMD_FDISC) &&
2050 ((stat.un.b.lsRjtRsnCodeExp == LSEXP_INVALID_PNAME) ||
2051 (stat.un.b.lsRjtRsnCodeExp == LSEXP_INVALID_NPORT_ID))
2052 ) {
2053 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
2054 "0123 FDISC Failed (x%x). "
2055 "Fabric Detected Bad WWN\n",
2056 stat.un.lsRjtError);
2057 lpfc_vport_set_state(vport,
2058 FC_VPORT_FABRIC_REJ_WWN);
2059 }
2060 break;
2061 }
2062 break;
2063
2064 case IOSTAT_INTERMED_RSP:
2065 case IOSTAT_BA_RJT:
2066 break;
2067
2068 default:
2069 break;
2070 }
2071
2072 if (did == FDMI_DID)
2073 retry = 1;
2074
2075 if ((cmd == ELS_CMD_FLOGI) &&
2076 (phba->fc_topology != TOPOLOGY_LOOP) &&
2077 !lpfc_error_lost_link(irsp)) {
2078 /* FLOGI retry policy */
2079 retry = 1;
2080 maxretry = 48;
2081 if (cmdiocb->retry >= 32)
2082 delay = 1000;
2083 }
2084
2085 if ((++cmdiocb->retry) >= maxretry) {
2086 phba->fc_stat.elsRetryExceeded++;
2087 retry = 0;
2088 }
2089
2090 if ((vport->load_flag & FC_UNLOADING) != 0)
2091 retry = 0;
2092
2093 if (retry) {
2094
2095 /* Retry ELS command <elsCmd> to remote NPORT <did> */
2096 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2097 "0107 Retry ELS command x%x to remote "
2098 "NPORT x%x Data: x%x x%x\n",
2099 cmd, did, cmdiocb->retry, delay);
2100
2101 if (((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_ADISC)) &&
2102 ((irsp->ulpStatus != IOSTAT_LOCAL_REJECT) ||
2103 ((irsp->un.ulpWord[4] & 0xff) != IOERR_NO_RESOURCES))) {
2104 /* Don't reset timer for no resources */
2105
2106 /* If discovery / RSCN timer is running, reset it */
2107 if (timer_pending(&vport->fc_disctmo) ||
2108 (vport->fc_flag & FC_RSCN_MODE))
2109 lpfc_set_disctmo(vport);
2110 }
2111
2112 phba->fc_stat.elsXmitRetry++;
2113 if (ndlp && NLP_CHK_NODE_ACT(ndlp) && delay) {
2114 phba->fc_stat.elsDelayRetry++;
2115 ndlp->nlp_retry = cmdiocb->retry;
2116
2117 /* delay is specified in milliseconds */
2118 mod_timer(&ndlp->nlp_delayfunc,
2119 jiffies + msecs_to_jiffies(delay));
2120 spin_lock_irq(shost->host_lock);
2121 ndlp->nlp_flag |= NLP_DELAY_TMO;
2122 spin_unlock_irq(shost->host_lock);
2123
2124 ndlp->nlp_prev_state = ndlp->nlp_state;
2125 if (cmd == ELS_CMD_PRLI)
2126 lpfc_nlp_set_state(vport, ndlp,
2127 NLP_STE_REG_LOGIN_ISSUE);
2128 else
2129 lpfc_nlp_set_state(vport, ndlp,
2130 NLP_STE_NPR_NODE);
2131 ndlp->nlp_last_elscmd = cmd;
2132
2133 return 1;
2134 }
2135 switch (cmd) {
2136 case ELS_CMD_FLOGI:
2137 lpfc_issue_els_flogi(vport, ndlp, cmdiocb->retry);
2138 return 1;
2139 case ELS_CMD_FDISC:
2140 lpfc_issue_els_fdisc(vport, ndlp, cmdiocb->retry);
2141 return 1;
2142 case ELS_CMD_PLOGI:
2143 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
2144 ndlp->nlp_prev_state = ndlp->nlp_state;
2145 lpfc_nlp_set_state(vport, ndlp,
2146 NLP_STE_PLOGI_ISSUE);
2147 }
2148 lpfc_issue_els_plogi(vport, did, cmdiocb->retry);
2149 return 1;
2150 case ELS_CMD_ADISC:
2151 ndlp->nlp_prev_state = ndlp->nlp_state;
2152 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
2153 lpfc_issue_els_adisc(vport, ndlp, cmdiocb->retry);
2154 return 1;
2155 case ELS_CMD_PRLI:
2156 ndlp->nlp_prev_state = ndlp->nlp_state;
2157 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PRLI_ISSUE);
2158 lpfc_issue_els_prli(vport, ndlp, cmdiocb->retry);
2159 return 1;
2160 case ELS_CMD_LOGO:
2161 ndlp->nlp_prev_state = ndlp->nlp_state;
2162 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
2163 lpfc_issue_els_logo(vport, ndlp, cmdiocb->retry);
2164 return 1;
2165 }
2166 }
2167 /* No retry ELS command <elsCmd> to remote NPORT <did> */
2168 if (logerr) {
2169 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
2170 "0137 No retry ELS command x%x to remote "
2171 "NPORT x%x: Out of Resources: Error:x%x/%x\n",
2172 cmd, did, irsp->ulpStatus,
2173 irsp->un.ulpWord[4]);
2174 }
2175 else {
2176 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2177 "0108 No retry ELS command x%x to remote "
2178 "NPORT x%x Retried:%d Error:x%x/%x\n",
2179 cmd, did, cmdiocb->retry, irsp->ulpStatus,
2180 irsp->un.ulpWord[4]);
2181 }
2182 return 0;
2183 }
2184
2185 static int
2186 lpfc_els_free_data(struct lpfc_hba *phba, struct lpfc_dmabuf *buf_ptr1)
2187 {
2188 struct lpfc_dmabuf *buf_ptr;
2189
2190 /* Free the response before processing the command. */
2191 if (!list_empty(&buf_ptr1->list)) {
2192 list_remove_head(&buf_ptr1->list, buf_ptr,
2193 struct lpfc_dmabuf,
2194 list);
2195 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
2196 kfree(buf_ptr);
2197 }
2198 lpfc_mbuf_free(phba, buf_ptr1->virt, buf_ptr1->phys);
2199 kfree(buf_ptr1);
2200 return 0;
2201 }
2202
2203 static int
2204 lpfc_els_free_bpl(struct lpfc_hba *phba, struct lpfc_dmabuf *buf_ptr)
2205 {
2206 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
2207 kfree(buf_ptr);
2208 return 0;
2209 }
2210
2211 int
2212 lpfc_els_free_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *elsiocb)
2213 {
2214 struct lpfc_dmabuf *buf_ptr, *buf_ptr1;
2215 struct lpfc_nodelist *ndlp;
2216
2217 ndlp = (struct lpfc_nodelist *)elsiocb->context1;
2218 if (ndlp) {
2219 if (ndlp->nlp_flag & NLP_DEFER_RM) {
2220 lpfc_nlp_put(ndlp);
2221
2222 /* If the ndlp is not being used by another discovery
2223 * thread, free it.
2224 */
2225 if (!lpfc_nlp_not_used(ndlp)) {
2226 /* If ndlp is being used by another discovery
2227 * thread, just clear NLP_DEFER_RM
2228 */
2229 ndlp->nlp_flag &= ~NLP_DEFER_RM;
2230 }
2231 }
2232 else
2233 lpfc_nlp_put(ndlp);
2234 elsiocb->context1 = NULL;
2235 }
2236 /* context2 = cmd, context2->next = rsp, context3 = bpl */
2237 if (elsiocb->context2) {
2238 if (elsiocb->iocb_flag & LPFC_DELAY_MEM_FREE) {
2239 /* Firmware could still be in progress of DMAing
2240 * payload, so don't free data buffer till after
2241 * a hbeat.
2242 */
2243 elsiocb->iocb_flag &= ~LPFC_DELAY_MEM_FREE;
2244 buf_ptr = elsiocb->context2;
2245 elsiocb->context2 = NULL;
2246 if (buf_ptr) {
2247 buf_ptr1 = NULL;
2248 spin_lock_irq(&phba->hbalock);
2249 if (!list_empty(&buf_ptr->list)) {
2250 list_remove_head(&buf_ptr->list,
2251 buf_ptr1, struct lpfc_dmabuf,
2252 list);
2253 INIT_LIST_HEAD(&buf_ptr1->list);
2254 list_add_tail(&buf_ptr1->list,
2255 &phba->elsbuf);
2256 phba->elsbuf_cnt++;
2257 }
2258 INIT_LIST_HEAD(&buf_ptr->list);
2259 list_add_tail(&buf_ptr->list, &phba->elsbuf);
2260 phba->elsbuf_cnt++;
2261 spin_unlock_irq(&phba->hbalock);
2262 }
2263 } else {
2264 buf_ptr1 = (struct lpfc_dmabuf *) elsiocb->context2;
2265 lpfc_els_free_data(phba, buf_ptr1);
2266 }
2267 }
2268
2269 if (elsiocb->context3) {
2270 buf_ptr = (struct lpfc_dmabuf *) elsiocb->context3;
2271 lpfc_els_free_bpl(phba, buf_ptr);
2272 }
2273 lpfc_sli_release_iocbq(phba, elsiocb);
2274 return 0;
2275 }
2276
2277 static void
2278 lpfc_cmpl_els_logo_acc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2279 struct lpfc_iocbq *rspiocb)
2280 {
2281 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
2282 struct lpfc_vport *vport = cmdiocb->vport;
2283 IOCB_t *irsp;
2284
2285 irsp = &rspiocb->iocb;
2286 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2287 "ACC LOGO cmpl: status:x%x/x%x did:x%x",
2288 irsp->ulpStatus, irsp->un.ulpWord[4], ndlp->nlp_DID);
2289 /* ACC to LOGO completes to NPort <nlp_DID> */
2290 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2291 "0109 ACC to LOGO completes to NPort x%x "
2292 "Data: x%x x%x x%x\n",
2293 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2294 ndlp->nlp_rpi);
2295
2296 if (ndlp->nlp_state == NLP_STE_NPR_NODE) {
2297 /* NPort Recovery mode or node is just allocated */
2298 if (!lpfc_nlp_not_used(ndlp)) {
2299 /* If the ndlp is being used by another discovery
2300 * thread, just unregister the RPI.
2301 */
2302 lpfc_unreg_rpi(vport, ndlp);
2303 } else {
2304 /* Indicate the node has already released, should
2305 * not reference to it from within lpfc_els_free_iocb.
2306 */
2307 cmdiocb->context1 = NULL;
2308 }
2309 }
2310 lpfc_els_free_iocb(phba, cmdiocb);
2311 return;
2312 }
2313
2314 void
2315 lpfc_mbx_cmpl_dflt_rpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2316 {
2317 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
2318 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
2319
2320 pmb->context1 = NULL;
2321 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2322 kfree(mp);
2323 mempool_free(pmb, phba->mbox_mem_pool);
2324 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
2325 lpfc_nlp_put(ndlp);
2326 /* This is the end of the default RPI cleanup logic for this
2327 * ndlp. If no other discovery threads are using this ndlp.
2328 * we should free all resources associated with it.
2329 */
2330 lpfc_nlp_not_used(ndlp);
2331 }
2332 return;
2333 }
2334
2335 static void
2336 lpfc_cmpl_els_rsp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
2337 struct lpfc_iocbq *rspiocb)
2338 {
2339 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
2340 struct lpfc_vport *vport = ndlp ? ndlp->vport : NULL;
2341 struct Scsi_Host *shost = vport ? lpfc_shost_from_vport(vport) : NULL;
2342 IOCB_t *irsp;
2343 uint8_t *pcmd;
2344 LPFC_MBOXQ_t *mbox = NULL;
2345 struct lpfc_dmabuf *mp = NULL;
2346 uint32_t ls_rjt = 0;
2347
2348 irsp = &rspiocb->iocb;
2349
2350 if (cmdiocb->context_un.mbox)
2351 mbox = cmdiocb->context_un.mbox;
2352
2353 /* First determine if this is a LS_RJT cmpl. Note, this callback
2354 * function can have cmdiocb->contest1 (ndlp) field set to NULL.
2355 */
2356 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) cmdiocb->context2)->virt);
2357 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
2358 (*((uint32_t *) (pcmd)) == ELS_CMD_LS_RJT)) {
2359 /* A LS_RJT associated with Default RPI cleanup has its own
2360 * seperate code path.
2361 */
2362 if (!(ndlp->nlp_flag & NLP_RM_DFLT_RPI))
2363 ls_rjt = 1;
2364 }
2365
2366 /* Check to see if link went down during discovery */
2367 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp) || lpfc_els_chk_latt(vport)) {
2368 if (mbox) {
2369 mp = (struct lpfc_dmabuf *) mbox->context1;
2370 if (mp) {
2371 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2372 kfree(mp);
2373 }
2374 mempool_free(mbox, phba->mbox_mem_pool);
2375 }
2376 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
2377 (ndlp->nlp_flag & NLP_RM_DFLT_RPI))
2378 if (lpfc_nlp_not_used(ndlp)) {
2379 ndlp = NULL;
2380 /* Indicate the node has already released,
2381 * should not reference to it from within
2382 * the routine lpfc_els_free_iocb.
2383 */
2384 cmdiocb->context1 = NULL;
2385 }
2386 goto out;
2387 }
2388
2389 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2390 "ELS rsp cmpl: status:x%x/x%x did:x%x",
2391 irsp->ulpStatus, irsp->un.ulpWord[4],
2392 cmdiocb->iocb.un.elsreq64.remoteID);
2393 /* ELS response tag <ulpIoTag> completes */
2394 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2395 "0110 ELS response tag x%x completes "
2396 "Data: x%x x%x x%x x%x x%x x%x x%x\n",
2397 cmdiocb->iocb.ulpIoTag, rspiocb->iocb.ulpStatus,
2398 rspiocb->iocb.un.ulpWord[4], rspiocb->iocb.ulpTimeout,
2399 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2400 ndlp->nlp_rpi);
2401 if (mbox) {
2402 if ((rspiocb->iocb.ulpStatus == 0)
2403 && (ndlp->nlp_flag & NLP_ACC_REGLOGIN)) {
2404 lpfc_unreg_rpi(vport, ndlp);
2405 /* Increment reference count to ndlp to hold the
2406 * reference to ndlp for the callback function.
2407 */
2408 mbox->context2 = lpfc_nlp_get(ndlp);
2409 mbox->vport = vport;
2410 if (ndlp->nlp_flag & NLP_RM_DFLT_RPI) {
2411 mbox->mbox_flag |= LPFC_MBX_IMED_UNREG;
2412 mbox->mbox_cmpl = lpfc_mbx_cmpl_dflt_rpi;
2413 }
2414 else {
2415 mbox->mbox_cmpl = lpfc_mbx_cmpl_reg_login;
2416 ndlp->nlp_prev_state = ndlp->nlp_state;
2417 lpfc_nlp_set_state(vport, ndlp,
2418 NLP_STE_REG_LOGIN_ISSUE);
2419 }
2420 if (lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT)
2421 != MBX_NOT_FINISHED)
2422 goto out;
2423 else
2424 /* Decrement the ndlp reference count we
2425 * set for this failed mailbox command.
2426 */
2427 lpfc_nlp_put(ndlp);
2428
2429 /* ELS rsp: Cannot issue reg_login for <NPortid> */
2430 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
2431 "0138 ELS rsp: Cannot issue reg_login for x%x "
2432 "Data: x%x x%x x%x\n",
2433 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2434 ndlp->nlp_rpi);
2435
2436 if (lpfc_nlp_not_used(ndlp)) {
2437 ndlp = NULL;
2438 /* Indicate node has already been released,
2439 * should not reference to it from within
2440 * the routine lpfc_els_free_iocb.
2441 */
2442 cmdiocb->context1 = NULL;
2443 }
2444 } else {
2445 /* Do not drop node for lpfc_els_abort'ed ELS cmds */
2446 if (!lpfc_error_lost_link(irsp) &&
2447 ndlp->nlp_flag & NLP_ACC_REGLOGIN) {
2448 if (lpfc_nlp_not_used(ndlp)) {
2449 ndlp = NULL;
2450 /* Indicate node has already been
2451 * released, should not reference
2452 * to it from within the routine
2453 * lpfc_els_free_iocb.
2454 */
2455 cmdiocb->context1 = NULL;
2456 }
2457 }
2458 }
2459 mp = (struct lpfc_dmabuf *) mbox->context1;
2460 if (mp) {
2461 lpfc_mbuf_free(phba, mp->virt, mp->phys);
2462 kfree(mp);
2463 }
2464 mempool_free(mbox, phba->mbox_mem_pool);
2465 }
2466 out:
2467 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
2468 spin_lock_irq(shost->host_lock);
2469 ndlp->nlp_flag &= ~(NLP_ACC_REGLOGIN | NLP_RM_DFLT_RPI);
2470 spin_unlock_irq(shost->host_lock);
2471
2472 /* If the node is not being used by another discovery thread,
2473 * and we are sending a reject, we are done with it.
2474 * Release driver reference count here and free associated
2475 * resources.
2476 */
2477 if (ls_rjt)
2478 if (lpfc_nlp_not_used(ndlp))
2479 /* Indicate node has already been released,
2480 * should not reference to it from within
2481 * the routine lpfc_els_free_iocb.
2482 */
2483 cmdiocb->context1 = NULL;
2484 }
2485
2486 lpfc_els_free_iocb(phba, cmdiocb);
2487 return;
2488 }
2489
2490 int
2491 lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
2492 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp,
2493 LPFC_MBOXQ_t *mbox)
2494 {
2495 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2496 struct lpfc_hba *phba = vport->phba;
2497 IOCB_t *icmd;
2498 IOCB_t *oldcmd;
2499 struct lpfc_iocbq *elsiocb;
2500 struct lpfc_sli_ring *pring;
2501 struct lpfc_sli *psli;
2502 uint8_t *pcmd;
2503 uint16_t cmdsize;
2504 int rc;
2505 ELS_PKT *els_pkt_ptr;
2506
2507 psli = &phba->sli;
2508 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2509 oldcmd = &oldiocb->iocb;
2510
2511 switch (flag) {
2512 case ELS_CMD_ACC:
2513 cmdsize = sizeof(uint32_t);
2514 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
2515 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2516 if (!elsiocb) {
2517 spin_lock_irq(shost->host_lock);
2518 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
2519 spin_unlock_irq(shost->host_lock);
2520 return 1;
2521 }
2522
2523 icmd = &elsiocb->iocb;
2524 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2525 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2526 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2527 pcmd += sizeof(uint32_t);
2528
2529 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2530 "Issue ACC: did:x%x flg:x%x",
2531 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2532 break;
2533 case ELS_CMD_PLOGI:
2534 cmdsize = (sizeof(struct serv_parm) + sizeof(uint32_t));
2535 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
2536 ndlp, ndlp->nlp_DID, ELS_CMD_ACC);
2537 if (!elsiocb)
2538 return 1;
2539
2540 icmd = &elsiocb->iocb;
2541 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2542 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2543
2544 if (mbox)
2545 elsiocb->context_un.mbox = mbox;
2546
2547 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2548 pcmd += sizeof(uint32_t);
2549 memcpy(pcmd, &vport->fc_sparam, sizeof(struct serv_parm));
2550
2551 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2552 "Issue ACC PLOGI: did:x%x flg:x%x",
2553 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2554 break;
2555 case ELS_CMD_PRLO:
2556 cmdsize = sizeof(uint32_t) + sizeof(PRLO);
2557 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry,
2558 ndlp, ndlp->nlp_DID, ELS_CMD_PRLO);
2559 if (!elsiocb)
2560 return 1;
2561
2562 icmd = &elsiocb->iocb;
2563 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2564 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2565
2566 memcpy(pcmd, ((struct lpfc_dmabuf *) oldiocb->context2)->virt,
2567 sizeof(uint32_t) + sizeof(PRLO));
2568 *((uint32_t *) (pcmd)) = ELS_CMD_PRLO_ACC;
2569 els_pkt_ptr = (ELS_PKT *) pcmd;
2570 els_pkt_ptr->un.prlo.acceptRspCode = PRLO_REQ_EXECUTED;
2571
2572 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2573 "Issue ACC PRLO: did:x%x flg:x%x",
2574 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2575 break;
2576 default:
2577 return 1;
2578 }
2579 /* Xmit ELS ACC response tag <ulpIoTag> */
2580 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2581 "0128 Xmit ELS ACC response tag x%x, XRI: x%x, "
2582 "DID: x%x, nlp_flag: x%x nlp_state: x%x RPI: x%x\n",
2583 elsiocb->iotag, elsiocb->iocb.ulpContext,
2584 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2585 ndlp->nlp_rpi);
2586 if (ndlp->nlp_flag & NLP_LOGO_ACC) {
2587 spin_lock_irq(shost->host_lock);
2588 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
2589 spin_unlock_irq(shost->host_lock);
2590 elsiocb->iocb_cmpl = lpfc_cmpl_els_logo_acc;
2591 } else {
2592 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
2593 }
2594
2595 phba->fc_stat.elsXmitACC++;
2596 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2597 if (rc == IOCB_ERROR) {
2598 lpfc_els_free_iocb(phba, elsiocb);
2599 return 1;
2600 }
2601 return 0;
2602 }
2603
2604 int
2605 lpfc_els_rsp_reject(struct lpfc_vport *vport, uint32_t rejectError,
2606 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp,
2607 LPFC_MBOXQ_t *mbox)
2608 {
2609 struct lpfc_hba *phba = vport->phba;
2610 IOCB_t *icmd;
2611 IOCB_t *oldcmd;
2612 struct lpfc_iocbq *elsiocb;
2613 struct lpfc_sli_ring *pring;
2614 struct lpfc_sli *psli;
2615 uint8_t *pcmd;
2616 uint16_t cmdsize;
2617 int rc;
2618
2619 psli = &phba->sli;
2620 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2621
2622 cmdsize = 2 * sizeof(uint32_t);
2623 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2624 ndlp->nlp_DID, ELS_CMD_LS_RJT);
2625 if (!elsiocb)
2626 return 1;
2627
2628 icmd = &elsiocb->iocb;
2629 oldcmd = &oldiocb->iocb;
2630 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2631 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2632
2633 *((uint32_t *) (pcmd)) = ELS_CMD_LS_RJT;
2634 pcmd += sizeof(uint32_t);
2635 *((uint32_t *) (pcmd)) = rejectError;
2636
2637 if (mbox)
2638 elsiocb->context_un.mbox = mbox;
2639
2640 /* Xmit ELS RJT <err> response tag <ulpIoTag> */
2641 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2642 "0129 Xmit ELS RJT x%x response tag x%x "
2643 "xri x%x, did x%x, nlp_flag x%x, nlp_state x%x, "
2644 "rpi x%x\n",
2645 rejectError, elsiocb->iotag,
2646 elsiocb->iocb.ulpContext, ndlp->nlp_DID,
2647 ndlp->nlp_flag, ndlp->nlp_state, ndlp->nlp_rpi);
2648 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2649 "Issue LS_RJT: did:x%x flg:x%x err:x%x",
2650 ndlp->nlp_DID, ndlp->nlp_flag, rejectError);
2651
2652 phba->fc_stat.elsXmitLSRJT++;
2653 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
2654 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2655
2656 if (rc == IOCB_ERROR) {
2657 lpfc_els_free_iocb(phba, elsiocb);
2658 return 1;
2659 }
2660 return 0;
2661 }
2662
2663 int
2664 lpfc_els_rsp_adisc_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
2665 struct lpfc_nodelist *ndlp)
2666 {
2667 struct lpfc_hba *phba = vport->phba;
2668 struct lpfc_sli *psli = &phba->sli;
2669 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
2670 ADISC *ap;
2671 IOCB_t *icmd, *oldcmd;
2672 struct lpfc_iocbq *elsiocb;
2673 uint8_t *pcmd;
2674 uint16_t cmdsize;
2675 int rc;
2676
2677 cmdsize = sizeof(uint32_t) + sizeof(ADISC);
2678 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2679 ndlp->nlp_DID, ELS_CMD_ACC);
2680 if (!elsiocb)
2681 return 1;
2682
2683 icmd = &elsiocb->iocb;
2684 oldcmd = &oldiocb->iocb;
2685 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2686
2687 /* Xmit ADISC ACC response tag <ulpIoTag> */
2688 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2689 "0130 Xmit ADISC ACC response iotag x%x xri: "
2690 "x%x, did x%x, nlp_flag x%x, nlp_state x%x rpi x%x\n",
2691 elsiocb->iotag, elsiocb->iocb.ulpContext,
2692 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2693 ndlp->nlp_rpi);
2694 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2695
2696 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2697 pcmd += sizeof(uint32_t);
2698
2699 ap = (ADISC *) (pcmd);
2700 ap->hardAL_PA = phba->fc_pref_ALPA;
2701 memcpy(&ap->portName, &vport->fc_portname, sizeof(struct lpfc_name));
2702 memcpy(&ap->nodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
2703 ap->DID = be32_to_cpu(vport->fc_myDID);
2704
2705 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2706 "Issue ACC ADISC: did:x%x flg:x%x",
2707 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2708
2709 phba->fc_stat.elsXmitACC++;
2710 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
2711 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2712 if (rc == IOCB_ERROR) {
2713 lpfc_els_free_iocb(phba, elsiocb);
2714 return 1;
2715 }
2716 return 0;
2717 }
2718
2719 int
2720 lpfc_els_rsp_prli_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
2721 struct lpfc_nodelist *ndlp)
2722 {
2723 struct lpfc_hba *phba = vport->phba;
2724 PRLI *npr;
2725 lpfc_vpd_t *vpd;
2726 IOCB_t *icmd;
2727 IOCB_t *oldcmd;
2728 struct lpfc_iocbq *elsiocb;
2729 struct lpfc_sli_ring *pring;
2730 struct lpfc_sli *psli;
2731 uint8_t *pcmd;
2732 uint16_t cmdsize;
2733 int rc;
2734
2735 psli = &phba->sli;
2736 pring = &psli->ring[LPFC_ELS_RING]; /* ELS ring */
2737
2738 cmdsize = sizeof(uint32_t) + sizeof(PRLI);
2739 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2740 ndlp->nlp_DID, (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK)));
2741 if (!elsiocb)
2742 return 1;
2743
2744 icmd = &elsiocb->iocb;
2745 oldcmd = &oldiocb->iocb;
2746 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2747 /* Xmit PRLI ACC response tag <ulpIoTag> */
2748 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2749 "0131 Xmit PRLI ACC response tag x%x xri x%x, "
2750 "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
2751 elsiocb->iotag, elsiocb->iocb.ulpContext,
2752 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
2753 ndlp->nlp_rpi);
2754 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2755
2756 *((uint32_t *) (pcmd)) = (ELS_CMD_ACC | (ELS_CMD_PRLI & ~ELS_RSP_MASK));
2757 pcmd += sizeof(uint32_t);
2758
2759 /* For PRLI, remainder of payload is PRLI parameter page */
2760 memset(pcmd, 0, sizeof(PRLI));
2761
2762 npr = (PRLI *) pcmd;
2763 vpd = &phba->vpd;
2764 /*
2765 * If the remote port is a target and our firmware version is 3.20 or
2766 * later, set the following bits for FC-TAPE support.
2767 */
2768 if ((ndlp->nlp_type & NLP_FCP_TARGET) &&
2769 (vpd->rev.feaLevelHigh >= 0x02)) {
2770 npr->ConfmComplAllowed = 1;
2771 npr->Retry = 1;
2772 npr->TaskRetryIdReq = 1;
2773 }
2774
2775 npr->acceptRspCode = PRLI_REQ_EXECUTED;
2776 npr->estabImagePair = 1;
2777 npr->readXferRdyDis = 1;
2778 npr->ConfmComplAllowed = 1;
2779
2780 npr->prliType = PRLI_FCP_TYPE;
2781 npr->initiatorFunc = 1;
2782
2783 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2784 "Issue ACC PRLI: did:x%x flg:x%x",
2785 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2786
2787 phba->fc_stat.elsXmitACC++;
2788 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
2789
2790 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2791 if (rc == IOCB_ERROR) {
2792 lpfc_els_free_iocb(phba, elsiocb);
2793 return 1;
2794 }
2795 return 0;
2796 }
2797
2798 static int
2799 lpfc_els_rsp_rnid_acc(struct lpfc_vport *vport, uint8_t format,
2800 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
2801 {
2802 struct lpfc_hba *phba = vport->phba;
2803 RNID *rn;
2804 IOCB_t *icmd, *oldcmd;
2805 struct lpfc_iocbq *elsiocb;
2806 struct lpfc_sli_ring *pring;
2807 struct lpfc_sli *psli;
2808 uint8_t *pcmd;
2809 uint16_t cmdsize;
2810 int rc;
2811
2812 psli = &phba->sli;
2813 pring = &psli->ring[LPFC_ELS_RING];
2814
2815 cmdsize = sizeof(uint32_t) + sizeof(uint32_t)
2816 + (2 * sizeof(struct lpfc_name));
2817 if (format)
2818 cmdsize += sizeof(RNID_TOP_DISC);
2819
2820 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
2821 ndlp->nlp_DID, ELS_CMD_ACC);
2822 if (!elsiocb)
2823 return 1;
2824
2825 icmd = &elsiocb->iocb;
2826 oldcmd = &oldiocb->iocb;
2827 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
2828 /* Xmit RNID ACC response tag <ulpIoTag> */
2829 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
2830 "0132 Xmit RNID ACC response tag x%x xri x%x\n",
2831 elsiocb->iotag, elsiocb->iocb.ulpContext);
2832 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
2833 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
2834 pcmd += sizeof(uint32_t);
2835
2836 memset(pcmd, 0, sizeof(RNID));
2837 rn = (RNID *) (pcmd);
2838 rn->Format = format;
2839 rn->CommonLen = (2 * sizeof(struct lpfc_name));
2840 memcpy(&rn->portName, &vport->fc_portname, sizeof(struct lpfc_name));
2841 memcpy(&rn->nodeName, &vport->fc_nodename, sizeof(struct lpfc_name));
2842 switch (format) {
2843 case 0:
2844 rn->SpecificLen = 0;
2845 break;
2846 case RNID_TOPOLOGY_DISC:
2847 rn->SpecificLen = sizeof(RNID_TOP_DISC);
2848 memcpy(&rn->un.topologyDisc.portName,
2849 &vport->fc_portname, sizeof(struct lpfc_name));
2850 rn->un.topologyDisc.unitType = RNID_HBA;
2851 rn->un.topologyDisc.physPort = 0;
2852 rn->un.topologyDisc.attachedNodes = 0;
2853 break;
2854 default:
2855 rn->CommonLen = 0;
2856 rn->SpecificLen = 0;
2857 break;
2858 }
2859
2860 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP,
2861 "Issue ACC RNID: did:x%x flg:x%x",
2862 ndlp->nlp_DID, ndlp->nlp_flag, 0);
2863
2864 phba->fc_stat.elsXmitACC++;
2865 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
2866 lpfc_nlp_put(ndlp);
2867 elsiocb->context1 = NULL; /* Don't need ndlp for cmpl,
2868 * it could be freed */
2869
2870 rc = lpfc_sli_issue_iocb(phba, pring, elsiocb, 0);
2871 if (rc == IOCB_ERROR) {
2872 lpfc_els_free_iocb(phba, elsiocb);
2873 return 1;
2874 }
2875 return 0;
2876 }
2877
2878 int
2879 lpfc_els_disc_adisc(struct lpfc_vport *vport)
2880 {
2881 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2882 struct lpfc_nodelist *ndlp, *next_ndlp;
2883 int sentadisc = 0;
2884
2885 /* go thru NPR nodes and issue any remaining ELS ADISCs */
2886 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2887 if (!NLP_CHK_NODE_ACT(ndlp))
2888 continue;
2889 if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
2890 (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
2891 (ndlp->nlp_flag & NLP_NPR_ADISC) != 0) {
2892 spin_lock_irq(shost->host_lock);
2893 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2894 spin_unlock_irq(shost->host_lock);
2895 ndlp->nlp_prev_state = ndlp->nlp_state;
2896 lpfc_nlp_set_state(vport, ndlp, NLP_STE_ADISC_ISSUE);
2897 lpfc_issue_els_adisc(vport, ndlp, 0);
2898 sentadisc++;
2899 vport->num_disc_nodes++;
2900 if (vport->num_disc_nodes >=
2901 vport->cfg_discovery_threads) {
2902 spin_lock_irq(shost->host_lock);
2903 vport->fc_flag |= FC_NLP_MORE;
2904 spin_unlock_irq(shost->host_lock);
2905 break;
2906 }
2907 }
2908 }
2909 if (sentadisc == 0) {
2910 spin_lock_irq(shost->host_lock);
2911 vport->fc_flag &= ~FC_NLP_MORE;
2912 spin_unlock_irq(shost->host_lock);
2913 }
2914 return sentadisc;
2915 }
2916
2917 int
2918 lpfc_els_disc_plogi(struct lpfc_vport *vport)
2919 {
2920 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2921 struct lpfc_nodelist *ndlp, *next_ndlp;
2922 int sentplogi = 0;
2923
2924 /* go thru NPR nodes and issue any remaining ELS PLOGIs */
2925 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2926 if (!NLP_CHK_NODE_ACT(ndlp))
2927 continue;
2928 if (ndlp->nlp_state == NLP_STE_NPR_NODE &&
2929 (ndlp->nlp_flag & NLP_NPR_2B_DISC) != 0 &&
2930 (ndlp->nlp_flag & NLP_DELAY_TMO) == 0 &&
2931 (ndlp->nlp_flag & NLP_NPR_ADISC) == 0) {
2932 ndlp->nlp_prev_state = ndlp->nlp_state;
2933 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
2934 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
2935 sentplogi++;
2936 vport->num_disc_nodes++;
2937 if (vport->num_disc_nodes >=
2938 vport->cfg_discovery_threads) {
2939 spin_lock_irq(shost->host_lock);
2940 vport->fc_flag |= FC_NLP_MORE;
2941 spin_unlock_irq(shost->host_lock);
2942 break;
2943 }
2944 }
2945 }
2946 if (sentplogi) {
2947 lpfc_set_disctmo(vport);
2948 }
2949 else {
2950 spin_lock_irq(shost->host_lock);
2951 vport->fc_flag &= ~FC_NLP_MORE;
2952 spin_unlock_irq(shost->host_lock);
2953 }
2954 return sentplogi;
2955 }
2956
2957 void
2958 lpfc_els_flush_rscn(struct lpfc_vport *vport)
2959 {
2960 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2961 struct lpfc_hba *phba = vport->phba;
2962 int i;
2963
2964 spin_lock_irq(shost->host_lock);
2965 if (vport->fc_rscn_flush) {
2966 /* Another thread is walking fc_rscn_id_list on this vport */
2967 spin_unlock_irq(shost->host_lock);
2968 return;
2969 }
2970 /* Indicate we are walking lpfc_els_flush_rscn on this vport */
2971 vport->fc_rscn_flush = 1;
2972 spin_unlock_irq(shost->host_lock);
2973
2974 for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
2975 lpfc_in_buf_free(phba, vport->fc_rscn_id_list[i]);
2976 vport->fc_rscn_id_list[i] = NULL;
2977 }
2978 spin_lock_irq(shost->host_lock);
2979 vport->fc_rscn_id_cnt = 0;
2980 vport->fc_flag &= ~(FC_RSCN_MODE | FC_RSCN_DISCOVERY);
2981 spin_unlock_irq(shost->host_lock);
2982 lpfc_can_disctmo(vport);
2983 /* Indicate we are done walking this fc_rscn_id_list */
2984 vport->fc_rscn_flush = 0;
2985 }
2986
2987 int
2988 lpfc_rscn_payload_check(struct lpfc_vport *vport, uint32_t did)
2989 {
2990 D_ID ns_did;
2991 D_ID rscn_did;
2992 uint32_t *lp;
2993 uint32_t payload_len, i;
2994 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2995
2996 ns_did.un.word = did;
2997
2998 /* Never match fabric nodes for RSCNs */
2999 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
3000 return 0;
3001
3002 /* If we are doing a FULL RSCN rediscovery, match everything */
3003 if (vport->fc_flag & FC_RSCN_DISCOVERY)
3004 return did;
3005
3006 spin_lock_irq(shost->host_lock);
3007 if (vport->fc_rscn_flush) {
3008 /* Another thread is walking fc_rscn_id_list on this vport */
3009 spin_unlock_irq(shost->host_lock);
3010 return 0;
3011 }
3012 /* Indicate we are walking fc_rscn_id_list on this vport */
3013 vport->fc_rscn_flush = 1;
3014 spin_unlock_irq(shost->host_lock);
3015 for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
3016 lp = vport->fc_rscn_id_list[i]->virt;
3017 payload_len = be32_to_cpu(*lp++ & ~ELS_CMD_MASK);
3018 payload_len -= sizeof(uint32_t); /* take off word 0 */
3019 while (payload_len) {
3020 rscn_did.un.word = be32_to_cpu(*lp++);
3021 payload_len -= sizeof(uint32_t);
3022 switch (rscn_did.un.b.resv) {
3023 case 0: /* Single N_Port ID effected */
3024 if (ns_did.un.word == rscn_did.un.word)
3025 goto return_did_out;
3026 break;
3027 case 1: /* Whole N_Port Area effected */
3028 if ((ns_did.un.b.domain == rscn_did.un.b.domain)
3029 && (ns_did.un.b.area == rscn_did.un.b.area))
3030 goto return_did_out;
3031 break;
3032 case 2: /* Whole N_Port Domain effected */
3033 if (ns_did.un.b.domain == rscn_did.un.b.domain)
3034 goto return_did_out;
3035 break;
3036 default:
3037 /* Unknown Identifier in RSCN node */
3038 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
3039 "0217 Unknown Identifier in "
3040 "RSCN payload Data: x%x\n",
3041 rscn_did.un.word);
3042 case 3: /* Whole Fabric effected */
3043 goto return_did_out;
3044 }
3045 }
3046 }
3047 /* Indicate we are done with walking fc_rscn_id_list on this vport */
3048 vport->fc_rscn_flush = 0;
3049 return 0;
3050 return_did_out:
3051 /* Indicate we are done with walking fc_rscn_id_list on this vport */
3052 vport->fc_rscn_flush = 0;
3053 return did;
3054 }
3055
3056 static int
3057 lpfc_rscn_recovery_check(struct lpfc_vport *vport)
3058 {
3059 struct lpfc_nodelist *ndlp = NULL;
3060
3061 /* Move all affected nodes by pending RSCNs to NPR state. */
3062 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
3063 if (!NLP_CHK_NODE_ACT(ndlp) ||
3064 (ndlp->nlp_state == NLP_STE_UNUSED_NODE) ||
3065 !lpfc_rscn_payload_check(vport, ndlp->nlp_DID))
3066 continue;
3067 lpfc_disc_state_machine(vport, ndlp, NULL,
3068 NLP_EVT_DEVICE_RECOVERY);
3069 lpfc_cancel_retry_delay_tmo(vport, ndlp);
3070 }
3071 return 0;
3072 }
3073
3074 static int
3075 lpfc_els_rcv_rscn(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3076 struct lpfc_nodelist *ndlp)
3077 {
3078 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3079 struct lpfc_hba *phba = vport->phba;
3080 struct lpfc_dmabuf *pcmd;
3081 uint32_t *lp, *datap;
3082 IOCB_t *icmd;
3083 uint32_t payload_len, length, nportid, *cmd;
3084 int rscn_cnt;
3085 int rscn_id = 0, hba_id = 0;
3086 int i;
3087
3088 icmd = &cmdiocb->iocb;
3089 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3090 lp = (uint32_t *) pcmd->virt;
3091
3092 payload_len = be32_to_cpu(*lp++ & ~ELS_CMD_MASK);
3093 payload_len -= sizeof(uint32_t); /* take off word 0 */
3094 /* RSCN received */
3095 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3096 "0214 RSCN received Data: x%x x%x x%x x%x\n",
3097 vport->fc_flag, payload_len, *lp,
3098 vport->fc_rscn_id_cnt);
3099 for (i = 0; i < payload_len/sizeof(uint32_t); i++)
3100 fc_host_post_event(shost, fc_get_event_number(),
3101 FCH_EVT_RSCN, lp[i]);
3102
3103 /* If we are about to begin discovery, just ACC the RSCN.
3104 * Discovery processing will satisfy it.
3105 */
3106 if (vport->port_state <= LPFC_NS_QRY) {
3107 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3108 "RCV RSCN ignore: did:x%x/ste:x%x flg:x%x",
3109 ndlp->nlp_DID, vport->port_state, ndlp->nlp_flag);
3110
3111 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3112 return 0;
3113 }
3114
3115 /* If this RSCN just contains NPortIDs for other vports on this HBA,
3116 * just ACC and ignore it.
3117 */
3118 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
3119 !(vport->cfg_peer_port_login)) {
3120 i = payload_len;
3121 datap = lp;
3122 while (i > 0) {
3123 nportid = *datap++;
3124 nportid = ((be32_to_cpu(nportid)) & Mask_DID);
3125 i -= sizeof(uint32_t);
3126 rscn_id++;
3127 if (lpfc_find_vport_by_did(phba, nportid))
3128 hba_id++;
3129 }
3130 if (rscn_id == hba_id) {
3131 /* ALL NPortIDs in RSCN are on HBA */
3132 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3133 "0214 Ignore RSCN "
3134 "Data: x%x x%x x%x x%x\n",
3135 vport->fc_flag, payload_len,
3136 *lp, vport->fc_rscn_id_cnt);
3137 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3138 "RCV RSCN vport: did:x%x/ste:x%x flg:x%x",
3139 ndlp->nlp_DID, vport->port_state,
3140 ndlp->nlp_flag);
3141
3142 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb,
3143 ndlp, NULL);
3144 return 0;
3145 }
3146 }
3147
3148 spin_lock_irq(shost->host_lock);
3149 if (vport->fc_rscn_flush) {
3150 /* Another thread is walking fc_rscn_id_list on this vport */
3151 spin_unlock_irq(shost->host_lock);
3152 vport->fc_flag |= FC_RSCN_DISCOVERY;
3153 /* Send back ACC */
3154 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3155 return 0;
3156 }
3157 /* Indicate we are walking fc_rscn_id_list on this vport */
3158 vport->fc_rscn_flush = 1;
3159 spin_unlock_irq(shost->host_lock);
3160 /* Get the array count after sucessfully have the token */
3161 rscn_cnt = vport->fc_rscn_id_cnt;
3162 /* If we are already processing an RSCN, save the received
3163 * RSCN payload buffer, cmdiocb->context2 to process later.
3164 */
3165 if (vport->fc_flag & (FC_RSCN_MODE | FC_NDISC_ACTIVE)) {
3166 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3167 "RCV RSCN defer: did:x%x/ste:x%x flg:x%x",
3168 ndlp->nlp_DID, vport->port_state, ndlp->nlp_flag);
3169
3170 spin_lock_irq(shost->host_lock);
3171 vport->fc_flag |= FC_RSCN_DEFERRED;
3172 if ((rscn_cnt < FC_MAX_HOLD_RSCN) &&
3173 !(vport->fc_flag & FC_RSCN_DISCOVERY)) {
3174 vport->fc_flag |= FC_RSCN_MODE;
3175 spin_unlock_irq(shost->host_lock);
3176 if (rscn_cnt) {
3177 cmd = vport->fc_rscn_id_list[rscn_cnt-1]->virt;
3178 length = be32_to_cpu(*cmd & ~ELS_CMD_MASK);
3179 }
3180 if ((rscn_cnt) &&
3181 (payload_len + length <= LPFC_BPL_SIZE)) {
3182 *cmd &= ELS_CMD_MASK;
3183 *cmd |= cpu_to_be32(payload_len + length);
3184 memcpy(((uint8_t *)cmd) + length, lp,
3185 payload_len);
3186 } else {
3187 vport->fc_rscn_id_list[rscn_cnt] = pcmd;
3188 vport->fc_rscn_id_cnt++;
3189 /* If we zero, cmdiocb->context2, the calling
3190 * routine will not try to free it.
3191 */
3192 cmdiocb->context2 = NULL;
3193 }
3194 /* Deferred RSCN */
3195 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3196 "0235 Deferred RSCN "
3197 "Data: x%x x%x x%x\n",
3198 vport->fc_rscn_id_cnt, vport->fc_flag,
3199 vport->port_state);
3200 } else {
3201 vport->fc_flag |= FC_RSCN_DISCOVERY;
3202 spin_unlock_irq(shost->host_lock);
3203 /* ReDiscovery RSCN */
3204 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3205 "0234 ReDiscovery RSCN "
3206 "Data: x%x x%x x%x\n",
3207 vport->fc_rscn_id_cnt, vport->fc_flag,
3208 vport->port_state);
3209 }
3210 /* Indicate we are done walking fc_rscn_id_list on this vport */
3211 vport->fc_rscn_flush = 0;
3212 /* Send back ACC */
3213 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3214 /* send RECOVERY event for ALL nodes that match RSCN payload */
3215 lpfc_rscn_recovery_check(vport);
3216 spin_lock_irq(shost->host_lock);
3217 vport->fc_flag &= ~FC_RSCN_DEFERRED;
3218 spin_unlock_irq(shost->host_lock);
3219 return 0;
3220 }
3221 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
3222 "RCV RSCN: did:x%x/ste:x%x flg:x%x",
3223 ndlp->nlp_DID, vport->port_state, ndlp->nlp_flag);
3224
3225 spin_lock_irq(shost->host_lock);
3226 vport->fc_flag |= FC_RSCN_MODE;
3227 spin_unlock_irq(shost->host_lock);
3228 vport->fc_rscn_id_list[vport->fc_rscn_id_cnt++] = pcmd;
3229 /* Indicate we are done walking fc_rscn_id_list on this vport */
3230 vport->fc_rscn_flush = 0;
3231 /*
3232 * If we zero, cmdiocb->context2, the calling routine will
3233 * not try to free it.
3234 */
3235 cmdiocb->context2 = NULL;
3236 lpfc_set_disctmo(vport);
3237 /* Send back ACC */
3238 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3239 /* send RECOVERY event for ALL nodes that match RSCN payload */
3240 lpfc_rscn_recovery_check(vport);
3241 return lpfc_els_handle_rscn(vport);
3242 }
3243
3244 int
3245 lpfc_els_handle_rscn(struct lpfc_vport *vport)
3246 {
3247 struct lpfc_nodelist *ndlp;
3248 struct lpfc_hba *phba = vport->phba;
3249
3250 /* Ignore RSCN if the port is being torn down. */
3251 if (vport->load_flag & FC_UNLOADING) {
3252 lpfc_els_flush_rscn(vport);
3253 return 0;
3254 }
3255
3256 /* Start timer for RSCN processing */
3257 lpfc_set_disctmo(vport);
3258
3259 /* RSCN processed */
3260 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
3261 "0215 RSCN processed Data: x%x x%x x%x x%x\n",
3262 vport->fc_flag, 0, vport->fc_rscn_id_cnt,
3263 vport->port_state);
3264
3265 /* To process RSCN, first compare RSCN data with NameServer */
3266 vport->fc_ns_retry = 0;
3267 vport->num_disc_nodes = 0;
3268
3269 ndlp = lpfc_findnode_did(vport, NameServer_DID);
3270 if (ndlp && NLP_CHK_NODE_ACT(ndlp)
3271 && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
3272 /* Good ndlp, issue CT Request to NameServer */
3273 if (lpfc_ns_cmd(vport, SLI_CTNS_GID_FT, 0, 0) == 0)
3274 /* Wait for NameServer query cmpl before we can
3275 continue */
3276 return 1;
3277 } else {
3278 /* If login to NameServer does not exist, issue one */
3279 /* Good status, issue PLOGI to NameServer */
3280 ndlp = lpfc_findnode_did(vport, NameServer_DID);
3281 if (ndlp && NLP_CHK_NODE_ACT(ndlp))
3282 /* Wait for NameServer login cmpl before we can
3283 continue */
3284 return 1;
3285
3286 if (ndlp) {
3287 ndlp = lpfc_enable_node(vport, ndlp,
3288 NLP_STE_PLOGI_ISSUE);
3289 if (!ndlp) {
3290 lpfc_els_flush_rscn(vport);
3291 return 0;
3292 }
3293 ndlp->nlp_prev_state = NLP_STE_UNUSED_NODE;
3294 } else {
3295 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
3296 if (!ndlp) {
3297 lpfc_els_flush_rscn(vport);
3298 return 0;
3299 }
3300 lpfc_nlp_init(vport, ndlp, NameServer_DID);
3301 ndlp->nlp_prev_state = ndlp->nlp_state;
3302 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
3303 }
3304 ndlp->nlp_type |= NLP_FABRIC;
3305 lpfc_issue_els_plogi(vport, NameServer_DID, 0);
3306 /* Wait for NameServer login cmpl before we can
3307 * continue
3308 */
3309 return 1;
3310 }
3311
3312 lpfc_els_flush_rscn(vport);
3313 return 0;
3314 }
3315
3316 static int
3317 lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3318 struct lpfc_nodelist *ndlp)
3319 {
3320 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3321 struct lpfc_hba *phba = vport->phba;
3322 struct lpfc_dmabuf *pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3323 uint32_t *lp = (uint32_t *) pcmd->virt;
3324 IOCB_t *icmd = &cmdiocb->iocb;
3325 struct serv_parm *sp;
3326 LPFC_MBOXQ_t *mbox;
3327 struct ls_rjt stat;
3328 uint32_t cmd, did;
3329 int rc;
3330
3331 cmd = *lp++;
3332 sp = (struct serv_parm *) lp;
3333
3334 /* FLOGI received */
3335
3336 lpfc_set_disctmo(vport);
3337
3338 if (phba->fc_topology == TOPOLOGY_LOOP) {
3339 /* We should never receive a FLOGI in loop mode, ignore it */
3340 did = icmd->un.elsreq64.remoteID;
3341
3342 /* An FLOGI ELS command <elsCmd> was received from DID <did> in
3343 Loop Mode */
3344 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
3345 "0113 An FLOGI ELS command x%x was "
3346 "received from DID x%x in Loop Mode\n",
3347 cmd, did);
3348 return 1;
3349 }
3350
3351 did = Fabric_DID;
3352
3353 if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3))) {
3354 /* For a FLOGI we accept, then if our portname is greater
3355 * then the remote portname we initiate Nport login.
3356 */
3357
3358 rc = memcmp(&vport->fc_portname, &sp->portName,
3359 sizeof(struct lpfc_name));
3360
3361 if (!rc) {
3362 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3363 if (!mbox)
3364 return 1;
3365
3366 lpfc_linkdown(phba);
3367 lpfc_init_link(phba, mbox,
3368 phba->cfg_topology,
3369 phba->cfg_link_speed);
3370 mbox->mb.un.varInitLnk.lipsr_AL_PA = 0;
3371 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
3372 mbox->vport = vport;
3373 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
3374 lpfc_set_loopback_flag(phba);
3375 if (rc == MBX_NOT_FINISHED) {
3376 mempool_free(mbox, phba->mbox_mem_pool);
3377 }
3378 return 1;
3379 } else if (rc > 0) { /* greater than */
3380 spin_lock_irq(shost->host_lock);
3381 vport->fc_flag |= FC_PT2PT_PLOGI;
3382 spin_unlock_irq(shost->host_lock);
3383 }
3384 spin_lock_irq(shost->host_lock);
3385 vport->fc_flag |= FC_PT2PT;
3386 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
3387 spin_unlock_irq(shost->host_lock);
3388 } else {
3389 /* Reject this request because invalid parameters */
3390 stat.un.b.lsRjtRsvd0 = 0;
3391 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3392 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
3393 stat.un.b.vendorUnique = 0;
3394 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3395 NULL);
3396 return 1;
3397 }
3398
3399 /* Send back ACC */
3400 lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL);
3401
3402 return 0;
3403 }
3404
3405 static int
3406 lpfc_els_rcv_rnid(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3407 struct lpfc_nodelist *ndlp)
3408 {
3409 struct lpfc_dmabuf *pcmd;
3410 uint32_t *lp;
3411 IOCB_t *icmd;
3412 RNID *rn;
3413 struct ls_rjt stat;
3414 uint32_t cmd, did;
3415
3416 icmd = &cmdiocb->iocb;
3417 did = icmd->un.elsreq64.remoteID;
3418 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3419 lp = (uint32_t *) pcmd->virt;
3420
3421 cmd = *lp++;
3422 rn = (RNID *) lp;
3423
3424 /* RNID received */
3425
3426 switch (rn->Format) {
3427 case 0:
3428 case RNID_TOPOLOGY_DISC:
3429 /* Send back ACC */
3430 lpfc_els_rsp_rnid_acc(vport, rn->Format, cmdiocb, ndlp);
3431 break;
3432 default:
3433 /* Reject this request because format not supported */
3434 stat.un.b.lsRjtRsvd0 = 0;
3435 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3436 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3437 stat.un.b.vendorUnique = 0;
3438 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3439 NULL);
3440 }
3441 return 0;
3442 }
3443
3444 static int
3445 lpfc_els_rcv_lirr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3446 struct lpfc_nodelist *ndlp)
3447 {
3448 struct ls_rjt stat;
3449
3450 /* For now, unconditionally reject this command */
3451 stat.un.b.lsRjtRsvd0 = 0;
3452 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3453 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3454 stat.un.b.vendorUnique = 0;
3455 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
3456 return 0;
3457 }
3458
3459 static void
3460 lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
3461 {
3462 struct lpfc_sli *psli = &phba->sli;
3463 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
3464 MAILBOX_t *mb;
3465 IOCB_t *icmd;
3466 RPS_RSP *rps_rsp;
3467 uint8_t *pcmd;
3468 struct lpfc_iocbq *elsiocb;
3469 struct lpfc_nodelist *ndlp;
3470 uint16_t xri, status;
3471 uint32_t cmdsize;
3472
3473 mb = &pmb->mb;
3474
3475 ndlp = (struct lpfc_nodelist *) pmb->context2;
3476 xri = (uint16_t) ((unsigned long)(pmb->context1));
3477 pmb->context1 = NULL;
3478 pmb->context2 = NULL;
3479
3480 if (mb->mbxStatus) {
3481 mempool_free(pmb, phba->mbox_mem_pool);
3482 return;
3483 }
3484
3485 cmdsize = sizeof(RPS_RSP) + sizeof(uint32_t);
3486 mempool_free(pmb, phba->mbox_mem_pool);
3487 elsiocb = lpfc_prep_els_iocb(phba->pport, 0, cmdsize,
3488 lpfc_max_els_tries, ndlp,
3489 ndlp->nlp_DID, ELS_CMD_ACC);
3490
3491 /* Decrement the ndlp reference count from previous mbox command */
3492 lpfc_nlp_put(ndlp);
3493
3494 if (!elsiocb)
3495 return;
3496
3497 icmd = &elsiocb->iocb;
3498 icmd->ulpContext = xri;
3499
3500 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
3501 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
3502 pcmd += sizeof(uint32_t); /* Skip past command */
3503 rps_rsp = (RPS_RSP *)pcmd;
3504
3505 if (phba->fc_topology != TOPOLOGY_LOOP)
3506 status = 0x10;
3507 else
3508 status = 0x8;
3509 if (phba->pport->fc_flag & FC_FABRIC)
3510 status |= 0x4;
3511
3512 rps_rsp->rsvd1 = 0;
3513 rps_rsp->portStatus = cpu_to_be16(status);
3514 rps_rsp->linkFailureCnt = cpu_to_be32(mb->un.varRdLnk.linkFailureCnt);
3515 rps_rsp->lossSyncCnt = cpu_to_be32(mb->un.varRdLnk.lossSyncCnt);
3516 rps_rsp->lossSignalCnt = cpu_to_be32(mb->un.varRdLnk.lossSignalCnt);
3517 rps_rsp->primSeqErrCnt = cpu_to_be32(mb->un.varRdLnk.primSeqErrCnt);
3518 rps_rsp->invalidXmitWord = cpu_to_be32(mb->un.varRdLnk.invalidXmitWord);
3519 rps_rsp->crcCnt = cpu_to_be32(mb->un.varRdLnk.crcCnt);
3520 /* Xmit ELS RPS ACC response tag <ulpIoTag> */
3521 lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_ELS,
3522 "0118 Xmit ELS RPS ACC response tag x%x xri x%x, "
3523 "did x%x, nlp_flag x%x, nlp_state x%x, rpi x%x\n",
3524 elsiocb->iotag, elsiocb->iocb.ulpContext,
3525 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
3526 ndlp->nlp_rpi);
3527 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
3528 phba->fc_stat.elsXmitACC++;
3529 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR)
3530 lpfc_els_free_iocb(phba, elsiocb);
3531 return;
3532 }
3533
3534 static int
3535 lpfc_els_rcv_rps(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3536 struct lpfc_nodelist *ndlp)
3537 {
3538 struct lpfc_hba *phba = vport->phba;
3539 uint32_t *lp;
3540 uint8_t flag;
3541 LPFC_MBOXQ_t *mbox;
3542 struct lpfc_dmabuf *pcmd;
3543 RPS *rps;
3544 struct ls_rjt stat;
3545
3546 if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
3547 (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
3548 stat.un.b.lsRjtRsvd0 = 0;
3549 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3550 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3551 stat.un.b.vendorUnique = 0;
3552 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3553 NULL);
3554 }
3555
3556 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3557 lp = (uint32_t *) pcmd->virt;
3558 flag = (be32_to_cpu(*lp++) & 0xf);
3559 rps = (RPS *) lp;
3560
3561 if ((flag == 0) ||
3562 ((flag == 1) && (be32_to_cpu(rps->un.portNum) == 0)) ||
3563 ((flag == 2) && (memcmp(&rps->un.portName, &vport->fc_portname,
3564 sizeof(struct lpfc_name)) == 0))) {
3565
3566 printk("Fix me....\n");
3567 dump_stack();
3568 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC);
3569 if (mbox) {
3570 lpfc_read_lnk_stat(phba, mbox);
3571 mbox->context1 =
3572 (void *)((unsigned long) cmdiocb->iocb.ulpContext);
3573 mbox->context2 = lpfc_nlp_get(ndlp);
3574 mbox->vport = vport;
3575 mbox->mbox_cmpl = lpfc_els_rsp_rps_acc;
3576 if (lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT)
3577 != MBX_NOT_FINISHED)
3578 /* Mbox completion will send ELS Response */
3579 return 0;
3580 /* Decrement reference count used for the failed mbox
3581 * command.
3582 */
3583 lpfc_nlp_put(ndlp);
3584 mempool_free(mbox, phba->mbox_mem_pool);
3585 }
3586 }
3587 stat.un.b.lsRjtRsvd0 = 0;
3588 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3589 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3590 stat.un.b.vendorUnique = 0;
3591 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
3592 return 0;
3593 }
3594
3595 static int
3596 lpfc_els_rsp_rpl_acc(struct lpfc_vport *vport, uint16_t cmdsize,
3597 struct lpfc_iocbq *oldiocb, struct lpfc_nodelist *ndlp)
3598 {
3599 struct lpfc_hba *phba = vport->phba;
3600 IOCB_t *icmd, *oldcmd;
3601 RPL_RSP rpl_rsp;
3602 struct lpfc_iocbq *elsiocb;
3603 struct lpfc_sli *psli = &phba->sli;
3604 struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
3605 uint8_t *pcmd;
3606
3607 elsiocb = lpfc_prep_els_iocb(vport, 0, cmdsize, oldiocb->retry, ndlp,
3608 ndlp->nlp_DID, ELS_CMD_ACC);
3609
3610 if (!elsiocb)
3611 return 1;
3612
3613 icmd = &elsiocb->iocb;
3614 oldcmd = &oldiocb->iocb;
3615 icmd->ulpContext = oldcmd->ulpContext; /* Xri */
3616
3617 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
3618 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
3619 pcmd += sizeof(uint16_t);
3620 *((uint16_t *)(pcmd)) = be16_to_cpu(cmdsize);
3621 pcmd += sizeof(uint16_t);
3622
3623 /* Setup the RPL ACC payload */
3624 rpl_rsp.listLen = be32_to_cpu(1);
3625 rpl_rsp.index = 0;
3626 rpl_rsp.port_num_blk.portNum = 0;
3627 rpl_rsp.port_num_blk.portID = be32_to_cpu(vport->fc_myDID);
3628 memcpy(&rpl_rsp.port_num_blk.portName, &vport->fc_portname,
3629 sizeof(struct lpfc_name));
3630 memcpy(pcmd, &rpl_rsp, cmdsize - sizeof(uint32_t));
3631 /* Xmit ELS RPL ACC response tag <ulpIoTag> */
3632 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3633 "0120 Xmit ELS RPL ACC response tag x%x "
3634 "xri x%x, did x%x, nlp_flag x%x, nlp_state x%x, "
3635 "rpi x%x\n",
3636 elsiocb->iotag, elsiocb->iocb.ulpContext,
3637 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
3638 ndlp->nlp_rpi);
3639 elsiocb->iocb_cmpl = lpfc_cmpl_els_rsp;
3640 phba->fc_stat.elsXmitACC++;
3641 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
3642 lpfc_els_free_iocb(phba, elsiocb);
3643 return 1;
3644 }
3645 return 0;
3646 }
3647
3648 static int
3649 lpfc_els_rcv_rpl(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3650 struct lpfc_nodelist *ndlp)
3651 {
3652 struct lpfc_dmabuf *pcmd;
3653 uint32_t *lp;
3654 uint32_t maxsize;
3655 uint16_t cmdsize;
3656 RPL *rpl;
3657 struct ls_rjt stat;
3658
3659 if ((ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
3660 (ndlp->nlp_state != NLP_STE_MAPPED_NODE)) {
3661 stat.un.b.lsRjtRsvd0 = 0;
3662 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
3663 stat.un.b.lsRjtRsnCodeExp = LSEXP_CANT_GIVE_DATA;
3664 stat.un.b.vendorUnique = 0;
3665 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
3666 NULL);
3667 }
3668
3669 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3670 lp = (uint32_t *) pcmd->virt;
3671 rpl = (RPL *) (lp + 1);
3672
3673 maxsize = be32_to_cpu(rpl->maxsize);
3674
3675 /* We support only one port */
3676 if ((rpl->index == 0) &&
3677 ((maxsize == 0) ||
3678 ((maxsize * sizeof(uint32_t)) >= sizeof(RPL_RSP)))) {
3679 cmdsize = sizeof(uint32_t) + sizeof(RPL_RSP);
3680 } else {
3681 cmdsize = sizeof(uint32_t) + maxsize * sizeof(uint32_t);
3682 }
3683 lpfc_els_rsp_rpl_acc(vport, cmdsize, cmdiocb, ndlp);
3684
3685 return 0;
3686 }
3687
3688 static int
3689 lpfc_els_rcv_farp(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3690 struct lpfc_nodelist *ndlp)
3691 {
3692 struct lpfc_dmabuf *pcmd;
3693 uint32_t *lp;
3694 IOCB_t *icmd;
3695 FARP *fp;
3696 uint32_t cmd, cnt, did;
3697
3698 icmd = &cmdiocb->iocb;
3699 did = icmd->un.elsreq64.remoteID;
3700 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3701 lp = (uint32_t *) pcmd->virt;
3702
3703 cmd = *lp++;
3704 fp = (FARP *) lp;
3705 /* FARP-REQ received from DID <did> */
3706 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3707 "0601 FARP-REQ received from DID x%x\n", did);
3708 /* We will only support match on WWPN or WWNN */
3709 if (fp->Mflags & ~(FARP_MATCH_NODE | FARP_MATCH_PORT)) {
3710 return 0;
3711 }
3712
3713 cnt = 0;
3714 /* If this FARP command is searching for my portname */
3715 if (fp->Mflags & FARP_MATCH_PORT) {
3716 if (memcmp(&fp->RportName, &vport->fc_portname,
3717 sizeof(struct lpfc_name)) == 0)
3718 cnt = 1;
3719 }
3720
3721 /* If this FARP command is searching for my nodename */
3722 if (fp->Mflags & FARP_MATCH_NODE) {
3723 if (memcmp(&fp->RnodeName, &vport->fc_nodename,
3724 sizeof(struct lpfc_name)) == 0)
3725 cnt = 1;
3726 }
3727
3728 if (cnt) {
3729 if ((ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) ||
3730 (ndlp->nlp_state == NLP_STE_MAPPED_NODE)) {
3731 /* Log back into the node before sending the FARP. */
3732 if (fp->Rflags & FARP_REQUEST_PLOGI) {
3733 ndlp->nlp_prev_state = ndlp->nlp_state;
3734 lpfc_nlp_set_state(vport, ndlp,
3735 NLP_STE_PLOGI_ISSUE);
3736 lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0);
3737 }
3738
3739 /* Send a FARP response to that node */
3740 if (fp->Rflags & FARP_REQUEST_FARPR)
3741 lpfc_issue_els_farpr(vport, did, 0);
3742 }
3743 }
3744 return 0;
3745 }
3746
3747 static int
3748 lpfc_els_rcv_farpr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3749 struct lpfc_nodelist *ndlp)
3750 {
3751 struct lpfc_dmabuf *pcmd;
3752 uint32_t *lp;
3753 IOCB_t *icmd;
3754 uint32_t cmd, did;
3755
3756 icmd = &cmdiocb->iocb;
3757 did = icmd->un.elsreq64.remoteID;
3758 pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
3759 lp = (uint32_t *) pcmd->virt;
3760
3761 cmd = *lp++;
3762 /* FARP-RSP received from DID <did> */
3763 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
3764 "0600 FARP-RSP received from DID x%x\n", did);
3765 /* ACCEPT the Farp resp request */
3766 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
3767
3768 return 0;
3769 }
3770
3771 static int
3772 lpfc_els_rcv_fan(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
3773 struct lpfc_nodelist *fan_ndlp)
3774 {
3775 struct lpfc_hba *phba = vport->phba;
3776 uint32_t *lp;
3777 FAN *fp;
3778
3779 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS, "0265 FAN received\n");
3780 lp = (uint32_t *)((struct lpfc_dmabuf *)cmdiocb->context2)->virt;
3781 fp = (FAN *) ++lp;
3782 /* FAN received; Fan does not have a reply sequence */
3783 if ((vport == phba->pport) &&
3784 (vport->port_state == LPFC_LOCAL_CFG_LINK)) {
3785 if ((memcmp(&phba->fc_fabparam.nodeName, &fp->FnodeName,
3786 sizeof(struct lpfc_name))) ||
3787 (memcmp(&phba->fc_fabparam.portName, &fp->FportName,
3788 sizeof(struct lpfc_name)))) {
3789 /* This port has switched fabrics. FLOGI is required */
3790 lpfc_initial_flogi(vport);
3791 } else {
3792 /* FAN verified - skip FLOGI */
3793 vport->fc_myDID = vport->fc_prevDID;
3794 lpfc_issue_fabric_reglogin(vport);
3795 }
3796 }
3797 return 0;
3798 }
3799
3800 void
3801 lpfc_els_timeout(unsigned long ptr)
3802 {
3803 struct lpfc_vport *vport = (struct lpfc_vport *) ptr;
3804 struct lpfc_hba *phba = vport->phba;
3805 uint32_t tmo_posted;
3806 unsigned long iflag;
3807
3808 spin_lock_irqsave(&vport->work_port_lock, iflag);
3809 tmo_posted = vport->work_port_events & WORKER_ELS_TMO;
3810 if (!tmo_posted)
3811 vport->work_port_events |= WORKER_ELS_TMO;
3812 spin_unlock_irqrestore(&vport->work_port_lock, iflag);
3813
3814 if (!tmo_posted)
3815 lpfc_worker_wake_up(phba);
3816 return;
3817 }
3818
3819 void
3820 lpfc_els_timeout_handler(struct lpfc_vport *vport)
3821 {
3822 struct lpfc_hba *phba = vport->phba;
3823 struct lpfc_sli_ring *pring;
3824 struct lpfc_iocbq *tmp_iocb, *piocb;
3825 IOCB_t *cmd = NULL;
3826 struct lpfc_dmabuf *pcmd;
3827 uint32_t els_command = 0;
3828 uint32_t timeout;
3829 uint32_t remote_ID = 0xffffffff;
3830
3831 /* If the timer is already canceled do nothing */
3832 if ((vport->work_port_events & WORKER_ELS_TMO) == 0) {
3833 return;
3834 }
3835 spin_lock_irq(&phba->hbalock);
3836 timeout = (uint32_t)(phba->fc_ratov << 1);
3837
3838 pring = &phba->sli.ring[LPFC_ELS_RING];
3839
3840 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3841 cmd = &piocb->iocb;
3842
3843 if ((piocb->iocb_flag & LPFC_IO_LIBDFC) != 0 ||
3844 piocb->iocb.ulpCommand == CMD_ABORT_XRI_CN ||
3845 piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)
3846 continue;
3847
3848 if (piocb->vport != vport)
3849 continue;
3850
3851 pcmd = (struct lpfc_dmabuf *) piocb->context2;
3852 if (pcmd)
3853 els_command = *(uint32_t *) (pcmd->virt);
3854
3855 if (els_command == ELS_CMD_FARP ||
3856 els_command == ELS_CMD_FARPR ||
3857 els_command == ELS_CMD_FDISC)
3858 continue;
3859
3860 if (piocb->drvrTimeout > 0) {
3861 if (piocb->drvrTimeout >= timeout)
3862 piocb->drvrTimeout -= timeout;
3863 else
3864 piocb->drvrTimeout = 0;
3865 continue;
3866 }
3867
3868 remote_ID = 0xffffffff;
3869 if (cmd->ulpCommand != CMD_GEN_REQUEST64_CR)
3870 remote_ID = cmd->un.elsreq64.remoteID;
3871 else {
3872 struct lpfc_nodelist *ndlp;
3873 ndlp = __lpfc_findnode_rpi(vport, cmd->ulpContext);
3874 if (ndlp && NLP_CHK_NODE_ACT(ndlp))
3875 remote_ID = ndlp->nlp_DID;
3876 }
3877 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
3878 "0127 ELS timeout Data: x%x x%x x%x "
3879 "x%x\n", els_command,
3880 remote_ID, cmd->ulpCommand, cmd->ulpIoTag);
3881 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3882 }
3883 spin_unlock_irq(&phba->hbalock);
3884
3885 if (phba->sli.ring[LPFC_ELS_RING].txcmplq_cnt)
3886 mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
3887 }
3888
3889 void
3890 lpfc_els_flush_cmd(struct lpfc_vport *vport)
3891 {
3892 LIST_HEAD(completions);
3893 struct lpfc_hba *phba = vport->phba;
3894 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
3895 struct lpfc_iocbq *tmp_iocb, *piocb;
3896 IOCB_t *cmd = NULL;
3897
3898 lpfc_fabric_abort_vport(vport);
3899
3900 spin_lock_irq(&phba->hbalock);
3901 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
3902 cmd = &piocb->iocb;
3903
3904 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3905 continue;
3906 }
3907
3908 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
3909 if (cmd->ulpCommand == CMD_QUE_RING_BUF_CN ||
3910 cmd->ulpCommand == CMD_QUE_RING_BUF64_CN ||
3911 cmd->ulpCommand == CMD_CLOSE_XRI_CN ||
3912 cmd->ulpCommand == CMD_ABORT_XRI_CN)
3913 continue;
3914
3915 if (piocb->vport != vport)
3916 continue;
3917
3918 list_move_tail(&piocb->list, &completions);
3919 pring->txq_cnt--;
3920 }
3921
3922 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3923 if (piocb->iocb_flag & LPFC_IO_LIBDFC) {
3924 continue;
3925 }
3926
3927 if (piocb->vport != vport)
3928 continue;
3929
3930 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3931 }
3932 spin_unlock_irq(&phba->hbalock);
3933
3934 while (!list_empty(&completions)) {
3935 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
3936 cmd = &piocb->iocb;
3937 list_del_init(&piocb->list);
3938
3939 if (!piocb->iocb_cmpl)
3940 lpfc_sli_release_iocbq(phba, piocb);
3941 else {
3942 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3943 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3944 (piocb->iocb_cmpl) (phba, piocb, piocb);
3945 }
3946 }
3947
3948 return;
3949 }
3950
3951 void
3952 lpfc_els_flush_all_cmd(struct lpfc_hba *phba)
3953 {
3954 LIST_HEAD(completions);
3955 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
3956 struct lpfc_iocbq *tmp_iocb, *piocb;
3957 IOCB_t *cmd = NULL;
3958
3959 lpfc_fabric_abort_hba(phba);
3960 spin_lock_irq(&phba->hbalock);
3961 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txq, list) {
3962 cmd = &piocb->iocb;
3963 if (piocb->iocb_flag & LPFC_IO_LIBDFC)
3964 continue;
3965 /* Do not flush out the QUE_RING and ABORT/CLOSE iocbs */
3966 if (cmd->ulpCommand == CMD_QUE_RING_BUF_CN ||
3967 cmd->ulpCommand == CMD_QUE_RING_BUF64_CN ||
3968 cmd->ulpCommand == CMD_CLOSE_XRI_CN ||
3969 cmd->ulpCommand == CMD_ABORT_XRI_CN)
3970 continue;
3971 list_move_tail(&piocb->list, &completions);
3972 pring->txq_cnt--;
3973 }
3974 list_for_each_entry_safe(piocb, tmp_iocb, &pring->txcmplq, list) {
3975 if (piocb->iocb_flag & LPFC_IO_LIBDFC)
3976 continue;
3977 lpfc_sli_issue_abort_iotag(phba, pring, piocb);
3978 }
3979 spin_unlock_irq(&phba->hbalock);
3980 while (!list_empty(&completions)) {
3981 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
3982 cmd = &piocb->iocb;
3983 list_del_init(&piocb->list);
3984 if (!piocb->iocb_cmpl)
3985 lpfc_sli_release_iocbq(phba, piocb);
3986 else {
3987 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
3988 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
3989 (piocb->iocb_cmpl) (phba, piocb, piocb);
3990 }
3991 }
3992 return;
3993 }
3994
3995 static void
3996 lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
3997 struct lpfc_vport *vport, struct lpfc_iocbq *elsiocb)
3998 {
3999 struct Scsi_Host *shost;
4000 struct lpfc_nodelist *ndlp;
4001 struct ls_rjt stat;
4002 uint32_t *payload;
4003 uint32_t cmd, did, newnode, rjt_err = 0;
4004 IOCB_t *icmd = &elsiocb->iocb;
4005
4006 if (!vport || !(elsiocb->context2))
4007 goto dropit;
4008
4009 newnode = 0;
4010 payload = ((struct lpfc_dmabuf *)elsiocb->context2)->virt;
4011 cmd = *payload;
4012 if ((phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) == 0)
4013 lpfc_post_buffer(phba, pring, 1);
4014
4015 did = icmd->un.rcvels.remoteID;
4016 if (icmd->ulpStatus) {
4017 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4018 "RCV Unsol ELS: status:x%x/x%x did:x%x",
4019 icmd->ulpStatus, icmd->un.ulpWord[4], did);
4020 goto dropit;
4021 }
4022
4023 /* Check to see if link went down during discovery */
4024 if (lpfc_els_chk_latt(vport))
4025 goto dropit;
4026
4027 /* Ignore traffic recevied during vport shutdown. */
4028 if (vport->load_flag & FC_UNLOADING)
4029 goto dropit;
4030
4031 ndlp = lpfc_findnode_did(vport, did);
4032 if (!ndlp) {
4033 /* Cannot find existing Fabric ndlp, so allocate a new one */
4034 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
4035 if (!ndlp)
4036 goto dropit;
4037
4038 lpfc_nlp_init(vport, ndlp, did);
4039 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
4040 newnode = 1;
4041 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
4042 ndlp->nlp_type |= NLP_FABRIC;
4043 } else if (!NLP_CHK_NODE_ACT(ndlp)) {
4044 ndlp = lpfc_enable_node(vport, ndlp,
4045 NLP_STE_UNUSED_NODE);
4046 if (!ndlp)
4047 goto dropit;
4048 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
4049 newnode = 1;
4050 if ((did & Fabric_DID_MASK) == Fabric_DID_MASK)
4051 ndlp->nlp_type |= NLP_FABRIC;
4052 } else if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) {
4053 /* This is similar to the new node path */
4054 ndlp = lpfc_nlp_get(ndlp);
4055 if (!ndlp)
4056 goto dropit;
4057 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
4058 newnode = 1;
4059 }
4060
4061 phba->fc_stat.elsRcvFrame++;
4062 if (elsiocb->context1)
4063 lpfc_nlp_put(elsiocb->context1);
4064
4065 elsiocb->context1 = lpfc_nlp_get(ndlp);
4066 elsiocb->vport = vport;
4067
4068 if ((cmd & ELS_CMD_MASK) == ELS_CMD_RSCN) {
4069 cmd &= ELS_CMD_MASK;
4070 }
4071 /* ELS command <elsCmd> received from NPORT <did> */
4072 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
4073 "0112 ELS command x%x received from NPORT x%x "
4074 "Data: x%x\n", cmd, did, vport->port_state);
4075 switch (cmd) {
4076 case ELS_CMD_PLOGI:
4077 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4078 "RCV PLOGI: did:x%x/ste:x%x flg:x%x",
4079 did, vport->port_state, ndlp->nlp_flag);
4080
4081 phba->fc_stat.elsRcvPLOGI++;
4082 ndlp = lpfc_plogi_confirm_nport(phba, payload, ndlp);
4083
4084 if (vport->port_state < LPFC_DISC_AUTH) {
4085 if (!(phba->pport->fc_flag & FC_PT2PT) ||
4086 (phba->pport->fc_flag & FC_PT2PT_PLOGI)) {
4087 rjt_err = LSRJT_UNABLE_TPC;
4088 break;
4089 }
4090 /* We get here, and drop thru, if we are PT2PT with
4091 * another NPort and the other side has initiated
4092 * the PLOGI before responding to our FLOGI.
4093 */
4094 }
4095
4096 shost = lpfc_shost_from_vport(vport);
4097 spin_lock_irq(shost->host_lock);
4098 ndlp->nlp_flag &= ~NLP_TARGET_REMOVE;
4099 spin_unlock_irq(shost->host_lock);
4100
4101 lpfc_disc_state_machine(vport, ndlp, elsiocb,
4102 NLP_EVT_RCV_PLOGI);
4103
4104 break;
4105 case ELS_CMD_FLOGI:
4106 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4107 "RCV FLOGI: did:x%x/ste:x%x flg:x%x",
4108 did, vport->port_state, ndlp->nlp_flag);
4109
4110 phba->fc_stat.elsRcvFLOGI++;
4111 lpfc_els_rcv_flogi(vport, elsiocb, ndlp);
4112 if (newnode)
4113 lpfc_nlp_put(ndlp);
4114 break;
4115 case ELS_CMD_LOGO:
4116 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4117 "RCV LOGO: did:x%x/ste:x%x flg:x%x",
4118 did, vport->port_state, ndlp->nlp_flag);
4119
4120 phba->fc_stat.elsRcvLOGO++;
4121 if (vport->port_state < LPFC_DISC_AUTH) {
4122 rjt_err = LSRJT_UNABLE_TPC;
4123 break;
4124 }
4125 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_LOGO);
4126 break;
4127 case ELS_CMD_PRLO:
4128 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4129 "RCV PRLO: did:x%x/ste:x%x flg:x%x",
4130 did, vport->port_state, ndlp->nlp_flag);
4131
4132 phba->fc_stat.elsRcvPRLO++;
4133 if (vport->port_state < LPFC_DISC_AUTH) {
4134 rjt_err = LSRJT_UNABLE_TPC;
4135 break;
4136 }
4137 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_PRLO);
4138 break;
4139 case ELS_CMD_RSCN:
4140 phba->fc_stat.elsRcvRSCN++;
4141 lpfc_els_rcv_rscn(vport, elsiocb, ndlp);
4142 if (newnode)
4143 lpfc_nlp_put(ndlp);
4144 break;
4145 case ELS_CMD_ADISC:
4146 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4147 "RCV ADISC: did:x%x/ste:x%x flg:x%x",
4148 did, vport->port_state, ndlp->nlp_flag);
4149
4150 phba->fc_stat.elsRcvADISC++;
4151 if (vport->port_state < LPFC_DISC_AUTH) {
4152 rjt_err = LSRJT_UNABLE_TPC;
4153 break;
4154 }
4155 lpfc_disc_state_machine(vport, ndlp, elsiocb,
4156 NLP_EVT_RCV_ADISC);
4157 break;
4158 case ELS_CMD_PDISC:
4159 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4160 "RCV PDISC: did:x%x/ste:x%x flg:x%x",
4161 did, vport->port_state, ndlp->nlp_flag);
4162
4163 phba->fc_stat.elsRcvPDISC++;
4164 if (vport->port_state < LPFC_DISC_AUTH) {
4165 rjt_err = LSRJT_UNABLE_TPC;
4166 break;
4167 }
4168 lpfc_disc_state_machine(vport, ndlp, elsiocb,
4169 NLP_EVT_RCV_PDISC);
4170 break;
4171 case ELS_CMD_FARPR:
4172 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4173 "RCV FARPR: did:x%x/ste:x%x flg:x%x",
4174 did, vport->port_state, ndlp->nlp_flag);
4175
4176 phba->fc_stat.elsRcvFARPR++;
4177 lpfc_els_rcv_farpr(vport, elsiocb, ndlp);
4178 break;
4179 case ELS_CMD_FARP:
4180 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4181 "RCV FARP: did:x%x/ste:x%x flg:x%x",
4182 did, vport->port_state, ndlp->nlp_flag);
4183
4184 phba->fc_stat.elsRcvFARP++;
4185 lpfc_els_rcv_farp(vport, elsiocb, ndlp);
4186 break;
4187 case ELS_CMD_FAN:
4188 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4189 "RCV FAN: did:x%x/ste:x%x flg:x%x",
4190 did, vport->port_state, ndlp->nlp_flag);
4191
4192 phba->fc_stat.elsRcvFAN++;
4193 lpfc_els_rcv_fan(vport, elsiocb, ndlp);
4194 break;
4195 case ELS_CMD_PRLI:
4196 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4197 "RCV PRLI: did:x%x/ste:x%x flg:x%x",
4198 did, vport->port_state, ndlp->nlp_flag);
4199
4200 phba->fc_stat.elsRcvPRLI++;
4201 if (vport->port_state < LPFC_DISC_AUTH) {
4202 rjt_err = LSRJT_UNABLE_TPC;
4203 break;
4204 }
4205 lpfc_disc_state_machine(vport, ndlp, elsiocb, NLP_EVT_RCV_PRLI);
4206 break;
4207 case ELS_CMD_LIRR:
4208 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4209 "RCV LIRR: did:x%x/ste:x%x flg:x%x",
4210 did, vport->port_state, ndlp->nlp_flag);
4211
4212 phba->fc_stat.elsRcvLIRR++;
4213 lpfc_els_rcv_lirr(vport, elsiocb, ndlp);
4214 if (newnode)
4215 lpfc_nlp_put(ndlp);
4216 break;
4217 case ELS_CMD_RPS:
4218 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4219 "RCV RPS: did:x%x/ste:x%x flg:x%x",
4220 did, vport->port_state, ndlp->nlp_flag);
4221
4222 phba->fc_stat.elsRcvRPS++;
4223 lpfc_els_rcv_rps(vport, elsiocb, ndlp);
4224 if (newnode)
4225 lpfc_nlp_put(ndlp);
4226 break;
4227 case ELS_CMD_RPL:
4228 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4229 "RCV RPL: did:x%x/ste:x%x flg:x%x",
4230 did, vport->port_state, ndlp->nlp_flag);
4231
4232 phba->fc_stat.elsRcvRPL++;
4233 lpfc_els_rcv_rpl(vport, elsiocb, ndlp);
4234 if (newnode)
4235 lpfc_nlp_put(ndlp);
4236 break;
4237 case ELS_CMD_RNID:
4238 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4239 "RCV RNID: did:x%x/ste:x%x flg:x%x",
4240 did, vport->port_state, ndlp->nlp_flag);
4241
4242 phba->fc_stat.elsRcvRNID++;
4243 lpfc_els_rcv_rnid(vport, elsiocb, ndlp);
4244 if (newnode)
4245 lpfc_nlp_put(ndlp);
4246 break;
4247 default:
4248 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
4249 "RCV ELS cmd: cmd:x%x did:x%x/ste:x%x",
4250 cmd, did, vport->port_state);
4251
4252 /* Unsupported ELS command, reject */
4253 rjt_err = LSRJT_INVALID_CMD;
4254
4255 /* Unknown ELS command <elsCmd> received from NPORT <did> */
4256 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4257 "0115 Unknown ELS command x%x "
4258 "received from NPORT x%x\n", cmd, did);
4259 if (newnode)
4260 lpfc_nlp_put(ndlp);
4261 break;
4262 }
4263
4264 /* check if need to LS_RJT received ELS cmd */
4265 if (rjt_err) {
4266 memset(&stat, 0, sizeof(stat));
4267 stat.un.b.lsRjtRsnCode = rjt_err;
4268 stat.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
4269 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, elsiocb, ndlp,
4270 NULL);
4271 }
4272
4273 return;
4274
4275 dropit:
4276 if (vport && !(vport->load_flag & FC_UNLOADING))
4277 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
4278 "(%d):0111 Dropping received ELS cmd "
4279 "Data: x%x x%x x%x\n",
4280 vport->vpi, icmd->ulpStatus,
4281 icmd->un.ulpWord[4], icmd->ulpTimeout);
4282 phba->fc_stat.elsRcvDrop++;
4283 }
4284
4285 static struct lpfc_vport *
4286 lpfc_find_vport_by_vpid(struct lpfc_hba *phba, uint16_t vpi)
4287 {
4288 struct lpfc_vport *vport;
4289 unsigned long flags;
4290
4291 spin_lock_irqsave(&phba->hbalock, flags);
4292 list_for_each_entry(vport, &phba->port_list, listentry) {
4293 if (vport->vpi == vpi) {
4294 spin_unlock_irqrestore(&phba->hbalock, flags);
4295 return vport;
4296 }
4297 }
4298 spin_unlock_irqrestore(&phba->hbalock, flags);
4299 return NULL;
4300 }
4301
4302 void
4303 lpfc_els_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
4304 struct lpfc_iocbq *elsiocb)
4305 {
4306 struct lpfc_vport *vport = phba->pport;
4307 IOCB_t *icmd = &elsiocb->iocb;
4308 dma_addr_t paddr;
4309 struct lpfc_dmabuf *bdeBuf1 = elsiocb->context2;
4310 struct lpfc_dmabuf *bdeBuf2 = elsiocb->context3;
4311
4312 elsiocb->context2 = NULL;
4313 elsiocb->context3 = NULL;
4314
4315 if (icmd->ulpStatus == IOSTAT_NEED_BUFFER) {
4316 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
4317 } else if (icmd->ulpStatus == IOSTAT_LOCAL_REJECT &&
4318 (icmd->un.ulpWord[4] & 0xff) == IOERR_RCV_BUFFER_WAITING) {
4319 phba->fc_stat.NoRcvBuf++;
4320 /* Not enough posted buffers; Try posting more buffers */
4321 if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
4322 lpfc_post_buffer(phba, pring, 0);
4323 return;
4324 }
4325
4326 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
4327 (icmd->ulpCommand == CMD_IOCB_RCV_ELS64_CX ||
4328 icmd->ulpCommand == CMD_IOCB_RCV_SEQ64_CX)) {
4329 if (icmd->unsli3.rcvsli3.vpi == 0xffff)
4330 vport = phba->pport;
4331 else {
4332 uint16_t vpi = icmd->unsli3.rcvsli3.vpi;
4333 vport = lpfc_find_vport_by_vpid(phba, vpi);
4334 }
4335 }
4336 /* If there are no BDEs associated
4337 * with this IOCB, there is nothing to do.
4338 */
4339 if (icmd->ulpBdeCount == 0)
4340 return;
4341
4342 /* type of ELS cmd is first 32bit word
4343 * in packet
4344 */
4345 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
4346 elsiocb->context2 = bdeBuf1;
4347 } else {
4348 paddr = getPaddr(icmd->un.cont64[0].addrHigh,
4349 icmd->un.cont64[0].addrLow);
4350 elsiocb->context2 = lpfc_sli_ringpostbuf_get(phba, pring,
4351 paddr);
4352 }
4353
4354 lpfc_els_unsol_buffer(phba, pring, vport, elsiocb);
4355 /*
4356 * The different unsolicited event handlers would tell us
4357 * if they are done with "mp" by setting context2 to NULL.
4358 */
4359 lpfc_nlp_put(elsiocb->context1);
4360 elsiocb->context1 = NULL;
4361 if (elsiocb->context2) {
4362 lpfc_in_buf_free(phba, (struct lpfc_dmabuf *)elsiocb->context2);
4363 elsiocb->context2 = NULL;
4364 }
4365
4366 /* RCV_ELS64_CX provide for 2 BDEs - process 2nd if included */
4367 if ((phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) &&
4368 icmd->ulpBdeCount == 2) {
4369 elsiocb->context2 = bdeBuf2;
4370 lpfc_els_unsol_buffer(phba, pring, vport, elsiocb);
4371 /* free mp if we are done with it */
4372 if (elsiocb->context2) {
4373 lpfc_in_buf_free(phba, elsiocb->context2);
4374 elsiocb->context2 = NULL;
4375 }
4376 }
4377 }
4378
4379 void
4380 lpfc_do_scr_ns_plogi(struct lpfc_hba *phba, struct lpfc_vport *vport)
4381 {
4382 struct lpfc_nodelist *ndlp, *ndlp_fdmi;
4383
4384 ndlp = lpfc_findnode_did(vport, NameServer_DID);
4385 if (!ndlp) {
4386 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
4387 if (!ndlp) {
4388 if (phba->fc_topology == TOPOLOGY_LOOP) {
4389 lpfc_disc_start(vport);
4390 return;
4391 }
4392 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4393 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4394 "0251 NameServer login: no memory\n");
4395 return;
4396 }
4397 lpfc_nlp_init(vport, ndlp, NameServer_DID);
4398 } else if (!NLP_CHK_NODE_ACT(ndlp)) {
4399 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
4400 if (!ndlp) {
4401 if (phba->fc_topology == TOPOLOGY_LOOP) {
4402 lpfc_disc_start(vport);
4403 return;
4404 }
4405 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4406 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4407 "0348 NameServer login: node freed\n");
4408 return;
4409 }
4410 }
4411 ndlp->nlp_type |= NLP_FABRIC;
4412
4413 lpfc_nlp_set_state(vport, ndlp, NLP_STE_PLOGI_ISSUE);
4414
4415 if (lpfc_issue_els_plogi(vport, ndlp->nlp_DID, 0)) {
4416 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4417 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4418 "0252 Cannot issue NameServer login\n");
4419 return;
4420 }
4421
4422 if (vport->cfg_fdmi_on) {
4423 ndlp_fdmi = mempool_alloc(phba->nlp_mem_pool,
4424 GFP_KERNEL);
4425 if (ndlp_fdmi) {
4426 lpfc_nlp_init(vport, ndlp_fdmi, FDMI_DID);
4427 ndlp_fdmi->nlp_type |= NLP_FABRIC;
4428 lpfc_nlp_set_state(vport, ndlp_fdmi,
4429 NLP_STE_PLOGI_ISSUE);
4430 lpfc_issue_els_plogi(vport, ndlp_fdmi->nlp_DID,
4431 0);
4432 }
4433 }
4434 return;
4435 }
4436
4437 static void
4438 lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
4439 {
4440 struct lpfc_vport *vport = pmb->vport;
4441 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4442 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
4443 MAILBOX_t *mb = &pmb->mb;
4444
4445 spin_lock_irq(shost->host_lock);
4446 vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
4447 spin_unlock_irq(shost->host_lock);
4448
4449 if (mb->mbxStatus) {
4450 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
4451 "0915 Register VPI failed: 0x%x\n",
4452 mb->mbxStatus);
4453
4454 switch (mb->mbxStatus) {
4455 case 0x11: /* unsupported feature */
4456 case 0x9603: /* max_vpi exceeded */
4457 case 0x9602: /* Link event since CLEAR_LA */
4458 /* giving up on vport registration */
4459 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4460 spin_lock_irq(shost->host_lock);
4461 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
4462 spin_unlock_irq(shost->host_lock);
4463 lpfc_can_disctmo(vport);
4464 break;
4465 default:
4466 /* Try to recover from this error */
4467 lpfc_mbx_unreg_vpi(vport);
4468 spin_lock_irq(shost->host_lock);
4469 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
4470 spin_unlock_irq(shost->host_lock);
4471 if (vport->port_type == LPFC_PHYSICAL_PORT)
4472 lpfc_initial_flogi(vport);
4473 else
4474 lpfc_initial_fdisc(vport);
4475 break;
4476 }
4477
4478 } else {
4479 if (vport == phba->pport)
4480 lpfc_issue_fabric_reglogin(vport);
4481 else
4482 lpfc_do_scr_ns_plogi(phba, vport);
4483 }
4484
4485 /* Now, we decrement the ndlp reference count held for this
4486 * callback function
4487 */
4488 lpfc_nlp_put(ndlp);
4489
4490 mempool_free(pmb, phba->mbox_mem_pool);
4491 return;
4492 }
4493
4494 static void
4495 lpfc_register_new_vport(struct lpfc_hba *phba, struct lpfc_vport *vport,
4496 struct lpfc_nodelist *ndlp)
4497 {
4498 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4499 LPFC_MBOXQ_t *mbox;
4500
4501 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4502 if (mbox) {
4503 lpfc_reg_vpi(phba, vport->vpi, vport->fc_myDID, mbox);
4504 mbox->vport = vport;
4505 mbox->context2 = lpfc_nlp_get(ndlp);
4506 mbox->mbox_cmpl = lpfc_cmpl_reg_new_vport;
4507 if (lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT)
4508 == MBX_NOT_FINISHED) {
4509 /* mailbox command not success, decrement ndlp
4510 * reference count for this command
4511 */
4512 lpfc_nlp_put(ndlp);
4513 mempool_free(mbox, phba->mbox_mem_pool);
4514
4515 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
4516 "0253 Register VPI: Can't send mbox\n");
4517 goto mbox_err_exit;
4518 }
4519 } else {
4520 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
4521 "0254 Register VPI: no memory\n");
4522 goto mbox_err_exit;
4523 }
4524 return;
4525
4526 mbox_err_exit:
4527 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4528 spin_lock_irq(shost->host_lock);
4529 vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
4530 spin_unlock_irq(shost->host_lock);
4531 return;
4532 }
4533
4534 static void
4535 lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4536 struct lpfc_iocbq *rspiocb)
4537 {
4538 struct lpfc_vport *vport = cmdiocb->vport;
4539 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4540 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) cmdiocb->context1;
4541 struct lpfc_nodelist *np;
4542 struct lpfc_nodelist *next_np;
4543 IOCB_t *irsp = &rspiocb->iocb;
4544 struct lpfc_iocbq *piocb;
4545
4546 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
4547 "0123 FDISC completes. x%x/x%x prevDID: x%x\n",
4548 irsp->ulpStatus, irsp->un.ulpWord[4],
4549 vport->fc_prevDID);
4550 /* Since all FDISCs are being single threaded, we
4551 * must reset the discovery timer for ALL vports
4552 * waiting to send FDISC when one completes.
4553 */
4554 list_for_each_entry(piocb, &phba->fabric_iocb_list, list) {
4555 lpfc_set_disctmo(piocb->vport);
4556 }
4557
4558 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4559 "FDISC cmpl: status:x%x/x%x prevdid:x%x",
4560 irsp->ulpStatus, irsp->un.ulpWord[4], vport->fc_prevDID);
4561
4562 if (irsp->ulpStatus) {
4563 /* Check for retry */
4564 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
4565 goto out;
4566 /* FDISC failed */
4567 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4568 "0124 FDISC failed. (%d/%d)\n",
4569 irsp->ulpStatus, irsp->un.ulpWord[4]);
4570 if (vport->fc_vport->vport_state == FC_VPORT_INITIALIZING)
4571 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4572 lpfc_nlp_put(ndlp);
4573 /* giving up on FDISC. Cancel discovery timer */
4574 lpfc_can_disctmo(vport);
4575 } else {
4576 spin_lock_irq(shost->host_lock);
4577 vport->fc_flag |= FC_FABRIC;
4578 if (vport->phba->fc_topology == TOPOLOGY_LOOP)
4579 vport->fc_flag |= FC_PUBLIC_LOOP;
4580 spin_unlock_irq(shost->host_lock);
4581
4582 vport->fc_myDID = irsp->un.ulpWord[4] & Mask_DID;
4583 lpfc_vport_set_state(vport, FC_VPORT_ACTIVE);
4584 if ((vport->fc_prevDID != vport->fc_myDID) &&
4585 !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) {
4586 /* If our NportID changed, we need to ensure all
4587 * remaining NPORTs get unreg_login'ed so we can
4588 * issue unreg_vpi.
4589 */
4590 list_for_each_entry_safe(np, next_np,
4591 &vport->fc_nodes, nlp_listp) {
4592 if (!NLP_CHK_NODE_ACT(ndlp) ||
4593 (np->nlp_state != NLP_STE_NPR_NODE) ||
4594 !(np->nlp_flag & NLP_NPR_ADISC))
4595 continue;
4596 spin_lock_irq(shost->host_lock);
4597 np->nlp_flag &= ~NLP_NPR_ADISC;
4598 spin_unlock_irq(shost->host_lock);
4599 lpfc_unreg_rpi(vport, np);
4600 }
4601 lpfc_mbx_unreg_vpi(vport);
4602 spin_lock_irq(shost->host_lock);
4603 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
4604 spin_unlock_irq(shost->host_lock);
4605 }
4606
4607 if (vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)
4608 lpfc_register_new_vport(phba, vport, ndlp);
4609 else
4610 lpfc_do_scr_ns_plogi(phba, vport);
4611
4612 /* Unconditionaly kick off releasing fabric node for vports */
4613 lpfc_nlp_put(ndlp);
4614 }
4615
4616 out:
4617 lpfc_els_free_iocb(phba, cmdiocb);
4618 }
4619
4620 static int
4621 lpfc_issue_els_fdisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
4622 uint8_t retry)
4623 {
4624 struct lpfc_hba *phba = vport->phba;
4625 IOCB_t *icmd;
4626 struct lpfc_iocbq *elsiocb;
4627 struct serv_parm *sp;
4628 uint8_t *pcmd;
4629 uint16_t cmdsize;
4630 int did = ndlp->nlp_DID;
4631 int rc;
4632
4633 cmdsize = (sizeof(uint32_t) + sizeof(struct serv_parm));
4634 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp, did,
4635 ELS_CMD_FDISC);
4636 if (!elsiocb) {
4637 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4638 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4639 "0255 Issue FDISC: no IOCB\n");
4640 return 1;
4641 }
4642
4643 icmd = &elsiocb->iocb;
4644 icmd->un.elsreq64.myID = 0;
4645 icmd->un.elsreq64.fl = 1;
4646
4647 /* For FDISC, Let FDISC rsp set the NPortID for this VPI */
4648 icmd->ulpCt_h = 1;
4649 icmd->ulpCt_l = 0;
4650
4651 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
4652 *((uint32_t *) (pcmd)) = ELS_CMD_FDISC;
4653 pcmd += sizeof(uint32_t); /* CSP Word 1 */
4654 memcpy(pcmd, &vport->phba->pport->fc_sparam, sizeof(struct serv_parm));
4655 sp = (struct serv_parm *) pcmd;
4656 /* Setup CSPs accordingly for Fabric */
4657 sp->cmn.e_d_tov = 0;
4658 sp->cmn.w2.r_a_tov = 0;
4659 sp->cls1.classValid = 0;
4660 sp->cls2.seqDelivery = 1;
4661 sp->cls3.seqDelivery = 1;
4662
4663 pcmd += sizeof(uint32_t); /* CSP Word 2 */
4664 pcmd += sizeof(uint32_t); /* CSP Word 3 */
4665 pcmd += sizeof(uint32_t); /* CSP Word 4 */
4666 pcmd += sizeof(uint32_t); /* Port Name */
4667 memcpy(pcmd, &vport->fc_portname, 8);
4668 pcmd += sizeof(uint32_t); /* Node Name */
4669 pcmd += sizeof(uint32_t); /* Node Name */
4670 memcpy(pcmd, &vport->fc_nodename, 8);
4671
4672 lpfc_set_disctmo(vport);
4673
4674 phba->fc_stat.elsXmitFDISC++;
4675 elsiocb->iocb_cmpl = lpfc_cmpl_els_fdisc;
4676
4677 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4678 "Issue FDISC: did:x%x",
4679 did, 0, 0);
4680
4681 rc = lpfc_issue_fabric_iocb(phba, elsiocb);
4682 if (rc == IOCB_ERROR) {
4683 lpfc_els_free_iocb(phba, elsiocb);
4684 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
4685 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
4686 "0256 Issue FDISC: Cannot send IOCB\n");
4687 return 1;
4688 }
4689 lpfc_vport_set_state(vport, FC_VPORT_INITIALIZING);
4690 vport->port_state = LPFC_FDISC;
4691 return 0;
4692 }
4693
4694 static void
4695 lpfc_cmpl_els_npiv_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4696 struct lpfc_iocbq *rspiocb)
4697 {
4698 struct lpfc_vport *vport = cmdiocb->vport;
4699 IOCB_t *irsp;
4700 struct lpfc_nodelist *ndlp;
4701 ndlp = (struct lpfc_nodelist *)cmdiocb->context1;
4702
4703 irsp = &rspiocb->iocb;
4704 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4705 "LOGO npiv cmpl: status:x%x/x%x did:x%x",
4706 irsp->ulpStatus, irsp->un.ulpWord[4], irsp->un.rcvels.remoteID);
4707
4708 lpfc_els_free_iocb(phba, cmdiocb);
4709 vport->unreg_vpi_cmpl = VPORT_ERROR;
4710
4711 /* Trigger the release of the ndlp after logo */
4712 lpfc_nlp_put(ndlp);
4713 }
4714
4715 int
4716 lpfc_issue_els_npiv_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
4717 {
4718 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4719 struct lpfc_hba *phba = vport->phba;
4720 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4721 IOCB_t *icmd;
4722 struct lpfc_iocbq *elsiocb;
4723 uint8_t *pcmd;
4724 uint16_t cmdsize;
4725
4726 cmdsize = 2 * sizeof(uint32_t) + sizeof(struct lpfc_name);
4727 elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, 0, ndlp, ndlp->nlp_DID,
4728 ELS_CMD_LOGO);
4729 if (!elsiocb)
4730 return 1;
4731
4732 icmd = &elsiocb->iocb;
4733 pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
4734 *((uint32_t *) (pcmd)) = ELS_CMD_LOGO;
4735 pcmd += sizeof(uint32_t);
4736
4737 /* Fill in LOGO payload */
4738 *((uint32_t *) (pcmd)) = be32_to_cpu(vport->fc_myDID);
4739 pcmd += sizeof(uint32_t);
4740 memcpy(pcmd, &vport->fc_portname, sizeof(struct lpfc_name));
4741
4742 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4743 "Issue LOGO npiv did:x%x flg:x%x",
4744 ndlp->nlp_DID, ndlp->nlp_flag, 0);
4745
4746 elsiocb->iocb_cmpl = lpfc_cmpl_els_npiv_logo;
4747 spin_lock_irq(shost->host_lock);
4748 ndlp->nlp_flag |= NLP_LOGO_SND;
4749 spin_unlock_irq(shost->host_lock);
4750 if (lpfc_sli_issue_iocb(phba, pring, elsiocb, 0) == IOCB_ERROR) {
4751 spin_lock_irq(shost->host_lock);
4752 ndlp->nlp_flag &= ~NLP_LOGO_SND;
4753 spin_unlock_irq(shost->host_lock);
4754 lpfc_els_free_iocb(phba, elsiocb);
4755 return 1;
4756 }
4757 return 0;
4758 }
4759
4760 void
4761 lpfc_fabric_block_timeout(unsigned long ptr)
4762 {
4763 struct lpfc_hba *phba = (struct lpfc_hba *) ptr;
4764 unsigned long iflags;
4765 uint32_t tmo_posted;
4766
4767 spin_lock_irqsave(&phba->pport->work_port_lock, iflags);
4768 tmo_posted = phba->pport->work_port_events & WORKER_FABRIC_BLOCK_TMO;
4769 if (!tmo_posted)
4770 phba->pport->work_port_events |= WORKER_FABRIC_BLOCK_TMO;
4771 spin_unlock_irqrestore(&phba->pport->work_port_lock, iflags);
4772
4773 if (!tmo_posted)
4774 lpfc_worker_wake_up(phba);
4775 return;
4776 }
4777
4778 static void
4779 lpfc_resume_fabric_iocbs(struct lpfc_hba *phba)
4780 {
4781 struct lpfc_iocbq *iocb;
4782 unsigned long iflags;
4783 int ret;
4784 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4785 IOCB_t *cmd;
4786
4787 repeat:
4788 iocb = NULL;
4789 spin_lock_irqsave(&phba->hbalock, iflags);
4790 /* Post any pending iocb to the SLI layer */
4791 if (atomic_read(&phba->fabric_iocb_count) == 0) {
4792 list_remove_head(&phba->fabric_iocb_list, iocb, typeof(*iocb),
4793 list);
4794 if (iocb)
4795 /* Increment fabric iocb count to hold the position */
4796 atomic_inc(&phba->fabric_iocb_count);
4797 }
4798 spin_unlock_irqrestore(&phba->hbalock, iflags);
4799 if (iocb) {
4800 iocb->fabric_iocb_cmpl = iocb->iocb_cmpl;
4801 iocb->iocb_cmpl = lpfc_cmpl_fabric_iocb;
4802 iocb->iocb_flag |= LPFC_IO_FABRIC;
4803
4804 lpfc_debugfs_disc_trc(iocb->vport, LPFC_DISC_TRC_ELS_CMD,
4805 "Fabric sched1: ste:x%x",
4806 iocb->vport->port_state, 0, 0);
4807
4808 ret = lpfc_sli_issue_iocb(phba, pring, iocb, 0);
4809
4810 if (ret == IOCB_ERROR) {
4811 iocb->iocb_cmpl = iocb->fabric_iocb_cmpl;
4812 iocb->fabric_iocb_cmpl = NULL;
4813 iocb->iocb_flag &= ~LPFC_IO_FABRIC;
4814 cmd = &iocb->iocb;
4815 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4816 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4817 iocb->iocb_cmpl(phba, iocb, iocb);
4818
4819 atomic_dec(&phba->fabric_iocb_count);
4820 goto repeat;
4821 }
4822 }
4823
4824 return;
4825 }
4826
4827 void
4828 lpfc_unblock_fabric_iocbs(struct lpfc_hba *phba)
4829 {
4830 clear_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
4831
4832 lpfc_resume_fabric_iocbs(phba);
4833 return;
4834 }
4835
4836 static void
4837 lpfc_block_fabric_iocbs(struct lpfc_hba *phba)
4838 {
4839 int blocked;
4840
4841 blocked = test_and_set_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
4842 /* Start a timer to unblock fabric iocbs after 100ms */
4843 if (!blocked)
4844 mod_timer(&phba->fabric_block_timer, jiffies + HZ/10 );
4845
4846 return;
4847 }
4848
4849 static void
4850 lpfc_cmpl_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
4851 struct lpfc_iocbq *rspiocb)
4852 {
4853 struct ls_rjt stat;
4854
4855 if ((cmdiocb->iocb_flag & LPFC_IO_FABRIC) != LPFC_IO_FABRIC)
4856 BUG();
4857
4858 switch (rspiocb->iocb.ulpStatus) {
4859 case IOSTAT_NPORT_RJT:
4860 case IOSTAT_FABRIC_RJT:
4861 if (rspiocb->iocb.un.ulpWord[4] & RJT_UNAVAIL_TEMP) {
4862 lpfc_block_fabric_iocbs(phba);
4863 }
4864 break;
4865
4866 case IOSTAT_NPORT_BSY:
4867 case IOSTAT_FABRIC_BSY:
4868 lpfc_block_fabric_iocbs(phba);
4869 break;
4870
4871 case IOSTAT_LS_RJT:
4872 stat.un.lsRjtError =
4873 be32_to_cpu(rspiocb->iocb.un.ulpWord[4]);
4874 if ((stat.un.b.lsRjtRsnCode == LSRJT_UNABLE_TPC) ||
4875 (stat.un.b.lsRjtRsnCode == LSRJT_LOGICAL_BSY))
4876 lpfc_block_fabric_iocbs(phba);
4877 break;
4878 }
4879
4880 if (atomic_read(&phba->fabric_iocb_count) == 0)
4881 BUG();
4882
4883 cmdiocb->iocb_cmpl = cmdiocb->fabric_iocb_cmpl;
4884 cmdiocb->fabric_iocb_cmpl = NULL;
4885 cmdiocb->iocb_flag &= ~LPFC_IO_FABRIC;
4886 cmdiocb->iocb_cmpl(phba, cmdiocb, rspiocb);
4887
4888 atomic_dec(&phba->fabric_iocb_count);
4889 if (!test_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags)) {
4890 /* Post any pending iocbs to HBA */
4891 lpfc_resume_fabric_iocbs(phba);
4892 }
4893 }
4894
4895 static int
4896 lpfc_issue_fabric_iocb(struct lpfc_hba *phba, struct lpfc_iocbq *iocb)
4897 {
4898 unsigned long iflags;
4899 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4900 int ready;
4901 int ret;
4902
4903 if (atomic_read(&phba->fabric_iocb_count) > 1)
4904 BUG();
4905
4906 spin_lock_irqsave(&phba->hbalock, iflags);
4907 ready = atomic_read(&phba->fabric_iocb_count) == 0 &&
4908 !test_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
4909
4910 if (ready)
4911 /* Increment fabric iocb count to hold the position */
4912 atomic_inc(&phba->fabric_iocb_count);
4913 spin_unlock_irqrestore(&phba->hbalock, iflags);
4914 if (ready) {
4915 iocb->fabric_iocb_cmpl = iocb->iocb_cmpl;
4916 iocb->iocb_cmpl = lpfc_cmpl_fabric_iocb;
4917 iocb->iocb_flag |= LPFC_IO_FABRIC;
4918
4919 lpfc_debugfs_disc_trc(iocb->vport, LPFC_DISC_TRC_ELS_CMD,
4920 "Fabric sched2: ste:x%x",
4921 iocb->vport->port_state, 0, 0);
4922
4923 ret = lpfc_sli_issue_iocb(phba, pring, iocb, 0);
4924
4925 if (ret == IOCB_ERROR) {
4926 iocb->iocb_cmpl = iocb->fabric_iocb_cmpl;
4927 iocb->fabric_iocb_cmpl = NULL;
4928 iocb->iocb_flag &= ~LPFC_IO_FABRIC;
4929 atomic_dec(&phba->fabric_iocb_count);
4930 }
4931 } else {
4932 spin_lock_irqsave(&phba->hbalock, iflags);
4933 list_add_tail(&iocb->list, &phba->fabric_iocb_list);
4934 spin_unlock_irqrestore(&phba->hbalock, iflags);
4935 ret = IOCB_SUCCESS;
4936 }
4937 return ret;
4938 }
4939
4940
4941 static void lpfc_fabric_abort_vport(struct lpfc_vport *vport)
4942 {
4943 LIST_HEAD(completions);
4944 struct lpfc_hba *phba = vport->phba;
4945 struct lpfc_iocbq *tmp_iocb, *piocb;
4946 IOCB_t *cmd;
4947
4948 spin_lock_irq(&phba->hbalock);
4949 list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list,
4950 list) {
4951
4952 if (piocb->vport != vport)
4953 continue;
4954
4955 list_move_tail(&piocb->list, &completions);
4956 }
4957 spin_unlock_irq(&phba->hbalock);
4958
4959 while (!list_empty(&completions)) {
4960 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
4961 list_del_init(&piocb->list);
4962
4963 cmd = &piocb->iocb;
4964 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4965 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4966 (piocb->iocb_cmpl) (phba, piocb, piocb);
4967 }
4968 }
4969
4970 void lpfc_fabric_abort_nport(struct lpfc_nodelist *ndlp)
4971 {
4972 LIST_HEAD(completions);
4973 struct lpfc_hba *phba = ndlp->vport->phba;
4974 struct lpfc_iocbq *tmp_iocb, *piocb;
4975 struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
4976 IOCB_t *cmd;
4977
4978 spin_lock_irq(&phba->hbalock);
4979 list_for_each_entry_safe(piocb, tmp_iocb, &phba->fabric_iocb_list,
4980 list) {
4981 if ((lpfc_check_sli_ndlp(phba, pring, piocb, ndlp))) {
4982
4983 list_move_tail(&piocb->list, &completions);
4984 }
4985 }
4986 spin_unlock_irq(&phba->hbalock);
4987
4988 while (!list_empty(&completions)) {
4989 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
4990 list_del_init(&piocb->list);
4991
4992 cmd = &piocb->iocb;
4993 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
4994 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
4995 (piocb->iocb_cmpl) (phba, piocb, piocb);
4996 }
4997 }
4998
4999 void lpfc_fabric_abort_hba(struct lpfc_hba *phba)
5000 {
5001 LIST_HEAD(completions);
5002 struct lpfc_iocbq *piocb;
5003 IOCB_t *cmd;
5004
5005 spin_lock_irq(&phba->hbalock);
5006 list_splice_init(&phba->fabric_iocb_list, &completions);
5007 spin_unlock_irq(&phba->hbalock);
5008
5009 while (!list_empty(&completions)) {
5010 piocb = list_get_first(&completions, struct lpfc_iocbq, list);
5011 list_del_init(&piocb->list);
5012
5013 cmd = &piocb->iocb;
5014 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
5015 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
5016 (piocb->iocb_cmpl) (phba, piocb, piocb);
5017 }
5018 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree