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