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