drivers/scsi/lpfc/lpfc_hbadisc.c

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2004-2012 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
   8  *                                                                 *
   9  * This program is free software; you can redistribute it and/or   *
  10  * modify it under the terms of version 2 of the GNU General       *
  11  * Public License as published by the Free Software Foundation.    *
  12  * This program is distributed in the hope that it will be useful. *
  13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  18  * more details, a copy of which can be found in the file COPYING  *
  19  * included with this package.                                     *
  20  *******************************************************************/
  21
  22 #include <linux/blkdev.h>
  23 #include <linux/delay.h>
  24 #include <linux/slab.h>
  25 #include <linux/pci.h>
  26 #include <linux/kthread.h>
  27 #include <linux/interrupt.h>
  28
  29 #include <scsi/scsi.h>
  30 #include <scsi/scsi_device.h>
  31 #include <scsi/scsi_host.h>
  32 #include <scsi/scsi_transport_fc.h>
  33
  34 #include "lpfc_hw4.h"
  35 #include "lpfc_hw.h"
  36 #include "lpfc_nl.h"
  37 #include "lpfc_disc.h"
  38 #include "lpfc_sli.h"
  39 #include "lpfc_sli4.h"
  40 #include "lpfc_scsi.h"
  41 #include "lpfc.h"
  42 #include "lpfc_logmsg.h"
  43 #include "lpfc_crtn.h"
  44 #include "lpfc_vport.h"
  45 #include "lpfc_debugfs.h"
  46
  47 /* AlpaArray for assignment of scsid for scan-down and bind_method */
  48 static uint8_t lpfcAlpaArray[] = {
  49         0xEF, 0xE8, 0xE4, 0xE2, 0xE1, 0xE0, 0xDC, 0xDA, 0xD9, 0xD6,
  50         0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xCE, 0xCD, 0xCC, 0xCB, 0xCA,
  51         0xC9, 0xC7, 0xC6, 0xC5, 0xC3, 0xBC, 0xBA, 0xB9, 0xB6, 0xB5,
  52         0xB4, 0xB3, 0xB2, 0xB1, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9,
  53         0xA7, 0xA6, 0xA5, 0xA3, 0x9F, 0x9E, 0x9D, 0x9B, 0x98, 0x97,
  54         0x90, 0x8F, 0x88, 0x84, 0x82, 0x81, 0x80, 0x7C, 0x7A, 0x79,
  55         0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x6E, 0x6D, 0x6C, 0x6B,
  56         0x6A, 0x69, 0x67, 0x66, 0x65, 0x63, 0x5C, 0x5A, 0x59, 0x56,
  57         0x55, 0x54, 0x53, 0x52, 0x51, 0x4E, 0x4D, 0x4C, 0x4B, 0x4A,
  58         0x49, 0x47, 0x46, 0x45, 0x43, 0x3C, 0x3A, 0x39, 0x36, 0x35,
  59         0x34, 0x33, 0x32, 0x31, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29,
  60         0x27, 0x26, 0x25, 0x23, 0x1F, 0x1E, 0x1D, 0x1B, 0x18, 0x17,
  61         0x10, 0x0F, 0x08, 0x04, 0x02, 0x01
  62 };
  63
  64 static void lpfc_disc_timeout_handler(struct lpfc_vport *);
  65 static void lpfc_disc_flush_list(struct lpfc_vport *vport);
  66 static void lpfc_unregister_fcfi_cmpl(struct lpfc_hba *, LPFC_MBOXQ_t *);
  67 static int lpfc_fcf_inuse(struct lpfc_hba *);
  68
  69 void
  70 lpfc_terminate_rport_io(struct fc_rport *rport)
  71 {
  72         struct lpfc_rport_data *rdata;
  73         struct lpfc_nodelist * ndlp;
  74         struct lpfc_hba *phba;
  75
  76         rdata = rport->dd_data;
  77         ndlp = rdata->pnode;
  78
  79         if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
  80                 if (rport->roles & FC_RPORT_ROLE_FCP_TARGET)
  81                         printk(KERN_ERR "Cannot find remote node"
  82                         " to terminate I/O Data x%x\n",
  83                         rport->port_id);
  84                 return;
  85         }
  86
  87         phba  = ndlp->phba;
  88
  89         lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_RPORT,
  90                 "rport terminate: sid:x%x did:x%x flg:x%x",
  91                 ndlp->nlp_sid, ndlp->nlp_DID, ndlp->nlp_flag);
  92
  93         if (ndlp->nlp_sid != NLP_NO_SID) {
  94                 lpfc_sli_abort_iocb(ndlp->vport,
  95                         &phba->sli.ring[phba->sli.fcp_ring],
  96                         ndlp->nlp_sid, 0, LPFC_CTX_TGT);
  97         }
  98 }
  99
 100 /*
 101  * This function will be called when dev_loss_tmo fire.
 102  */
 103 void
 104 lpfc_dev_loss_tmo_callbk(struct fc_rport *rport)
 105 {
 106         struct lpfc_rport_data *rdata;
 107         struct lpfc_nodelist * ndlp;
 108         struct lpfc_vport *vport;
 109         struct lpfc_hba   *phba;
 110         struct lpfc_work_evt *evtp;
 111         int  put_node;
 112         int  put_rport;
 113
 114         rdata = rport->dd_data;
 115         ndlp = rdata->pnode;
 116         if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
 117                 return;
 118
 119         vport = ndlp->vport;
 120         phba  = vport->phba;
 121
 122         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT,
 123                 "rport devlosscb: sid:x%x did:x%x flg:x%x",
 124                 ndlp->nlp_sid, ndlp->nlp_DID, ndlp->nlp_flag);
 125
 126         lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE,
 127                          "3181 dev_loss_callbk x%06x, rport %p flg x%x\n",
 128                          ndlp->nlp_DID, ndlp->rport, ndlp->nlp_flag);
 129
 130         /* Don't defer this if we are in the process of deleting the vport
 131          * or unloading the driver. The unload will cleanup the node
 132          * appropriately we just need to cleanup the ndlp rport info here.
 133          */
 134         if (vport->load_flag & FC_UNLOADING) {
 135                 put_node = rdata->pnode != NULL;
 136                 put_rport = ndlp->rport != NULL;
 137                 rdata->pnode = NULL;
 138                 ndlp->rport = NULL;
 139                 if (put_node)
 140                         lpfc_nlp_put(ndlp);
 141                 if (put_rport)
 142                         put_device(&rport->dev);
 143                 return;
 144         }
 145
 146         if (ndlp->nlp_state == NLP_STE_MAPPED_NODE)
 147                 return;
 148
 149         if (ndlp->nlp_type & NLP_FABRIC) {
 150
 151                 /* If the WWPN of the rport and ndlp don't match, ignore it */
 152                 if (rport->port_name != wwn_to_u64(ndlp->nlp_portname.u.wwn)) {
 153                         put_device(&rport->dev);
 154                         return;
 155                 }
 156         }
 157
 158         evtp = &ndlp->dev_loss_evt;
 159
 160         if (!list_empty(&evtp->evt_listp))
 161                 return;
 162
 163         spin_lock_irq(&phba->hbalock);
 164         /* We need to hold the node by incrementing the reference
 165          * count until this queued work is done
 166          */
 167         evtp->evt_arg1  = lpfc_nlp_get(ndlp);
 168         if (evtp->evt_arg1) {
 169                 evtp->evt = LPFC_EVT_DEV_LOSS;
 170                 list_add_tail(&evtp->evt_listp, &phba->work_list);
 171                 lpfc_worker_wake_up(phba);
 172         }
 173         spin_unlock_irq(&phba->hbalock);
 174
 175         return;
 176 }
 177
 178 /**
 179  * lpfc_dev_loss_tmo_handler - Remote node devloss timeout handler
 180  * @ndlp: Pointer to remote node object.
 181  *
 182  * This function is called from the worker thread when devloss timeout timer
 183  * expires. For SLI4 host, this routine shall return 1 when at lease one
 184  * remote node, including this @ndlp, is still in use of FCF; otherwise, this
 185  * routine shall return 0 when there is no remote node is still in use of FCF
 186  * when devloss timeout happened to this @ndlp.
 187  **/
 188 static int
 189 lpfc_dev_loss_tmo_handler(struct lpfc_nodelist *ndlp)
 190 {
 191         struct lpfc_rport_data *rdata;
 192         struct fc_rport   *rport;
 193         struct lpfc_vport *vport;
 194         struct lpfc_hba   *phba;
 195         uint8_t *name;
 196         int  put_node;
 197         int  put_rport;
 198         int warn_on = 0;
 199         int fcf_inuse = 0;
 200
 201         rport = ndlp->rport;
 202
 203         if (!rport)
 204                 return fcf_inuse;
 205
 206         rdata = rport->dd_data;
 207         name = (uint8_t *) &ndlp->nlp_portname;
 208         vport = ndlp->vport;
 209         phba  = vport->phba;
 210
 211         if (phba->sli_rev == LPFC_SLI_REV4)
 212                 fcf_inuse = lpfc_fcf_inuse(phba);
 213
 214         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT,
 215                 "rport devlosstmo:did:x%x type:x%x id:x%x",
 216                 ndlp->nlp_DID, ndlp->nlp_type, rport->scsi_target_id);
 217
 218         lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE,
 219                          "3182 dev_loss_tmo_handler x%06x, rport %p flg x%x\n",
 220                          ndlp->nlp_DID, ndlp->rport, ndlp->nlp_flag);
 221
 222         /* Don't defer this if we are in the process of deleting the vport
 223          * or unloading the driver. The unload will cleanup the node
 224          * appropriately we just need to cleanup the ndlp rport info here.
 225          */
 226         if (vport->load_flag & FC_UNLOADING) {
 227                 if (ndlp->nlp_sid != NLP_NO_SID) {
 228                         /* flush the target */
 229                         lpfc_sli_abort_iocb(vport,
 230                                         &phba->sli.ring[phba->sli.fcp_ring],
 231                                         ndlp->nlp_sid, 0, LPFC_CTX_TGT);
 232                 }
 233                 put_node = rdata->pnode != NULL;
 234                 put_rport = ndlp->rport != NULL;
 235                 rdata->pnode = NULL;
 236                 ndlp->rport = NULL;
 237                 if (put_node)
 238                         lpfc_nlp_put(ndlp);
 239                 if (put_rport)
 240                         put_device(&rport->dev);
 241                 return fcf_inuse;
 242         }
 243
 244         if (ndlp->nlp_state == NLP_STE_MAPPED_NODE) {
 245                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 246                                  "0284 Devloss timeout Ignored on "
 247                                  "WWPN %x:%x:%x:%x:%x:%x:%x:%x "
 248                                  "NPort x%x\n",
 249                                  *name, *(name+1), *(name+2), *(name+3),
 250                                  *(name+4), *(name+5), *(name+6), *(name+7),
 251                                  ndlp->nlp_DID);
 252                 return fcf_inuse;
 253         }
 254
 255         if (ndlp->nlp_type & NLP_FABRIC) {
 256                 /* We will clean up these Nodes in linkup */
 257                 put_node = rdata->pnode != NULL;
 258                 put_rport = ndlp->rport != NULL;
 259                 rdata->pnode = NULL;
 260                 ndlp->rport = NULL;
 261                 if (put_node)
 262                         lpfc_nlp_put(ndlp);
 263                 if (put_rport)
 264                         put_device(&rport->dev);
 265                 return fcf_inuse;
 266         }
 267
 268         if (ndlp->nlp_sid != NLP_NO_SID) {
 269                 warn_on = 1;
 270                 /* flush the target */
 271                 lpfc_sli_abort_iocb(vport, &phba->sli.ring[phba->sli.fcp_ring],
 272                                     ndlp->nlp_sid, 0, LPFC_CTX_TGT);
 273         }
 274
 275         if (warn_on) {
 276                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
 277                                  "0203 Devloss timeout on "
 278                                  "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x "
 279                                  "NPort x%06x Data: x%x x%x x%x\n",
 280                                  *name, *(name+1), *(name+2), *(name+3),
 281                                  *(name+4), *(name+5), *(name+6), *(name+7),
 282                                  ndlp->nlp_DID, ndlp->nlp_flag,
 283                                  ndlp->nlp_state, ndlp->nlp_rpi);
 284         } else {
 285                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 286                                  "0204 Devloss timeout on "
 287                                  "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x "
 288                                  "NPort x%06x Data: x%x x%x x%x\n",
 289                                  *name, *(name+1), *(name+2), *(name+3),
 290                                  *(name+4), *(name+5), *(name+6), *(name+7),
 291                                  ndlp->nlp_DID, ndlp->nlp_flag,
 292                                  ndlp->nlp_state, ndlp->nlp_rpi);
 293         }
 294
 295         put_node = rdata->pnode != NULL;
 296         put_rport = ndlp->rport != NULL;
 297         rdata->pnode = NULL;
 298         ndlp->rport = NULL;
 299         if (put_node)
 300                 lpfc_nlp_put(ndlp);
 301         if (put_rport)
 302                 put_device(&rport->dev);
 303
 304         if (!(vport->load_flag & FC_UNLOADING) &&
 305             !(ndlp->nlp_flag & NLP_DELAY_TMO) &&
 306             !(ndlp->nlp_flag & NLP_NPR_2B_DISC) &&
 307             (ndlp->nlp_state != NLP_STE_UNMAPPED_NODE) &&
 308             (ndlp->nlp_state != NLP_STE_REG_LOGIN_ISSUE) &&
 309             (ndlp->nlp_state != NLP_STE_PRLI_ISSUE))
 310                 lpfc_disc_state_machine(vport, ndlp, NULL, NLP_EVT_DEVICE_RM);
 311
 312         return fcf_inuse;
 313 }
 314
 315 /**
 316  * lpfc_sli4_post_dev_loss_tmo_handler - SLI4 post devloss timeout handler
 317  * @phba: Pointer to hba context object.
 318  * @fcf_inuse: SLI4 FCF in-use state reported from devloss timeout handler.
 319  * @nlp_did: remote node identifer with devloss timeout.
 320  *
 321  * This function is called from the worker thread after invoking devloss
 322  * timeout handler and releasing the reference count for the ndlp with
 323  * which the devloss timeout was handled for SLI4 host. For the devloss
 324  * timeout of the last remote node which had been in use of FCF, when this
 325  * routine is invoked, it shall be guaranteed that none of the remote are
 326  * in-use of FCF. When devloss timeout to the last remote using the FCF,
 327  * if the FIP engine is neither in FCF table scan process nor roundrobin
 328  * failover process, the in-use FCF shall be unregistered. If the FIP
 329  * engine is in FCF discovery process, the devloss timeout state shall
 330  * be set for either the FCF table scan process or roundrobin failover
 331  * process to unregister the in-use FCF.
 332  **/
 333 static void
 334 lpfc_sli4_post_dev_loss_tmo_handler(struct lpfc_hba *phba, int fcf_inuse,
 335                                     uint32_t nlp_did)
 336 {
 337         /* If devloss timeout happened to a remote node when FCF had no
 338          * longer been in-use, do nothing.
 339          */
 340         if (!fcf_inuse)
 341                 return;
 342
 343         if ((phba->hba_flag & HBA_FIP_SUPPORT) && !lpfc_fcf_inuse(phba)) {
 344                 spin_lock_irq(&phba->hbalock);
 345                 if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
 346                         if (phba->hba_flag & HBA_DEVLOSS_TMO) {
 347                                 spin_unlock_irq(&phba->hbalock);
 348                                 return;
 349                         }
 350                         phba->hba_flag |= HBA_DEVLOSS_TMO;
 351                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
 352                                         "2847 Last remote node (x%x) using "
 353                                         "FCF devloss tmo\n", nlp_did);
 354                 }
 355                 if (phba->fcf.fcf_flag & FCF_REDISC_PROG) {
 356                         spin_unlock_irq(&phba->hbalock);
 357                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
 358                                         "2868 Devloss tmo to FCF rediscovery "
 359                                         "in progress\n");
 360                         return;
 361                 }
 362                 if (!(phba->hba_flag & (FCF_TS_INPROG | FCF_RR_INPROG))) {
 363                         spin_unlock_irq(&phba->hbalock);
 364                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
 365                                         "2869 Devloss tmo to idle FIP engine, "
 366                                         "unreg in-use FCF and rescan.\n");
 367                         /* Unregister in-use FCF and rescan */
 368                         lpfc_unregister_fcf_rescan(phba);
 369                         return;
 370                 }
 371                 spin_unlock_irq(&phba->hbalock);
 372                 if (phba->hba_flag & FCF_TS_INPROG)
 373                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
 374                                         "2870 FCF table scan in progress\n");
 375                 if (phba->hba_flag & FCF_RR_INPROG)
 376                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
 377                                         "2871 FLOGI roundrobin FCF failover "
 378                                         "in progress\n");
 379         }
 380         lpfc_unregister_unused_fcf(phba);
 381 }
 382
 383 /**
 384  * lpfc_alloc_fast_evt - Allocates data structure for posting event
 385  * @phba: Pointer to hba context object.
 386  *
 387  * This function is called from the functions which need to post
 388  * events from interrupt context. This function allocates data
 389  * structure required for posting event. It also keeps track of
 390  * number of events pending and prevent event storm when there are
 391  * too many events.
 392  **/
 393 struct lpfc_fast_path_event *
 394 lpfc_alloc_fast_evt(struct lpfc_hba *phba) {
 395         struct lpfc_fast_path_event *ret;
 396
 397         /* If there are lot of fast event do not exhaust memory due to this */
 398         if (atomic_read(&phba->fast_event_count) > LPFC_MAX_EVT_COUNT)
 399                 return NULL;
 400
 401         ret = kzalloc(sizeof(struct lpfc_fast_path_event),
 402                         GFP_ATOMIC);
 403         if (ret) {
 404                 atomic_inc(&phba->fast_event_count);
 405                 INIT_LIST_HEAD(&ret->work_evt.evt_listp);
 406                 ret->work_evt.evt = LPFC_EVT_FASTPATH_MGMT_EVT;
 407         }
 408         return ret;
 409 }
 410
 411 /**
 412  * lpfc_free_fast_evt - Frees event data structure
 413  * @phba: Pointer to hba context object.
 414  * @evt:  Event object which need to be freed.
 415  *
 416  * This function frees the data structure required for posting
 417  * events.
 418  **/
 419 void
 420 lpfc_free_fast_evt(struct lpfc_hba *phba,
 421                 struct lpfc_fast_path_event *evt) {
 422
 423         atomic_dec(&phba->fast_event_count);
 424         kfree(evt);
 425 }
 426
 427 /**
 428  * lpfc_send_fastpath_evt - Posts events generated from fast path
 429  * @phba: Pointer to hba context object.
 430  * @evtp: Event data structure.
 431  *
 432  * This function is called from worker thread, when the interrupt
 433  * context need to post an event. This function posts the event
 434  * to fc transport netlink interface.
 435  **/
 436 static void
 437 lpfc_send_fastpath_evt(struct lpfc_hba *phba,
 438                 struct lpfc_work_evt *evtp)
 439 {
 440         unsigned long evt_category, evt_sub_category;
 441         struct lpfc_fast_path_event *fast_evt_data;
 442         char *evt_data;
 443         uint32_t evt_data_size;
 444         struct Scsi_Host *shost;
 445
 446         fast_evt_data = container_of(evtp, struct lpfc_fast_path_event,
 447                 work_evt);
 448
 449         evt_category = (unsigned long) fast_evt_data->un.fabric_evt.event_type;
 450         evt_sub_category = (unsigned long) fast_evt_data->un.
 451                         fabric_evt.subcategory;
 452         shost = lpfc_shost_from_vport(fast_evt_data->vport);
 453         if (evt_category == FC_REG_FABRIC_EVENT) {
 454                 if (evt_sub_category == LPFC_EVENT_FCPRDCHKERR) {
 455                         evt_data = (char *) &fast_evt_data->un.read_check_error;
 456                         evt_data_size = sizeof(fast_evt_data->un.
 457                                 read_check_error);
 458                 } else if ((evt_sub_category == LPFC_EVENT_FABRIC_BUSY) ||
 459                         (evt_sub_category == LPFC_EVENT_PORT_BUSY)) {
 460                         evt_data = (char *) &fast_evt_data->un.fabric_evt;
 461                         evt_data_size = sizeof(fast_evt_data->un.fabric_evt);
 462                 } else {
 463                         lpfc_free_fast_evt(phba, fast_evt_data);
 464                         return;
 465                 }
 466         } else if (evt_category == FC_REG_SCSI_EVENT) {
 467                 switch (evt_sub_category) {
 468                 case LPFC_EVENT_QFULL:
 469                 case LPFC_EVENT_DEVBSY:
 470                         evt_data = (char *) &fast_evt_data->un.scsi_evt;
 471                         evt_data_size = sizeof(fast_evt_data->un.scsi_evt);
 472                         break;
 473                 case LPFC_EVENT_CHECK_COND:
 474                         evt_data = (char *) &fast_evt_data->un.check_cond_evt;
 475                         evt_data_size =  sizeof(fast_evt_data->un.
 476                                 check_cond_evt);
 477                         break;
 478                 case LPFC_EVENT_VARQUEDEPTH:
 479                         evt_data = (char *) &fast_evt_data->un.queue_depth_evt;
 480                         evt_data_size = sizeof(fast_evt_data->un.
 481                                 queue_depth_evt);
 482                         break;
 483                 default:
 484                         lpfc_free_fast_evt(phba, fast_evt_data);
 485                         return;
 486                 }
 487         } else {
 488                 lpfc_free_fast_evt(phba, fast_evt_data);
 489                 return;
 490         }
 491
 492         fc_host_post_vendor_event(shost,
 493                 fc_get_event_number(),
 494                 evt_data_size,
 495                 evt_data,
 496                 LPFC_NL_VENDOR_ID);
 497
 498         lpfc_free_fast_evt(phba, fast_evt_data);
 499         return;
 500 }
 501
 502 static void
 503 lpfc_work_list_done(struct lpfc_hba *phba)
 504 {
 505         struct lpfc_work_evt  *evtp = NULL;
 506         struct lpfc_nodelist  *ndlp;
 507         int free_evt;
 508         int fcf_inuse;
 509         uint32_t nlp_did;
 510
 511         spin_lock_irq(&phba->hbalock);
 512         while (!list_empty(&phba->work_list)) {
 513                 list_remove_head((&phba->work_list), evtp, typeof(*evtp),
 514                                  evt_listp);
 515                 spin_unlock_irq(&phba->hbalock);
 516                 free_evt = 1;
 517                 switch (evtp->evt) {
 518                 case LPFC_EVT_ELS_RETRY:
 519                         ndlp = (struct lpfc_nodelist *) (evtp->evt_arg1);
 520                         lpfc_els_retry_delay_handler(ndlp);
 521                         free_evt = 0; /* evt is part of ndlp */
 522                         /* decrement the node reference count held
 523                          * for this queued work
 524                          */
 525                         lpfc_nlp_put(ndlp);
 526                         break;
 527                 case LPFC_EVT_DEV_LOSS:
 528                         ndlp = (struct lpfc_nodelist *)(evtp->evt_arg1);
 529                         fcf_inuse = lpfc_dev_loss_tmo_handler(ndlp);
 530                         free_evt = 0;
 531                         /* decrement the node reference count held for
 532                          * this queued work
 533                          */
 534                         nlp_did = ndlp->nlp_DID;
 535                         lpfc_nlp_put(ndlp);
 536                         if (phba->sli_rev == LPFC_SLI_REV4)
 537                                 lpfc_sli4_post_dev_loss_tmo_handler(phba,
 538                                                                     fcf_inuse,
 539                                                                     nlp_did);
 540                         break;
 541                 case LPFC_EVT_ONLINE:
 542                         if (phba->link_state < LPFC_LINK_DOWN)
 543                                 *(int *) (evtp->evt_arg1) = lpfc_online(phba);
 544                         else
 545                                 *(int *) (evtp->evt_arg1) = 0;
 546                         complete((struct completion *)(evtp->evt_arg2));
 547                         break;
 548                 case LPFC_EVT_OFFLINE_PREP:
 549                         if (phba->link_state >= LPFC_LINK_DOWN)
 550                                 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
 551                         *(int *)(evtp->evt_arg1) = 0;
 552                         complete((struct completion *)(evtp->evt_arg2));
 553                         break;
 554                 case LPFC_EVT_OFFLINE:
 555                         lpfc_offline(phba);
 556                         lpfc_sli_brdrestart(phba);
 557                         *(int *)(evtp->evt_arg1) =
 558                                 lpfc_sli_brdready(phba, HS_FFRDY | HS_MBRDY);
 559                         lpfc_unblock_mgmt_io(phba);
 560                         complete((struct completion *)(evtp->evt_arg2));
 561                         break;
 562                 case LPFC_EVT_WARM_START:
 563                         lpfc_offline(phba);
 564                         lpfc_reset_barrier(phba);
 565                         lpfc_sli_brdreset(phba);
 566                         lpfc_hba_down_post(phba);
 567                         *(int *)(evtp->evt_arg1) =
 568                                 lpfc_sli_brdready(phba, HS_MBRDY);
 569                         lpfc_unblock_mgmt_io(phba);
 570                         complete((struct completion *)(evtp->evt_arg2));
 571                         break;
 572                 case LPFC_EVT_KILL:
 573                         lpfc_offline(phba);
 574                         *(int *)(evtp->evt_arg1)
 575                                 = (phba->pport->stopped)
 576                                         ? 0 : lpfc_sli_brdkill(phba);
 577                         lpfc_unblock_mgmt_io(phba);
 578                         complete((struct completion *)(evtp->evt_arg2));
 579                         break;
 580                 case LPFC_EVT_FASTPATH_MGMT_EVT:
 581                         lpfc_send_fastpath_evt(phba, evtp);
 582                         free_evt = 0;
 583                         break;
 584                 case LPFC_EVT_RESET_HBA:
 585                         if (!(phba->pport->load_flag & FC_UNLOADING))
 586                                 lpfc_reset_hba(phba);
 587                         break;
 588                 }
 589                 if (free_evt)
 590                         kfree(evtp);
 591                 spin_lock_irq(&phba->hbalock);
 592         }
 593         spin_unlock_irq(&phba->hbalock);
 594
 595 }
 596
 597 static void
 598 lpfc_work_done(struct lpfc_hba *phba)
 599 {
 600         struct lpfc_sli_ring *pring;
 601         uint32_t ha_copy, status, control, work_port_events;
 602         struct lpfc_vport **vports;
 603         struct lpfc_vport *vport;
 604         int i;
 605
 606         spin_lock_irq(&phba->hbalock);
 607         ha_copy = phba->work_ha;
 608         phba->work_ha = 0;
 609         spin_unlock_irq(&phba->hbalock);
 610
 611         /* First, try to post the next mailbox command to SLI4 device */
 612         if (phba->pci_dev_grp == LPFC_PCI_DEV_OC)
 613                 lpfc_sli4_post_async_mbox(phba);
 614
 615         if (ha_copy & HA_ERATT)
 616                 /* Handle the error attention event */
 617                 lpfc_handle_eratt(phba);
 618
 619         if (ha_copy & HA_MBATT)
 620                 lpfc_sli_handle_mb_event(phba);
 621
 622         if (ha_copy & HA_LATT)
 623                 lpfc_handle_latt(phba);
 624
 625         /* Process SLI4 events */
 626         if (phba->pci_dev_grp == LPFC_PCI_DEV_OC) {
 627                 if (phba->hba_flag & HBA_RRQ_ACTIVE)
 628                         lpfc_handle_rrq_active(phba);
 629                 if (phba->hba_flag & FCP_XRI_ABORT_EVENT)
 630                         lpfc_sli4_fcp_xri_abort_event_proc(phba);
 631                 if (phba->hba_flag & ELS_XRI_ABORT_EVENT)
 632                         lpfc_sli4_els_xri_abort_event_proc(phba);
 633                 if (phba->hba_flag & ASYNC_EVENT)
 634                         lpfc_sli4_async_event_proc(phba);
 635                 if (phba->hba_flag & HBA_POST_RECEIVE_BUFFER) {
 636                         spin_lock_irq(&phba->hbalock);
 637                         phba->hba_flag &= ~HBA_POST_RECEIVE_BUFFER;
 638                         spin_unlock_irq(&phba->hbalock);
 639                         lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
 640                 }
 641                 if (phba->fcf.fcf_flag & FCF_REDISC_EVT)
 642                         lpfc_sli4_fcf_redisc_event_proc(phba);
 643         }
 644
 645         vports = lpfc_create_vport_work_array(phba);
 646         if (vports != NULL)
 647                 for (i = 0; i <= phba->max_vports; i++) {
 648                         /*
 649                          * We could have no vports in array if unloading, so if
 650                          * this happens then just use the pport
 651                          */
 652                         if (vports[i] == NULL && i == 0)
 653                                 vport = phba->pport;
 654                         else
 655                                 vport = vports[i];
 656                         if (vport == NULL)
 657                                 break;
 658                         spin_lock_irq(&vport->work_port_lock);
 659                         work_port_events = vport->work_port_events;
 660                         vport->work_port_events &= ~work_port_events;
 661                         spin_unlock_irq(&vport->work_port_lock);
 662                         if (work_port_events & WORKER_DISC_TMO)
 663                                 lpfc_disc_timeout_handler(vport);
 664                         if (work_port_events & WORKER_ELS_TMO)
 665                                 lpfc_els_timeout_handler(vport);
 666                         if (work_port_events & WORKER_HB_TMO)
 667                                 lpfc_hb_timeout_handler(phba);
 668                         if (work_port_events & WORKER_MBOX_TMO)
 669                                 lpfc_mbox_timeout_handler(phba);
 670                         if (work_port_events & WORKER_FABRIC_BLOCK_TMO)
 671                                 lpfc_unblock_fabric_iocbs(phba);
 672                         if (work_port_events & WORKER_FDMI_TMO)
 673                                 lpfc_fdmi_timeout_handler(vport);
 674                         if (work_port_events & WORKER_RAMP_DOWN_QUEUE)
 675                                 lpfc_ramp_down_queue_handler(phba);
 676                         if (work_port_events & WORKER_RAMP_UP_QUEUE)
 677                                 lpfc_ramp_up_queue_handler(phba);
 678                         if (work_port_events & WORKER_DELAYED_DISC_TMO)
 679                                 lpfc_delayed_disc_timeout_handler(vport);
 680                 }
 681         lpfc_destroy_vport_work_array(phba, vports);
 682
 683         pring = &phba->sli.ring[LPFC_ELS_RING];
 684         status = (ha_copy & (HA_RXMASK  << (4*LPFC_ELS_RING)));
 685         status >>= (4*LPFC_ELS_RING);
 686         if ((status & HA_RXMASK) ||
 687             (pring->flag & LPFC_DEFERRED_RING_EVENT) ||
 688             (phba->hba_flag & HBA_SP_QUEUE_EVT)) {
 689                 if (pring->flag & LPFC_STOP_IOCB_EVENT) {
 690                         pring->flag |= LPFC_DEFERRED_RING_EVENT;
 691                         /* Set the lpfc data pending flag */
 692                         set_bit(LPFC_DATA_READY, &phba->data_flags);
 693                 } else {
 694                         if (phba->link_state >= LPFC_LINK_UP) {
 695                                 pring->flag &= ~LPFC_DEFERRED_RING_EVENT;
 696                                 lpfc_sli_handle_slow_ring_event(phba, pring,
 697                                                                 (status &
 698                                                                 HA_RXMASK));
 699                         }
 700                 }
 701                 if ((phba->sli_rev == LPFC_SLI_REV4) &
 702                                  (!list_empty(&pring->txq)))
 703                         lpfc_drain_txq(phba);
 704                 /*
 705                  * Turn on Ring interrupts
 706                  */
 707                 if (phba->sli_rev <= LPFC_SLI_REV3) {
 708                         spin_lock_irq(&phba->hbalock);
 709                         control = readl(phba->HCregaddr);
 710                         if (!(control & (HC_R0INT_ENA << LPFC_ELS_RING))) {
 711                                 lpfc_debugfs_slow_ring_trc(phba,
 712                                         "WRK Enable ring: cntl:x%x hacopy:x%x",
 713                                         control, ha_copy, 0);
 714
 715                                 control |= (HC_R0INT_ENA << LPFC_ELS_RING);
 716                                 writel(control, phba->HCregaddr);
 717                                 readl(phba->HCregaddr); /* flush */
 718                         } else {
 719                                 lpfc_debugfs_slow_ring_trc(phba,
 720                                         "WRK Ring ok:     cntl:x%x hacopy:x%x",
 721                                         control, ha_copy, 0);
 722                         }
 723                         spin_unlock_irq(&phba->hbalock);
 724                 }
 725         }
 726         lpfc_work_list_done(phba);
 727 }
 728
 729 int
 730 lpfc_do_work(void *p)
 731 {
 732         struct lpfc_hba *phba = p;
 733         int rc;
 734
 735         set_user_nice(current, -20);
 736         current->flags |= PF_NOFREEZE;
 737         phba->data_flags = 0;
 738
 739         while (!kthread_should_stop()) {
 740                 /* wait and check worker queue activities */
 741                 rc = wait_event_interruptible(phba->work_waitq,
 742                                         (test_and_clear_bit(LPFC_DATA_READY,
 743                                                             &phba->data_flags)
 744                                          || kthread_should_stop()));
 745                 /* Signal wakeup shall terminate the worker thread */
 746                 if (rc) {
 747                         lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
 748                                         "0433 Wakeup on signal: rc=x%x\n", rc);
 749                         break;
 750                 }
 751
 752                 /* Attend pending lpfc data processing */
 753                 lpfc_work_done(phba);
 754         }
 755         phba->worker_thread = NULL;
 756         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
 757                         "0432 Worker thread stopped.\n");
 758         return 0;
 759 }
 760
 761 /*
 762  * This is only called to handle FC worker events. Since this a rare
 763  * occurrence, we allocate a struct lpfc_work_evt structure here instead of
 764  * embedding it in the IOCB.
 765  */
 766 int
 767 lpfc_workq_post_event(struct lpfc_hba *phba, void *arg1, void *arg2,
 768                       uint32_t evt)
 769 {
 770         struct lpfc_work_evt  *evtp;
 771         unsigned long flags;
 772
 773         /*
 774          * All Mailbox completions and LPFC_ELS_RING rcv ring IOCB events will
 775          * be queued to worker thread for processing
 776          */
 777         evtp = kmalloc(sizeof(struct lpfc_work_evt), GFP_ATOMIC);
 778         if (!evtp)
 779                 return 0;
 780
 781         evtp->evt_arg1  = arg1;
 782         evtp->evt_arg2  = arg2;
 783         evtp->evt       = evt;
 784
 785         spin_lock_irqsave(&phba->hbalock, flags);
 786         list_add_tail(&evtp->evt_listp, &phba->work_list);
 787         spin_unlock_irqrestore(&phba->hbalock, flags);
 788
 789         lpfc_worker_wake_up(phba);
 790
 791         return 1;
 792 }
 793
 794 void
 795 lpfc_cleanup_rpis(struct lpfc_vport *vport, int remove)
 796 {
 797         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 798         struct lpfc_hba  *phba = vport->phba;
 799         struct lpfc_nodelist *ndlp, *next_ndlp;
 800         int  rc;
 801
 802         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
 803                 if (!NLP_CHK_NODE_ACT(ndlp))
 804                         continue;
 805                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
 806                         continue;
 807                 if ((phba->sli3_options & LPFC_SLI3_VPORT_TEARDOWN) ||
 808                         ((vport->port_type == LPFC_NPIV_PORT) &&
 809                         (ndlp->nlp_DID == NameServer_DID)))
 810                         lpfc_unreg_rpi(vport, ndlp);
 811
 812                 /* Leave Fabric nodes alone on link down */
 813                 if ((phba->sli_rev < LPFC_SLI_REV4) &&
 814                     (!remove && ndlp->nlp_type & NLP_FABRIC))
 815                         continue;
 816                 rc = lpfc_disc_state_machine(vport, ndlp, NULL,
 817                                              remove
 818                                              ? NLP_EVT_DEVICE_RM
 819                                              : NLP_EVT_DEVICE_RECOVERY);
 820         }
 821         if (phba->sli3_options & LPFC_SLI3_VPORT_TEARDOWN) {
 822                 if (phba->sli_rev == LPFC_SLI_REV4)
 823                         lpfc_sli4_unreg_all_rpis(vport);
 824                 lpfc_mbx_unreg_vpi(vport);
 825                 spin_lock_irq(shost->host_lock);
 826                 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
 827                 spin_unlock_irq(shost->host_lock);
 828         }
 829 }
 830
 831 void
 832 lpfc_port_link_failure(struct lpfc_vport *vport)
 833 {
 834         lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
 835
 836         /* Cleanup any outstanding received buffers */
 837         lpfc_cleanup_rcv_buffers(vport);
 838
 839         /* Cleanup any outstanding RSCN activity */
 840         lpfc_els_flush_rscn(vport);
 841
 842         /* Cleanup any outstanding ELS commands */
 843         lpfc_els_flush_cmd(vport);
 844
 845         lpfc_cleanup_rpis(vport, 0);
 846
 847         /* Turn off discovery timer if its running */
 848         lpfc_can_disctmo(vport);
 849 }
 850
 851 void
 852 lpfc_linkdown_port(struct lpfc_vport *vport)
 853 {
 854         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
 855
 856         fc_host_post_event(shost, fc_get_event_number(), FCH_EVT_LINKDOWN, 0);
 857
 858         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
 859                 "Link Down:       state:x%x rtry:x%x flg:x%x",
 860                 vport->port_state, vport->fc_ns_retry, vport->fc_flag);
 861
 862         lpfc_port_link_failure(vport);
 863
 864         /* Stop delayed Nport discovery */
 865         spin_lock_irq(shost->host_lock);
 866         vport->fc_flag &= ~FC_DISC_DELAYED;
 867         spin_unlock_irq(shost->host_lock);
 868         del_timer_sync(&vport->delayed_disc_tmo);
 869 }
 870
 871 int
 872 lpfc_linkdown(struct lpfc_hba *phba)
 873 {
 874         struct lpfc_vport *vport = phba->pport;
 875         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
 876         struct lpfc_vport **vports;
 877         LPFC_MBOXQ_t          *mb;
 878         int i;
 879
 880         if (phba->link_state == LPFC_LINK_DOWN)
 881                 return 0;
 882
 883         /* Block all SCSI stack I/Os */
 884         lpfc_scsi_dev_block(phba);
 885
 886         spin_lock_irq(&phba->hbalock);
 887         phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
 888         spin_unlock_irq(&phba->hbalock);
 889         if (phba->link_state > LPFC_LINK_DOWN) {
 890                 phba->link_state = LPFC_LINK_DOWN;
 891                 spin_lock_irq(shost->host_lock);
 892                 phba->pport->fc_flag &= ~FC_LBIT;
 893                 spin_unlock_irq(shost->host_lock);
 894         }
 895         vports = lpfc_create_vport_work_array(phba);
 896         if (vports != NULL)
 897                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
 898                         /* Issue a LINK DOWN event to all nodes */
 899                         lpfc_linkdown_port(vports[i]);
 900                 }
 901         lpfc_destroy_vport_work_array(phba, vports);
 902         /* Clean up any firmware default rpi's */
 903         mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 904         if (mb) {
 905                 lpfc_unreg_did(phba, 0xffff, LPFC_UNREG_ALL_DFLT_RPIS, mb);
 906                 mb->vport = vport;
 907                 mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 908                 if (lpfc_sli_issue_mbox(phba, mb, MBX_NOWAIT)
 909                     == MBX_NOT_FINISHED) {
 910                         mempool_free(mb, phba->mbox_mem_pool);
 911                 }
 912         }
 913
 914         /* Setup myDID for link up if we are in pt2pt mode */
 915         if (phba->pport->fc_flag & FC_PT2PT) {
 916                 phba->pport->fc_myDID = 0;
 917                 mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 918                 if (mb) {
 919                         lpfc_config_link(phba, mb);
 920                         mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 921                         mb->vport = vport;
 922                         if (lpfc_sli_issue_mbox(phba, mb, MBX_NOWAIT)
 923                             == MBX_NOT_FINISHED) {
 924                                 mempool_free(mb, phba->mbox_mem_pool);
 925                         }
 926                 }
 927                 spin_lock_irq(shost->host_lock);
 928                 phba->pport->fc_flag &= ~(FC_PT2PT | FC_PT2PT_PLOGI);
 929                 spin_unlock_irq(shost->host_lock);
 930         }
 931
 932         return 0;
 933 }
 934
 935 static void
 936 lpfc_linkup_cleanup_nodes(struct lpfc_vport *vport)
 937 {
 938         struct lpfc_nodelist *ndlp;
 939
 940         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
 941                 if (!NLP_CHK_NODE_ACT(ndlp))
 942                         continue;
 943                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
 944                         continue;
 945                 if (ndlp->nlp_type & NLP_FABRIC) {
 946                         /* On Linkup its safe to clean up the ndlp
 947                          * from Fabric connections.
 948                          */
 949                         if (ndlp->nlp_DID != Fabric_DID)
 950                                 lpfc_unreg_rpi(vport, ndlp);
 951                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
 952                 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
 953                         /* Fail outstanding IO now since device is
 954                          * marked for PLOGI.
 955                          */
 956                         lpfc_unreg_rpi(vport, ndlp);
 957                 }
 958         }
 959 }
 960
 961 static void
 962 lpfc_linkup_port(struct lpfc_vport *vport)
 963 {
 964         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 965         struct lpfc_hba  *phba = vport->phba;
 966
 967         if ((vport->load_flag & FC_UNLOADING) != 0)
 968                 return;
 969
 970         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
 971                 "Link Up:         top:x%x speed:x%x flg:x%x",
 972                 phba->fc_topology, phba->fc_linkspeed, phba->link_flag);
 973
 974         /* If NPIV is not enabled, only bring the physical port up */
 975         if (!(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
 976                 (vport != phba->pport))
 977                 return;
 978
 979         fc_host_post_event(shost, fc_get_event_number(), FCH_EVT_LINKUP, 0);
 980
 981         spin_lock_irq(shost->host_lock);
 982         vport->fc_flag &= ~(FC_PT2PT | FC_PT2PT_PLOGI | FC_ABORT_DISCOVERY |
 983                             FC_RSCN_MODE | FC_NLP_MORE | FC_RSCN_DISCOVERY);
 984         vport->fc_flag |= FC_NDISC_ACTIVE;
 985         vport->fc_ns_retry = 0;
 986         spin_unlock_irq(shost->host_lock);
 987
 988         if (vport->fc_flag & FC_LBIT)
 989                 lpfc_linkup_cleanup_nodes(vport);
 990
 991 }
 992
 993 static int
 994 lpfc_linkup(struct lpfc_hba *phba)
 995 {
 996         struct lpfc_vport **vports;
 997         int i;
 998
 999         lpfc_cleanup_wt_rrqs(phba);
1000         phba->link_state = LPFC_LINK_UP;
1001
1002         /* Unblock fabric iocbs if they are blocked */
1003         clear_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
1004         del_timer_sync(&phba->fabric_block_timer);
1005
1006         vports = lpfc_create_vport_work_array(phba);
1007         if (vports != NULL)
1008                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
1009                         lpfc_linkup_port(vports[i]);
1010         lpfc_destroy_vport_work_array(phba, vports);
1011         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
1012             (phba->sli_rev < LPFC_SLI_REV4))
1013                 lpfc_issue_clear_la(phba, phba->pport);
1014
1015         return 0;
1016 }
1017
1018 /*
1019  * This routine handles processing a CLEAR_LA mailbox
1020  * command upon completion. It is setup in the LPFC_MBOXQ
1021  * as the completion routine when the command is
1022  * handed off to the SLI layer.
1023  */
1024 static void
1025 lpfc_mbx_cmpl_clear_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1026 {
1027         struct lpfc_vport *vport = pmb->vport;
1028         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1029         struct lpfc_sli   *psli = &phba->sli;
1030         MAILBOX_t *mb = &pmb->u.mb;
1031         uint32_t control;
1032
1033         /* Since we don't do discovery right now, turn these off here */
1034         psli->ring[psli->extra_ring].flag &= ~LPFC_STOP_IOCB_EVENT;
1035         psli->ring[psli->fcp_ring].flag &= ~LPFC_STOP_IOCB_EVENT;
1036         psli->ring[psli->next_ring].flag &= ~LPFC_STOP_IOCB_EVENT;
1037
1038         /* Check for error */
1039         if ((mb->mbxStatus) && (mb->mbxStatus != 0x1601)) {
1040                 /* CLEAR_LA mbox error <mbxStatus> state <hba_state> */
1041                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
1042                                  "0320 CLEAR_LA mbxStatus error x%x hba "
1043                                  "state x%x\n",
1044                                  mb->mbxStatus, vport->port_state);
1045                 phba->link_state = LPFC_HBA_ERROR;
1046                 goto out;
1047         }
1048
1049         if (vport->port_type == LPFC_PHYSICAL_PORT)
1050                 phba->link_state = LPFC_HBA_READY;
1051
1052         spin_lock_irq(&phba->hbalock);
1053         psli->sli_flag |= LPFC_PROCESS_LA;
1054         control = readl(phba->HCregaddr);
1055         control |= HC_LAINT_ENA;
1056         writel(control, phba->HCregaddr);
1057         readl(phba->HCregaddr); /* flush */
1058         spin_unlock_irq(&phba->hbalock);
1059         mempool_free(pmb, phba->mbox_mem_pool);
1060         return;
1061
1062 out:
1063         /* Device Discovery completes */
1064         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1065                          "0225 Device Discovery completes\n");
1066         mempool_free(pmb, phba->mbox_mem_pool);
1067
1068         spin_lock_irq(shost->host_lock);
1069         vport->fc_flag &= ~FC_ABORT_DISCOVERY;
1070         spin_unlock_irq(shost->host_lock);
1071
1072         lpfc_can_disctmo(vport);
1073
1074         /* turn on Link Attention interrupts */
1075
1076         spin_lock_irq(&phba->hbalock);
1077         psli->sli_flag |= LPFC_PROCESS_LA;
1078         control = readl(phba->HCregaddr);
1079         control |= HC_LAINT_ENA;
1080         writel(control, phba->HCregaddr);
1081         readl(phba->HCregaddr); /* flush */
1082         spin_unlock_irq(&phba->hbalock);
1083
1084         return;
1085 }
1086
1087
1088 static void
1089 lpfc_mbx_cmpl_local_config_link(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1090 {
1091         struct lpfc_vport *vport = pmb->vport;
1092
1093         if (pmb->u.mb.mbxStatus)
1094                 goto out;
1095
1096         mempool_free(pmb, phba->mbox_mem_pool);
1097
1098         /* don't perform discovery for SLI4 loopback diagnostic test */
1099         if ((phba->sli_rev == LPFC_SLI_REV4) &&
1100             !(phba->hba_flag & HBA_FCOE_MODE) &&
1101             (phba->link_flag & LS_LOOPBACK_MODE))
1102                 return;
1103
1104         if (phba->fc_topology == LPFC_TOPOLOGY_LOOP &&
1105             vport->fc_flag & FC_PUBLIC_LOOP &&
1106             !(vport->fc_flag & FC_LBIT)) {
1107                         /* Need to wait for FAN - use discovery timer
1108                          * for timeout.  port_state is identically
1109                          * LPFC_LOCAL_CFG_LINK while waiting for FAN
1110                          */
1111                         lpfc_set_disctmo(vport);
1112                         return;
1113         }
1114
1115         /* Start discovery by sending a FLOGI. port_state is identically
1116          * LPFC_FLOGI while waiting for FLOGI cmpl
1117          */
1118         if (vport->port_state != LPFC_FLOGI || vport->fc_flag & FC_PT2PT_PLOGI)
1119                 lpfc_initial_flogi(vport);
1120         return;
1121
1122 out:
1123         lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
1124                          "0306 CONFIG_LINK mbxStatus error x%x "
1125                          "HBA state x%x\n",
1126                          pmb->u.mb.mbxStatus, vport->port_state);
1127         mempool_free(pmb, phba->mbox_mem_pool);
1128
1129         lpfc_linkdown(phba);
1130
1131         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
1132                          "0200 CONFIG_LINK bad hba state x%x\n",
1133                          vport->port_state);
1134
1135         lpfc_issue_clear_la(phba, vport);
1136         return;
1137 }
1138
1139 /**
1140  * lpfc_sli4_clear_fcf_rr_bmask
1141  * @phba pointer to the struct lpfc_hba for this port.
1142  * This fucnction resets the round robin bit mask and clears the
1143  * fcf priority list. The list deletions are done while holding the
1144  * hbalock. The ON_LIST flag and the FLOGI_FAILED flags are cleared
1145  * from the lpfc_fcf_pri record.
1146  **/
1147 void
1148 lpfc_sli4_clear_fcf_rr_bmask(struct lpfc_hba *phba)
1149 {
1150         struct lpfc_fcf_pri *fcf_pri;
1151         struct lpfc_fcf_pri *next_fcf_pri;
1152         memset(phba->fcf.fcf_rr_bmask, 0, sizeof(*phba->fcf.fcf_rr_bmask));
1153         spin_lock_irq(&phba->hbalock);
1154         list_for_each_entry_safe(fcf_pri, next_fcf_pri,
1155                                 &phba->fcf.fcf_pri_list, list) {
1156                 list_del_init(&fcf_pri->list);
1157                 fcf_pri->fcf_rec.flag = 0;
1158         }
1159         spin_unlock_irq(&phba->hbalock);
1160 }
1161 static void
1162 lpfc_mbx_cmpl_reg_fcfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
1163 {
1164         struct lpfc_vport *vport = mboxq->vport;
1165
1166         if (mboxq->u.mb.mbxStatus) {
1167                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
1168                          "2017 REG_FCFI mbxStatus error x%x "
1169                          "HBA state x%x\n",
1170                          mboxq->u.mb.mbxStatus, vport->port_state);
1171                 goto fail_out;
1172         }
1173
1174         /* Start FCoE discovery by sending a FLOGI. */
1175         phba->fcf.fcfi = bf_get(lpfc_reg_fcfi_fcfi, &mboxq->u.mqe.un.reg_fcfi);
1176         /* Set the FCFI registered flag */
1177         spin_lock_irq(&phba->hbalock);
1178         phba->fcf.fcf_flag |= FCF_REGISTERED;
1179         spin_unlock_irq(&phba->hbalock);
1180
1181         /* If there is a pending FCoE event, restart FCF table scan. */
1182         if ((!(phba->hba_flag & FCF_RR_INPROG)) &&
1183                 lpfc_check_pending_fcoe_event(phba, LPFC_UNREG_FCF))
1184                 goto fail_out;
1185
1186         /* Mark successful completion of FCF table scan */
1187         spin_lock_irq(&phba->hbalock);
1188         phba->fcf.fcf_flag |= (FCF_SCAN_DONE | FCF_IN_USE);
1189         phba->hba_flag &= ~FCF_TS_INPROG;
1190         if (vport->port_state != LPFC_FLOGI) {
1191                 phba->hba_flag |= FCF_RR_INPROG;
1192                 spin_unlock_irq(&phba->hbalock);
1193                 lpfc_issue_init_vfi(vport);
1194                 goto out;
1195         }
1196         spin_unlock_irq(&phba->hbalock);
1197         goto out;
1198
1199 fail_out:
1200         spin_lock_irq(&phba->hbalock);
1201         phba->hba_flag &= ~FCF_RR_INPROG;
1202         spin_unlock_irq(&phba->hbalock);
1203 out:
1204         mempool_free(mboxq, phba->mbox_mem_pool);
1205 }
1206
1207 /**
1208  * lpfc_fab_name_match - Check if the fcf fabric name match.
1209  * @fab_name: pointer to fabric name.
1210  * @new_fcf_record: pointer to fcf record.
1211  *
1212  * This routine compare the fcf record's fabric name with provided
1213  * fabric name. If the fabric name are identical this function
1214  * returns 1 else return 0.
1215  **/
1216 static uint32_t
1217 lpfc_fab_name_match(uint8_t *fab_name, struct fcf_record *new_fcf_record)
1218 {
1219         if (fab_name[0] != bf_get(lpfc_fcf_record_fab_name_0, new_fcf_record))
1220                 return 0;
1221         if (fab_name[1] != bf_get(lpfc_fcf_record_fab_name_1, new_fcf_record))
1222                 return 0;
1223         if (fab_name[2] != bf_get(lpfc_fcf_record_fab_name_2, new_fcf_record))
1224                 return 0;
1225         if (fab_name[3] != bf_get(lpfc_fcf_record_fab_name_3, new_fcf_record))
1226                 return 0;
1227         if (fab_name[4] != bf_get(lpfc_fcf_record_fab_name_4, new_fcf_record))
1228                 return 0;
1229         if (fab_name[5] != bf_get(lpfc_fcf_record_fab_name_5, new_fcf_record))
1230                 return 0;
1231         if (fab_name[6] != bf_get(lpfc_fcf_record_fab_name_6, new_fcf_record))
1232                 return 0;
1233         if (fab_name[7] != bf_get(lpfc_fcf_record_fab_name_7, new_fcf_record))
1234                 return 0;
1235         return 1;
1236 }
1237
1238 /**
1239  * lpfc_sw_name_match - Check if the fcf switch name match.
1240  * @fab_name: pointer to fabric name.
1241  * @new_fcf_record: pointer to fcf record.
1242  *
1243  * This routine compare the fcf record's switch name with provided
1244  * switch name. If the switch name are identical this function
1245  * returns 1 else return 0.
1246  **/
1247 static uint32_t
1248 lpfc_sw_name_match(uint8_t *sw_name, struct fcf_record *new_fcf_record)
1249 {
1250         if (sw_name[0] != bf_get(lpfc_fcf_record_switch_name_0, new_fcf_record))
1251                 return 0;
1252         if (sw_name[1] != bf_get(lpfc_fcf_record_switch_name_1, new_fcf_record))
1253                 return 0;
1254         if (sw_name[2] != bf_get(lpfc_fcf_record_switch_name_2, new_fcf_record))
1255                 return 0;
1256         if (sw_name[3] != bf_get(lpfc_fcf_record_switch_name_3, new_fcf_record))
1257                 return 0;
1258         if (sw_name[4] != bf_get(lpfc_fcf_record_switch_name_4, new_fcf_record))
1259                 return 0;
1260         if (sw_name[5] != bf_get(lpfc_fcf_record_switch_name_5, new_fcf_record))
1261                 return 0;
1262         if (sw_name[6] != bf_get(lpfc_fcf_record_switch_name_6, new_fcf_record))
1263                 return 0;
1264         if (sw_name[7] != bf_get(lpfc_fcf_record_switch_name_7, new_fcf_record))
1265                 return 0;
1266         return 1;
1267 }
1268
1269 /**
1270  * lpfc_mac_addr_match - Check if the fcf mac address match.
1271  * @mac_addr: pointer to mac address.
1272  * @new_fcf_record: pointer to fcf record.
1273  *
1274  * This routine compare the fcf record's mac address with HBA's
1275  * FCF mac address. If the mac addresses are identical this function
1276  * returns 1 else return 0.
1277  **/
1278 static uint32_t
1279 lpfc_mac_addr_match(uint8_t *mac_addr, struct fcf_record *new_fcf_record)
1280 {
1281         if (mac_addr[0] != bf_get(lpfc_fcf_record_mac_0, new_fcf_record))
1282                 return 0;
1283         if (mac_addr[1] != bf_get(lpfc_fcf_record_mac_1, new_fcf_record))
1284                 return 0;
1285         if (mac_addr[2] != bf_get(lpfc_fcf_record_mac_2, new_fcf_record))
1286                 return 0;
1287         if (mac_addr[3] != bf_get(lpfc_fcf_record_mac_3, new_fcf_record))
1288                 return 0;
1289         if (mac_addr[4] != bf_get(lpfc_fcf_record_mac_4, new_fcf_record))
1290                 return 0;
1291         if (mac_addr[5] != bf_get(lpfc_fcf_record_mac_5, new_fcf_record))
1292                 return 0;
1293         return 1;
1294 }
1295
1296 static bool
1297 lpfc_vlan_id_match(uint16_t curr_vlan_id, uint16_t new_vlan_id)
1298 {
1299         return (curr_vlan_id == new_vlan_id);
1300 }
1301
1302 /**
1303  * lpfc_update_fcf_record - Update driver fcf record
1304  * __lpfc_update_fcf_record_pri - update the lpfc_fcf_pri record.
1305  * @phba: pointer to lpfc hba data structure.
1306  * @fcf_index: Index for the lpfc_fcf_record.
1307  * @new_fcf_record: pointer to hba fcf record.
1308  *
1309  * This routine updates the driver FCF priority record from the new HBA FCF
1310  * record. This routine is called with the host lock held.
1311  **/
1312 static void
1313 __lpfc_update_fcf_record_pri(struct lpfc_hba *phba, uint16_t fcf_index,
1314                                  struct fcf_record *new_fcf_record
1315                                  )
1316 {
1317         struct lpfc_fcf_pri *fcf_pri;
1318
1319         fcf_pri = &phba->fcf.fcf_pri[fcf_index];
1320         fcf_pri->fcf_rec.fcf_index = fcf_index;
1321         /* FCF record priority */
1322         fcf_pri->fcf_rec.priority = new_fcf_record->fip_priority;
1323
1324 }
1325
1326 /**
1327  * lpfc_copy_fcf_record - Copy fcf information to lpfc_hba.
1328  * @fcf: pointer to driver fcf record.
1329  * @new_fcf_record: pointer to fcf record.
1330  *
1331  * This routine copies the FCF information from the FCF
1332  * record to lpfc_hba data structure.
1333  **/
1334 static void
1335 lpfc_copy_fcf_record(struct lpfc_fcf_rec *fcf_rec,
1336                      struct fcf_record *new_fcf_record)
1337 {
1338         /* Fabric name */
1339         fcf_rec->fabric_name[0] =
1340                 bf_get(lpfc_fcf_record_fab_name_0, new_fcf_record);
1341         fcf_rec->fabric_name[1] =
1342                 bf_get(lpfc_fcf_record_fab_name_1, new_fcf_record);
1343         fcf_rec->fabric_name[2] =
1344                 bf_get(lpfc_fcf_record_fab_name_2, new_fcf_record);
1345         fcf_rec->fabric_name[3] =
1346                 bf_get(lpfc_fcf_record_fab_name_3, new_fcf_record);
1347         fcf_rec->fabric_name[4] =
1348                 bf_get(lpfc_fcf_record_fab_name_4, new_fcf_record);
1349         fcf_rec->fabric_name[5] =
1350                 bf_get(lpfc_fcf_record_fab_name_5, new_fcf_record);
1351         fcf_rec->fabric_name[6] =
1352                 bf_get(lpfc_fcf_record_fab_name_6, new_fcf_record);
1353         fcf_rec->fabric_name[7] =
1354                 bf_get(lpfc_fcf_record_fab_name_7, new_fcf_record);
1355         /* Mac address */
1356         fcf_rec->mac_addr[0] = bf_get(lpfc_fcf_record_mac_0, new_fcf_record);
1357         fcf_rec->mac_addr[1] = bf_get(lpfc_fcf_record_mac_1, new_fcf_record);
1358         fcf_rec->mac_addr[2] = bf_get(lpfc_fcf_record_mac_2, new_fcf_record);
1359         fcf_rec->mac_addr[3] = bf_get(lpfc_fcf_record_mac_3, new_fcf_record);
1360         fcf_rec->mac_addr[4] = bf_get(lpfc_fcf_record_mac_4, new_fcf_record);
1361         fcf_rec->mac_addr[5] = bf_get(lpfc_fcf_record_mac_5, new_fcf_record);
1362         /* FCF record index */
1363         fcf_rec->fcf_indx = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
1364         /* FCF record priority */
1365         fcf_rec->priority = new_fcf_record->fip_priority;
1366         /* Switch name */
1367         fcf_rec->switch_name[0] =
1368                 bf_get(lpfc_fcf_record_switch_name_0, new_fcf_record);
1369         fcf_rec->switch_name[1] =
1370                 bf_get(lpfc_fcf_record_switch_name_1, new_fcf_record);
1371         fcf_rec->switch_name[2] =
1372                 bf_get(lpfc_fcf_record_switch_name_2, new_fcf_record);
1373         fcf_rec->switch_name[3] =
1374                 bf_get(lpfc_fcf_record_switch_name_3, new_fcf_record);
1375         fcf_rec->switch_name[4] =
1376                 bf_get(lpfc_fcf_record_switch_name_4, new_fcf_record);
1377         fcf_rec->switch_name[5] =
1378                 bf_get(lpfc_fcf_record_switch_name_5, new_fcf_record);
1379         fcf_rec->switch_name[6] =
1380                 bf_get(lpfc_fcf_record_switch_name_6, new_fcf_record);
1381         fcf_rec->switch_name[7] =
1382                 bf_get(lpfc_fcf_record_switch_name_7, new_fcf_record);
1383 }
1384
1385 /**
1386  * lpfc_update_fcf_record - Update driver fcf record
1387  * @phba: pointer to lpfc hba data structure.
1388  * @fcf_rec: pointer to driver fcf record.
1389  * @new_fcf_record: pointer to hba fcf record.
1390  * @addr_mode: address mode to be set to the driver fcf record.
1391  * @vlan_id: vlan tag to be set to the driver fcf record.
1392  * @flag: flag bits to be set to the driver fcf record.
1393  *
1394  * This routine updates the driver FCF record from the new HBA FCF record
1395  * together with the address mode, vlan_id, and other informations. This
1396  * routine is called with the host lock held.
1397  **/
1398 static void
1399 __lpfc_update_fcf_record(struct lpfc_hba *phba, struct lpfc_fcf_rec *fcf_rec,
1400                        struct fcf_record *new_fcf_record, uint32_t addr_mode,
1401                        uint16_t vlan_id, uint32_t flag)
1402 {
1403         /* Copy the fields from the HBA's FCF record */
1404         lpfc_copy_fcf_record(fcf_rec, new_fcf_record);
1405         /* Update other fields of driver FCF record */
1406         fcf_rec->addr_mode = addr_mode;
1407         fcf_rec->vlan_id = vlan_id;
1408         fcf_rec->flag |= (flag | RECORD_VALID);
1409         __lpfc_update_fcf_record_pri(phba,
1410                 bf_get(lpfc_fcf_record_fcf_index, new_fcf_record),
1411                                  new_fcf_record);
1412 }
1413
1414 /**
1415  * lpfc_register_fcf - Register the FCF with hba.
1416  * @phba: pointer to lpfc hba data structure.
1417  *
1418  * This routine issues a register fcfi mailbox command to register
1419  * the fcf with HBA.
1420  **/
1421 static void
1422 lpfc_register_fcf(struct lpfc_hba *phba)
1423 {
1424         LPFC_MBOXQ_t *fcf_mbxq;
1425         int rc;
1426
1427         spin_lock_irq(&phba->hbalock);
1428         /* If the FCF is not available do nothing. */
1429         if (!(phba->fcf.fcf_flag & FCF_AVAILABLE)) {
1430                 phba->hba_flag &= ~(FCF_TS_INPROG | FCF_RR_INPROG);
1431                 spin_unlock_irq(&phba->hbalock);
1432                 return;
1433         }
1434
1435         /* The FCF is already registered, start discovery */
1436         if (phba->fcf.fcf_flag & FCF_REGISTERED) {
1437                 phba->fcf.fcf_flag |= (FCF_SCAN_DONE | FCF_IN_USE);
1438                 phba->hba_flag &= ~FCF_TS_INPROG;
1439                 if (phba->pport->port_state != LPFC_FLOGI) {
1440                         phba->hba_flag |= FCF_RR_INPROG;
1441                         spin_unlock_irq(&phba->hbalock);
1442                         lpfc_initial_flogi(phba->pport);
1443                         return;
1444                 }
1445                 spin_unlock_irq(&phba->hbalock);
1446                 return;
1447         }
1448         spin_unlock_irq(&phba->hbalock);
1449
1450         fcf_mbxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1451         if (!fcf_mbxq) {
1452                 spin_lock_irq(&phba->hbalock);
1453                 phba->hba_flag &= ~(FCF_TS_INPROG | FCF_RR_INPROG);
1454                 spin_unlock_irq(&phba->hbalock);
1455                 return;
1456         }
1457
1458         lpfc_reg_fcfi(phba, fcf_mbxq);
1459         fcf_mbxq->vport = phba->pport;
1460         fcf_mbxq->mbox_cmpl = lpfc_mbx_cmpl_reg_fcfi;
1461         rc = lpfc_sli_issue_mbox(phba, fcf_mbxq, MBX_NOWAIT);
1462         if (rc == MBX_NOT_FINISHED) {
1463                 spin_lock_irq(&phba->hbalock);
1464                 phba->hba_flag &= ~(FCF_TS_INPROG | FCF_RR_INPROG);
1465                 spin_unlock_irq(&phba->hbalock);
1466                 mempool_free(fcf_mbxq, phba->mbox_mem_pool);
1467         }
1468
1469         return;
1470 }
1471
1472 /**
1473  * lpfc_match_fcf_conn_list - Check if the FCF record can be used for discovery.
1474  * @phba: pointer to lpfc hba data structure.
1475  * @new_fcf_record: pointer to fcf record.
1476  * @boot_flag: Indicates if this record used by boot bios.
1477  * @addr_mode: The address mode to be used by this FCF
1478  * @vlan_id: The vlan id to be used as vlan tagging by this FCF.
1479  *
1480  * This routine compare the fcf record with connect list obtained from the
1481  * config region to decide if this FCF can be used for SAN discovery. It returns
1482  * 1 if this record can be used for SAN discovery else return zero. If this FCF
1483  * record can be used for SAN discovery, the boot_flag will indicate if this FCF
1484  * is used by boot bios and addr_mode will indicate the addressing mode to be
1485  * used for this FCF when the function returns.
1486  * If the FCF record need to be used with a particular vlan id, the vlan is
1487  * set in the vlan_id on return of the function. If not VLAN tagging need to
1488  * be used with the FCF vlan_id will be set to LPFC_FCOE_NULL_VID;
1489  **/
1490 static int
1491 lpfc_match_fcf_conn_list(struct lpfc_hba *phba,
1492                         struct fcf_record *new_fcf_record,
1493                         uint32_t *boot_flag, uint32_t *addr_mode,
1494                         uint16_t *vlan_id)
1495 {
1496         struct lpfc_fcf_conn_entry *conn_entry;
1497         int i, j, fcf_vlan_id = 0;
1498
1499         /* Find the lowest VLAN id in the FCF record */
1500         for (i = 0; i < 512; i++) {
1501                 if (new_fcf_record->vlan_bitmap[i]) {
1502                         fcf_vlan_id = i * 8;
1503                         j = 0;
1504                         while (!((new_fcf_record->vlan_bitmap[i] >> j) & 1)) {
1505                                 j++;
1506                                 fcf_vlan_id++;
1507                         }
1508                         break;
1509                 }
1510         }
1511
1512         /* FCF not valid/available or solicitation in progress */
1513         if (!bf_get(lpfc_fcf_record_fcf_avail, new_fcf_record) ||
1514             !bf_get(lpfc_fcf_record_fcf_valid, new_fcf_record) ||
1515             bf_get(lpfc_fcf_record_fcf_sol, new_fcf_record))
1516                 return 0;
1517
1518         if (!(phba->hba_flag & HBA_FIP_SUPPORT)) {
1519                 *boot_flag = 0;
1520                 *addr_mode = bf_get(lpfc_fcf_record_mac_addr_prov,
1521                                 new_fcf_record);
1522                 if (phba->valid_vlan)
1523                         *vlan_id = phba->vlan_id;
1524                 else
1525                         *vlan_id = LPFC_FCOE_NULL_VID;
1526                 return 1;
1527         }
1528
1529         /*
1530          * If there are no FCF connection table entry, driver connect to all
1531          * FCFs.
1532          */
1533         if (list_empty(&phba->fcf_conn_rec_list)) {
1534                 *boot_flag = 0;
1535                 *addr_mode = bf_get(lpfc_fcf_record_mac_addr_prov,
1536                         new_fcf_record);
1537
1538                 /*
1539                  * When there are no FCF connect entries, use driver's default
1540                  * addressing mode - FPMA.
1541                  */
1542                 if (*addr_mode & LPFC_FCF_FPMA)
1543                         *addr_mode = LPFC_FCF_FPMA;
1544
1545                 /* If FCF record report a vlan id use that vlan id */
1546                 if (fcf_vlan_id)
1547                         *vlan_id = fcf_vlan_id;
1548                 else
1549                         *vlan_id = LPFC_FCOE_NULL_VID;
1550                 return 1;
1551         }
1552
1553         list_for_each_entry(conn_entry,
1554                             &phba->fcf_conn_rec_list, list) {
1555                 if (!(conn_entry->conn_rec.flags & FCFCNCT_VALID))
1556                         continue;
1557
1558                 if ((conn_entry->conn_rec.flags & FCFCNCT_FBNM_VALID) &&
1559                         !lpfc_fab_name_match(conn_entry->conn_rec.fabric_name,
1560                                              new_fcf_record))
1561                         continue;
1562                 if ((conn_entry->conn_rec.flags & FCFCNCT_SWNM_VALID) &&
1563                         !lpfc_sw_name_match(conn_entry->conn_rec.switch_name,
1564                                             new_fcf_record))
1565                         continue;
1566                 if (conn_entry->conn_rec.flags & FCFCNCT_VLAN_VALID) {
1567                         /*
1568                          * If the vlan bit map does not have the bit set for the
1569                          * vlan id to be used, then it is not a match.
1570                          */
1571                         if (!(new_fcf_record->vlan_bitmap
1572                                 [conn_entry->conn_rec.vlan_tag / 8] &
1573                                 (1 << (conn_entry->conn_rec.vlan_tag % 8))))
1574                                 continue;
1575                 }
1576
1577                 /*
1578                  * If connection record does not support any addressing mode,
1579                  * skip the FCF record.
1580                  */
1581                 if (!(bf_get(lpfc_fcf_record_mac_addr_prov, new_fcf_record)
1582                         & (LPFC_FCF_FPMA | LPFC_FCF_SPMA)))
1583                         continue;
1584
1585                 /*
1586                  * Check if the connection record specifies a required
1587                  * addressing mode.
1588                  */
1589                 if ((conn_entry->conn_rec.flags & FCFCNCT_AM_VALID) &&
1590                         !(conn_entry->conn_rec.flags & FCFCNCT_AM_PREFERRED)) {
1591
1592                         /*
1593                          * If SPMA required but FCF not support this continue.
1594                          */
1595                         if ((conn_entry->conn_rec.flags & FCFCNCT_AM_SPMA) &&
1596                                 !(bf_get(lpfc_fcf_record_mac_addr_prov,
1597                                         new_fcf_record) & LPFC_FCF_SPMA))
1598                                 continue;
1599
1600                         /*
1601                          * If FPMA required but FCF not support this continue.
1602                          */
1603                         if (!(conn_entry->conn_rec.flags & FCFCNCT_AM_SPMA) &&
1604                                 !(bf_get(lpfc_fcf_record_mac_addr_prov,
1605                                 new_fcf_record) & LPFC_FCF_FPMA))
1606                                 continue;
1607                 }
1608
1609                 /*
1610                  * This fcf record matches filtering criteria.
1611                  */
1612                 if (conn_entry->conn_rec.flags & FCFCNCT_BOOT)
1613                         *boot_flag = 1;
1614                 else
1615                         *boot_flag = 0;
1616
1617                 /*
1618                  * If user did not specify any addressing mode, or if the
1619                  * preferred addressing mode specified by user is not supported
1620                  * by FCF, allow fabric to pick the addressing mode.
1621                  */
1622                 *addr_mode = bf_get(lpfc_fcf_record_mac_addr_prov,
1623                                 new_fcf_record);
1624                 /*
1625                  * If the user specified a required address mode, assign that
1626                  * address mode
1627                  */
1628                 if ((conn_entry->conn_rec.flags & FCFCNCT_AM_VALID) &&
1629                         (!(conn_entry->conn_rec.flags & FCFCNCT_AM_PREFERRED)))
1630                         *addr_mode = (conn_entry->conn_rec.flags &
1631                                 FCFCNCT_AM_SPMA) ?
1632                                 LPFC_FCF_SPMA : LPFC_FCF_FPMA;
1633                 /*
1634                  * If the user specified a preferred address mode, use the
1635                  * addr mode only if FCF support the addr_mode.
1636                  */
1637                 else if ((conn_entry->conn_rec.flags & FCFCNCT_AM_VALID) &&
1638                         (conn_entry->conn_rec.flags & FCFCNCT_AM_PREFERRED) &&
1639                         (conn_entry->conn_rec.flags & FCFCNCT_AM_SPMA) &&
1640                         (*addr_mode & LPFC_FCF_SPMA))
1641                                 *addr_mode = LPFC_FCF_SPMA;
1642                 else if ((conn_entry->conn_rec.flags & FCFCNCT_AM_VALID) &&
1643                         (conn_entry->conn_rec.flags & FCFCNCT_AM_PREFERRED) &&
1644                         !(conn_entry->conn_rec.flags & FCFCNCT_AM_SPMA) &&
1645                         (*addr_mode & LPFC_FCF_FPMA))
1646                                 *addr_mode = LPFC_FCF_FPMA;
1647
1648                 /* If matching connect list has a vlan id, use it */
1649                 if (conn_entry->conn_rec.flags & FCFCNCT_VLAN_VALID)
1650                         *vlan_id = conn_entry->conn_rec.vlan_tag;
1651                 /*
1652                  * If no vlan id is specified in connect list, use the vlan id
1653                  * in the FCF record
1654                  */
1655                 else if (fcf_vlan_id)
1656                         *vlan_id = fcf_vlan_id;
1657                 else
1658                         *vlan_id = LPFC_FCOE_NULL_VID;
1659
1660                 return 1;
1661         }
1662
1663         return 0;
1664 }
1665
1666 /**
1667  * lpfc_check_pending_fcoe_event - Check if there is pending fcoe event.
1668  * @phba: pointer to lpfc hba data structure.
1669  * @unreg_fcf: Unregister FCF if FCF table need to be re-scaned.
1670  *
1671  * This function check if there is any fcoe event pending while driver
1672  * scan FCF entries. If there is any pending event, it will restart the
1673  * FCF saning and return 1 else return 0.
1674  */
1675 int
1676 lpfc_check_pending_fcoe_event(struct lpfc_hba *phba, uint8_t unreg_fcf)
1677 {
1678         /*
1679          * If the Link is up and no FCoE events while in the
1680          * FCF discovery, no need to restart FCF discovery.
1681          */
1682         if ((phba->link_state  >= LPFC_LINK_UP) &&
1683             (phba->fcoe_eventtag == phba->fcoe_eventtag_at_fcf_scan))
1684                 return 0;
1685
1686         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
1687                         "2768 Pending link or FCF event during current "
1688                         "handling of the previous event: link_state:x%x, "
1689                         "evt_tag_at_scan:x%x, evt_tag_current:x%x\n",
1690                         phba->link_state, phba->fcoe_eventtag_at_fcf_scan,
1691                         phba->fcoe_eventtag);
1692
1693         spin_lock_irq(&phba->hbalock);
1694         phba->fcf.fcf_flag &= ~FCF_AVAILABLE;
1695         spin_unlock_irq(&phba->hbalock);
1696
1697         if (phba->link_state >= LPFC_LINK_UP) {
1698                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
1699                                 "2780 Restart FCF table scan due to "
1700                                 "pending FCF event:evt_tag_at_scan:x%x, "
1701                                 "evt_tag_current:x%x\n",
1702                                 phba->fcoe_eventtag_at_fcf_scan,
1703                                 phba->fcoe_eventtag);
1704                 lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
1705         } else {
1706                 /*
1707                  * Do not continue FCF discovery and clear FCF_TS_INPROG
1708                  * flag
1709                  */
1710                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
1711                                 "2833 Stop FCF discovery process due to link "
1712                                 "state change (x%x)\n", phba->link_state);
1713                 spin_lock_irq(&phba->hbalock);
1714                 phba->hba_flag &= ~(FCF_TS_INPROG | FCF_RR_INPROG);
1715                 phba->fcf.fcf_flag &= ~(FCF_REDISC_FOV | FCF_DISCOVERY);
1716                 spin_unlock_irq(&phba->hbalock);
1717         }
1718
1719         /* Unregister the currently registered FCF if required */
1720         if (unreg_fcf) {
1721                 spin_lock_irq(&phba->hbalock);
1722                 phba->fcf.fcf_flag &= ~FCF_REGISTERED;
1723                 spin_unlock_irq(&phba->hbalock);
1724                 lpfc_sli4_unregister_fcf(phba);
1725         }
1726         return 1;
1727 }
1728
1729 /**
1730  * lpfc_sli4_new_fcf_random_select - Randomly select an eligible new fcf record
1731  * @phba: pointer to lpfc hba data structure.
1732  * @fcf_cnt: number of eligible fcf record seen so far.
1733  *
1734  * This function makes an running random selection decision on FCF record to
1735  * use through a sequence of @fcf_cnt eligible FCF records with equal
1736  * probability. To perform integer manunipulation of random numbers with
1737  * size unit32_t, the lower 16 bits of the 32-bit random number returned
1738  * from prandom_u32() are taken as the random random number generated.
1739  *
1740  * Returns true when outcome is for the newly read FCF record should be
1741  * chosen; otherwise, return false when outcome is for keeping the previously
1742  * chosen FCF record.
1743  **/
1744 static bool
1745 lpfc_sli4_new_fcf_random_select(struct lpfc_hba *phba, uint32_t fcf_cnt)
1746 {
1747         uint32_t rand_num;
1748
1749         /* Get 16-bit uniform random number */
1750         rand_num = 0xFFFF & prandom_u32();
1751
1752         /* Decision with probability 1/fcf_cnt */
1753         if ((fcf_cnt * rand_num) < 0xFFFF)
1754                 return true;
1755         else
1756                 return false;
1757 }
1758
1759 /**
1760  * lpfc_sli4_fcf_rec_mbox_parse - Parse read_fcf mbox command.
1761  * @phba: pointer to lpfc hba data structure.
1762  * @mboxq: pointer to mailbox object.
1763  * @next_fcf_index: pointer to holder of next fcf index.
1764  *
1765  * This routine parses the non-embedded fcf mailbox command by performing the
1766  * necessarily error checking, non-embedded read FCF record mailbox command
1767  * SGE parsing, and endianness swapping.
1768  *
1769  * Returns the pointer to the new FCF record in the non-embedded mailbox
1770  * command DMA memory if successfully, other NULL.
1771  */
1772 static struct fcf_record *
1773 lpfc_sli4_fcf_rec_mbox_parse(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
1774                              uint16_t *next_fcf_index)
1775 {
1776         void *virt_addr;
1777         dma_addr_t phys_addr;
1778         struct lpfc_mbx_sge sge;
1779         struct lpfc_mbx_read_fcf_tbl *read_fcf;
1780         uint32_t shdr_status, shdr_add_status;
1781         union lpfc_sli4_cfg_shdr *shdr;
1782         struct fcf_record *new_fcf_record;
1783
1784         /* Get the first SGE entry from the non-embedded DMA memory. This
1785          * routine only uses a single SGE.
1786          */
1787         lpfc_sli4_mbx_sge_get(mboxq, 0, &sge);
1788         phys_addr = getPaddr(sge.pa_hi, sge.pa_lo);
1789         if (unlikely(!mboxq->sge_array)) {
1790                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1791                                 "2524 Failed to get the non-embedded SGE "
1792                                 "virtual address\n");
1793                 return NULL;
1794         }
1795         virt_addr = mboxq->sge_array->addr[0];
1796
1797         shdr = (union lpfc_sli4_cfg_shdr *)virt_addr;
1798         lpfc_sli_pcimem_bcopy(shdr, shdr,
1799                               sizeof(union lpfc_sli4_cfg_shdr));
1800         shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
1801         shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
1802         if (shdr_status || shdr_add_status) {
1803                 if (shdr_status == STATUS_FCF_TABLE_EMPTY)
1804                         lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
1805                                         "2726 READ_FCF_RECORD Indicates empty "
1806                                         "FCF table.\n");
1807                 else
1808                         lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
1809                                         "2521 READ_FCF_RECORD mailbox failed "
1810                                         "with status x%x add_status x%x, "
1811                                         "mbx\n", shdr_status, shdr_add_status);
1812                 return NULL;
1813         }
1814
1815         /* Interpreting the returned information of the FCF record */
1816         read_fcf = (struct lpfc_mbx_read_fcf_tbl *)virt_addr;
1817         lpfc_sli_pcimem_bcopy(read_fcf, read_fcf,
1818                               sizeof(struct lpfc_mbx_read_fcf_tbl));
1819         *next_fcf_index = bf_get(lpfc_mbx_read_fcf_tbl_nxt_vindx, read_fcf);
1820         new_fcf_record = (struct fcf_record *)(virt_addr +
1821                           sizeof(struct lpfc_mbx_read_fcf_tbl));
1822         lpfc_sli_pcimem_bcopy(new_fcf_record, new_fcf_record,
1823                                 offsetof(struct fcf_record, vlan_bitmap));
1824         new_fcf_record->word137 = le32_to_cpu(new_fcf_record->word137);
1825         new_fcf_record->word138 = le32_to_cpu(new_fcf_record->word138);
1826
1827         return new_fcf_record;
1828 }
1829
1830 /**
1831  * lpfc_sli4_log_fcf_record_info - Log the information of a fcf record
1832  * @phba: pointer to lpfc hba data structure.
1833  * @fcf_record: pointer to the fcf record.
1834  * @vlan_id: the lowest vlan identifier associated to this fcf record.
1835  * @next_fcf_index: the index to the next fcf record in hba's fcf table.
1836  *
1837  * This routine logs the detailed FCF record if the LOG_FIP loggin is
1838  * enabled.
1839  **/
1840 static void
1841 lpfc_sli4_log_fcf_record_info(struct lpfc_hba *phba,
1842                               struct fcf_record *fcf_record,
1843                               uint16_t vlan_id,
1844                               uint16_t next_fcf_index)
1845 {
1846         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
1847                         "2764 READ_FCF_RECORD:\n"
1848                         "\tFCF_Index     : x%x\n"
1849                         "\tFCF_Avail     : x%x\n"
1850                         "\tFCF_Valid     : x%x\n"
1851                         "\tFCF_SOL       : x%x\n"
1852                         "\tFIP_Priority  : x%x\n"
1853                         "\tMAC_Provider  : x%x\n"
1854                         "\tLowest VLANID : x%x\n"
1855                         "\tFCF_MAC Addr  : x%x:%x:%x:%x:%x:%x\n"
1856                         "\tFabric_Name   : x%x:%x:%x:%x:%x:%x:%x:%x\n"
1857                         "\tSwitch_Name   : x%x:%x:%x:%x:%x:%x:%x:%x\n"
1858                         "\tNext_FCF_Index: x%x\n",
1859                         bf_get(lpfc_fcf_record_fcf_index, fcf_record),
1860                         bf_get(lpfc_fcf_record_fcf_avail, fcf_record),
1861                         bf_get(lpfc_fcf_record_fcf_valid, fcf_record),
1862                         bf_get(lpfc_fcf_record_fcf_sol, fcf_record),
1863                         fcf_record->fip_priority,
1864                         bf_get(lpfc_fcf_record_mac_addr_prov, fcf_record),
1865                         vlan_id,
1866                         bf_get(lpfc_fcf_record_mac_0, fcf_record),
1867                         bf_get(lpfc_fcf_record_mac_1, fcf_record),
1868                         bf_get(lpfc_fcf_record_mac_2, fcf_record),
1869                         bf_get(lpfc_fcf_record_mac_3, fcf_record),
1870                         bf_get(lpfc_fcf_record_mac_4, fcf_record),
1871                         bf_get(lpfc_fcf_record_mac_5, fcf_record),
1872                         bf_get(lpfc_fcf_record_fab_name_0, fcf_record),
1873                         bf_get(lpfc_fcf_record_fab_name_1, fcf_record),
1874                         bf_get(lpfc_fcf_record_fab_name_2, fcf_record),
1875                         bf_get(lpfc_fcf_record_fab_name_3, fcf_record),
1876                         bf_get(lpfc_fcf_record_fab_name_4, fcf_record),
1877                         bf_get(lpfc_fcf_record_fab_name_5, fcf_record),
1878                         bf_get(lpfc_fcf_record_fab_name_6, fcf_record),
1879                         bf_get(lpfc_fcf_record_fab_name_7, fcf_record),
1880                         bf_get(lpfc_fcf_record_switch_name_0, fcf_record),
1881                         bf_get(lpfc_fcf_record_switch_name_1, fcf_record),
1882                         bf_get(lpfc_fcf_record_switch_name_2, fcf_record),
1883                         bf_get(lpfc_fcf_record_switch_name_3, fcf_record),
1884                         bf_get(lpfc_fcf_record_switch_name_4, fcf_record),
1885                         bf_get(lpfc_fcf_record_switch_name_5, fcf_record),
1886                         bf_get(lpfc_fcf_record_switch_name_6, fcf_record),
1887                         bf_get(lpfc_fcf_record_switch_name_7, fcf_record),
1888                         next_fcf_index);
1889 }
1890
1891 /**
1892  lpfc_sli4_fcf_record_match - testing new FCF record for matching existing FCF
1893  * @phba: pointer to lpfc hba data structure.
1894  * @fcf_rec: pointer to an existing FCF record.
1895  * @new_fcf_record: pointer to a new FCF record.
1896  * @new_vlan_id: vlan id from the new FCF record.
1897  *
1898  * This function performs matching test of a new FCF record against an existing
1899  * FCF record. If the new_vlan_id passed in is LPFC_FCOE_IGNORE_VID, vlan id
1900  * will not be used as part of the FCF record matching criteria.
1901  *
1902  * Returns true if all the fields matching, otherwise returns false.
1903  */
1904 static bool
1905 lpfc_sli4_fcf_record_match(struct lpfc_hba *phba,
1906                            struct lpfc_fcf_rec *fcf_rec,
1907                            struct fcf_record *new_fcf_record,
1908                            uint16_t new_vlan_id)
1909 {
1910         if (new_vlan_id != LPFC_FCOE_IGNORE_VID)
1911                 if (!lpfc_vlan_id_match(fcf_rec->vlan_id, new_vlan_id))
1912                         return false;
1913         if (!lpfc_mac_addr_match(fcf_rec->mac_addr, new_fcf_record))
1914                 return false;
1915         if (!lpfc_sw_name_match(fcf_rec->switch_name, new_fcf_record))
1916                 return false;
1917         if (!lpfc_fab_name_match(fcf_rec->fabric_name, new_fcf_record))
1918                 return false;
1919         if (fcf_rec->priority != new_fcf_record->fip_priority)
1920                 return false;
1921         return true;
1922 }
1923
1924 /**
1925  * lpfc_sli4_fcf_rr_next_proc - processing next roundrobin fcf
1926  * @vport: Pointer to vport object.
1927  * @fcf_index: index to next fcf.
1928  *
1929  * This function processing the roundrobin fcf failover to next fcf index.
1930  * When this function is invoked, there will be a current fcf registered
1931  * for flogi.
1932  * Return: 0 for continue retrying flogi on currently registered fcf;
1933  *         1 for stop flogi on currently registered fcf;
1934  */
1935 int lpfc_sli4_fcf_rr_next_proc(struct lpfc_vport *vport, uint16_t fcf_index)
1936 {
1937         struct lpfc_hba *phba = vport->phba;
1938         int rc;
1939
1940         if (fcf_index == LPFC_FCOE_FCF_NEXT_NONE) {
1941                 spin_lock_irq(&phba->hbalock);
1942                 if (phba->hba_flag & HBA_DEVLOSS_TMO) {
1943                         spin_unlock_irq(&phba->hbalock);
1944                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
1945                                         "2872 Devloss tmo with no eligible "
1946                                         "FCF, unregister in-use FCF (x%x) "
1947                                         "and rescan FCF table\n",
1948                                         phba->fcf.current_rec.fcf_indx);
1949                         lpfc_unregister_fcf_rescan(phba);
1950                         goto stop_flogi_current_fcf;
1951                 }
1952                 /* Mark the end to FLOGI roundrobin failover */
1953                 phba->hba_flag &= ~FCF_RR_INPROG;
1954                 /* Allow action to new fcf asynchronous event */
1955                 phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
1956                 spin_unlock_irq(&phba->hbalock);
1957                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
1958                                 "2865 No FCF available, stop roundrobin FCF "
1959                                 "failover and change port state:x%x/x%x\n",
1960                                 phba->pport->port_state, LPFC_VPORT_UNKNOWN);
1961                 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
1962                 goto stop_flogi_current_fcf;
1963         } else {
1964                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_ELS,
1965                                 "2794 Try FLOGI roundrobin FCF failover to "
1966                                 "(x%x)\n", fcf_index);
1967                 rc = lpfc_sli4_fcf_rr_read_fcf_rec(phba, fcf_index);
1968                 if (rc)
1969                         lpfc_printf_log(phba, KERN_WARNING, LOG_FIP | LOG_ELS,
1970                                         "2761 FLOGI roundrobin FCF failover "
1971                                         "failed (rc:x%x) to read FCF (x%x)\n",
1972                                         rc, phba->fcf.current_rec.fcf_indx);
1973                 else
1974                         goto stop_flogi_current_fcf;
1975         }
1976         return 0;
1977
1978 stop_flogi_current_fcf:
1979         lpfc_can_disctmo(vport);
1980         return 1;
1981 }
1982
1983 /**
1984  * lpfc_sli4_fcf_pri_list_del
1985  * @phba: pointer to lpfc hba data structure.
1986  * @fcf_index the index of the fcf record to delete
1987  * This routine checks the on list flag of the fcf_index to be deleted.
1988  * If it is one the list then it is removed from the list, and the flag
1989  * is cleared. This routine grab the hbalock before removing the fcf
1990  * record from the list.
1991  **/
1992 static void lpfc_sli4_fcf_pri_list_del(struct lpfc_hba *phba,
1993                         uint16_t fcf_index)
1994 {
1995         struct lpfc_fcf_pri *new_fcf_pri;
1996
1997         new_fcf_pri = &phba->fcf.fcf_pri[fcf_index];
1998         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
1999                 "3058 deleting idx x%x pri x%x flg x%x\n",
2000                 fcf_index, new_fcf_pri->fcf_rec.priority,
2001                  new_fcf_pri->fcf_rec.flag);
2002         spin_lock_irq(&phba->hbalock);
2003         if (new_fcf_pri->fcf_rec.flag & LPFC_FCF_ON_PRI_LIST) {
2004                 if (phba->fcf.current_rec.priority ==
2005                                 new_fcf_pri->fcf_rec.priority)
2006                         phba->fcf.eligible_fcf_cnt--;
2007                 list_del_init(&new_fcf_pri->list);
2008                 new_fcf_pri->fcf_rec.flag &= ~LPFC_FCF_ON_PRI_LIST;
2009         }
2010         spin_unlock_irq(&phba->hbalock);
2011 }
2012
2013 /**
2014  * lpfc_sli4_set_fcf_flogi_fail
2015  * @phba: pointer to lpfc hba data structure.
2016  * @fcf_index the index of the fcf record to update
2017  * This routine acquires the hbalock and then set the LPFC_FCF_FLOGI_FAILED
2018  * flag so the the round robin slection for the particular priority level
2019  * will try a different fcf record that does not have this bit set.
2020  * If the fcf record is re-read for any reason this flag is cleared brfore
2021  * adding it to the priority list.
2022  **/
2023 void
2024 lpfc_sli4_set_fcf_flogi_fail(struct lpfc_hba *phba, uint16_t fcf_index)
2025 {
2026         struct lpfc_fcf_pri *new_fcf_pri;
2027         new_fcf_pri = &phba->fcf.fcf_pri[fcf_index];
2028         spin_lock_irq(&phba->hbalock);
2029         new_fcf_pri->fcf_rec.flag |= LPFC_FCF_FLOGI_FAILED;
2030         spin_unlock_irq(&phba->hbalock);
2031 }
2032
2033 /**
2034  * lpfc_sli4_fcf_pri_list_add
2035  * @phba: pointer to lpfc hba data structure.
2036  * @fcf_index the index of the fcf record to add
2037  * This routine checks the priority of the fcf_index to be added.
2038  * If it is a lower priority than the current head of the fcf_pri list
2039  * then it is added to the list in the right order.
2040  * If it is the same priority as the current head of the list then it
2041  * is added to the head of the list and its bit in the rr_bmask is set.
2042  * If the fcf_index to be added is of a higher priority than the current
2043  * head of the list then the rr_bmask is cleared, its bit is set in the
2044  * rr_bmask and it is added to the head of the list.
2045  * returns:
2046  * 0=success 1=failure
2047  **/
2048 int lpfc_sli4_fcf_pri_list_add(struct lpfc_hba *phba, uint16_t fcf_index,
2049         struct fcf_record *new_fcf_record)
2050 {
2051         uint16_t current_fcf_pri;
2052         uint16_t last_index;
2053         struct lpfc_fcf_pri *fcf_pri;
2054         struct lpfc_fcf_pri *next_fcf_pri;
2055         struct lpfc_fcf_pri *new_fcf_pri;
2056         int ret;
2057
2058         new_fcf_pri = &phba->fcf.fcf_pri[fcf_index];
2059         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2060                 "3059 adding idx x%x pri x%x flg x%x\n",
2061                 fcf_index, new_fcf_record->fip_priority,
2062                  new_fcf_pri->fcf_rec.flag);
2063         spin_lock_irq(&phba->hbalock);
2064         if (new_fcf_pri->fcf_rec.flag & LPFC_FCF_ON_PRI_LIST)
2065                 list_del_init(&new_fcf_pri->list);
2066         new_fcf_pri->fcf_rec.fcf_index = fcf_index;
2067         new_fcf_pri->fcf_rec.priority = new_fcf_record->fip_priority;
2068         if (list_empty(&phba->fcf.fcf_pri_list)) {
2069                 list_add(&new_fcf_pri->list, &phba->fcf.fcf_pri_list);
2070                 ret = lpfc_sli4_fcf_rr_index_set(phba,
2071                                 new_fcf_pri->fcf_rec.fcf_index);
2072                 goto out;
2073         }
2074
2075         last_index = find_first_bit(phba->fcf.fcf_rr_bmask,
2076                                 LPFC_SLI4_FCF_TBL_INDX_MAX);
2077         if (last_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {
2078                 ret = 0; /* Empty rr list */
2079                 goto out;
2080         }
2081         current_fcf_pri = phba->fcf.fcf_pri[last_index].fcf_rec.priority;
2082         if (new_fcf_pri->fcf_rec.priority <=  current_fcf_pri) {
2083                 list_add(&new_fcf_pri->list, &phba->fcf.fcf_pri_list);
2084                 if (new_fcf_pri->fcf_rec.priority <  current_fcf_pri) {
2085                         memset(phba->fcf.fcf_rr_bmask, 0,
2086                                 sizeof(*phba->fcf.fcf_rr_bmask));
2087                         /* fcfs_at_this_priority_level = 1; */
2088                         phba->fcf.eligible_fcf_cnt = 1;
2089                 } else
2090                         /* fcfs_at_this_priority_level++; */
2091                         phba->fcf.eligible_fcf_cnt++;
2092                 ret = lpfc_sli4_fcf_rr_index_set(phba,
2093                                 new_fcf_pri->fcf_rec.fcf_index);
2094                 goto out;
2095         }
2096
2097         list_for_each_entry_safe(fcf_pri, next_fcf_pri,
2098                                 &phba->fcf.fcf_pri_list, list) {
2099                 if (new_fcf_pri->fcf_rec.priority <=
2100                                 fcf_pri->fcf_rec.priority) {
2101                         if (fcf_pri->list.prev == &phba->fcf.fcf_pri_list)
2102                                 list_add(&new_fcf_pri->list,
2103                                                 &phba->fcf.fcf_pri_list);
2104                         else
2105                                 list_add(&new_fcf_pri->list,
2106                                          &((struct lpfc_fcf_pri *)
2107                                         fcf_pri->list.prev)->list);
2108                         ret = 0;
2109                         goto out;
2110                 } else if (fcf_pri->list.next == &phba->fcf.fcf_pri_list
2111                         || new_fcf_pri->fcf_rec.priority <
2112                                 next_fcf_pri->fcf_rec.priority) {
2113                         list_add(&new_fcf_pri->list, &fcf_pri->list);
2114                         ret = 0;
2115                         goto out;
2116                 }
2117                 if (new_fcf_pri->fcf_rec.priority > fcf_pri->fcf_rec.priority)
2118                         continue;
2119
2120         }
2121         ret = 1;
2122 out:
2123         /* we use = instead of |= to clear the FLOGI_FAILED flag. */
2124         new_fcf_pri->fcf_rec.flag = LPFC_FCF_ON_PRI_LIST;
2125         spin_unlock_irq(&phba->hbalock);
2126         return ret;
2127 }
2128
2129 /**
2130  * lpfc_mbx_cmpl_fcf_scan_read_fcf_rec - fcf scan read_fcf mbox cmpl handler.
2131  * @phba: pointer to lpfc hba data structure.
2132  * @mboxq: pointer to mailbox object.
2133  *
2134  * This function iterates through all the fcf records available in
2135  * HBA and chooses the optimal FCF record for discovery. After finding
2136  * the FCF for discovery it registers the FCF record and kicks start
2137  * discovery.
2138  * If FCF_IN_USE flag is set in currently used FCF, the routine tries to
2139  * use an FCF record which matches fabric name and mac address of the
2140  * currently used FCF record.
2141  * If the driver supports only one FCF, it will try to use the FCF record
2142  * used by BOOT_BIOS.
2143  */
2144 void
2145 lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
2146 {
2147         struct fcf_record *new_fcf_record;
2148         uint32_t boot_flag, addr_mode;
2149         uint16_t fcf_index, next_fcf_index;
2150         struct lpfc_fcf_rec *fcf_rec = NULL;
2151         uint16_t vlan_id;
2152         uint32_t seed;
2153         bool select_new_fcf;
2154         int rc;
2155
2156         /* If there is pending FCoE event restart FCF table scan */
2157         if (lpfc_check_pending_fcoe_event(phba, LPFC_SKIP_UNREG_FCF)) {
2158                 lpfc_sli4_mbox_cmd_free(phba, mboxq);
2159                 return;
2160         }
2161
2162         /* Parse the FCF record from the non-embedded mailbox command */
2163         new_fcf_record = lpfc_sli4_fcf_rec_mbox_parse(phba, mboxq,
2164                                                       &next_fcf_index);
2165         if (!new_fcf_record) {
2166                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
2167                                 "2765 Mailbox command READ_FCF_RECORD "
2168                                 "failed to retrieve a FCF record.\n");
2169                 /* Let next new FCF event trigger fast failover */
2170                 spin_lock_irq(&phba->hbalock);
2171                 phba->hba_flag &= ~FCF_TS_INPROG;
2172                 spin_unlock_irq(&phba->hbalock);
2173                 lpfc_sli4_mbox_cmd_free(phba, mboxq);
2174                 return;
2175         }
2176
2177         /* Check the FCF record against the connection list */
2178         rc = lpfc_match_fcf_conn_list(phba, new_fcf_record, &boot_flag,
2179                                       &addr_mode, &vlan_id);
2180
2181         /* Log the FCF record information if turned on */
2182         lpfc_sli4_log_fcf_record_info(phba, new_fcf_record, vlan_id,
2183                                       next_fcf_index);
2184
2185         /*
2186          * If the fcf record does not match with connect list entries
2187          * read the next entry; otherwise, this is an eligible FCF
2188          * record for roundrobin FCF failover.
2189          */
2190         if (!rc) {
2191                 lpfc_sli4_fcf_pri_list_del(phba,
2192                                         bf_get(lpfc_fcf_record_fcf_index,
2193                                                new_fcf_record));
2194                 lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
2195                                 "2781 FCF (x%x) failed connection "
2196                                 "list check: (x%x/x%x/%x)\n",
2197                                 bf_get(lpfc_fcf_record_fcf_index,
2198                                        new_fcf_record),
2199                                 bf_get(lpfc_fcf_record_fcf_avail,
2200                                        new_fcf_record),
2201                                 bf_get(lpfc_fcf_record_fcf_valid,
2202                                        new_fcf_record),
2203                                 bf_get(lpfc_fcf_record_fcf_sol,
2204                                        new_fcf_record));
2205                 if ((phba->fcf.fcf_flag & FCF_IN_USE) &&
2206                     lpfc_sli4_fcf_record_match(phba, &phba->fcf.current_rec,
2207                     new_fcf_record, LPFC_FCOE_IGNORE_VID)) {
2208                         if (bf_get(lpfc_fcf_record_fcf_index, new_fcf_record) !=
2209                             phba->fcf.current_rec.fcf_indx) {
2210                                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
2211                                         "2862 FCF (x%x) matches property "
2212                                         "of in-use FCF (x%x)\n",
2213                                         bf_get(lpfc_fcf_record_fcf_index,
2214                                                new_fcf_record),
2215                                         phba->fcf.current_rec.fcf_indx);
2216                                 goto read_next_fcf;
2217                         }
2218                         /*
2219                          * In case the current in-use FCF record becomes
2220                          * invalid/unavailable during FCF discovery that
2221                          * was not triggered by fast FCF failover process,
2222                          * treat it as fast FCF failover.
2223                          */
2224                         if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND) &&
2225                             !(phba->fcf.fcf_flag & FCF_REDISC_FOV)) {
2226                                 lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
2227                                                 "2835 Invalid in-use FCF "
2228                                                 "(x%x), enter FCF failover "
2229                                                 "table scan.\n",
2230                                                 phba->fcf.current_rec.fcf_indx);
2231                                 spin_lock_irq(&phba->hbalock);
2232                                 phba->fcf.fcf_flag |= FCF_REDISC_FOV;
2233                                 spin_unlock_irq(&phba->hbalock);
2234                                 lpfc_sli4_mbox_cmd_free(phba, mboxq);
2235                                 lpfc_sli4_fcf_scan_read_fcf_rec(phba,
2236                                                 LPFC_FCOE_FCF_GET_FIRST);
2237                                 return;
2238                         }
2239                 }
2240                 goto read_next_fcf;
2241         } else {
2242                 fcf_index = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
2243                 rc = lpfc_sli4_fcf_pri_list_add(phba, fcf_index,
2244                                                         new_fcf_record);
2245                 if (rc)
2246                         goto read_next_fcf;
2247         }
2248
2249         /*
2250          * If this is not the first FCF discovery of the HBA, use last
2251          * FCF record for the discovery. The condition that a rescan
2252          * matches the in-use FCF record: fabric name, switch name, mac
2253          * address, and vlan_id.
2254          */
2255         spin_lock_irq(&phba->hbalock);
2256         if (phba->fcf.fcf_flag & FCF_IN_USE) {
2257                 if (phba->cfg_fcf_failover_policy == LPFC_FCF_FOV &&
2258                         lpfc_sli4_fcf_record_match(phba, &phba->fcf.current_rec,
2259                     new_fcf_record, vlan_id)) {
2260                         if (bf_get(lpfc_fcf_record_fcf_index, new_fcf_record) ==
2261                             phba->fcf.current_rec.fcf_indx) {
2262                                 phba->fcf.fcf_flag |= FCF_AVAILABLE;
2263                                 if (phba->fcf.fcf_flag & FCF_REDISC_PEND)
2264                                         /* Stop FCF redisc wait timer */
2265                                         __lpfc_sli4_stop_fcf_redisc_wait_timer(
2266                                                                         phba);
2267                                 else if (phba->fcf.fcf_flag & FCF_REDISC_FOV)
2268                                         /* Fast failover, mark completed */
2269                                         phba->fcf.fcf_flag &= ~FCF_REDISC_FOV;
2270                                 spin_unlock_irq(&phba->hbalock);
2271                                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2272                                                 "2836 New FCF matches in-use "
2273                                                 "FCF (x%x)\n",
2274                                                 phba->fcf.current_rec.fcf_indx);
2275                                 goto out;
2276                         } else
2277                                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
2278                                         "2863 New FCF (x%x) matches "
2279                                         "property of in-use FCF (x%x)\n",
2280                                         bf_get(lpfc_fcf_record_fcf_index,
2281                                                new_fcf_record),
2282                                         phba->fcf.current_rec.fcf_indx);
2283                 }
2284                 /*
2285                  * Read next FCF record from HBA searching for the matching
2286                  * with in-use record only if not during the fast failover
2287                  * period. In case of fast failover period, it shall try to
2288                  * determine whether the FCF record just read should be the
2289                  * next candidate.
2290                  */
2291                 if (!(phba->fcf.fcf_flag & FCF_REDISC_FOV)) {
2292                         spin_unlock_irq(&phba->hbalock);
2293                         goto read_next_fcf;
2294                 }
2295         }
2296         /*
2297          * Update on failover FCF record only if it's in FCF fast-failover
2298          * period; otherwise, update on current FCF record.
2299          */
2300         if (phba->fcf.fcf_flag & FCF_REDISC_FOV)
2301                 fcf_rec = &phba->fcf.failover_rec;
2302         else
2303                 fcf_rec = &phba->fcf.current_rec;
2304
2305         if (phba->fcf.fcf_flag & FCF_AVAILABLE) {
2306                 /*
2307                  * If the driver FCF record does not have boot flag
2308                  * set and new hba fcf record has boot flag set, use
2309                  * the new hba fcf record.
2310                  */
2311                 if (boot_flag && !(fcf_rec->flag & BOOT_ENABLE)) {
2312                         /* Choose this FCF record */
2313                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2314                                         "2837 Update current FCF record "
2315                                         "(x%x) with new FCF record (x%x)\n",
2316                                         fcf_rec->fcf_indx,
2317                                         bf_get(lpfc_fcf_record_fcf_index,
2318                                         new_fcf_record));
2319                         __lpfc_update_fcf_record(phba, fcf_rec, new_fcf_record,
2320                                         addr_mode, vlan_id, BOOT_ENABLE);
2321                         spin_unlock_irq(&phba->hbalock);
2322                         goto read_next_fcf;
2323                 }
2324                 /*
2325                  * If the driver FCF record has boot flag set and the
2326                  * new hba FCF record does not have boot flag, read
2327                  * the next FCF record.
2328                  */
2329                 if (!boot_flag && (fcf_rec->flag & BOOT_ENABLE)) {
2330                         spin_unlock_irq(&phba->hbalock);
2331                         goto read_next_fcf;
2332                 }
2333                 /*
2334                  * If the new hba FCF record has lower priority value
2335                  * than the driver FCF record, use the new record.
2336                  */
2337                 if (new_fcf_record->fip_priority < fcf_rec->priority) {
2338                         /* Choose the new FCF record with lower priority */
2339                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2340                                         "2838 Update current FCF record "
2341                                         "(x%x) with new FCF record (x%x)\n",
2342                                         fcf_rec->fcf_indx,
2343                                         bf_get(lpfc_fcf_record_fcf_index,
2344                                                new_fcf_record));
2345                         __lpfc_update_fcf_record(phba, fcf_rec, new_fcf_record,
2346                                         addr_mode, vlan_id, 0);
2347                         /* Reset running random FCF selection count */
2348                         phba->fcf.eligible_fcf_cnt = 1;
2349                 } else if (new_fcf_record->fip_priority == fcf_rec->priority) {
2350                         /* Update running random FCF selection count */
2351                         phba->fcf.eligible_fcf_cnt++;
2352                         select_new_fcf = lpfc_sli4_new_fcf_random_select(phba,
2353                                                 phba->fcf.eligible_fcf_cnt);
2354                         if (select_new_fcf) {
2355                                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2356                                         "2839 Update current FCF record "
2357                                         "(x%x) with new FCF record (x%x)\n",
2358                                         fcf_rec->fcf_indx,
2359                                         bf_get(lpfc_fcf_record_fcf_index,
2360                                                new_fcf_record));
2361                                 /* Choose the new FCF by random selection */
2362                                 __lpfc_update_fcf_record(phba, fcf_rec,
2363                                                          new_fcf_record,
2364                                                          addr_mode, vlan_id, 0);
2365                         }
2366                 }
2367                 spin_unlock_irq(&phba->hbalock);
2368                 goto read_next_fcf;
2369         }
2370         /*
2371          * This is the first suitable FCF record, choose this record for
2372          * initial best-fit FCF.
2373          */
2374         if (fcf_rec) {
2375                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2376                                 "2840 Update initial FCF candidate "
2377                                 "with FCF (x%x)\n",
2378                                 bf_get(lpfc_fcf_record_fcf_index,
2379                                        new_fcf_record));
2380                 __lpfc_update_fcf_record(phba, fcf_rec, new_fcf_record,
2381                                          addr_mode, vlan_id, (boot_flag ?
2382                                          BOOT_ENABLE : 0));
2383                 phba->fcf.fcf_flag |= FCF_AVAILABLE;
2384                 /* Setup initial running random FCF selection count */
2385                 phba->fcf.eligible_fcf_cnt = 1;
2386                 /* Seeding the random number generator for random selection */
2387                 seed = (uint32_t)(0xFFFFFFFF & jiffies);
2388                 prandom_seed(seed);
2389         }
2390         spin_unlock_irq(&phba->hbalock);
2391         goto read_next_fcf;
2392
2393 read_next_fcf:
2394         lpfc_sli4_mbox_cmd_free(phba, mboxq);
2395         if (next_fcf_index == LPFC_FCOE_FCF_NEXT_NONE || next_fcf_index == 0) {
2396                 if (phba->fcf.fcf_flag & FCF_REDISC_FOV) {
2397                         /*
2398                          * Case of FCF fast failover scan
2399                          */
2400
2401                         /*
2402                          * It has not found any suitable FCF record, cancel
2403                          * FCF scan inprogress, and do nothing
2404                          */
2405                         if (!(phba->fcf.failover_rec.flag & RECORD_VALID)) {
2406                                 lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
2407                                                "2782 No suitable FCF found: "
2408                                                "(x%x/x%x)\n",
2409                                                phba->fcoe_eventtag_at_fcf_scan,
2410                                                bf_get(lpfc_fcf_record_fcf_index,
2411                                                       new_fcf_record));
2412                                 spin_lock_irq(&phba->hbalock);
2413                                 if (phba->hba_flag & HBA_DEVLOSS_TMO) {
2414                                         phba->hba_flag &= ~FCF_TS_INPROG;
2415                                         spin_unlock_irq(&phba->hbalock);
2416                                         /* Unregister in-use FCF and rescan */
2417                                         lpfc_printf_log(phba, KERN_INFO,
2418                                                         LOG_FIP,
2419                                                         "2864 On devloss tmo "
2420                                                         "unreg in-use FCF and "
2421                                                         "rescan FCF table\n");
2422                                         lpfc_unregister_fcf_rescan(phba);
2423                                         return;
2424                                 }
2425                                 /*
2426                                  * Let next new FCF event trigger fast failover
2427                                  */
2428                                 phba->hba_flag &= ~FCF_TS_INPROG;
2429                                 spin_unlock_irq(&phba->hbalock);
2430                                 return;
2431                         }
2432                         /*
2433                          * It has found a suitable FCF record that is not
2434                          * the same as in-use FCF record, unregister the
2435                          * in-use FCF record, replace the in-use FCF record
2436                          * with the new FCF record, mark FCF fast failover
2437                          * completed, and then start register the new FCF
2438                          * record.
2439                          */
2440
2441                         /* Unregister the current in-use FCF record */
2442                         lpfc_unregister_fcf(phba);
2443
2444                         /* Replace in-use record with the new record */
2445                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2446                                         "2842 Replace in-use FCF (x%x) "
2447                                         "with failover FCF (x%x)\n",
2448                                         phba->fcf.current_rec.fcf_indx,
2449                                         phba->fcf.failover_rec.fcf_indx);
2450                         memcpy(&phba->fcf.current_rec,
2451                                &phba->fcf.failover_rec,
2452                                sizeof(struct lpfc_fcf_rec));
2453                         /*
2454                          * Mark the fast FCF failover rediscovery completed
2455                          * and the start of the first round of the roundrobin
2456                          * FCF failover.
2457                          */
2458                         spin_lock_irq(&phba->hbalock);
2459                         phba->fcf.fcf_flag &= ~FCF_REDISC_FOV;
2460                         spin_unlock_irq(&phba->hbalock);
2461                         /* Register to the new FCF record */
2462                         lpfc_register_fcf(phba);
2463                 } else {
2464                         /*
2465                          * In case of transaction period to fast FCF failover,
2466                          * do nothing when search to the end of the FCF table.
2467                          */
2468                         if ((phba->fcf.fcf_flag & FCF_REDISC_EVT) ||
2469                             (phba->fcf.fcf_flag & FCF_REDISC_PEND))
2470                                 return;
2471
2472                         if (phba->cfg_fcf_failover_policy == LPFC_FCF_FOV &&
2473                                 phba->fcf.fcf_flag & FCF_IN_USE) {
2474                                 /*
2475                                  * In case the current in-use FCF record no
2476                                  * longer existed during FCF discovery that
2477                                  * was not triggered by fast FCF failover
2478                                  * process, treat it as fast FCF failover.
2479                                  */
2480                                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2481                                                 "2841 In-use FCF record (x%x) "
2482                                                 "not reported, entering fast "
2483                                                 "FCF failover mode scanning.\n",
2484                                                 phba->fcf.current_rec.fcf_indx);
2485                                 spin_lock_irq(&phba->hbalock);
2486                                 phba->fcf.fcf_flag |= FCF_REDISC_FOV;
2487                                 spin_unlock_irq(&phba->hbalock);
2488                                 lpfc_sli4_fcf_scan_read_fcf_rec(phba,
2489                                                 LPFC_FCOE_FCF_GET_FIRST);
2490                                 return;
2491                         }
2492                         /* Register to the new FCF record */
2493                         lpfc_register_fcf(phba);
2494                 }
2495         } else
2496                 lpfc_sli4_fcf_scan_read_fcf_rec(phba, next_fcf_index);
2497         return;
2498
2499 out:
2500         lpfc_sli4_mbox_cmd_free(phba, mboxq);
2501         lpfc_register_fcf(phba);
2502
2503         return;
2504 }
2505
2506 /**
2507  * lpfc_mbx_cmpl_fcf_rr_read_fcf_rec - fcf roundrobin read_fcf mbox cmpl hdler
2508  * @phba: pointer to lpfc hba data structure.
2509  * @mboxq: pointer to mailbox object.
2510  *
2511  * This is the callback function for FLOGI failure roundrobin FCF failover
2512  * read FCF record mailbox command from the eligible FCF record bmask for
2513  * performing the failover. If the FCF read back is not valid/available, it
2514  * fails through to retrying FLOGI to the currently registered FCF again.
2515  * Otherwise, if the FCF read back is valid and available, it will set the
2516  * newly read FCF record to the failover FCF record, unregister currently
2517  * registered FCF record, copy the failover FCF record to the current
2518  * FCF record, and then register the current FCF record before proceeding
2519  * to trying FLOGI on the new failover FCF.
2520  */
2521 void
2522 lpfc_mbx_cmpl_fcf_rr_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
2523 {
2524         struct fcf_record *new_fcf_record;
2525         uint32_t boot_flag, addr_mode;
2526         uint16_t next_fcf_index, fcf_index;
2527         uint16_t current_fcf_index;
2528         uint16_t vlan_id;
2529         int rc;
2530
2531         /* If link state is not up, stop the roundrobin failover process */
2532         if (phba->link_state < LPFC_LINK_UP) {
2533                 spin_lock_irq(&phba->hbalock);
2534                 phba->fcf.fcf_flag &= ~FCF_DISCOVERY;
2535                 phba->hba_flag &= ~FCF_RR_INPROG;
2536                 spin_unlock_irq(&phba->hbalock);
2537                 goto out;
2538         }
2539
2540         /* Parse the FCF record from the non-embedded mailbox command */
2541         new_fcf_record = lpfc_sli4_fcf_rec_mbox_parse(phba, mboxq,
2542                                                       &next_fcf_index);
2543         if (!new_fcf_record) {
2544                 lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
2545                                 "2766 Mailbox command READ_FCF_RECORD "
2546                                 "failed to retrieve a FCF record.\n");
2547                 goto error_out;
2548         }
2549
2550         /* Get the needed parameters from FCF record */
2551         rc = lpfc_match_fcf_conn_list(phba, new_fcf_record, &boot_flag,
2552                                       &addr_mode, &vlan_id);
2553
2554         /* Log the FCF record information if turned on */
2555         lpfc_sli4_log_fcf_record_info(phba, new_fcf_record, vlan_id,
2556                                       next_fcf_index);
2557
2558         fcf_index = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
2559         if (!rc) {
2560                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2561                                 "2848 Remove ineligible FCF (x%x) from "
2562                                 "from roundrobin bmask\n", fcf_index);
2563                 /* Clear roundrobin bmask bit for ineligible FCF */
2564                 lpfc_sli4_fcf_rr_index_clear(phba, fcf_index);
2565                 /* Perform next round of roundrobin FCF failover */
2566                 fcf_index = lpfc_sli4_fcf_rr_next_index_get(phba);
2567                 rc = lpfc_sli4_fcf_rr_next_proc(phba->pport, fcf_index);
2568                 if (rc)
2569                         goto out;
2570                 goto error_out;
2571         }
2572
2573         if (fcf_index == phba->fcf.current_rec.fcf_indx) {
2574                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2575                                 "2760 Perform FLOGI roundrobin FCF failover: "
2576                                 "FCF (x%x) back to FCF (x%x)\n",
2577                                 phba->fcf.current_rec.fcf_indx, fcf_index);
2578                 /* Wait 500 ms before retrying FLOGI to current FCF */
2579                 msleep(500);
2580                 lpfc_issue_init_vfi(phba->pport);
2581                 goto out;
2582         }
2583
2584         /* Upload new FCF record to the failover FCF record */
2585         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2586                         "2834 Update current FCF (x%x) with new FCF (x%x)\n",
2587                         phba->fcf.failover_rec.fcf_indx, fcf_index);
2588         spin_lock_irq(&phba->hbalock);
2589         __lpfc_update_fcf_record(phba, &phba->fcf.failover_rec,
2590                                  new_fcf_record, addr_mode, vlan_id,
2591                                  (boot_flag ? BOOT_ENABLE : 0));
2592         spin_unlock_irq(&phba->hbalock);
2593
2594         current_fcf_index = phba->fcf.current_rec.fcf_indx;
2595
2596         /* Unregister the current in-use FCF record */
2597         lpfc_unregister_fcf(phba);
2598
2599         /* Replace in-use record with the new record */
2600         memcpy(&phba->fcf.current_rec, &phba->fcf.failover_rec,
2601                sizeof(struct lpfc_fcf_rec));
2602
2603         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2604                         "2783 Perform FLOGI roundrobin FCF failover: FCF "
2605                         "(x%x) to FCF (x%x)\n", current_fcf_index, fcf_index);
2606
2607 error_out:
2608         lpfc_register_fcf(phba);
2609 out:
2610         lpfc_sli4_mbox_cmd_free(phba, mboxq);
2611 }
2612
2613 /**
2614  * lpfc_mbx_cmpl_read_fcf_rec - read fcf completion handler.
2615  * @phba: pointer to lpfc hba data structure.
2616  * @mboxq: pointer to mailbox object.
2617  *
2618  * This is the callback function of read FCF record mailbox command for
2619  * updating the eligible FCF bmask for FLOGI failure roundrobin FCF
2620  * failover when a new FCF event happened. If the FCF read back is
2621  * valid/available and it passes the connection list check, it updates
2622  * the bmask for the eligible FCF record for roundrobin failover.
2623  */
2624 void
2625 lpfc_mbx_cmpl_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
2626 {
2627         struct fcf_record *new_fcf_record;
2628         uint32_t boot_flag, addr_mode;
2629         uint16_t fcf_index, next_fcf_index;
2630         uint16_t vlan_id;
2631         int rc;
2632
2633         /* If link state is not up, no need to proceed */
2634         if (phba->link_state < LPFC_LINK_UP)
2635                 goto out;
2636
2637         /* If FCF discovery period is over, no need to proceed */
2638         if (!(phba->fcf.fcf_flag & FCF_DISCOVERY))
2639                 goto out;
2640
2641         /* Parse the FCF record from the non-embedded mailbox command */
2642         new_fcf_record = lpfc_sli4_fcf_rec_mbox_parse(phba, mboxq,
2643                                                       &next_fcf_index);
2644         if (!new_fcf_record) {
2645                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
2646                                 "2767 Mailbox command READ_FCF_RECORD "
2647                                 "failed to retrieve a FCF record.\n");
2648                 goto out;
2649         }
2650
2651         /* Check the connection list for eligibility */
2652         rc = lpfc_match_fcf_conn_list(phba, new_fcf_record, &boot_flag,
2653                                       &addr_mode, &vlan_id);
2654
2655         /* Log the FCF record information if turned on */
2656         lpfc_sli4_log_fcf_record_info(phba, new_fcf_record, vlan_id,
2657                                       next_fcf_index);
2658
2659         if (!rc)
2660                 goto out;
2661
2662         /* Update the eligible FCF record index bmask */
2663         fcf_index = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
2664
2665         rc = lpfc_sli4_fcf_pri_list_add(phba, fcf_index, new_fcf_record);
2666
2667 out:
2668         lpfc_sli4_mbox_cmd_free(phba, mboxq);
2669 }
2670
2671 /**
2672  * lpfc_init_vfi_cmpl - Completion handler for init_vfi mbox command.
2673  * @phba: pointer to lpfc hba data structure.
2674  * @mboxq: pointer to mailbox data structure.
2675  *
2676  * This function handles completion of init vfi mailbox command.
2677  */
2678 void
2679 lpfc_init_vfi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
2680 {
2681         struct lpfc_vport *vport = mboxq->vport;
2682
2683         /*
2684          * VFI not supported on interface type 0, just do the flogi
2685          * Also continue if the VFI is in use - just use the same one.
2686          */
2687         if (mboxq->u.mb.mbxStatus &&
2688             (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
2689                         LPFC_SLI_INTF_IF_TYPE_0) &&
2690             mboxq->u.mb.mbxStatus != MBX_VFI_IN_USE) {
2691                 lpfc_printf_vlog(vport, KERN_ERR,
2692                                 LOG_MBOX,
2693                                 "2891 Init VFI mailbox failed 0x%x\n",
2694                                 mboxq->u.mb.mbxStatus);
2695                 mempool_free(mboxq, phba->mbox_mem_pool);
2696                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
2697                 return;
2698         }
2699
2700         lpfc_initial_flogi(vport);
2701         mempool_free(mboxq, phba->mbox_mem_pool);
2702         return;
2703 }
2704
2705 /**
2706  * lpfc_issue_init_vfi - Issue init_vfi mailbox command.
2707  * @vport: pointer to lpfc_vport data structure.
2708  *
2709  * This function issue a init_vfi mailbox command to initialize the VFI and
2710  * VPI for the physical port.
2711  */
2712 void
2713 lpfc_issue_init_vfi(struct lpfc_vport *vport)
2714 {
2715         LPFC_MBOXQ_t *mboxq;
2716         int rc;
2717         struct lpfc_hba *phba = vport->phba;
2718
2719         mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2720         if (!mboxq) {
2721                 lpfc_printf_vlog(vport, KERN_ERR,
2722                         LOG_MBOX, "2892 Failed to allocate "
2723                         "init_vfi mailbox\n");
2724                 return;
2725         }
2726         lpfc_init_vfi(mboxq, vport);
2727         mboxq->mbox_cmpl = lpfc_init_vfi_cmpl;
2728         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
2729         if (rc == MBX_NOT_FINISHED) {
2730                 lpfc_printf_vlog(vport, KERN_ERR,
2731                         LOG_MBOX, "2893 Failed to issue init_vfi mailbox\n");
2732                 mempool_free(mboxq, vport->phba->mbox_mem_pool);
2733         }
2734 }
2735
2736 /**
2737  * lpfc_init_vpi_cmpl - Completion handler for init_vpi mbox command.
2738  * @phba: pointer to lpfc hba data structure.
2739  * @mboxq: pointer to mailbox data structure.
2740  *
2741  * This function handles completion of init vpi mailbox command.
2742  */
2743 void
2744 lpfc_init_vpi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
2745 {
2746         struct lpfc_vport *vport = mboxq->vport;
2747         struct lpfc_nodelist *ndlp;
2748         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2749
2750         if (mboxq->u.mb.mbxStatus) {
2751                 lpfc_printf_vlog(vport, KERN_ERR,
2752                                 LOG_MBOX,
2753                                 "2609 Init VPI mailbox failed 0x%x\n",
2754                                 mboxq->u.mb.mbxStatus);
2755                 mempool_free(mboxq, phba->mbox_mem_pool);
2756                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
2757                 return;
2758         }
2759         spin_lock_irq(shost->host_lock);
2760         vport->fc_flag &= ~FC_VPORT_NEEDS_INIT_VPI;
2761         spin_unlock_irq(shost->host_lock);
2762
2763         /* If this port is physical port or FDISC is done, do reg_vpi */
2764         if ((phba->pport == vport) || (vport->port_state == LPFC_FDISC)) {
2765                         ndlp = lpfc_findnode_did(vport, Fabric_DID);
2766                         if (!ndlp)
2767                                 lpfc_printf_vlog(vport, KERN_ERR,
2768                                         LOG_DISCOVERY,
2769                                         "2731 Cannot find fabric "
2770                                         "controller node\n");
2771                         else
2772                                 lpfc_register_new_vport(phba, vport, ndlp);
2773                         mempool_free(mboxq, phba->mbox_mem_pool);
2774                         return;
2775         }
2776
2777         if (phba->link_flag & LS_NPIV_FAB_SUPPORTED)
2778                 lpfc_initial_fdisc(vport);
2779         else {
2780                 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
2781                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
2782                                  "2606 No NPIV Fabric support\n");
2783         }
2784         mempool_free(mboxq, phba->mbox_mem_pool);
2785         return;
2786 }
2787
2788 /**
2789  * lpfc_issue_init_vpi - Issue init_vpi mailbox command.
2790  * @vport: pointer to lpfc_vport data structure.
2791  *
2792  * This function issue a init_vpi mailbox command to initialize
2793  * VPI for the vport.
2794  */
2795 void
2796 lpfc_issue_init_vpi(struct lpfc_vport *vport)
2797 {
2798         LPFC_MBOXQ_t *mboxq;
2799         int rc;
2800
2801         mboxq = mempool_alloc(vport->phba->mbox_mem_pool, GFP_KERNEL);
2802         if (!mboxq) {
2803                 lpfc_printf_vlog(vport, KERN_ERR,
2804                         LOG_MBOX, "2607 Failed to allocate "
2805                         "init_vpi mailbox\n");
2806                 return;
2807         }
2808         lpfc_init_vpi(vport->phba, mboxq, vport->vpi);
2809         mboxq->vport = vport;
2810         mboxq->mbox_cmpl = lpfc_init_vpi_cmpl;
2811         rc = lpfc_sli_issue_mbox(vport->phba, mboxq, MBX_NOWAIT);
2812         if (rc == MBX_NOT_FINISHED) {
2813                 lpfc_printf_vlog(vport, KERN_ERR,
2814                         LOG_MBOX, "2608 Failed to issue init_vpi mailbox\n");
2815                 mempool_free(mboxq, vport->phba->mbox_mem_pool);
2816         }
2817 }
2818
2819 /**
2820  * lpfc_start_fdiscs - send fdiscs for each vports on this port.
2821  * @phba: pointer to lpfc hba data structure.
2822  *
2823  * This function loops through the list of vports on the @phba and issues an
2824  * FDISC if possible.
2825  */
2826 void
2827 lpfc_start_fdiscs(struct lpfc_hba *phba)
2828 {
2829         struct lpfc_vport **vports;
2830         int i;
2831
2832         vports = lpfc_create_vport_work_array(phba);
2833         if (vports != NULL) {
2834                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2835                         if (vports[i]->port_type == LPFC_PHYSICAL_PORT)
2836                                 continue;
2837                         /* There are no vpi for this vport */
2838                         if (vports[i]->vpi > phba->max_vpi) {
2839                                 lpfc_vport_set_state(vports[i],
2840                                                      FC_VPORT_FAILED);
2841                                 continue;
2842                         }
2843                         if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
2844                                 lpfc_vport_set_state(vports[i],
2845                                                      FC_VPORT_LINKDOWN);
2846                                 continue;
2847                         }
2848                         if (vports[i]->fc_flag & FC_VPORT_NEEDS_INIT_VPI) {
2849                                 lpfc_issue_init_vpi(vports[i]);
2850                                 continue;
2851                         }
2852                         if (phba->link_flag & LS_NPIV_FAB_SUPPORTED)
2853                                 lpfc_initial_fdisc(vports[i]);
2854                         else {
2855                                 lpfc_vport_set_state(vports[i],
2856                                                      FC_VPORT_NO_FABRIC_SUPP);
2857                                 lpfc_printf_vlog(vports[i], KERN_ERR,
2858                                                  LOG_ELS,
2859                                                  "0259 No NPIV "
2860                                                  "Fabric support\n");
2861                         }
2862                 }
2863         }
2864         lpfc_destroy_vport_work_array(phba, vports);
2865 }
2866
2867 void
2868 lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
2869 {
2870         struct lpfc_dmabuf *dmabuf = mboxq->context1;
2871         struct lpfc_vport *vport = mboxq->vport;
2872         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2873
2874         /*
2875          * VFI not supported for interface type 0, so ignore any mailbox
2876          * error (except VFI in use) and continue with the discovery.
2877          */
2878         if (mboxq->u.mb.mbxStatus &&
2879             (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
2880                         LPFC_SLI_INTF_IF_TYPE_0) &&
2881             mboxq->u.mb.mbxStatus != MBX_VFI_IN_USE) {
2882                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
2883                          "2018 REG_VFI mbxStatus error x%x "
2884                          "HBA state x%x\n",
2885                          mboxq->u.mb.mbxStatus, vport->port_state);
2886                 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
2887                         /* FLOGI failed, use loop map to make discovery list */
2888                         lpfc_disc_list_loopmap(vport);
2889                         /* Start discovery */
2890                         lpfc_disc_start(vport);
2891                         goto out_free_mem;
2892                 }
2893                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
2894                 goto out_free_mem;
2895         }
2896
2897         /* If the VFI is already registered, there is nothing else to do */
2898         if (vport->fc_flag & FC_VFI_REGISTERED)
2899                 goto out_free_mem;
2900
2901         /* The VPI is implicitly registered when the VFI is registered */
2902         spin_lock_irq(shost->host_lock);
2903         vport->vpi_state |= LPFC_VPI_REGISTERED;
2904         vport->fc_flag |= FC_VFI_REGISTERED;
2905         vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
2906         vport->fc_flag &= ~FC_VPORT_NEEDS_INIT_VPI;
2907         spin_unlock_irq(shost->host_lock);
2908
2909         /* In case SLI4 FC loopback test, we are ready */
2910         if ((phba->sli_rev == LPFC_SLI_REV4) &&
2911             (phba->link_flag & LS_LOOPBACK_MODE)) {
2912                 phba->link_state = LPFC_HBA_READY;
2913                 goto out_free_mem;
2914         }
2915
2916         if (vport->port_state == LPFC_FABRIC_CFG_LINK) {
2917                 /*
2918                  * For private loop or for NPort pt2pt,
2919                  * just start discovery and we are done.
2920                  */
2921                 if ((vport->fc_flag & FC_PT2PT) ||
2922                     ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
2923                     !(vport->fc_flag & FC_PUBLIC_LOOP))) {
2924
2925                         /* Use loop map to make discovery list */
2926                         lpfc_disc_list_loopmap(vport);
2927                         /* Start discovery */
2928                         lpfc_disc_start(vport);
2929                 } else {
2930                         lpfc_start_fdiscs(phba);
2931                         lpfc_do_scr_ns_plogi(phba, vport);
2932                 }
2933         }
2934
2935 out_free_mem:
2936         mempool_free(mboxq, phba->mbox_mem_pool);
2937         lpfc_mbuf_free(phba, dmabuf->virt, dmabuf->phys);
2938         kfree(dmabuf);
2939         return;
2940 }
2941
2942 static void
2943 lpfc_mbx_cmpl_read_sparam(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2944 {
2945         MAILBOX_t *mb = &pmb->u.mb;
2946         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) pmb->context1;
2947         struct lpfc_vport  *vport = pmb->vport;
2948
2949
2950         /* Check for error */
2951         if (mb->mbxStatus) {
2952                 /* READ_SPARAM mbox error <mbxStatus> state <hba_state> */
2953                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
2954                                  "0319 READ_SPARAM mbxStatus error x%x "
2955                                  "hba state x%x>\n",
2956                                  mb->mbxStatus, vport->port_state);
2957                 lpfc_linkdown(phba);
2958                 goto out;
2959         }
2960
2961         memcpy((uint8_t *) &vport->fc_sparam, (uint8_t *) mp->virt,
2962                sizeof (struct serv_parm));
2963         lpfc_update_vport_wwn(vport);
2964         if (vport->port_type == LPFC_PHYSICAL_PORT) {
2965                 memcpy(&phba->wwnn, &vport->fc_nodename, sizeof(phba->wwnn));
2966                 memcpy(&phba->wwpn, &vport->fc_portname, sizeof(phba->wwnn));
2967         }
2968
2969         lpfc_mbuf_free(phba, mp->virt, mp->phys);
2970         kfree(mp);
2971         mempool_free(pmb, phba->mbox_mem_pool);
2972         return;
2973
2974 out:
2975         pmb->context1 = NULL;
2976         lpfc_mbuf_free(phba, mp->virt, mp->phys);
2977         kfree(mp);
2978         lpfc_issue_clear_la(phba, vport);
2979         mempool_free(pmb, phba->mbox_mem_pool);
2980         return;
2981 }
2982
2983 static void
2984 lpfc_mbx_process_link_up(struct lpfc_hba *phba, struct lpfc_mbx_read_top *la)
2985 {
2986         struct lpfc_vport *vport = phba->pport;
2987         LPFC_MBOXQ_t *sparam_mbox, *cfglink_mbox = NULL;
2988         struct Scsi_Host *shost;
2989         int i;
2990         struct lpfc_dmabuf *mp;
2991         int rc;
2992         struct fcf_record *fcf_record;
2993         uint32_t fc_flags = 0;
2994
2995         spin_lock_irq(&phba->hbalock);
2996         switch (bf_get(lpfc_mbx_read_top_link_spd, la)) {
2997         case LPFC_LINK_SPEED_1GHZ:
2998         case LPFC_LINK_SPEED_2GHZ:
2999         case LPFC_LINK_SPEED_4GHZ:
3000         case LPFC_LINK_SPEED_8GHZ:
3001         case LPFC_LINK_SPEED_10GHZ:
3002         case LPFC_LINK_SPEED_16GHZ:
3003                 phba->fc_linkspeed = bf_get(lpfc_mbx_read_top_link_spd, la);
3004                 break;
3005         default:
3006                 phba->fc_linkspeed = LPFC_LINK_SPEED_UNKNOWN;
3007                 break;
3008         }
3009
3010         phba->fc_topology = bf_get(lpfc_mbx_read_top_topology, la);
3011         phba->link_flag &= ~LS_NPIV_FAB_SUPPORTED;
3012
3013         shost = lpfc_shost_from_vport(vport);
3014         if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
3015                 phba->sli3_options &= ~LPFC_SLI3_NPIV_ENABLED;
3016
3017                 /* if npiv is enabled and this adapter supports npiv log
3018                  * a message that npiv is not supported in this topology
3019                  */
3020                 if (phba->cfg_enable_npiv && phba->max_vpi)
3021                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
3022                                 "1309 Link Up Event npiv not supported in loop "
3023                                 "topology\n");
3024                                 /* Get Loop Map information */
3025                 if (bf_get(lpfc_mbx_read_top_il, la))
3026                         fc_flags |= FC_LBIT;
3027
3028                 vport->fc_myDID = bf_get(lpfc_mbx_read_top_alpa_granted, la);
3029                 i = la->lilpBde64.tus.f.bdeSize;
3030
3031                 if (i == 0) {
3032                         phba->alpa_map[0] = 0;
3033                 } else {
3034                         if (vport->cfg_log_verbose & LOG_LINK_EVENT) {
3035                                 int numalpa, j, k;
3036                                 union {
3037                                         uint8_t pamap[16];
3038                                         struct {
3039                                                 uint32_t wd1;
3040                                                 uint32_t wd2;
3041                                                 uint32_t wd3;
3042                                                 uint32_t wd4;
3043                                         } pa;
3044                                 } un;
3045                                 numalpa = phba->alpa_map[0];
3046                                 j = 0;
3047                                 while (j < numalpa) {
3048                                         memset(un.pamap, 0, 16);
3049                                         for (k = 1; j < numalpa; k++) {
3050                                                 un.pamap[k - 1] =
3051                                                         phba->alpa_map[j + 1];
3052                                                 j++;
3053                                                 if (k == 16)
3054                                                         break;
3055                                         }
3056                                         /* Link Up Event ALPA map */
3057                                         lpfc_printf_log(phba,
3058                                                         KERN_WARNING,
3059                                                         LOG_LINK_EVENT,
3060                                                         "1304 Link Up Event "
3061                                                         "ALPA map Data: x%x "
3062                                                         "x%x x%x x%x\n",
3063                                                         un.pa.wd1, un.pa.wd2,
3064                                                         un.pa.wd3, un.pa.wd4);
3065                                 }
3066                         }
3067                 }
3068         } else {
3069                 if (!(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)) {
3070                         if (phba->max_vpi && phba->cfg_enable_npiv &&
3071                            (phba->sli_rev >= LPFC_SLI_REV3))
3072                                 phba->sli3_options |= LPFC_SLI3_NPIV_ENABLED;
3073                 }
3074                 vport->fc_myDID = phba->fc_pref_DID;
3075                 fc_flags |= FC_LBIT;
3076         }
3077         spin_unlock_irq(&phba->hbalock);
3078
3079         if (fc_flags) {
3080                 spin_lock_irq(shost->host_lock);
3081                 vport->fc_flag |= fc_flags;
3082                 spin_unlock_irq(shost->host_lock);
3083         }
3084
3085         lpfc_linkup(phba);
3086         sparam_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3087         if (!sparam_mbox)
3088                 goto out;
3089
3090         rc = lpfc_read_sparam(phba, sparam_mbox, 0);
3091         if (rc) {
3092                 mempool_free(sparam_mbox, phba->mbox_mem_pool);
3093                 goto out;
3094         }
3095         sparam_mbox->vport = vport;
3096         sparam_mbox->mbox_cmpl = lpfc_mbx_cmpl_read_sparam;
3097         rc = lpfc_sli_issue_mbox(phba, sparam_mbox, MBX_NOWAIT);
3098         if (rc == MBX_NOT_FINISHED) {
3099                 mp = (struct lpfc_dmabuf *) sparam_mbox->context1;
3100                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3101                 kfree(mp);
3102                 mempool_free(sparam_mbox, phba->mbox_mem_pool);
3103                 goto out;
3104         }
3105
3106         if (!(phba->hba_flag & HBA_FCOE_MODE)) {
3107                 cfglink_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3108                 if (!cfglink_mbox)
3109                         goto out;
3110                 vport->port_state = LPFC_LOCAL_CFG_LINK;
3111                 lpfc_config_link(phba, cfglink_mbox);
3112                 cfglink_mbox->vport = vport;
3113                 cfglink_mbox->mbox_cmpl = lpfc_mbx_cmpl_local_config_link;
3114                 rc = lpfc_sli_issue_mbox(phba, cfglink_mbox, MBX_NOWAIT);
3115                 if (rc == MBX_NOT_FINISHED) {
3116                         mempool_free(cfglink_mbox, phba->mbox_mem_pool);
3117                         goto out;
3118                 }
3119         } else {
3120                 vport->port_state = LPFC_VPORT_UNKNOWN;
3121                 /*
3122                  * Add the driver's default FCF record at FCF index 0 now. This
3123                  * is phase 1 implementation that support FCF index 0 and driver
3124                  * defaults.
3125                  */
3126                 if (!(phba->hba_flag & HBA_FIP_SUPPORT)) {
3127                         fcf_record = kzalloc(sizeof(struct fcf_record),
3128                                         GFP_KERNEL);
3129                         if (unlikely(!fcf_record)) {
3130                                 lpfc_printf_log(phba, KERN_ERR,
3131                                         LOG_MBOX | LOG_SLI,
3132                                         "2554 Could not allocate memory for "
3133                                         "fcf record\n");
3134                                 rc = -ENODEV;
3135                                 goto out;
3136                         }
3137
3138                         lpfc_sli4_build_dflt_fcf_record(phba, fcf_record,
3139                                                 LPFC_FCOE_FCF_DEF_INDEX);
3140                         rc = lpfc_sli4_add_fcf_record(phba, fcf_record);
3141                         if (unlikely(rc)) {
3142                                 lpfc_printf_log(phba, KERN_ERR,
3143                                         LOG_MBOX | LOG_SLI,
3144                                         "2013 Could not manually add FCF "
3145                                         "record 0, status %d\n", rc);
3146                                 rc = -ENODEV;
3147                                 kfree(fcf_record);
3148                                 goto out;
3149                         }
3150                         kfree(fcf_record);
3151                 }
3152                 /*
3153                  * The driver is expected to do FIP/FCF. Call the port
3154                  * and get the FCF Table.
3155                  */
3156                 spin_lock_irq(&phba->hbalock);
3157                 if (phba->hba_flag & FCF_TS_INPROG) {
3158                         spin_unlock_irq(&phba->hbalock);
3159                         return;
3160                 }
3161                 /* This is the initial FCF discovery scan */
3162                 phba->fcf.fcf_flag |= FCF_INIT_DISC;
3163                 spin_unlock_irq(&phba->hbalock);
3164                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
3165                                 "2778 Start FCF table scan at linkup\n");
3166                 rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,
3167                                                      LPFC_FCOE_FCF_GET_FIRST);
3168                 if (rc) {
3169                         spin_lock_irq(&phba->hbalock);
3170                         phba->fcf.fcf_flag &= ~FCF_INIT_DISC;
3171                         spin_unlock_irq(&phba->hbalock);
3172                         goto out;
3173                 }
3174                 /* Reset FCF roundrobin bmask for new discovery */
3175                 lpfc_sli4_clear_fcf_rr_bmask(phba);
3176         }
3177
3178         return;
3179 out:
3180         lpfc_vport_set_state(vport, FC_VPORT_FAILED);
3181         lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
3182                          "0263 Discovery Mailbox error: state: 0x%x : %p %p\n",
3183                          vport->port_state, sparam_mbox, cfglink_mbox);
3184         lpfc_issue_clear_la(phba, vport);
3185         return;
3186 }
3187
3188 static void
3189 lpfc_enable_la(struct lpfc_hba *phba)
3190 {
3191         uint32_t control;
3192         struct lpfc_sli *psli = &phba->sli;
3193         spin_lock_irq(&phba->hbalock);
3194         psli->sli_flag |= LPFC_PROCESS_LA;
3195         if (phba->sli_rev <= LPFC_SLI_REV3) {
3196                 control = readl(phba->HCregaddr);
3197                 control |= HC_LAINT_ENA;
3198                 writel(control, phba->HCregaddr);
3199                 readl(phba->HCregaddr); /* flush */
3200         }
3201         spin_unlock_irq(&phba->hbalock);
3202 }
3203
3204 static void
3205 lpfc_mbx_issue_link_down(struct lpfc_hba *phba)
3206 {
3207         lpfc_linkdown(phba);
3208         lpfc_enable_la(phba);
3209         lpfc_unregister_unused_fcf(phba);
3210         /* turn on Link Attention interrupts - no CLEAR_LA needed */
3211 }
3212
3213
3214 /*
3215  * This routine handles processing a READ_TOPOLOGY mailbox
3216  * command upon completion. It is setup in the LPFC_MBOXQ
3217  * as the completion routine when the command is
3218  * handed off to the SLI layer.
3219  */
3220 void
3221 lpfc_mbx_cmpl_read_topology(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
3222 {
3223         struct lpfc_vport *vport = pmb->vport;
3224         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
3225         struct lpfc_mbx_read_top *la;
3226         MAILBOX_t *mb = &pmb->u.mb;
3227         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
3228
3229         /* Unblock ELS traffic */
3230         phba->sli.ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT;
3231         /* Check for error */
3232         if (mb->mbxStatus) {
3233                 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
3234                                 "1307 READ_LA mbox error x%x state x%x\n",
3235                                 mb->mbxStatus, vport->port_state);
3236                 lpfc_mbx_issue_link_down(phba);
3237                 phba->link_state = LPFC_HBA_ERROR;
3238                 goto lpfc_mbx_cmpl_read_topology_free_mbuf;
3239         }
3240
3241         la = (struct lpfc_mbx_read_top *) &pmb->u.mb.un.varReadTop;
3242
3243         memcpy(&phba->alpa_map[0], mp->virt, 128);
3244
3245         spin_lock_irq(shost->host_lock);
3246         if (bf_get(lpfc_mbx_read_top_pb, la))
3247                 vport->fc_flag |= FC_BYPASSED_MODE;
3248         else
3249                 vport->fc_flag &= ~FC_BYPASSED_MODE;
3250         spin_unlock_irq(shost->host_lock);
3251
3252         if (phba->fc_eventTag <= la->eventTag) {
3253                 phba->fc_stat.LinkMultiEvent++;
3254                 if (bf_get(lpfc_mbx_read_top_att_type, la) == LPFC_ATT_LINK_UP)
3255                         if (phba->fc_eventTag != 0)
3256                                 lpfc_linkdown(phba);
3257         }
3258
3259         phba->fc_eventTag = la->eventTag;
3260         if (phba->sli_rev < LPFC_SLI_REV4) {
3261                 spin_lock_irq(&phba->hbalock);
3262                 if (bf_get(lpfc_mbx_read_top_mm, la))
3263                         phba->sli.sli_flag |= LPFC_MENLO_MAINT;
3264                 else
3265                         phba->sli.sli_flag &= ~LPFC_MENLO_MAINT;
3266                 spin_unlock_irq(&phba->hbalock);
3267         }
3268
3269         phba->link_events++;
3270         if ((bf_get(lpfc_mbx_read_top_att_type, la) == LPFC_ATT_LINK_UP) &&
3271             !(phba->sli.sli_flag & LPFC_MENLO_MAINT)) {
3272                 phba->fc_stat.LinkUp++;
3273                 if (phba->link_flag & LS_LOOPBACK_MODE) {
3274                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
3275                                         "1306 Link Up Event in loop back mode "
3276                                         "x%x received Data: x%x x%x x%x x%x\n",
3277                                         la->eventTag, phba->fc_eventTag,
3278                                         bf_get(lpfc_mbx_read_top_alpa_granted,
3279                                                la),
3280                                         bf_get(lpfc_mbx_read_top_link_spd, la),
3281                                         phba->alpa_map[0]);
3282                 } else {
3283                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
3284                                         "1303 Link Up Event x%x received "
3285                                         "Data: x%x x%x x%x x%x x%x x%x %d\n",
3286                                         la->eventTag, phba->fc_eventTag,
3287                                         bf_get(lpfc_mbx_read_top_alpa_granted,
3288                                                la),
3289                                         bf_get(lpfc_mbx_read_top_link_spd, la),
3290                                         phba->alpa_map[0],
3291                                         bf_get(lpfc_mbx_read_top_mm, la),
3292                                         bf_get(lpfc_mbx_read_top_fa, la),
3293                                         phba->wait_4_mlo_maint_flg);
3294                 }
3295                 lpfc_mbx_process_link_up(phba, la);
3296         } else if (bf_get(lpfc_mbx_read_top_att_type, la) ==
3297                    LPFC_ATT_LINK_DOWN) {
3298                 phba->fc_stat.LinkDown++;
3299                 if (phba->link_flag & LS_LOOPBACK_MODE)
3300                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
3301                                 "1308 Link Down Event in loop back mode "
3302                                 "x%x received "
3303                                 "Data: x%x x%x x%x\n",
3304                                 la->eventTag, phba->fc_eventTag,
3305                                 phba->pport->port_state, vport->fc_flag);
3306                 else
3307                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
3308                                 "1305 Link Down Event x%x received "
3309                                 "Data: x%x x%x x%x x%x x%x\n",
3310                                 la->eventTag, phba->fc_eventTag,
3311                                 phba->pport->port_state, vport->fc_flag,
3312                                 bf_get(lpfc_mbx_read_top_mm, la),
3313                                 bf_get(lpfc_mbx_read_top_fa, la));
3314                 lpfc_mbx_issue_link_down(phba);
3315         }
3316         if ((phba->sli.sli_flag & LPFC_MENLO_MAINT) &&
3317             ((bf_get(lpfc_mbx_read_top_att_type, la) == LPFC_ATT_LINK_UP))) {
3318                 if (phba->link_state != LPFC_LINK_DOWN) {
3319                         phba->fc_stat.LinkDown++;
3320                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
3321                                 "1312 Link Down Event x%x received "
3322                                 "Data: x%x x%x x%x\n",
3323                                 la->eventTag, phba->fc_eventTag,
3324                                 phba->pport->port_state, vport->fc_flag);
3325                         lpfc_mbx_issue_link_down(phba);
3326                 } else
3327                         lpfc_enable_la(phba);
3328
3329                 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
3330                                 "1310 Menlo Maint Mode Link up Event x%x rcvd "
3331                                 "Data: x%x x%x x%x\n",
3332                                 la->eventTag, phba->fc_eventTag,
3333                                 phba->pport->port_state, vport->fc_flag);
3334                 /*
3335                  * The cmnd that triggered this will be waiting for this
3336                  * signal.
3337                  */
3338                 /* WAKEUP for MENLO_SET_MODE or MENLO_RESET command. */
3339                 if (phba->wait_4_mlo_maint_flg) {
3340                         phba->wait_4_mlo_maint_flg = 0;
3341                         wake_up_interruptible(&phba->wait_4_mlo_m_q);
3342                 }
3343         }
3344
3345         if ((phba->sli_rev < LPFC_SLI_REV4) &&
3346             bf_get(lpfc_mbx_read_top_fa, la)) {
3347                 if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
3348                         lpfc_issue_clear_la(phba, vport);
3349                 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
3350                                 "1311 fa %d\n",
3351                                 bf_get(lpfc_mbx_read_top_fa, la));
3352         }
3353
3354 lpfc_mbx_cmpl_read_topology_free_mbuf:
3355         lpfc_mbuf_free(phba, mp->virt, mp->phys);
3356         kfree(mp);
3357         mempool_free(pmb, phba->mbox_mem_pool);
3358         return;
3359 }
3360
3361 /*
3362  * This routine handles processing a REG_LOGIN mailbox
3363  * command upon completion. It is setup in the LPFC_MBOXQ
3364  * as the completion routine when the command is
3365  * handed off to the SLI layer.
3366  */
3367 void
3368 lpfc_mbx_cmpl_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
3369 {
3370         struct lpfc_vport  *vport = pmb->vport;
3371         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
3372         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
3373         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
3374
3375         pmb->context1 = NULL;
3376         pmb->context2 = NULL;
3377
3378         if (ndlp->nlp_flag & NLP_REG_LOGIN_SEND)
3379                 ndlp->nlp_flag &= ~NLP_REG_LOGIN_SEND;
3380
3381         if (ndlp->nlp_flag & NLP_IGNR_REG_CMPL ||
3382             ndlp->nlp_state != NLP_STE_REG_LOGIN_ISSUE) {
3383                 /* We rcvd a rscn after issuing this
3384                  * mbox reg login, we may have cycled
3385                  * back through the state and be
3386                  * back at reg login state so this
3387                  * mbox needs to be ignored becase
3388                  * there is another reg login in
3389                  * process.
3390                  */
3391                 spin_lock_irq(shost->host_lock);
3392                 ndlp->nlp_flag &= ~NLP_IGNR_REG_CMPL;
3393                 spin_unlock_irq(shost->host_lock);
3394         } else
3395                 /* Good status, call state machine */
3396                 lpfc_disc_state_machine(vport, ndlp, pmb,
3397                                 NLP_EVT_CMPL_REG_LOGIN);
3398
3399         lpfc_mbuf_free(phba, mp->virt, mp->phys);
3400         kfree(mp);
3401         mempool_free(pmb, phba->mbox_mem_pool);
3402         /* decrement the node reference count held for this callback
3403          * function.
3404          */
3405         lpfc_nlp_put(ndlp);
3406
3407         return;
3408 }
3409
3410 static void
3411 lpfc_mbx_cmpl_unreg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
3412 {
3413         MAILBOX_t *mb = &pmb->u.mb;
3414         struct lpfc_vport *vport = pmb->vport;
3415         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
3416
3417         switch (mb->mbxStatus) {
3418         case 0x0011:
3419         case 0x0020:
3420                 lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
3421                                  "0911 cmpl_unreg_vpi, mb status = 0x%x\n",
3422                                  mb->mbxStatus);
3423                 break;
3424         /* If VPI is busy, reset the HBA */
3425         case 0x9700:
3426                 lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE,
3427                         "2798 Unreg_vpi failed vpi 0x%x, mb status = 0x%x\n",
3428                         vport->vpi, mb->mbxStatus);
3429                 if (!(phba->pport->load_flag & FC_UNLOADING))
3430                         lpfc_workq_post_event(phba, NULL, NULL,
3431                                 LPFC_EVT_RESET_HBA);
3432         }
3433         spin_lock_irq(shost->host_lock);
3434         vport->vpi_state &= ~LPFC_VPI_REGISTERED;
3435         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
3436         spin_unlock_irq(shost->host_lock);
3437         vport->unreg_vpi_cmpl = VPORT_OK;
3438         mempool_free(pmb, phba->mbox_mem_pool);
3439         lpfc_cleanup_vports_rrqs(vport, NULL);
3440         /*
3441          * This shost reference might have been taken at the beginning of
3442          * lpfc_vport_delete()
3443          */
3444         if ((vport->load_flag & FC_UNLOADING) && (vport != phba->pport))
3445                 scsi_host_put(shost);
3446 }
3447
3448 int
3449 lpfc_mbx_unreg_vpi(struct lpfc_vport *vport)
3450 {
3451         struct lpfc_hba  *phba = vport->phba;
3452         LPFC_MBOXQ_t *mbox;
3453         int rc;
3454
3455         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3456         if (!mbox)
3457                 return 1;
3458
3459         lpfc_unreg_vpi(phba, vport->vpi, mbox);
3460         mbox->vport = vport;
3461         mbox->mbox_cmpl = lpfc_mbx_cmpl_unreg_vpi;
3462         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
3463         if (rc == MBX_NOT_FINISHED) {
3464                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX | LOG_VPORT,
3465                                  "1800 Could not issue unreg_vpi\n");
3466                 mempool_free(mbox, phba->mbox_mem_pool);
3467                 vport->unreg_vpi_cmpl = VPORT_ERROR;
3468                 return rc;
3469         }
3470         return 0;
3471 }
3472
3473 static void
3474 lpfc_mbx_cmpl_reg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
3475 {
3476         struct lpfc_vport *vport = pmb->vport;
3477         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
3478         MAILBOX_t *mb = &pmb->u.mb;
3479
3480         switch (mb->mbxStatus) {
3481         case 0x0011:
3482         case 0x9601:
3483         case 0x9602:
3484                 lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
3485                                  "0912 cmpl_reg_vpi, mb status = 0x%x\n",
3486                                  mb->mbxStatus);
3487                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
3488                 spin_lock_irq(shost->host_lock);
3489                 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
3490                 spin_unlock_irq(shost->host_lock);
3491                 vport->fc_myDID = 0;
3492                 goto out;
3493         }
3494
3495         spin_lock_irq(shost->host_lock);
3496         vport->vpi_state |= LPFC_VPI_REGISTERED;
3497         vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
3498         spin_unlock_irq(shost->host_lock);
3499         vport->num_disc_nodes = 0;
3500         /* go thru NPR list and issue ELS PLOGIs */
3501         if (vport->fc_npr_cnt)
3502                 lpfc_els_disc_plogi(vport);
3503
3504         if (!vport->num_disc_nodes) {
3505                 spin_lock_irq(shost->host_lock);
3506                 vport->fc_flag &= ~FC_NDISC_ACTIVE;
3507                 spin_unlock_irq(shost->host_lock);
3508                 lpfc_can_disctmo(vport);
3509         }
3510         vport->port_state = LPFC_VPORT_READY;
3511
3512 out:
3513         mempool_free(pmb, phba->mbox_mem_pool);
3514         return;
3515 }
3516
3517 /**
3518  * lpfc_create_static_vport - Read HBA config region to create static vports.
3519  * @phba: pointer to lpfc hba data structure.
3520  *
3521  * This routine issue a DUMP mailbox command for config region 22 to get
3522  * the list of static vports to be created. The function create vports
3523  * based on the information returned from the HBA.
3524  **/
3525 void
3526 lpfc_create_static_vport(struct lpfc_hba *phba)
3527 {
3528         LPFC_MBOXQ_t *pmb = NULL;
3529         MAILBOX_t *mb;
3530         struct static_vport_info *vport_info;
3531         int mbx_wait_rc = 0, i;
3532         struct fc_vport_identifiers vport_id;
3533         struct fc_vport *new_fc_vport;
3534         struct Scsi_Host *shost;
3535         struct lpfc_vport *vport;
3536         uint16_t offset = 0;
3537         uint8_t *vport_buff;
3538         struct lpfc_dmabuf *mp;
3539         uint32_t byte_count = 0;
3540
3541         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3542         if (!pmb) {
3543                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3544                                 "0542 lpfc_create_static_vport failed to"
3545                                 " allocate mailbox memory\n");
3546                 return;
3547         }
3548         memset(pmb, 0, sizeof(LPFC_MBOXQ_t));
3549         mb = &pmb->u.mb;
3550
3551         vport_info = kzalloc(sizeof(struct static_vport_info), GFP_KERNEL);
3552         if (!vport_info) {
3553                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3554                                 "0543 lpfc_create_static_vport failed to"
3555                                 " allocate vport_info\n");
3556                 mempool_free(pmb, phba->mbox_mem_pool);
3557                 return;
3558         }
3559
3560         vport_buff = (uint8_t *) vport_info;
3561         do {
3562                 /* free dma buffer from previous round */
3563                 if (pmb->context1) {
3564                         mp = (struct lpfc_dmabuf *)pmb->context1;
3565                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
3566                         kfree(mp);
3567                 }
3568                 if (lpfc_dump_static_vport(phba, pmb, offset))
3569                         goto out;
3570
3571                 pmb->vport = phba->pport;
3572                 mbx_wait_rc = lpfc_sli_issue_mbox_wait(phba, pmb,
3573                                                         LPFC_MBOX_TMO);
3574
3575                 if ((mbx_wait_rc != MBX_SUCCESS) || mb->mbxStatus) {
3576                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
3577                                 "0544 lpfc_create_static_vport failed to"
3578                                 " issue dump mailbox command ret 0x%x "
3579                                 "status 0x%x\n",
3580                                 mbx_wait_rc, mb->mbxStatus);
3581                         goto out;
3582                 }
3583
3584                 if (phba->sli_rev == LPFC_SLI_REV4) {
3585                         byte_count = pmb->u.mqe.un.mb_words[5];
3586                         mp = (struct lpfc_dmabuf *)pmb->context1;
3587                         if (byte_count > sizeof(struct static_vport_info) -
3588                                         offset)
3589                                 byte_count = sizeof(struct static_vport_info)
3590                                         - offset;
3591                         memcpy(vport_buff + offset, mp->virt, byte_count);
3592                         offset += byte_count;
3593                 } else {
3594                         if (mb->un.varDmp.word_cnt >
3595                                 sizeof(struct static_vport_info) - offset)
3596                                 mb->un.varDmp.word_cnt =
3597                                         sizeof(struct static_vport_info)
3598                                                 - offset;
3599                         byte_count = mb->un.varDmp.word_cnt;
3600                         lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
3601                                 vport_buff + offset,
3602                                 byte_count);
3603
3604                         offset += byte_count;
3605                 }
3606
3607         } while (byte_count &&
3608                 offset < sizeof(struct static_vport_info));
3609
3610
3611         if ((le32_to_cpu(vport_info->signature) != VPORT_INFO_SIG) ||
3612                 ((le32_to_cpu(vport_info->rev) & VPORT_INFO_REV_MASK)
3613                         != VPORT_INFO_REV)) {
3614                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3615                         "0545 lpfc_create_static_vport bad"
3616                         " information header 0x%x 0x%x\n",
3617                         le32_to_cpu(vport_info->signature),
3618                         le32_to_cpu(vport_info->rev) & VPORT_INFO_REV_MASK);
3619
3620                 goto out;
3621         }
3622
3623         shost = lpfc_shost_from_vport(phba->pport);
3624
3625         for (i = 0; i < MAX_STATIC_VPORT_COUNT; i++) {
3626                 memset(&vport_id, 0, sizeof(vport_id));
3627                 vport_id.port_name = wwn_to_u64(vport_info->vport_list[i].wwpn);
3628                 vport_id.node_name = wwn_to_u64(vport_info->vport_list[i].wwnn);
3629                 if (!vport_id.port_name || !vport_id.node_name)
3630                         continue;
3631
3632                 vport_id.roles = FC_PORT_ROLE_FCP_INITIATOR;
3633                 vport_id.vport_type = FC_PORTTYPE_NPIV;
3634                 vport_id.disable = false;
3635                 new_fc_vport = fc_vport_create(shost, 0, &vport_id);
3636
3637                 if (!new_fc_vport) {
3638                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
3639                                 "0546 lpfc_create_static_vport failed to"
3640                                 " create vport\n");
3641                         continue;
3642                 }
3643
3644                 vport = *(struct lpfc_vport **)new_fc_vport->dd_data;
3645                 vport->vport_flag |= STATIC_VPORT;
3646         }
3647
3648 out:
3649         kfree(vport_info);
3650         if (mbx_wait_rc != MBX_TIMEOUT) {
3651                 if (pmb->context1) {
3652                         mp = (struct lpfc_dmabuf *)pmb->context1;
3653                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
3654                         kfree(mp);
3655                 }
3656                 mempool_free(pmb, phba->mbox_mem_pool);
3657         }
3658
3659         return;
3660 }
3661
3662 /*
3663  * This routine handles processing a Fabric REG_LOGIN mailbox
3664  * command upon completion. It is setup in the LPFC_MBOXQ
3665  * as the completion routine when the command is
3666  * handed off to the SLI layer.
3667  */
3668 void
3669 lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
3670 {
3671         struct lpfc_vport *vport = pmb->vport;
3672         MAILBOX_t *mb = &pmb->u.mb;
3673         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
3674         struct lpfc_nodelist *ndlp;
3675         struct Scsi_Host *shost;
3676
3677         ndlp = (struct lpfc_nodelist *) pmb->context2;
3678         pmb->context1 = NULL;
3679         pmb->context2 = NULL;
3680
3681         if (mb->mbxStatus) {
3682                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
3683                                  "0258 Register Fabric login error: 0x%x\n",
3684                                  mb->mbxStatus);
3685                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3686                 kfree(mp);
3687                 mempool_free(pmb, phba->mbox_mem_pool);
3688
3689                 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
3690                         /* FLOGI failed, use loop map to make discovery list */
3691                         lpfc_disc_list_loopmap(vport);
3692
3693                         /* Start discovery */
3694                         lpfc_disc_start(vport);
3695                         /* Decrement the reference count to ndlp after the
3696                          * reference to the ndlp are done.
3697                          */
3698                         lpfc_nlp_put(ndlp);
3699                         return;
3700                 }
3701
3702                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
3703                 /* Decrement the reference count to ndlp after the reference
3704                  * to the ndlp are done.
3705                  */
3706                 lpfc_nlp_put(ndlp);
3707                 return;
3708         }
3709
3710         if (phba->sli_rev < LPFC_SLI_REV4)
3711                 ndlp->nlp_rpi = mb->un.varWords[0];
3712         ndlp->nlp_flag |= NLP_RPI_REGISTERED;
3713         ndlp->nlp_type |= NLP_FABRIC;
3714         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
3715
3716         if (vport->port_state == LPFC_FABRIC_CFG_LINK) {
3717                 /* when physical port receive logo donot start
3718                  * vport discovery */
3719                 if (!(vport->fc_flag & FC_LOGO_RCVD_DID_CHNG))
3720                         lpfc_start_fdiscs(phba);
3721                 else {
3722                         shost = lpfc_shost_from_vport(vport);
3723                         spin_lock_irq(shost->host_lock);
3724                         vport->fc_flag &= ~FC_LOGO_RCVD_DID_CHNG ;
3725                         spin_unlock_irq(shost->host_lock);
3726                 }
3727                 lpfc_do_scr_ns_plogi(phba, vport);
3728         }
3729
3730         lpfc_mbuf_free(phba, mp->virt, mp->phys);
3731         kfree(mp);
3732         mempool_free(pmb, phba->mbox_mem_pool);
3733
3734         /* Drop the reference count from the mbox at the end after
3735          * all the current reference to the ndlp have been done.
3736          */
3737         lpfc_nlp_put(ndlp);
3738         return;
3739 }
3740
3741 /*
3742  * This routine handles processing a NameServer REG_LOGIN mailbox
3743  * command upon completion. It is setup in the LPFC_MBOXQ
3744  * as the completion routine when the command is
3745  * handed off to the SLI layer.
3746  */
3747 void
3748 lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
3749 {
3750         MAILBOX_t *mb = &pmb->u.mb;
3751         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
3752         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
3753         struct lpfc_vport *vport = pmb->vport;
3754
3755         pmb->context1 = NULL;
3756         pmb->context2 = NULL;
3757
3758         if (mb->mbxStatus) {
3759 out:
3760                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
3761                                  "0260 Register NameServer error: 0x%x\n",
3762                                  mb->mbxStatus);
3763                 /* decrement the node reference count held for this
3764                  * callback function.
3765                  */
3766                 lpfc_nlp_put(ndlp);
3767                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
3768                 kfree(mp);
3769                 mempool_free(pmb, phba->mbox_mem_pool);
3770
3771                 /* If no other thread is using the ndlp, free it */
3772                 lpfc_nlp_not_used(ndlp);
3773
3774                 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
3775                         /*
3776                          * RegLogin failed, use loop map to make discovery
3777                          * list
3778                          */
3779                         lpfc_disc_list_loopmap(vport);
3780
3781                         /* Start discovery */
3782                         lpfc_disc_start(vport);
3783                         return;
3784                 }
3785                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
3786                 return;
3787         }
3788
3789         if (phba->sli_rev < LPFC_SLI_REV4)
3790                 ndlp->nlp_rpi = mb->un.varWords[0];
3791         ndlp->nlp_flag |= NLP_RPI_REGISTERED;
3792         ndlp->nlp_type |= NLP_FABRIC;
3793         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
3794
3795         if (vport->port_state < LPFC_VPORT_READY) {
3796                 /* Link up discovery requires Fabric registration. */
3797                 lpfc_ns_cmd(vport, SLI_CTNS_RFF_ID, 0, 0); /* Do this first! */
3798                 lpfc_ns_cmd(vport, SLI_CTNS_RNN_ID, 0, 0);
3799                 lpfc_ns_cmd(vport, SLI_CTNS_RSNN_NN, 0, 0);
3800                 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
3801                 lpfc_ns_cmd(vport, SLI_CTNS_RFT_ID, 0, 0);
3802
3803                 /* Issue SCR just before NameServer GID_FT Query */
3804                 lpfc_issue_els_scr(vport, SCR_DID, 0);
3805         }
3806
3807         vport->fc_ns_retry = 0;
3808         /* Good status, issue CT Request to NameServer */
3809         if (lpfc_ns_cmd(vport, SLI_CTNS_GID_FT, 0, 0)) {
3810                 /* Cannot issue NameServer Query, so finish up discovery */
3811                 goto out;
3812         }
3813
3814         /* decrement the node reference count held for this
3815          * callback function.
3816          */
3817         lpfc_nlp_put(ndlp);
3818         lpfc_mbuf_free(phba, mp->virt, mp->phys);
3819         kfree(mp);
3820         mempool_free(pmb, phba->mbox_mem_pool);
3821
3822         return;
3823 }
3824
3825 static void
3826 lpfc_register_remote_port(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
3827 {
3828         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3829         struct fc_rport  *rport;
3830         struct lpfc_rport_data *rdata;
3831         struct fc_rport_identifiers rport_ids;
3832         struct lpfc_hba  *phba = vport->phba;
3833
3834         /* Remote port has reappeared. Re-register w/ FC transport */
3835         rport_ids.node_name = wwn_to_u64(ndlp->nlp_nodename.u.wwn);
3836         rport_ids.port_name = wwn_to_u64(ndlp->nlp_portname.u.wwn);
3837         rport_ids.port_id = ndlp->nlp_DID;
3838         rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
3839
3840         /*
3841          * We leave our node pointer in rport->dd_data when we unregister a
3842          * FCP target port.  But fc_remote_port_add zeros the space to which
3843          * rport->dd_data points.  So, if we're reusing a previously
3844          * registered port, drop the reference that we took the last time we
3845          * registered the port.
3846          */
3847         if (ndlp->rport && ndlp->rport->dd_data &&
3848             ((struct lpfc_rport_data *) ndlp->rport->dd_data)->pnode == ndlp)
3849                 lpfc_nlp_put(ndlp);
3850
3851         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT,
3852                 "rport add:       did:x%x flg:x%x type x%x",
3853                 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type);
3854
3855         /* Don't add the remote port if unloading. */
3856         if (vport->load_flag & FC_UNLOADING)
3857                 return;
3858
3859         ndlp->rport = rport = fc_remote_port_add(shost, 0, &rport_ids);
3860         if (!rport || !get_device(&rport->dev)) {
3861                 dev_printk(KERN_WARNING, &phba->pcidev->dev,
3862                            "Warning: fc_remote_port_add failed\n");
3863                 return;
3864         }
3865
3866         /* initialize static port data */
3867         rport->maxframe_size = ndlp->nlp_maxframe;
3868         rport->supported_classes = ndlp->nlp_class_sup;
3869         rdata = rport->dd_data;
3870         rdata->pnode = lpfc_nlp_get(ndlp);
3871
3872         if (ndlp->nlp_type & NLP_FCP_TARGET)
3873                 rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
3874         if (ndlp->nlp_type & NLP_FCP_INITIATOR)
3875                 rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR;
3876
3877         if (rport_ids.roles !=  FC_RPORT_ROLE_UNKNOWN)
3878                 fc_remote_port_rolechg(rport, rport_ids.roles);
3879
3880         lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE,
3881                          "3183 rport register x%06x, rport %p role x%x\n",
3882                          ndlp->nlp_DID, rport, rport_ids.roles);
3883
3884         if ((rport->scsi_target_id != -1) &&
3885             (rport->scsi_target_id < LPFC_MAX_TARGET)) {
3886                 ndlp->nlp_sid = rport->scsi_target_id;
3887         }
3888         return;
3889 }
3890
3891 static void
3892 lpfc_unregister_remote_port(struct lpfc_nodelist *ndlp)
3893 {
3894         struct fc_rport *rport = ndlp->rport;
3895
3896         lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_RPORT,
3897                 "rport delete:    did:x%x flg:x%x type x%x",
3898                 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type);
3899
3900         lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE,
3901                          "3184 rport unregister x%06x, rport %p\n",
3902                          ndlp->nlp_DID, rport);
3903
3904         fc_remote_port_delete(rport);
3905
3906         return;
3907 }
3908
3909 static void
3910 lpfc_nlp_counters(struct lpfc_vport *vport, int state, int count)
3911 {
3912         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3913
3914         spin_lock_irq(shost->host_lock);
3915         switch (state) {
3916         case NLP_STE_UNUSED_NODE:
3917                 vport->fc_unused_cnt += count;
3918                 break;
3919         case NLP_STE_PLOGI_ISSUE:
3920                 vport->fc_plogi_cnt += count;
3921                 break;
3922         case NLP_STE_ADISC_ISSUE:
3923                 vport->fc_adisc_cnt += count;
3924                 break;
3925         case NLP_STE_REG_LOGIN_ISSUE:
3926                 vport->fc_reglogin_cnt += count;
3927                 break;
3928         case NLP_STE_PRLI_ISSUE:
3929                 vport->fc_prli_cnt += count;
3930                 break;
3931         case NLP_STE_UNMAPPED_NODE:
3932                 vport->fc_unmap_cnt += count;
3933                 break;
3934         case NLP_STE_MAPPED_NODE:
3935                 vport->fc_map_cnt += count;
3936                 break;
3937         case NLP_STE_NPR_NODE:
3938                 vport->fc_npr_cnt += count;
3939                 break;
3940         }
3941         spin_unlock_irq(shost->host_lock);
3942 }
3943
3944 static void
3945 lpfc_nlp_state_cleanup(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
3946                        int old_state, int new_state)
3947 {
3948         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3949
3950         if (new_state == NLP_STE_UNMAPPED_NODE) {
3951                 ndlp->nlp_flag &= ~NLP_NODEV_REMOVE;
3952                 ndlp->nlp_type |= NLP_FC_NODE;
3953         }
3954         if (new_state == NLP_STE_MAPPED_NODE)
3955                 ndlp->nlp_flag &= ~NLP_NODEV_REMOVE;
3956         if (new_state == NLP_STE_NPR_NODE)
3957                 ndlp->nlp_flag &= ~NLP_RCV_PLOGI;
3958
3959         /* Transport interface */
3960         if (ndlp->rport && (old_state == NLP_STE_MAPPED_NODE ||
3961                             old_state == NLP_STE_UNMAPPED_NODE)) {
3962                 vport->phba->nport_event_cnt++;
3963                 lpfc_unregister_remote_port(ndlp);
3964         }
3965
3966         if (new_state ==  NLP_STE_MAPPED_NODE ||
3967             new_state == NLP_STE_UNMAPPED_NODE) {
3968                 vport->phba->nport_event_cnt++;
3969                 /*
3970                  * Tell the fc transport about the port, if we haven't
3971                  * already. If we have, and it's a scsi entity, be
3972                  * sure to unblock any attached scsi devices
3973                  */
3974                 lpfc_register_remote_port(vport, ndlp);
3975         }
3976         if ((new_state ==  NLP_STE_MAPPED_NODE) &&
3977                 (vport->stat_data_enabled)) {
3978                 /*
3979                  * A new target is discovered, if there is no buffer for
3980                  * statistical data collection allocate buffer.
3981                  */
3982                 ndlp->lat_data = kcalloc(LPFC_MAX_BUCKET_COUNT,
3983                                          sizeof(struct lpfc_scsicmd_bkt),
3984                                          GFP_KERNEL);
3985
3986                 if (!ndlp->lat_data)
3987                         lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE,
3988                                 "0286 lpfc_nlp_state_cleanup failed to "
3989                                 "allocate statistical data buffer DID "
3990                                 "0x%x\n", ndlp->nlp_DID);
3991         }
3992         /*
3993          * if we added to Mapped list, but the remote port
3994          * registration failed or assigned a target id outside
3995          * our presentable range - move the node to the
3996          * Unmapped List
3997          */
3998         if (new_state == NLP_STE_MAPPED_NODE &&
3999             (!ndlp->rport ||
4000              ndlp->rport->scsi_target_id == -1 ||
4001              ndlp->rport->scsi_target_id >= LPFC_MAX_TARGET)) {
4002                 spin_lock_irq(shost->host_lock);
4003                 ndlp->nlp_flag |= NLP_TGT_NO_SCSIID;
4004                 spin_unlock_irq(shost->host_lock);
4005                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
4006         }
4007 }
4008
4009 static char *
4010 lpfc_nlp_state_name(char *buffer, size_t size, int state)
4011 {
4012         static char *states[] = {
4013                 [NLP_STE_UNUSED_NODE] = "UNUSED",
4014                 [NLP_STE_PLOGI_ISSUE] = "PLOGI",
4015                 [NLP_STE_ADISC_ISSUE] = "ADISC",
4016                 [NLP_STE_REG_LOGIN_ISSUE] = "REGLOGIN",
4017                 [NLP_STE_PRLI_ISSUE] = "PRLI",
4018                 [NLP_STE_LOGO_ISSUE] = "LOGO",
4019                 [NLP_STE_UNMAPPED_NODE] = "UNMAPPED",
4020                 [NLP_STE_MAPPED_NODE] = "MAPPED",
4021                 [NLP_STE_NPR_NODE] = "NPR",
4022         };
4023
4024         if (state < NLP_STE_MAX_STATE && states[state])
4025                 strlcpy(buffer, states[state], size);
4026         else
4027                 snprintf(buffer, size, "unknown (%d)", state);
4028         return buffer;
4029 }
4030
4031 void
4032 lpfc_nlp_set_state(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
4033                    int state)
4034 {
4035         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4036         int  old_state = ndlp->nlp_state;
4037         char name1[16], name2[16];
4038
4039         lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
4040                          "0904 NPort state transition x%06x, %s -> %s\n",
4041                          ndlp->nlp_DID,
4042                          lpfc_nlp_state_name(name1, sizeof(name1), old_state),
4043                          lpfc_nlp_state_name(name2, sizeof(name2), state));
4044
4045         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE,
4046                 "node statechg    did:x%x old:%d ste:%d",
4047                 ndlp->nlp_DID, old_state, state);
4048
4049         if (old_state == NLP_STE_NPR_NODE &&
4050             state != NLP_STE_NPR_NODE)
4051                 lpfc_cancel_retry_delay_tmo(vport, ndlp);
4052         if (old_state == NLP_STE_UNMAPPED_NODE) {
4053                 ndlp->nlp_flag &= ~NLP_TGT_NO_SCSIID;
4054                 ndlp->nlp_type &= ~NLP_FC_NODE;
4055         }
4056
4057         if (list_empty(&ndlp->nlp_listp)) {
4058                 spin_lock_irq(shost->host_lock);
4059                 list_add_tail(&ndlp->nlp_listp, &vport->fc_nodes);
4060                 spin_unlock_irq(shost->host_lock);
4061         } else if (old_state)
4062                 lpfc_nlp_counters(vport, old_state, -1);
4063
4064         ndlp->nlp_state = state;
4065         lpfc_nlp_counters(vport, state, 1);
4066         lpfc_nlp_state_cleanup(vport, ndlp, old_state, state);
4067 }
4068
4069 void
4070 lpfc_enqueue_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
4071 {
4072         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4073
4074         if (list_empty(&ndlp->nlp_listp)) {
4075                 spin_lock_irq(shost->host_lock);
4076                 list_add_tail(&ndlp->nlp_listp, &vport->fc_nodes);
4077                 spin_unlock_irq(shost->host_lock);
4078         }
4079 }
4080
4081 void
4082 lpfc_dequeue_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
4083 {
4084         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4085
4086         lpfc_cancel_retry_delay_tmo(vport, ndlp);
4087         if (ndlp->nlp_state && !list_empty(&ndlp->nlp_listp))
4088                 lpfc_nlp_counters(vport, ndlp->nlp_state, -1);
4089         spin_lock_irq(shost->host_lock);
4090         list_del_init(&ndlp->nlp_listp);
4091         spin_unlock_irq(shost->host_lock);
4092         lpfc_nlp_state_cleanup(vport, ndlp, ndlp->nlp_state,
4093                                 NLP_STE_UNUSED_NODE);
4094 }
4095
4096 static void
4097 lpfc_disable_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
4098 {
4099         lpfc_cancel_retry_delay_tmo(vport, ndlp);
4100         if (ndlp->nlp_state && !list_empty(&ndlp->nlp_listp))
4101                 lpfc_nlp_counters(vport, ndlp->nlp_state, -1);
4102         lpfc_nlp_state_cleanup(vport, ndlp, ndlp->nlp_state,
4103                                 NLP_STE_UNUSED_NODE);
4104 }
4105 /**
4106  * lpfc_initialize_node - Initialize all fields of node object
4107  * @vport: Pointer to Virtual Port object.
4108  * @ndlp: Pointer to FC node object.
4109  * @did: FC_ID of the node.
4110  *
4111  * This function is always called when node object need to be initialized.
4112  * It initializes all the fields of the node object. Although the reference
4113  * to phba from @ndlp can be obtained indirectly through it's reference to
4114  * @vport, a direct reference to phba is taken here by @ndlp. This is due
4115  * to the life-span of the @ndlp might go beyond the existence of @vport as
4116  * the final release of ndlp is determined by its reference count. And, the
4117  * operation on @ndlp needs the reference to phba.
4118  **/
4119 static inline void
4120 lpfc_initialize_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
4121         uint32_t did)
4122 {
4123         INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp);
4124         INIT_LIST_HEAD(&ndlp->dev_loss_evt.evt_listp);
4125         init_timer(&ndlp->nlp_delayfunc);
4126         ndlp->nlp_delayfunc.function = lpfc_els_retry_delay;
4127         ndlp->nlp_delayfunc.data = (unsigned long)ndlp;
4128         ndlp->nlp_DID = did;
4129         ndlp->vport = vport;
4130         ndlp->phba = vport->phba;
4131         ndlp->nlp_sid = NLP_NO_SID;
4132         kref_init(&ndlp->kref);
4133         NLP_INT_NODE_ACT(ndlp);
4134         atomic_set(&ndlp->cmd_pending, 0);
4135         ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
4136         if (vport->phba->sli_rev == LPFC_SLI_REV4)
4137                 ndlp->nlp_rpi = lpfc_sli4_alloc_rpi(vport->phba);
4138 }
4139
4140 struct lpfc_nodelist *
4141 lpfc_enable_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
4142                  int state)
4143 {
4144         struct lpfc_hba *phba = vport->phba;
4145         uint32_t did;
4146         unsigned long flags;
4147
4148         if (!ndlp)
4149                 return NULL;
4150
4151         spin_lock_irqsave(&phba->ndlp_lock, flags);
4152         /* The ndlp should not be in memory free mode */
4153         if (NLP_CHK_FREE_REQ(ndlp)) {
4154                 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
4155                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE,
4156                                 "0277 lpfc_enable_node: ndlp:x%p "
4157                                 "usgmap:x%x refcnt:%d\n",
4158                                 (void *)ndlp, ndlp->nlp_usg_map,
4159                                 atomic_read(&ndlp->kref.refcount));
4160                 return NULL;
4161         }
4162         /* The ndlp should not already be in active mode */
4163         if (NLP_CHK_NODE_ACT(ndlp)) {
4164                 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
4165                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE,
4166                                 "0278 lpfc_enable_node: ndlp:x%p "
4167                                 "usgmap:x%x refcnt:%d\n",
4168                                 (void *)ndlp, ndlp->nlp_usg_map,
4169                                 atomic_read(&ndlp->kref.refcount));
4170                 return NULL;
4171         }
4172
4173         /* Keep the original DID */
4174         did = ndlp->nlp_DID;
4175
4176         /* re-initialize ndlp except of ndlp linked list pointer */
4177         memset((((char *)ndlp) + sizeof (struct list_head)), 0,
4178                 sizeof (struct lpfc_nodelist) - sizeof (struct list_head));
4179         lpfc_initialize_node(vport, ndlp, did);
4180
4181         spin_unlock_irqrestore(&phba->ndlp_lock, flags);
4182
4183         if (state != NLP_STE_UNUSED_NODE)
4184                 lpfc_nlp_set_state(vport, ndlp, state);
4185
4186         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE,
4187                 "node enable:       did:x%x",
4188                 ndlp->nlp_DID, 0, 0);
4189         return ndlp;
4190 }
4191
4192 void
4193 lpfc_drop_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
4194 {
4195         /*
4196          * Use of lpfc_drop_node and UNUSED list: lpfc_drop_node should
4197          * be used if we wish to issue the "last" lpfc_nlp_put() to remove
4198          * the ndlp from the vport. The ndlp marked as UNUSED on the list
4199          * until ALL other outstanding threads have completed. We check
4200          * that the ndlp not already in the UNUSED state before we proceed.
4201          */
4202         if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
4203                 return;
4204         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNUSED_NODE);
4205         if (vport->phba->sli_rev == LPFC_SLI_REV4)
4206                 lpfc_cleanup_vports_rrqs(vport, ndlp);
4207         lpfc_nlp_put(ndlp);
4208         return;
4209 }
4210
4211 /*
4212  * Start / ReStart rescue timer for Discovery / RSCN handling
4213  */
4214 void
4215 lpfc_set_disctmo(struct lpfc_vport *vport)
4216 {
4217         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4218         struct lpfc_hba  *phba = vport->phba;
4219         uint32_t tmo;
4220
4221         if (vport->port_state == LPFC_LOCAL_CFG_LINK) {
4222                 /* For FAN, timeout should be greater than edtov */
4223                 tmo = (((phba->fc_edtov + 999) / 1000) + 1);
4224         } else {
4225                 /* Normal discovery timeout should be > than ELS/CT timeout
4226                  * FC spec states we need 3 * ratov for CT requests
4227                  */
4228                 tmo = ((phba->fc_ratov * 3) + 3);
4229         }
4230
4231
4232         if (!timer_pending(&vport->fc_disctmo)) {
4233                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4234                         "set disc timer:  tmo:x%x state:x%x flg:x%x",
4235                         tmo, vport->port_state, vport->fc_flag);
4236         }
4237
4238         mod_timer(&vport->fc_disctmo, jiffies + HZ * tmo);
4239         spin_lock_irq(shost->host_lock);
4240         vport->fc_flag |= FC_DISC_TMO;
4241         spin_unlock_irq(shost->host_lock);
4242
4243         /* Start Discovery Timer state <hba_state> */
4244         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
4245                          "0247 Start Discovery Timer state x%x "
4246                          "Data: x%x x%lx x%x x%x\n",
4247                          vport->port_state, tmo,
4248                          (unsigned long)&vport->fc_disctmo, vport->fc_plogi_cnt,
4249                          vport->fc_adisc_cnt);
4250
4251         return;
4252 }
4253
4254 /*
4255  * Cancel rescue timer for Discovery / RSCN handling
4256  */
4257 int
4258 lpfc_can_disctmo(struct lpfc_vport *vport)
4259 {
4260         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4261         unsigned long iflags;
4262
4263         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
4264                 "can disc timer:  state:x%x rtry:x%x flg:x%x",
4265                 vport->port_state, vport->fc_ns_retry, vport->fc_flag);
4266
4267         /* Turn off discovery timer if its running */
4268         if (vport->fc_flag & FC_DISC_TMO) {
4269                 spin_lock_irqsave(shost->host_lock, iflags);
4270                 vport->fc_flag &= ~FC_DISC_TMO;
4271                 spin_unlock_irqrestore(shost->host_lock, iflags);
4272                 del_timer_sync(&vport->fc_disctmo);
4273                 spin_lock_irqsave(&vport->work_port_lock, iflags);
4274                 vport->work_port_events &= ~WORKER_DISC_TMO;
4275                 spin_unlock_irqrestore(&vport->work_port_lock, iflags);
4276         }
4277
4278         /* Cancel Discovery Timer state <hba_state> */
4279         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
4280                          "0248 Cancel Discovery Timer state x%x "
4281                          "Data: x%x x%x x%x\n",
4282                          vport->port_state, vport->fc_flag,
4283                          vport->fc_plogi_cnt, vport->fc_adisc_cnt);
4284         return 0;
4285 }
4286
4287 /*
4288  * Check specified ring for outstanding IOCB on the SLI queue
4289  * Return true if iocb matches the specified nport
4290  */
4291 int
4292 lpfc_check_sli_ndlp(struct lpfc_hba *phba,
4293                     struct lpfc_sli_ring *pring,
4294                     struct lpfc_iocbq *iocb,
4295                     struct lpfc_nodelist *ndlp)
4296 {
4297         struct lpfc_sli *psli = &phba->sli;
4298         IOCB_t *icmd = &iocb->iocb;
4299         struct lpfc_vport    *vport = ndlp->vport;
4300
4301         if (iocb->vport != vport)
4302                 return 0;
4303
4304         if (pring->ringno == LPFC_ELS_RING) {
4305                 switch (icmd->ulpCommand) {
4306                 case CMD_GEN_REQUEST64_CR:
4307                         if (iocb->context_un.ndlp == ndlp)
4308                                 return 1;
4309                 case CMD_ELS_REQUEST64_CR:
4310                         if (icmd->un.elsreq64.remoteID == ndlp->nlp_DID)
4311                                 return 1;
4312                 case CMD_XMIT_ELS_RSP64_CX:
4313                         if (iocb->context1 == (uint8_t *) ndlp)
4314                                 return 1;
4315                 }
4316         } else if (pring->ringno == psli->extra_ring) {
4317
4318         } else if (pring->ringno == psli->fcp_ring) {
4319                 /* Skip match check if waiting to relogin to FCP target */
4320                 if ((ndlp->nlp_type & NLP_FCP_TARGET) &&
4321                     (ndlp->nlp_flag & NLP_DELAY_TMO)) {
4322                         return 0;
4323                 }
4324                 if (icmd->ulpContext == (volatile ushort)ndlp->nlp_rpi) {
4325                         return 1;
4326                 }
4327         } else if (pring->ringno == psli->next_ring) {
4328
4329         }
4330         return 0;
4331 }
4332
4333 /*
4334  * Free resources / clean up outstanding I/Os
4335  * associated with nlp_rpi in the LPFC_NODELIST entry.
4336  */
4337 static int
4338 lpfc_no_rpi(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
4339 {
4340         LIST_HEAD(completions);
4341         struct lpfc_sli *psli;
4342         struct lpfc_sli_ring *pring;
4343         struct lpfc_iocbq *iocb, *next_iocb;
4344         uint32_t i;
4345
4346         lpfc_fabric_abort_nport(ndlp);
4347
4348         /*
4349          * Everything that matches on txcmplq will be returned
4350          * by firmware with a no rpi error.
4351          */
4352         psli = &phba->sli;
4353         if (ndlp->nlp_flag & NLP_RPI_REGISTERED) {
4354                 /* Now process each ring */
4355                 for (i = 0; i < psli->num_rings; i++) {
4356                         pring = &psli->ring[i];
4357
4358                         spin_lock_irq(&phba->hbalock);
4359                         list_for_each_entry_safe(iocb, next_iocb, &pring->txq,
4360                                                  list) {
4361                                 /*
4362                                  * Check to see if iocb matches the nport we are
4363                                  * looking for
4364                                  */
4365                                 if ((lpfc_check_sli_ndlp(phba, pring, iocb,
4366                                                          ndlp))) {
4367                                         /* It matches, so deque and call compl
4368                                            with an error */
4369                                         list_move_tail(&iocb->list,
4370                                                        &completions);
4371                                 }
4372                         }
4373                         spin_unlock_irq(&phba->hbalock);
4374                 }
4375         }
4376
4377         /* Cancel all the IOCBs from the completions list */
4378         lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
4379                               IOERR_SLI_ABORTED);
4380
4381         return 0;
4382 }
4383
4384 /**
4385  * lpfc_nlp_logo_unreg - Unreg mailbox completion handler before LOGO
4386  * @phba: Pointer to HBA context object.
4387  * @pmb: Pointer to mailbox object.
4388  *
4389  * This function will issue an ELS LOGO command after completing
4390  * the UNREG_RPI.
4391  **/
4392 void
4393 lpfc_nlp_logo_unreg(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
4394 {
4395         struct lpfc_vport  *vport = pmb->vport;
4396         struct lpfc_nodelist *ndlp;
4397
4398         ndlp = (struct lpfc_nodelist *)(pmb->context1);
4399         if (!ndlp)
4400                 return;
4401         lpfc_issue_els_logo(vport, ndlp, 0);
4402 }
4403
4404 /*
4405  * Free rpi associated with LPFC_NODELIST entry.
4406  * This routine is called from lpfc_freenode(), when we are removing
4407  * a LPFC_NODELIST entry. It is also called if the driver initiates a
4408  * LOGO that completes successfully, and we are waiting to PLOGI back
4409  * to the remote NPort. In addition, it is called after we receive
4410  * and unsolicated ELS cmd, send back a rsp, the rsp completes and
4411  * we are waiting to PLOGI back to the remote NPort.
4412  */
4413 int
4414 lpfc_unreg_rpi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
4415 {
4416         struct lpfc_hba *phba = vport->phba;
4417         LPFC_MBOXQ_t    *mbox;
4418         int rc;
4419         uint16_t rpi;
4420
4421         if (ndlp->nlp_flag & NLP_RPI_REGISTERED) {
4422                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4423                 if (mbox) {
4424                         /* SLI4 ports require the physical rpi value. */
4425                         rpi = ndlp->nlp_rpi;
4426                         if (phba->sli_rev == LPFC_SLI_REV4)
4427                                 rpi = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
4428
4429                         lpfc_unreg_login(phba, vport->vpi, rpi, mbox);
4430                         mbox->vport = vport;
4431                         if (ndlp->nlp_flag & NLP_ISSUE_LOGO) {
4432                                 mbox->context1 = ndlp;
4433                                 mbox->mbox_cmpl = lpfc_nlp_logo_unreg;
4434                         } else {
4435                                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
4436                         }
4437
4438                         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
4439                         if (rc == MBX_NOT_FINISHED)
4440                                 mempool_free(mbox, phba->mbox_mem_pool);
4441                 }
4442                 lpfc_no_rpi(phba, ndlp);
4443
4444                 if (phba->sli_rev != LPFC_SLI_REV4)
4445                         ndlp->nlp_rpi = 0;
4446                 ndlp->nlp_flag &= ~NLP_RPI_REGISTERED;
4447                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
4448                 return 1;
4449         }
4450         return 0;
4451 }
4452
4453 /**
4454  * lpfc_unreg_hba_rpis - Unregister rpis registered to the hba.
4455  * @phba: pointer to lpfc hba data structure.
4456  *
4457  * This routine is invoked to unregister all the currently registered RPIs
4458  * to the HBA.
4459  **/
4460 void
4461 lpfc_unreg_hba_rpis(struct lpfc_hba *phba)
4462 {
4463         struct lpfc_vport **vports;
4464         struct lpfc_nodelist *ndlp;
4465         struct Scsi_Host *shost;
4466         int i;
4467
4468         vports = lpfc_create_vport_work_array(phba);
4469         if (!vports) {
4470                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
4471                         "2884 Vport array allocation failed \n");
4472                 return;
4473         }
4474         for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
4475                 shost = lpfc_shost_from_vport(vports[i]);
4476                 spin_lock_irq(shost->host_lock);
4477                 list_for_each_entry(ndlp, &vports[i]->fc_nodes, nlp_listp) {
4478                         if (ndlp->nlp_flag & NLP_RPI_REGISTERED) {
4479                                 /* The mempool_alloc might sleep */
4480                                 spin_unlock_irq(shost->host_lock);
4481                                 lpfc_unreg_rpi(vports[i], ndlp);
4482                                 spin_lock_irq(shost->host_lock);
4483                         }
4484                 }
4485                 spin_unlock_irq(shost->host_lock);
4486         }
4487         lpfc_destroy_vport_work_array(phba, vports);
4488 }
4489
4490 void
4491 lpfc_unreg_all_rpis(struct lpfc_vport *vport)
4492 {
4493         struct lpfc_hba  *phba  = vport->phba;
4494         LPFC_MBOXQ_t     *mbox;
4495         int rc;
4496
4497         if (phba->sli_rev == LPFC_SLI_REV4) {
4498                 lpfc_sli4_unreg_all_rpis(vport);
4499                 return;
4500         }
4501
4502         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4503         if (mbox) {
4504                 lpfc_unreg_login(phba, vport->vpi, LPFC_UNREG_ALL_RPIS_VPORT,
4505                                  mbox);
4506                 mbox->vport = vport;
4507                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
4508                 mbox->context1 = NULL;
4509                 rc = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
4510                 if (rc != MBX_TIMEOUT)
4511                         mempool_free(mbox, phba->mbox_mem_pool);
4512
4513                 if ((rc == MBX_TIMEOUT) || (rc == MBX_NOT_FINISHED))
4514                         lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX | LOG_VPORT,
4515                                 "1836 Could not issue "
4516                                 "unreg_login(all_rpis) status %d\n", rc);
4517         }
4518 }
4519
4520 void
4521 lpfc_unreg_default_rpis(struct lpfc_vport *vport)
4522 {
4523         struct lpfc_hba  *phba  = vport->phba;
4524         LPFC_MBOXQ_t     *mbox;
4525         int rc;
4526
4527         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4528         if (mbox) {
4529                 lpfc_unreg_did(phba, vport->vpi, LPFC_UNREG_ALL_DFLT_RPIS,
4530                                mbox);
4531                 mbox->vport = vport;
4532                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
4533                 mbox->context1 = NULL;
4534                 rc = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
4535                 if (rc != MBX_TIMEOUT)
4536                         mempool_free(mbox, phba->mbox_mem_pool);
4537
4538                 if ((rc == MBX_TIMEOUT) || (rc == MBX_NOT_FINISHED))
4539                         lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX | LOG_VPORT,
4540                                          "1815 Could not issue "
4541                                          "unreg_did (default rpis) status %d\n",
4542                                          rc);
4543         }
4544 }
4545
4546 /*
4547  * Free resources associated with LPFC_NODELIST entry
4548  * so it can be freed.
4549  */
4550 static int
4551 lpfc_cleanup_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
4552 {
4553         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4554         struct lpfc_hba  *phba = vport->phba;
4555         LPFC_MBOXQ_t *mb, *nextmb;
4556         struct lpfc_dmabuf *mp;
4557
4558         /* Cleanup node for NPort <nlp_DID> */
4559         lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
4560                          "0900 Cleanup node for NPort x%x "
4561                          "Data: x%x x%x x%x\n",
4562                          ndlp->nlp_DID, ndlp->nlp_flag,
4563                          ndlp->nlp_state, ndlp->nlp_rpi);
4564         if (NLP_CHK_FREE_REQ(ndlp)) {
4565                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE,
4566                                 "0280 lpfc_cleanup_node: ndlp:x%p "
4567                                 "usgmap:x%x refcnt:%d\n",
4568                                 (void *)ndlp, ndlp->nlp_usg_map,
4569                                 atomic_read(&ndlp->kref.refcount));
4570                 lpfc_dequeue_node(vport, ndlp);
4571         } else {
4572                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE,
4573                                 "0281 lpfc_cleanup_node: ndlp:x%p "
4574                                 "usgmap:x%x refcnt:%d\n",
4575                                 (void *)ndlp, ndlp->nlp_usg_map,
4576                                 atomic_read(&ndlp->kref.refcount));
4577                 lpfc_disable_node(vport, ndlp);
4578         }
4579
4580
4581         /* Don't need to clean up REG_LOGIN64 cmds for Default RPI cleanup */
4582
4583         /* cleanup any ndlp on mbox q waiting for reglogin cmpl */
4584         if ((mb = phba->sli.mbox_active)) {
4585                 if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&
4586                    !(mb->mbox_flag & LPFC_MBX_IMED_UNREG) &&
4587                    (ndlp == (struct lpfc_nodelist *) mb->context2)) {
4588                         mb->context2 = NULL;
4589                         mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
4590                 }
4591         }
4592
4593         spin_lock_irq(&phba->hbalock);
4594         /* Cleanup REG_LOGIN completions which are not yet processed */
4595         list_for_each_entry(mb, &phba->sli.mboxq_cmpl, list) {
4596                 if ((mb->u.mb.mbxCommand != MBX_REG_LOGIN64) ||
4597                         (mb->mbox_flag & LPFC_MBX_IMED_UNREG) ||
4598                         (ndlp != (struct lpfc_nodelist *) mb->context2))
4599                         continue;
4600
4601                 mb->context2 = NULL;
4602                 mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
4603         }
4604
4605         list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
4606                 if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&
4607                    !(mb->mbox_flag & LPFC_MBX_IMED_UNREG) &&
4608                     (ndlp == (struct lpfc_nodelist *) mb->context2)) {
4609                         mp = (struct lpfc_dmabuf *) (mb->context1);
4610                         if (mp) {
4611                                 __lpfc_mbuf_free(phba, mp->virt, mp->phys);
4612                                 kfree(mp);
4613                         }
4614                         list_del(&mb->list);
4615                         mempool_free(mb, phba->mbox_mem_pool);
4616                         /* We shall not invoke the lpfc_nlp_put to decrement
4617                          * the ndlp reference count as we are in the process
4618                          * of lpfc_nlp_release.
4619                          */
4620                 }
4621         }
4622         spin_unlock_irq(&phba->hbalock);
4623
4624         lpfc_els_abort(phba, ndlp);
4625
4626         spin_lock_irq(shost->host_lock);
4627         ndlp->nlp_flag &= ~NLP_DELAY_TMO;
4628         spin_unlock_irq(shost->host_lock);
4629
4630         ndlp->nlp_last_elscmd = 0;
4631         del_timer_sync(&ndlp->nlp_delayfunc);
4632
4633         list_del_init(&ndlp->els_retry_evt.evt_listp);
4634         list_del_init(&ndlp->dev_loss_evt.evt_listp);
4635         lpfc_cleanup_vports_rrqs(vport, ndlp);
4636         lpfc_unreg_rpi(vport, ndlp);
4637
4638         return 0;
4639 }
4640
4641 /*
4642  * Check to see if we can free the nlp back to the freelist.
4643  * If we are in the middle of using the nlp in the discovery state
4644  * machine, defer the free till we reach the end of the state machine.
4645  */
4646 static void
4647 lpfc_nlp_remove(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
4648 {
4649         struct lpfc_hba  *phba = vport->phba;
4650         struct lpfc_rport_data *rdata;
4651         LPFC_MBOXQ_t *mbox;
4652         int rc;
4653
4654         lpfc_cancel_retry_delay_tmo(vport, ndlp);
4655         if ((ndlp->nlp_flag & NLP_DEFER_RM) &&
4656             !(ndlp->nlp_flag & NLP_REG_LOGIN_SEND) &&
4657             !(ndlp->nlp_flag & NLP_RPI_REGISTERED)) {
4658                 /* For this case we need to cleanup the default rpi
4659                  * allocated by the firmware.
4660                  */
4661                 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))
4662                         != NULL) {
4663                         rc = lpfc_reg_rpi(phba, vport->vpi, ndlp->nlp_DID,
4664                             (uint8_t *) &vport->fc_sparam, mbox, ndlp->nlp_rpi);
4665                         if (rc) {
4666                                 mempool_free(mbox, phba->mbox_mem_pool);
4667                         }
4668                         else {
4669                                 mbox->mbox_flag |= LPFC_MBX_IMED_UNREG;
4670                                 mbox->mbox_cmpl = lpfc_mbx_cmpl_dflt_rpi;
4671                                 mbox->vport = vport;
4672                                 mbox->context2 = ndlp;
4673                                 rc =lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
4674                                 if (rc == MBX_NOT_FINISHED) {
4675                                         mempool_free(mbox, phba->mbox_mem_pool);
4676                                 }
4677                         }
4678                 }
4679         }
4680         lpfc_cleanup_node(vport, ndlp);
4681
4682         /*
4683          * We can get here with a non-NULL ndlp->rport because when we
4684          * unregister a rport we don't break the rport/node linkage.  So if we
4685          * do, make sure we don't leaving any dangling pointers behind.
4686          */
4687         if (ndlp->rport) {
4688                 rdata = ndlp->rport->dd_data;
4689                 rdata->pnode = NULL;
4690                 ndlp->rport = NULL;
4691         }
4692 }
4693
4694 static int
4695 lpfc_matchdid(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
4696               uint32_t did)
4697 {
4698         D_ID mydid, ndlpdid, matchdid;
4699
4700         if (did == Bcast_DID)
4701                 return 0;
4702
4703         /* First check for Direct match */
4704         if (ndlp->nlp_DID == did)
4705                 return 1;
4706
4707         /* Next check for area/domain identically equals 0 match */
4708         mydid.un.word = vport->fc_myDID;
4709         if ((mydid.un.b.domain == 0) && (mydid.un.b.area == 0)) {
4710                 return 0;
4711         }
4712
4713         matchdid.un.word = did;
4714         ndlpdid.un.word = ndlp->nlp_DID;
4715         if (matchdid.un.b.id == ndlpdid.un.b.id) {
4716                 if ((mydid.un.b.domain == matchdid.un.b.domain) &&
4717                     (mydid.un.b.area == matchdid.un.b.area)) {
4718                         if ((ndlpdid.un.b.domain == 0) &&
4719                             (ndlpdid.un.b.area == 0)) {
4720                                 if (ndlpdid.un.b.id)
4721                                         return 1;
4722                         }
4723                         return 0;
4724                 }
4725
4726                 matchdid.un.word = ndlp->nlp_DID;
4727                 if ((mydid.un.b.domain == ndlpdid.un.b.domain) &&
4728                     (mydid.un.b.area == ndlpdid.un.b.area)) {
4729                         if ((matchdid.un.b.domain == 0) &&
4730                             (matchdid.un.b.area == 0)) {
4731                                 if (matchdid.un.b.id)
4732                                         return 1;
4733                         }
4734                 }
4735         }
4736         return 0;
4737 }
4738
4739 /* Search for a nodelist entry */
4740 static struct lpfc_nodelist *
4741 __lpfc_findnode_did(struct lpfc_vport *vport, uint32_t did)
4742 {
4743         struct lpfc_nodelist *ndlp;
4744         uint32_t data1;
4745
4746         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
4747                 if (lpfc_matchdid(vport, ndlp, did)) {
4748                         data1 = (((uint32_t) ndlp->nlp_state << 24) |
4749                                  ((uint32_t) ndlp->nlp_xri << 16) |
4750                                  ((uint32_t) ndlp->nlp_type << 8) |
4751                                  ((uint32_t) ndlp->nlp_rpi & 0xff));
4752                         lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
4753                                          "0929 FIND node DID "
4754                                          "Data: x%p x%x x%x x%x\n",
4755                                          ndlp, ndlp->nlp_DID,
4756                                          ndlp->nlp_flag, data1);
4757                         return ndlp;
4758                 }
4759         }
4760
4761         /* FIND node did <did> NOT FOUND */
4762         lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
4763                          "0932 FIND node did x%x NOT FOUND.\n", did);
4764         return NULL;
4765 }
4766
4767 struct lpfc_nodelist *
4768 lpfc_findnode_did(struct lpfc_vport *vport, uint32_t did)
4769 {
4770         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4771         struct lpfc_nodelist *ndlp;
4772         unsigned long iflags;
4773
4774         spin_lock_irqsave(shost->host_lock, iflags);
4775         ndlp = __lpfc_findnode_did(vport, did);
4776         spin_unlock_irqrestore(shost->host_lock, iflags);
4777         return ndlp;
4778 }
4779
4780 struct lpfc_nodelist *
4781 lpfc_setup_disc_node(struct lpfc_vport *vport, uint32_t did)
4782 {
4783         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4784         struct lpfc_nodelist *ndlp;
4785
4786         ndlp = lpfc_findnode_did(vport, did);
4787         if (!ndlp) {
4788                 if ((vport->fc_flag & FC_RSCN_MODE) != 0 &&
4789                     lpfc_rscn_payload_check(vport, did) == 0)
4790                         return NULL;
4791                 ndlp = (struct lpfc_nodelist *)
4792                      mempool_alloc(vport->phba->nlp_mem_pool, GFP_KERNEL);
4793                 if (!ndlp)
4794                         return NULL;
4795                 lpfc_nlp_init(vport, ndlp, did);
4796                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
4797                 spin_lock_irq(shost->host_lock);
4798                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
4799                 spin_unlock_irq(shost->host_lock);
4800                 return ndlp;
4801         } else if (!NLP_CHK_NODE_ACT(ndlp)) {
4802                 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_NPR_NODE);
4803                 if (!ndlp)
4804                         return NULL;
4805                 spin_lock_irq(shost->host_lock);
4806                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
4807                 spin_unlock_irq(shost->host_lock);
4808                 return ndlp;
4809         }
4810
4811         if ((vport->fc_flag & FC_RSCN_MODE) &&
4812             !(vport->fc_flag & FC_NDISC_ACTIVE)) {
4813                 if (lpfc_rscn_payload_check(vport, did)) {
4814                         /* If we've already received a PLOGI from this NPort
4815                          * we don't need to try to discover it again.
4816                          */
4817                         if (ndlp->nlp_flag & NLP_RCV_PLOGI)
4818                                 return NULL;
4819
4820                         /* Since this node is marked for discovery,
4821                          * delay timeout is not needed.
4822                          */
4823                         lpfc_cancel_retry_delay_tmo(vport, ndlp);
4824                         spin_lock_irq(shost->host_lock);
4825                         ndlp->nlp_flag |= NLP_NPR_2B_DISC;
4826                         spin_unlock_irq(shost->host_lock);
4827                 } else
4828                         ndlp = NULL;
4829         } else {
4830                 /* If we've already received a PLOGI from this NPort,
4831                  * or we are already in the process of discovery on it,
4832                  * we don't need to try to discover it again.
4833                  */
4834                 if (ndlp->nlp_state == NLP_STE_ADISC_ISSUE ||
4835                     ndlp->nlp_state == NLP_STE_PLOGI_ISSUE ||
4836                     ndlp->nlp_flag & NLP_RCV_PLOGI)
4837                         return NULL;
4838                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
4839                 spin_lock_irq(shost->host_lock);
4840                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
4841                 spin_unlock_irq(shost->host_lock);
4842         }
4843         return ndlp;
4844 }
4845
4846 /* Build a list of nodes to discover based on the loopmap */
4847 void
4848 lpfc_disc_list_loopmap(struct lpfc_vport *vport)
4849 {
4850         struct lpfc_hba  *phba = vport->phba;
4851         int j;
4852         uint32_t alpa, index;
4853
4854         if (!lpfc_is_link_up(phba))
4855                 return;
4856
4857         if (phba->fc_topology != LPFC_TOPOLOGY_LOOP)
4858                 return;
4859
4860         /* Check for loop map present or not */
4861         if (phba->alpa_map[0]) {
4862                 for (j = 1; j <= phba->alpa_map[0]; j++) {
4863                         alpa = phba->alpa_map[j];
4864                         if (((vport->fc_myDID & 0xff) == alpa) || (alpa == 0))
4865                                 continue;
4866                         lpfc_setup_disc_node(vport, alpa);
4867                 }
4868         } else {
4869                 /* No alpamap, so try all alpa's */
4870                 for (j = 0; j < FC_MAXLOOP; j++) {
4871                         /* If cfg_scan_down is set, start from highest
4872                          * ALPA (0xef) to lowest (0x1).
4873                          */
4874                         if (vport->cfg_scan_down)
4875                                 index = j;
4876                         else
4877                                 index = FC_MAXLOOP - j - 1;
4878                         alpa = lpfcAlpaArray[index];
4879                         if ((vport->fc_myDID & 0xff) == alpa)
4880                                 continue;
4881                         lpfc_setup_disc_node(vport, alpa);
4882                 }
4883         }
4884         return;
4885 }
4886
4887 void
4888 lpfc_issue_clear_la(struct lpfc_hba *phba, struct lpfc_vport *vport)
4889 {
4890         LPFC_MBOXQ_t *mbox;
4891         struct lpfc_sli *psli = &phba->sli;
4892         struct lpfc_sli_ring *extra_ring = &psli->ring[psli->extra_ring];
4893         struct lpfc_sli_ring *fcp_ring   = &psli->ring[psli->fcp_ring];
4894         struct lpfc_sli_ring *next_ring  = &psli->ring[psli->next_ring];
4895         int  rc;
4896
4897         /*
4898          * if it's not a physical port or if we already send
4899          * clear_la then don't send it.
4900          */
4901         if ((phba->link_state >= LPFC_CLEAR_LA) ||
4902             (vport->port_type != LPFC_PHYSICAL_PORT) ||
4903                 (phba->sli_rev == LPFC_SLI_REV4))
4904                 return;
4905
4906                         /* Link up discovery */
4907         if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL)) != NULL) {
4908                 phba->link_state = LPFC_CLEAR_LA;
4909                 lpfc_clear_la(phba, mbox);
4910                 mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la;
4911                 mbox->vport = vport;
4912                 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
4913                 if (rc == MBX_NOT_FINISHED) {
4914                         mempool_free(mbox, phba->mbox_mem_pool);
4915                         lpfc_disc_flush_list(vport);
4916                         extra_ring->flag &= ~LPFC_STOP_IOCB_EVENT;
4917                         fcp_ring->flag &= ~LPFC_STOP_IOCB_EVENT;
4918                         next_ring->flag &= ~LPFC_STOP_IOCB_EVENT;
4919                         phba->link_state = LPFC_HBA_ERROR;
4920                 }
4921         }
4922 }
4923
4924 /* Reg_vpi to tell firmware to resume normal operations */
4925 void
4926 lpfc_issue_reg_vpi(struct lpfc_hba *phba, struct lpfc_vport *vport)
4927 {
4928         LPFC_MBOXQ_t *regvpimbox;
4929
4930         regvpimbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4931         if (regvpimbox) {
4932                 lpfc_reg_vpi(vport, regvpimbox);
4933                 regvpimbox->mbox_cmpl = lpfc_mbx_cmpl_reg_vpi;
4934                 regvpimbox->vport = vport;
4935                 if (lpfc_sli_issue_mbox(phba, regvpimbox, MBX_NOWAIT)
4936                                         == MBX_NOT_FINISHED) {
4937                         mempool_free(regvpimbox, phba->mbox_mem_pool);
4938                 }
4939         }
4940 }
4941
4942 /* Start Link up / RSCN discovery on NPR nodes */
4943 void
4944 lpfc_disc_start(struct lpfc_vport *vport)
4945 {
4946         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4947         struct lpfc_hba  *phba = vport->phba;
4948         uint32_t num_sent;
4949         uint32_t clear_la_pending;
4950         int did_changed;
4951
4952         if (!lpfc_is_link_up(phba))
4953                 return;
4954
4955         if (phba->link_state == LPFC_CLEAR_LA)
4956                 clear_la_pending = 1;
4957         else
4958                 clear_la_pending = 0;
4959
4960         if (vport->port_state < LPFC_VPORT_READY)
4961                 vport->port_state = LPFC_DISC_AUTH;
4962
4963         lpfc_set_disctmo(vport);
4964
4965         if (vport->fc_prevDID == vport->fc_myDID)
4966                 did_changed = 0;
4967         else
4968                 did_changed = 1;
4969
4970         vport->fc_prevDID = vport->fc_myDID;
4971         vport->num_disc_nodes = 0;
4972
4973         /* Start Discovery state <hba_state> */
4974         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
4975                          "0202 Start Discovery hba state x%x "
4976                          "Data: x%x x%x x%x\n",
4977                          vport->port_state, vport->fc_flag, vport->fc_plogi_cnt,
4978                          vport->fc_adisc_cnt);
4979
4980         /* First do ADISCs - if any */
4981         num_sent = lpfc_els_disc_adisc(vport);
4982
4983         if (num_sent)
4984                 return;
4985
4986         /* Register the VPI for SLI3, NON-NPIV only. */
4987         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
4988             !(vport->fc_flag & FC_PT2PT) &&
4989             !(vport->fc_flag & FC_RSCN_MODE) &&
4990             (phba->sli_rev < LPFC_SLI_REV4)) {
4991                 lpfc_issue_reg_vpi(phba, vport);
4992                 return;
4993         }
4994
4995         /*
4996          * For SLI2, we need to set port_state to READY and continue
4997          * discovery.
4998          */
4999         if (vport->port_state < LPFC_VPORT_READY && !clear_la_pending) {
5000                 /* If we get here, there is nothing to ADISC */
5001                 if (vport->port_type == LPFC_PHYSICAL_PORT)
5002                         lpfc_issue_clear_la(phba, vport);
5003
5004                 if (!(vport->fc_flag & FC_ABORT_DISCOVERY)) {
5005                         vport->num_disc_nodes = 0;
5006                         /* go thru NPR nodes and issue ELS PLOGIs */
5007                         if (vport->fc_npr_cnt)
5008                                 lpfc_els_disc_plogi(vport);
5009
5010                         if (!vport->num_disc_nodes) {
5011                                 spin_lock_irq(shost->host_lock);
5012                                 vport->fc_flag &= ~FC_NDISC_ACTIVE;
5013                                 spin_unlock_irq(shost->host_lock);
5014                                 lpfc_can_disctmo(vport);
5015                         }
5016                 }
5017                 vport->port_state = LPFC_VPORT_READY;
5018         } else {
5019                 /* Next do PLOGIs - if any */
5020                 num_sent = lpfc_els_disc_plogi(vport);
5021
5022                 if (num_sent)
5023                         return;
5024
5025                 if (vport->fc_flag & FC_RSCN_MODE) {
5026                         /* Check to see if more RSCNs came in while we
5027                          * were processing this one.
5028                          */
5029                         if ((vport->fc_rscn_id_cnt == 0) &&
5030                             (!(vport->fc_flag & FC_RSCN_DISCOVERY))) {
5031                                 spin_lock_irq(shost->host_lock);
5032                                 vport->fc_flag &= ~FC_RSCN_MODE;
5033                                 spin_unlock_irq(shost->host_lock);
5034                                 lpfc_can_disctmo(vport);
5035                         } else
5036                                 lpfc_els_handle_rscn(vport);
5037                 }
5038         }
5039         return;
5040 }
5041
5042 /*
5043  *  Ignore completion for all IOCBs on tx and txcmpl queue for ELS
5044  *  ring the match the sppecified nodelist.
5045  */
5046 static void
5047 lpfc_free_tx(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
5048 {
5049         LIST_HEAD(completions);
5050         struct lpfc_sli *psli;
5051         IOCB_t     *icmd;
5052         struct lpfc_iocbq    *iocb, *next_iocb;
5053         struct lpfc_sli_ring *pring;
5054
5055         psli = &phba->sli;
5056         pring = &psli->ring[LPFC_ELS_RING];
5057
5058         /* Error matching iocb on txq or txcmplq
5059          * First check the txq.
5060          */
5061         spin_lock_irq(&phba->hbalock);
5062         list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
5063                 if (iocb->context1 != ndlp) {
5064                         continue;
5065                 }
5066                 icmd = &iocb->iocb;
5067                 if ((icmd->ulpCommand == CMD_ELS_REQUEST64_CR) ||
5068                     (icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX)) {
5069
5070                         list_move_tail(&iocb->list, &completions);
5071                 }
5072         }
5073
5074         /* Next check the txcmplq */
5075         list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
5076                 if (iocb->context1 != ndlp) {
5077                         continue;
5078                 }
5079                 icmd = &iocb->iocb;
5080                 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR ||
5081                     icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX) {
5082                         lpfc_sli_issue_abort_iotag(phba, pring, iocb);
5083                 }
5084         }
5085         spin_unlock_irq(&phba->hbalock);
5086
5087         /* Cancel all the IOCBs from the completions list */
5088         lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
5089                               IOERR_SLI_ABORTED);
5090 }
5091
5092 static void
5093 lpfc_disc_flush_list(struct lpfc_vport *vport)
5094 {
5095         struct lpfc_nodelist *ndlp, *next_ndlp;
5096         struct lpfc_hba *phba = vport->phba;
5097
5098         if (vport->fc_plogi_cnt || vport->fc_adisc_cnt) {
5099                 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes,
5100                                          nlp_listp) {
5101                         if (!NLP_CHK_NODE_ACT(ndlp))
5102                                 continue;
5103                         if (ndlp->nlp_state == NLP_STE_PLOGI_ISSUE ||
5104                             ndlp->nlp_state == NLP_STE_ADISC_ISSUE) {
5105                                 lpfc_free_tx(phba, ndlp);
5106                         }
5107                 }
5108         }
5109 }
5110
5111 void
5112 lpfc_cleanup_discovery_resources(struct lpfc_vport *vport)
5113 {
5114         lpfc_els_flush_rscn(vport);
5115         lpfc_els_flush_cmd(vport);
5116         lpfc_disc_flush_list(vport);
5117 }
5118
5119 /*****************************************************************************/
5120 /*
5121  * NAME:     lpfc_disc_timeout
5122  *
5123  * FUNCTION: Fibre Channel driver discovery timeout routine.
5124  *
5125  * EXECUTION ENVIRONMENT: interrupt only
5126  *
5127  * CALLED FROM:
5128  *      Timer function
5129  *
5130  * RETURNS:
5131  *      none
5132  */
5133 /*****************************************************************************/
5134 void
5135 lpfc_disc_timeout(unsigned long ptr)
5136 {
5137         struct lpfc_vport *vport = (struct lpfc_vport *) ptr;
5138         struct lpfc_hba   *phba = vport->phba;
5139         uint32_t tmo_posted;
5140         unsigned long flags = 0;
5141
5142         if (unlikely(!phba))
5143                 return;
5144
5145         spin_lock_irqsave(&vport->work_port_lock, flags);
5146         tmo_posted = vport->work_port_events & WORKER_DISC_TMO;
5147         if (!tmo_posted)
5148                 vport->work_port_events |= WORKER_DISC_TMO;
5149         spin_unlock_irqrestore(&vport->work_port_lock, flags);
5150
5151         if (!tmo_posted)
5152                 lpfc_worker_wake_up(phba);
5153         return;
5154 }
5155
5156 static void
5157 lpfc_disc_timeout_handler(struct lpfc_vport *vport)
5158 {
5159         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5160         struct lpfc_hba  *phba = vport->phba;
5161         struct lpfc_sli  *psli = &phba->sli;
5162         struct lpfc_nodelist *ndlp, *next_ndlp;
5163         LPFC_MBOXQ_t *initlinkmbox;
5164         int rc, clrlaerr = 0;
5165
5166         if (!(vport->fc_flag & FC_DISC_TMO))
5167                 return;
5168
5169         spin_lock_irq(shost->host_lock);
5170         vport->fc_flag &= ~FC_DISC_TMO;
5171         spin_unlock_irq(shost->host_lock);
5172
5173         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
5174                 "disc timeout:    state:x%x rtry:x%x flg:x%x",
5175                 vport->port_state, vport->fc_ns_retry, vport->fc_flag);
5176
5177         switch (vport->port_state) {
5178
5179         case LPFC_LOCAL_CFG_LINK:
5180         /* port_state is identically  LPFC_LOCAL_CFG_LINK while waiting for
5181          * FAN
5182          */
5183                                 /* FAN timeout */
5184                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_DISCOVERY,
5185                                  "0221 FAN timeout\n");
5186                 /* Start discovery by sending FLOGI, clean up old rpis */
5187                 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes,
5188                                          nlp_listp) {
5189                         if (!NLP_CHK_NODE_ACT(ndlp))
5190                                 continue;
5191                         if (ndlp->nlp_state != NLP_STE_NPR_NODE)
5192                                 continue;
5193                         if (ndlp->nlp_type & NLP_FABRIC) {
5194                                 /* Clean up the ndlp on Fabric connections */
5195                                 lpfc_drop_node(vport, ndlp);
5196
5197                         } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
5198                                 /* Fail outstanding IO now since device
5199                                  * is marked for PLOGI.
5200                                  */
5201                                 lpfc_unreg_rpi(vport, ndlp);
5202                         }
5203                 }
5204                 if (vport->port_state != LPFC_FLOGI) {
5205                         if (phba->sli_rev <= LPFC_SLI_REV3)
5206                                 lpfc_initial_flogi(vport);
5207                         else
5208                                 lpfc_issue_init_vfi(vport);
5209                         return;
5210                 }
5211                 break;
5212
5213         case LPFC_FDISC:
5214         case LPFC_FLOGI:
5215         /* port_state is identically LPFC_FLOGI while waiting for FLOGI cmpl */
5216                 /* Initial FLOGI timeout */
5217                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
5218                                  "0222 Initial %s timeout\n",
5219                                  vport->vpi ? "FDISC" : "FLOGI");
5220
5221                 /* Assume no Fabric and go on with discovery.
5222                  * Check for outstanding ELS FLOGI to abort.
5223                  */
5224
5225                 /* FLOGI failed, so just use loop map to make discovery list */
5226                 lpfc_disc_list_loopmap(vport);
5227
5228                 /* Start discovery */
5229                 lpfc_disc_start(vport);
5230                 break;
5231
5232         case LPFC_FABRIC_CFG_LINK:
5233         /* hba_state is identically LPFC_FABRIC_CFG_LINK while waiting for
5234            NameServer login */
5235                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
5236                                  "0223 Timeout while waiting for "
5237                                  "NameServer login\n");
5238                 /* Next look for NameServer ndlp */
5239                 ndlp = lpfc_findnode_did(vport, NameServer_DID);
5240                 if (ndlp && NLP_CHK_NODE_ACT(ndlp))
5241                         lpfc_els_abort(phba, ndlp);
5242
5243                 /* ReStart discovery */
5244                 goto restart_disc;
5245
5246         case LPFC_NS_QRY:
5247         /* Check for wait for NameServer Rsp timeout */
5248                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
5249                                  "0224 NameServer Query timeout "
5250                                  "Data: x%x x%x\n",
5251                                  vport->fc_ns_retry, LPFC_MAX_NS_RETRY);
5252
5253                 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) {
5254                         /* Try it one more time */
5255                         vport->fc_ns_retry++;
5256                         rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT,
5257                                          vport->fc_ns_retry, 0);
5258                         if (rc == 0)
5259                                 break;
5260                 }
5261                 vport->fc_ns_retry = 0;
5262
5263 restart_disc:
5264                 /*
5265                  * Discovery is over.
5266                  * set port_state to PORT_READY if SLI2.
5267                  * cmpl_reg_vpi will set port_state to READY for SLI3.
5268                  */
5269                 if (phba->sli_rev < LPFC_SLI_REV4) {
5270                         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
5271                                 lpfc_issue_reg_vpi(phba, vport);
5272                         else  {
5273                                 lpfc_issue_clear_la(phba, vport);
5274                                 vport->port_state = LPFC_VPORT_READY;
5275                         }
5276                 }
5277
5278                 /* Setup and issue mailbox INITIALIZE LINK command */
5279                 initlinkmbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5280                 if (!initlinkmbox) {
5281                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
5282                                          "0206 Device Discovery "
5283                                          "completion error\n");
5284                         phba->link_state = LPFC_HBA_ERROR;
5285                         break;
5286                 }
5287
5288                 lpfc_linkdown(phba);
5289                 lpfc_init_link(phba, initlinkmbox, phba->cfg_topology,
5290                                phba->cfg_link_speed);
5291                 initlinkmbox->u.mb.un.varInitLnk.lipsr_AL_PA = 0;
5292                 initlinkmbox->vport = vport;
5293                 initlinkmbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
5294                 rc = lpfc_sli_issue_mbox(phba, initlinkmbox, MBX_NOWAIT);
5295                 lpfc_set_loopback_flag(phba);
5296                 if (rc == MBX_NOT_FINISHED)
5297                         mempool_free(initlinkmbox, phba->mbox_mem_pool);
5298
5299                 break;
5300
5301         case LPFC_DISC_AUTH:
5302         /* Node Authentication timeout */
5303                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
5304                                  "0227 Node Authentication timeout\n");
5305                 lpfc_disc_flush_list(vport);
5306
5307                 /*
5308                  * set port_state to PORT_READY if SLI2.
5309                  * cmpl_reg_vpi will set port_state to READY for SLI3.
5310                  */
5311                 if (phba->sli_rev < LPFC_SLI_REV4) {
5312                         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
5313                                 lpfc_issue_reg_vpi(phba, vport);
5314                         else  { /* NPIV Not enabled */
5315                                 lpfc_issue_clear_la(phba, vport);
5316                                 vport->port_state = LPFC_VPORT_READY;
5317                         }
5318                 }
5319                 break;
5320
5321         case LPFC_VPORT_READY:
5322                 if (vport->fc_flag & FC_RSCN_MODE) {
5323                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
5324                                          "0231 RSCN timeout Data: x%x "
5325                                          "x%x\n",
5326                                          vport->fc_ns_retry, LPFC_MAX_NS_RETRY);
5327
5328                         /* Cleanup any outstanding ELS commands */
5329                         lpfc_els_flush_cmd(vport);
5330
5331                         lpfc_els_flush_rscn(vport);
5332                         lpfc_disc_flush_list(vport);
5333                 }
5334                 break;
5335
5336         default:
5337                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
5338                                  "0273 Unexpected discovery timeout, "
5339                                  "vport State x%x\n", vport->port_state);
5340                 break;
5341         }
5342
5343         switch (phba->link_state) {
5344         case LPFC_CLEAR_LA:
5345                                 /* CLEAR LA timeout */
5346                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
5347                                  "0228 CLEAR LA timeout\n");
5348                 clrlaerr = 1;
5349                 break;
5350
5351         case LPFC_LINK_UP:
5352                 lpfc_issue_clear_la(phba, vport);
5353                 /* Drop thru */
5354         case LPFC_LINK_UNKNOWN:
5355         case LPFC_WARM_START:
5356         case LPFC_INIT_START:
5357         case LPFC_INIT_MBX_CMDS:
5358         case LPFC_LINK_DOWN:
5359         case LPFC_HBA_ERROR:
5360                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
5361                                  "0230 Unexpected timeout, hba link "
5362                                  "state x%x\n", phba->link_state);
5363                 clrlaerr = 1;
5364                 break;
5365
5366         case LPFC_HBA_READY:
5367                 break;
5368         }
5369
5370         if (clrlaerr) {
5371                 lpfc_disc_flush_list(vport);
5372                 psli->ring[(psli->extra_ring)].flag &= ~LPFC_STOP_IOCB_EVENT;
5373                 psli->ring[(psli->fcp_ring)].flag &= ~LPFC_STOP_IOCB_EVENT;
5374                 psli->ring[(psli->next_ring)].flag &= ~LPFC_STOP_IOCB_EVENT;
5375                 vport->port_state = LPFC_VPORT_READY;
5376         }
5377
5378         return;
5379 }
5380
5381 /*
5382  * This routine handles processing a NameServer REG_LOGIN mailbox
5383  * command upon completion. It is setup in the LPFC_MBOXQ
5384  * as the completion routine when the command is
5385  * handed off to the SLI layer.
5386  */
5387 void
5388 lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
5389 {
5390         MAILBOX_t *mb = &pmb->u.mb;
5391         struct lpfc_dmabuf   *mp = (struct lpfc_dmabuf *) (pmb->context1);
5392         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
5393         struct lpfc_vport    *vport = pmb->vport;
5394
5395         pmb->context1 = NULL;
5396         pmb->context2 = NULL;
5397
5398         if (phba->sli_rev < LPFC_SLI_REV4)
5399                 ndlp->nlp_rpi = mb->un.varWords[0];
5400         ndlp->nlp_flag |= NLP_RPI_REGISTERED;
5401         ndlp->nlp_type |= NLP_FABRIC;
5402         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
5403
5404         /*
5405          * Start issuing Fabric-Device Management Interface (FDMI) command to
5406          * 0xfffffa (FDMI well known port) or Delay issuing FDMI command if
5407          * fdmi-on=2 (supporting RPA/hostnmae)
5408          */
5409
5410         if (vport->cfg_fdmi_on == 1)
5411                 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA);
5412         else
5413                 mod_timer(&vport->fc_fdmitmo, jiffies + HZ * 60);
5414
5415         /* decrement the node reference count held for this callback
5416          * function.
5417          */
5418         lpfc_nlp_put(ndlp);
5419         lpfc_mbuf_free(phba, mp->virt, mp->phys);
5420         kfree(mp);
5421         mempool_free(pmb, phba->mbox_mem_pool);
5422
5423         return;
5424 }
5425
5426 static int
5427 lpfc_filter_by_rpi(struct lpfc_nodelist *ndlp, void *param)
5428 {
5429         uint16_t *rpi = param;
5430
5431         /* check for active node */
5432         if (!NLP_CHK_NODE_ACT(ndlp))
5433                 return 0;
5434
5435         return ndlp->nlp_rpi == *rpi;
5436 }
5437
5438 static int
5439 lpfc_filter_by_wwpn(struct lpfc_nodelist *ndlp, void *param)
5440 {
5441         return memcmp(&ndlp->nlp_portname, param,
5442                       sizeof(ndlp->nlp_portname)) == 0;
5443 }
5444
5445 static struct lpfc_nodelist *
5446 __lpfc_find_node(struct lpfc_vport *vport, node_filter filter, void *param)
5447 {
5448         struct lpfc_nodelist *ndlp;
5449
5450         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
5451                 if (filter(ndlp, param)) {
5452                         lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
5453                                          "3185 FIND node filter %p DID "
5454                                          "Data: x%p x%x x%x\n",
5455                                          filter, ndlp, ndlp->nlp_DID,
5456                                          ndlp->nlp_flag);
5457                         return ndlp;
5458                 }
5459         }
5460         lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
5461                          "3186 FIND node filter %p NOT FOUND.\n", filter);
5462         return NULL;
5463 }
5464
5465 /*
5466  * This routine looks up the ndlp lists for the given RPI. If rpi found it
5467  * returns the node list element pointer else return NULL.
5468  */
5469 struct lpfc_nodelist *
5470 __lpfc_findnode_rpi(struct lpfc_vport *vport, uint16_t rpi)
5471 {
5472         return __lpfc_find_node(vport, lpfc_filter_by_rpi, &rpi);
5473 }
5474
5475 /*
5476  * This routine looks up the ndlp lists for the given WWPN. If WWPN found it
5477  * returns the node element list pointer else return NULL.
5478  */
5479 struct lpfc_nodelist *
5480 lpfc_findnode_wwpn(struct lpfc_vport *vport, struct lpfc_name *wwpn)
5481 {
5482         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5483         struct lpfc_nodelist *ndlp;
5484
5485         spin_lock_irq(shost->host_lock);
5486         ndlp = __lpfc_find_node(vport, lpfc_filter_by_wwpn, wwpn);
5487         spin_unlock_irq(shost->host_lock);
5488         return ndlp;
5489 }
5490
5491 /*
5492  * This routine looks up the ndlp lists for the given RPI. If the rpi
5493  * is found, the routine returns the node element list pointer else
5494  * return NULL.
5495  */
5496 struct lpfc_nodelist *
5497 lpfc_findnode_rpi(struct lpfc_vport *vport, uint16_t rpi)
5498 {
5499         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5500         struct lpfc_nodelist *ndlp;
5501
5502         spin_lock_irq(shost->host_lock);
5503         ndlp = __lpfc_findnode_rpi(vport, rpi);
5504         spin_unlock_irq(shost->host_lock);
5505         return ndlp;
5506 }
5507
5508 /**
5509  * lpfc_find_vport_by_vpid - Find a vport on a HBA through vport identifier
5510  * @phba: pointer to lpfc hba data structure.
5511  * @vpi: the physical host virtual N_Port identifier.
5512  *
5513  * This routine finds a vport on a HBA (referred by @phba) through a
5514  * @vpi. The function walks the HBA's vport list and returns the address
5515  * of the vport with the matching @vpi.
5516  *
5517  * Return code
5518  *    NULL - No vport with the matching @vpi found
5519  *    Otherwise - Address to the vport with the matching @vpi.
5520  **/
5521 struct lpfc_vport *
5522 lpfc_find_vport_by_vpid(struct lpfc_hba *phba, uint16_t vpi)
5523 {
5524         struct lpfc_vport *vport;
5525         unsigned long flags;
5526         int i = 0;
5527
5528         /* The physical ports are always vpi 0 - translate is unnecessary. */
5529         if (vpi > 0) {
5530                 /*
5531                  * Translate the physical vpi to the logical vpi.  The
5532                  * vport stores the logical vpi.
5533                  */
5534                 for (i = 0; i < phba->max_vpi; i++) {
5535                         if (vpi == phba->vpi_ids[i])
5536                                 break;
5537                 }
5538
5539                 if (i >= phba->max_vpi) {
5540                         lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
5541                                          "2936 Could not find Vport mapped "
5542                                          "to vpi %d\n", vpi);
5543                         return NULL;
5544                 }
5545         }
5546
5547         spin_lock_irqsave(&phba->hbalock, flags);
5548         list_for_each_entry(vport, &phba->port_list, listentry) {
5549                 if (vport->vpi == i) {
5550                         spin_unlock_irqrestore(&phba->hbalock, flags);
5551                         return vport;
5552                 }
5553         }
5554         spin_unlock_irqrestore(&phba->hbalock, flags);
5555         return NULL;
5556 }
5557
5558 void
5559 lpfc_nlp_init(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
5560               uint32_t did)
5561 {
5562         memset(ndlp, 0, sizeof (struct lpfc_nodelist));
5563
5564         lpfc_initialize_node(vport, ndlp, did);
5565         INIT_LIST_HEAD(&ndlp->nlp_listp);
5566
5567         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE,
5568                 "node init:       did:x%x",
5569                 ndlp->nlp_DID, 0, 0);
5570
5571         return;
5572 }
5573
5574 /* This routine releases all resources associated with a specifc NPort's ndlp
5575  * and mempool_free's the nodelist.
5576  */
5577 static void
5578 lpfc_nlp_release(struct kref *kref)
5579 {
5580         struct lpfc_hba *phba;
5581         unsigned long flags;
5582         struct lpfc_nodelist *ndlp = container_of(kref, struct lpfc_nodelist,
5583                                                   kref);
5584
5585         lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE,
5586                 "node release:    did:x%x flg:x%x type:x%x",
5587                 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type);
5588
5589         lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE,
5590                         "0279 lpfc_nlp_release: ndlp:x%p did %x "
5591                         "usgmap:x%x refcnt:%d\n",
5592                         (void *)ndlp, ndlp->nlp_DID, ndlp->nlp_usg_map,
5593                         atomic_read(&ndlp->kref.refcount));
5594
5595         /* remove ndlp from action. */
5596         lpfc_nlp_remove(ndlp->vport, ndlp);
5597
5598         /* clear the ndlp active flag for all release cases */
5599         phba = ndlp->phba;
5600         spin_lock_irqsave(&phba->ndlp_lock, flags);
5601         NLP_CLR_NODE_ACT(ndlp);
5602         spin_unlock_irqrestore(&phba->ndlp_lock, flags);
5603         if (phba->sli_rev == LPFC_SLI_REV4)
5604                 lpfc_sli4_free_rpi(phba, ndlp->nlp_rpi);
5605
5606         /* free ndlp memory for final ndlp release */
5607         if (NLP_CHK_FREE_REQ(ndlp)) {
5608                 kfree(ndlp->lat_data);
5609                 mempool_free(ndlp, ndlp->phba->nlp_mem_pool);
5610         }
5611 }
5612
5613 /* This routine bumps the reference count for a ndlp structure to ensure
5614  * that one discovery thread won't free a ndlp while another discovery thread
5615  * is using it.
5616  */
5617 struct lpfc_nodelist *
5618 lpfc_nlp_get(struct lpfc_nodelist *ndlp)
5619 {
5620         struct lpfc_hba *phba;
5621         unsigned long flags;
5622
5623         if (ndlp) {
5624                 lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE,
5625                         "node get:        did:x%x flg:x%x refcnt:x%x",
5626                         ndlp->nlp_DID, ndlp->nlp_flag,
5627                         atomic_read(&ndlp->kref.refcount));
5628                 /* The check of ndlp usage to prevent incrementing the
5629                  * ndlp reference count that is in the process of being
5630                  * released.
5631                  */
5632                 phba = ndlp->phba;
5633                 spin_lock_irqsave(&phba->ndlp_lock, flags);
5634                 if (!NLP_CHK_NODE_ACT(ndlp) || NLP_CHK_FREE_ACK(ndlp)) {
5635                         spin_unlock_irqrestore(&phba->ndlp_lock, flags);
5636                         lpfc_printf_vlog(ndlp->vport, KERN_WARNING, LOG_NODE,
5637                                 "0276 lpfc_nlp_get: ndlp:x%p "
5638                                 "usgmap:x%x refcnt:%d\n",
5639                                 (void *)ndlp, ndlp->nlp_usg_map,
5640                                 atomic_read(&ndlp->kref.refcount));
5641                         return NULL;
5642                 } else
5643                         kref_get(&ndlp->kref);
5644                 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
5645         }
5646         return ndlp;
5647 }
5648
5649 /* This routine decrements the reference count for a ndlp structure. If the
5650  * count goes to 0, this indicates the the associated nodelist should be
5651  * freed. Returning 1 indicates the ndlp resource has been released; on the
5652  * other hand, returning 0 indicates the ndlp resource has not been released
5653  * yet.
5654  */
5655 int
5656 lpfc_nlp_put(struct lpfc_nodelist *ndlp)
5657 {
5658         struct lpfc_hba *phba;
5659         unsigned long flags;
5660
5661         if (!ndlp)
5662                 return 1;
5663
5664         lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE,
5665         "node put:        did:x%x flg:x%x refcnt:x%x",
5666                 ndlp->nlp_DID, ndlp->nlp_flag,
5667                 atomic_read(&ndlp->kref.refcount));
5668         phba = ndlp->phba;
5669         spin_lock_irqsave(&phba->ndlp_lock, flags);
5670         /* Check the ndlp memory free acknowledge flag to avoid the
5671          * possible race condition that kref_put got invoked again
5672          * after previous one has done ndlp memory free.
5673          */
5674         if (NLP_CHK_FREE_ACK(ndlp)) {
5675                 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
5676                 lpfc_printf_vlog(ndlp->vport, KERN_WARNING, LOG_NODE,
5677                                 "0274 lpfc_nlp_put: ndlp:x%p "
5678                                 "usgmap:x%x refcnt:%d\n",
5679                                 (void *)ndlp, ndlp->nlp_usg_map,
5680                                 atomic_read(&ndlp->kref.refcount));
5681                 return 1;
5682         }
5683         /* Check the ndlp inactivate log flag to avoid the possible
5684          * race condition that kref_put got invoked again after ndlp
5685          * is already in inactivating state.
5686          */
5687         if (NLP_CHK_IACT_REQ(ndlp)) {
5688                 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
5689                 lpfc_printf_vlog(ndlp->vport, KERN_WARNING, LOG_NODE,
5690                                 "0275 lpfc_nlp_put: ndlp:x%p "
5691                                 "usgmap:x%x refcnt:%d\n",
5692                                 (void *)ndlp, ndlp->nlp_usg_map,
5693                                 atomic_read(&ndlp->kref.refcount));
5694                 return 1;
5695         }
5696         /* For last put, mark the ndlp usage flags to make sure no
5697          * other kref_get and kref_put on the same ndlp shall get
5698          * in between the process when the final kref_put has been
5699          * invoked on this ndlp.
5700          */
5701         if (atomic_read(&ndlp->kref.refcount) == 1) {
5702                 /* Indicate ndlp is put to inactive state. */
5703                 NLP_SET_IACT_REQ(ndlp);
5704                 /* Acknowledge ndlp memory free has been seen. */
5705                 if (NLP_CHK_FREE_REQ(ndlp))
5706                         NLP_SET_FREE_ACK(ndlp);
5707         }
5708         spin_unlock_irqrestore(&phba->ndlp_lock, flags);
5709         /* Note, the kref_put returns 1 when decrementing a reference
5710          * count that was 1, it invokes the release callback function,
5711          * but it still left the reference count as 1 (not actually
5712          * performs the last decrementation). Otherwise, it actually
5713          * decrements the reference count and returns 0.
5714          */
5715         return kref_put(&ndlp->kref, lpfc_nlp_release);
5716 }
5717
5718 /* This routine free's the specified nodelist if it is not in use
5719  * by any other discovery thread. This routine returns 1 if the
5720  * ndlp has been freed. A return value of 0 indicates the ndlp is
5721  * not yet been released.
5722  */
5723 int
5724 lpfc_nlp_not_used(struct lpfc_nodelist *ndlp)
5725 {
5726         lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE,
5727                 "node not used:   did:x%x flg:x%x refcnt:x%x",
5728                 ndlp->nlp_DID, ndlp->nlp_flag,
5729                 atomic_read(&ndlp->kref.refcount));
5730         if (atomic_read(&ndlp->kref.refcount) == 1)
5731                 if (lpfc_nlp_put(ndlp))
5732                         return 1;
5733         return 0;
5734 }
5735
5736 /**
5737  * lpfc_fcf_inuse - Check if FCF can be unregistered.
5738  * @phba: Pointer to hba context object.
5739  *
5740  * This function iterate through all FC nodes associated
5741  * will all vports to check if there is any node with
5742  * fc_rports associated with it. If there is an fc_rport
5743  * associated with the node, then the node is either in
5744  * discovered state or its devloss_timer is pending.
5745  */
5746 static int
5747 lpfc_fcf_inuse(struct lpfc_hba *phba)
5748 {
5749         struct lpfc_vport **vports;
5750         int i, ret = 0;
5751         struct lpfc_nodelist *ndlp;
5752         struct Scsi_Host  *shost;
5753
5754         vports = lpfc_create_vport_work_array(phba);
5755
5756         /* If driver cannot allocate memory, indicate fcf is in use */
5757         if (!vports)
5758                 return 1;
5759
5760         for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
5761                 shost = lpfc_shost_from_vport(vports[i]);
5762                 spin_lock_irq(shost->host_lock);
5763                 /*
5764                  * IF the CVL_RCVD bit is not set then we have sent the
5765                  * flogi.
5766                  * If dev_loss fires while we are waiting we do not want to
5767                  * unreg the fcf.
5768                  */
5769                 if (!(vports[i]->fc_flag & FC_VPORT_CVL_RCVD)) {
5770                         spin_unlock_irq(shost->host_lock);
5771                         ret =  1;
5772                         goto out;
5773                 }
5774                 list_for_each_entry(ndlp, &vports[i]->fc_nodes, nlp_listp) {
5775                         if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport &&
5776                           (ndlp->rport->roles & FC_RPORT_ROLE_FCP_TARGET)) {
5777                                 ret = 1;
5778                                 spin_unlock_irq(shost->host_lock);
5779                                 goto out;
5780                         } else if (ndlp->nlp_flag & NLP_RPI_REGISTERED) {
5781                                 ret = 1;
5782                                 lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
5783                                                 "2624 RPI %x DID %x flag %x "
5784                                                 "still logged in\n",
5785                                                 ndlp->nlp_rpi, ndlp->nlp_DID,
5786                                                 ndlp->nlp_flag);
5787                         }
5788                 }
5789                 spin_unlock_irq(shost->host_lock);
5790         }
5791 out:
5792         lpfc_destroy_vport_work_array(phba, vports);
5793         return ret;
5794 }
5795
5796 /**
5797  * lpfc_unregister_vfi_cmpl - Completion handler for unreg vfi.
5798  * @phba: Pointer to hba context object.
5799  * @mboxq: Pointer to mailbox object.
5800  *
5801  * This function frees memory associated with the mailbox command.
5802  */
5803 void
5804 lpfc_unregister_vfi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
5805 {
5806         struct lpfc_vport *vport = mboxq->vport;
5807         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5808
5809         if (mboxq->u.mb.mbxStatus) {
5810                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
5811                         "2555 UNREG_VFI mbxStatus error x%x "
5812                         "HBA state x%x\n",
5813                         mboxq->u.mb.mbxStatus, vport->port_state);
5814         }
5815         spin_lock_irq(shost->host_lock);
5816         phba->pport->fc_flag &= ~FC_VFI_REGISTERED;
5817         spin_unlock_irq(shost->host_lock);
5818         mempool_free(mboxq, phba->mbox_mem_pool);
5819         return;
5820 }
5821
5822 /**
5823  * lpfc_unregister_fcfi_cmpl - Completion handler for unreg fcfi.
5824  * @phba: Pointer to hba context object.
5825  * @mboxq: Pointer to mailbox object.
5826  *
5827  * This function frees memory associated with the mailbox command.
5828  */
5829 static void
5830 lpfc_unregister_fcfi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
5831 {
5832         struct lpfc_vport *vport = mboxq->vport;
5833
5834         if (mboxq->u.mb.mbxStatus) {
5835                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
5836                         "2550 UNREG_FCFI mbxStatus error x%x "
5837                         "HBA state x%x\n",
5838                         mboxq->u.mb.mbxStatus, vport->port_state);
5839         }
5840         mempool_free(mboxq, phba->mbox_mem_pool);
5841         return;
5842 }
5843
5844 /**
5845  * lpfc_unregister_fcf_prep - Unregister fcf record preparation
5846  * @phba: Pointer to hba context object.
5847  *
5848  * This function prepare the HBA for unregistering the currently registered
5849  * FCF from the HBA. It performs unregistering, in order, RPIs, VPIs, and
5850  * VFIs.
5851  */
5852 int
5853 lpfc_unregister_fcf_prep(struct lpfc_hba *phba)
5854 {
5855         struct lpfc_vport **vports;
5856         struct lpfc_nodelist *ndlp;
5857         struct Scsi_Host *shost;
5858         int i, rc;
5859
5860         /* Unregister RPIs */
5861         if (lpfc_fcf_inuse(phba))
5862                 lpfc_unreg_hba_rpis(phba);
5863
5864         /* At this point, all discovery is aborted */
5865         phba->pport->port_state = LPFC_VPORT_UNKNOWN;
5866
5867         /* Unregister VPIs */
5868         vports = lpfc_create_vport_work_array(phba);
5869         if (vports && (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED))
5870                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
5871                         /* Stop FLOGI/FDISC retries */
5872                         ndlp = lpfc_findnode_did(vports[i], Fabric_DID);
5873                         if (ndlp)
5874                                 lpfc_cancel_retry_delay_tmo(vports[i], ndlp);
5875                         lpfc_cleanup_pending_mbox(vports[i]);
5876                         if (phba->sli_rev == LPFC_SLI_REV4)
5877                                 lpfc_sli4_unreg_all_rpis(vports[i]);
5878                         lpfc_mbx_unreg_vpi(vports[i]);
5879                         shost = lpfc_shost_from_vport(vports[i]);
5880                         spin_lock_irq(shost->host_lock);
5881                         vports[i]->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
5882                         vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
5883                         spin_unlock_irq(shost->host_lock);
5884                 }
5885         lpfc_destroy_vport_work_array(phba, vports);
5886
5887         /* Cleanup any outstanding ELS commands */
5888         lpfc_els_flush_all_cmd(phba);
5889
5890         /* Unregister the physical port VFI */
5891         rc = lpfc_issue_unreg_vfi(phba->pport);
5892         return rc;
5893 }
5894
5895 /**
5896  * lpfc_sli4_unregister_fcf - Unregister currently registered FCF record
5897  * @phba: Pointer to hba context object.
5898  *
5899  * This function issues synchronous unregister FCF mailbox command to HBA to
5900  * unregister the currently registered FCF record. The driver does not reset
5901  * the driver FCF usage state flags.
5902  *
5903  * Return 0 if successfully issued, none-zero otherwise.
5904  */
5905 int
5906 lpfc_sli4_unregister_fcf(struct lpfc_hba *phba)
5907 {
5908         LPFC_MBOXQ_t *mbox;
5909         int rc;
5910
5911         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5912         if (!mbox) {
5913                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
5914                                 "2551 UNREG_FCFI mbox allocation failed"
5915                                 "HBA state x%x\n", phba->pport->port_state);
5916                 return -ENOMEM;
5917         }
5918         lpfc_unreg_fcfi(mbox, phba->fcf.fcfi);
5919         mbox->vport = phba->pport;
5920         mbox->mbox_cmpl = lpfc_unregister_fcfi_cmpl;
5921         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
5922
5923         if (rc == MBX_NOT_FINISHED) {
5924                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5925                                 "2552 Unregister FCFI command failed rc x%x "
5926                                 "HBA state x%x\n",
5927                                 rc, phba->pport->port_state);
5928                 return -EINVAL;
5929         }
5930         return 0;
5931 }
5932
5933 /**
5934  * lpfc_unregister_fcf_rescan - Unregister currently registered fcf and rescan
5935  * @phba: Pointer to hba context object.
5936  *
5937  * This function unregisters the currently reigstered FCF. This function
5938  * also tries to find another FCF for discovery by rescan the HBA FCF table.
5939  */
5940 void
5941 lpfc_unregister_fcf_rescan(struct lpfc_hba *phba)
5942 {
5943         int rc;
5944
5945         /* Preparation for unregistering fcf */
5946         rc = lpfc_unregister_fcf_prep(phba);
5947         if (rc) {
5948                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
5949                                 "2748 Failed to prepare for unregistering "
5950                                 "HBA's FCF record: rc=%d\n", rc);
5951                 return;
5952         }
5953
5954         /* Now, unregister FCF record and reset HBA FCF state */
5955         rc = lpfc_sli4_unregister_fcf(phba);
5956         if (rc)
5957                 return;
5958         /* Reset HBA FCF states after successful unregister FCF */
5959         phba->fcf.fcf_flag = 0;
5960         phba->fcf.current_rec.flag = 0;
5961
5962         /*
5963          * If driver is not unloading, check if there is any other
5964          * FCF record that can be used for discovery.
5965          */
5966         if ((phba->pport->load_flag & FC_UNLOADING) ||
5967             (phba->link_state < LPFC_LINK_UP))
5968                 return;
5969
5970         /* This is considered as the initial FCF discovery scan */
5971         spin_lock_irq(&phba->hbalock);
5972         phba->fcf.fcf_flag |= FCF_INIT_DISC;
5973         spin_unlock_irq(&phba->hbalock);
5974
5975         /* Reset FCF roundrobin bmask for new discovery */
5976         lpfc_sli4_clear_fcf_rr_bmask(phba);
5977
5978         rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
5979
5980         if (rc) {
5981                 spin_lock_irq(&phba->hbalock);
5982                 phba->fcf.fcf_flag &= ~FCF_INIT_DISC;
5983                 spin_unlock_irq(&phba->hbalock);
5984                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
5985                                 "2553 lpfc_unregister_unused_fcf failed "
5986                                 "to read FCF record HBA state x%x\n",
5987                                 phba->pport->port_state);
5988         }
5989 }
5990
5991 /**
5992  * lpfc_unregister_fcf - Unregister the currently registered fcf record
5993  * @phba: Pointer to hba context object.
5994  *
5995  * This function just unregisters the currently reigstered FCF. It does not
5996  * try to find another FCF for discovery.
5997  */
5998 void
5999 lpfc_unregister_fcf(struct lpfc_hba *phba)
6000 {
6001         int rc;
6002
6003         /* Preparation for unregistering fcf */
6004         rc = lpfc_unregister_fcf_prep(phba);
6005         if (rc) {
6006                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
6007                                 "2749 Failed to prepare for unregistering "
6008                                 "HBA's FCF record: rc=%d\n", rc);
6009                 return;
6010         }
6011
6012         /* Now, unregister FCF record and reset HBA FCF state */
6013         rc = lpfc_sli4_unregister_fcf(phba);
6014         if (rc)
6015                 return;
6016         /* Set proper HBA FCF states after successful unregister FCF */
6017         spin_lock_irq(&phba->hbalock);
6018         phba->fcf.fcf_flag &= ~FCF_REGISTERED;
6019         spin_unlock_irq(&phba->hbalock);
6020 }
6021
6022 /**
6023  * lpfc_unregister_unused_fcf - Unregister FCF if all devices are disconnected.
6024  * @phba: Pointer to hba context object.
6025  *
6026  * This function check if there are any connected remote port for the FCF and
6027  * if all the devices are disconnected, this function unregister FCFI.
6028  * This function also tries to use another FCF for discovery.
6029  */
6030 void
6031 lpfc_unregister_unused_fcf(struct lpfc_hba *phba)
6032 {
6033         /*
6034          * If HBA is not running in FIP mode, if HBA does not support
6035          * FCoE, if FCF discovery is ongoing, or if FCF has not been
6036          * registered, do nothing.
6037          */
6038         spin_lock_irq(&phba->hbalock);
6039         if (!(phba->hba_flag & HBA_FCOE_MODE) ||
6040             !(phba->fcf.fcf_flag & FCF_REGISTERED) ||
6041             !(phba->hba_flag & HBA_FIP_SUPPORT) ||
6042             (phba->fcf.fcf_flag & FCF_DISCOVERY) ||
6043             (phba->pport->port_state == LPFC_FLOGI)) {
6044                 spin_unlock_irq(&phba->hbalock);
6045                 return;
6046         }
6047         spin_unlock_irq(&phba->hbalock);
6048
6049         if (lpfc_fcf_inuse(phba))
6050                 return;
6051
6052         lpfc_unregister_fcf_rescan(phba);
6053 }
6054
6055 /**
6056  * lpfc_read_fcf_conn_tbl - Create driver FCF connection table.
6057  * @phba: Pointer to hba context object.
6058  * @buff: Buffer containing the FCF connection table as in the config
6059  *         region.
6060  * This function create driver data structure for the FCF connection
6061  * record table read from config region 23.
6062  */
6063 static void
6064 lpfc_read_fcf_conn_tbl(struct lpfc_hba *phba,
6065         uint8_t *buff)
6066 {
6067         struct lpfc_fcf_conn_entry *conn_entry, *next_conn_entry;
6068         struct lpfc_fcf_conn_hdr *conn_hdr;
6069         struct lpfc_fcf_conn_rec *conn_rec;
6070         uint32_t record_count;
6071         int i;
6072
6073         /* Free the current connect table */
6074         list_for_each_entry_safe(conn_entry, next_conn_entry,
6075                 &phba->fcf_conn_rec_list, list) {
6076                 list_del_init(&conn_entry->list);
6077                 kfree(conn_entry);
6078         }
6079
6080         conn_hdr = (struct lpfc_fcf_conn_hdr *) buff;
6081         record_count = conn_hdr->length * sizeof(uint32_t)/
6082                 sizeof(struct lpfc_fcf_conn_rec);
6083
6084         conn_rec = (struct lpfc_fcf_conn_rec *)
6085                 (buff + sizeof(struct lpfc_fcf_conn_hdr));
6086
6087         for (i = 0; i < record_count; i++) {
6088                 if (!(conn_rec[i].flags & FCFCNCT_VALID))
6089                         continue;
6090                 conn_entry = kzalloc(sizeof(struct lpfc_fcf_conn_entry),
6091                         GFP_KERNEL);
6092                 if (!conn_entry) {
6093                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6094                                 "2566 Failed to allocate connection"
6095                                 " table entry\n");
6096                         return;
6097                 }
6098
6099                 memcpy(&conn_entry->conn_rec, &conn_rec[i],
6100                         sizeof(struct lpfc_fcf_conn_rec));
6101                 conn_entry->conn_rec.vlan_tag =
6102                         le16_to_cpu(conn_entry->conn_rec.vlan_tag) & 0xFFF;
6103                 conn_entry->conn_rec.flags =
6104                         le16_to_cpu(conn_entry->conn_rec.flags);
6105                 list_add_tail(&conn_entry->list,
6106                         &phba->fcf_conn_rec_list);
6107         }
6108 }
6109
6110 /**
6111  * lpfc_read_fcoe_param - Read FCoe parameters from conf region..
6112  * @phba: Pointer to hba context object.
6113  * @buff: Buffer containing the FCoE parameter data structure.
6114  *
6115  *  This function update driver data structure with config
6116  *  parameters read from config region 23.
6117  */
6118 static void
6119 lpfc_read_fcoe_param(struct lpfc_hba *phba,
6120                         uint8_t *buff)
6121 {
6122         struct lpfc_fip_param_hdr *fcoe_param_hdr;
6123         struct lpfc_fcoe_params *fcoe_param;
6124
6125         fcoe_param_hdr = (struct lpfc_fip_param_hdr *)
6126                 buff;
6127         fcoe_param = (struct lpfc_fcoe_params *)
6128                 (buff + sizeof(struct lpfc_fip_param_hdr));
6129
6130         if ((fcoe_param_hdr->parm_version != FIPP_VERSION) ||
6131                 (fcoe_param_hdr->length != FCOE_PARAM_LENGTH))
6132                 return;
6133
6134         if (fcoe_param_hdr->parm_flags & FIPP_VLAN_VALID) {
6135                 phba->valid_vlan = 1;
6136                 phba->vlan_id = le16_to_cpu(fcoe_param->vlan_tag) &
6137                         0xFFF;
6138         }
6139
6140         phba->fc_map[0] = fcoe_param->fc_map[0];
6141         phba->fc_map[1] = fcoe_param->fc_map[1];
6142         phba->fc_map[2] = fcoe_param->fc_map[2];
6143         return;
6144 }
6145
6146 /**
6147  * lpfc_get_rec_conf23 - Get a record type in config region data.
6148  * @buff: Buffer containing config region 23 data.
6149  * @size: Size of the data buffer.
6150  * @rec_type: Record type to be searched.
6151  *
6152  * This function searches config region data to find the beginning
6153  * of the record specified by record_type. If record found, this
6154  * function return pointer to the record else return NULL.
6155  */
6156 static uint8_t *
6157 lpfc_get_rec_conf23(uint8_t *buff, uint32_t size, uint8_t rec_type)
6158 {
6159         uint32_t offset = 0, rec_length;
6160
6161         if ((buff[0] == LPFC_REGION23_LAST_REC) ||
6162                 (size < sizeof(uint32_t)))
6163                 return NULL;
6164
6165         rec_length = buff[offset + 1];
6166
6167         /*
6168          * One TLV record has one word header and number of data words
6169          * specified in the rec_length field of the record header.
6170          */
6171         while ((offset + rec_length * sizeof(uint32_t) + sizeof(uint32_t))
6172                 <= size) {
6173                 if (buff[offset] == rec_type)
6174                         return &buff[offset];
6175
6176                 if (buff[offset] == LPFC_REGION23_LAST_REC)
6177                         return NULL;
6178
6179                 offset += rec_length * sizeof(uint32_t) + sizeof(uint32_t);
6180                 rec_length = buff[offset + 1];
6181         }
6182         return NULL;
6183 }
6184
6185 /**
6186  * lpfc_parse_fcoe_conf - Parse FCoE config data read from config region 23.
6187  * @phba: Pointer to lpfc_hba data structure.
6188  * @buff: Buffer containing config region 23 data.
6189  * @size: Size of the data buffer.
6190  *
6191  * This function parses the FCoE config parameters in config region 23 and
6192  * populate driver data structure with the parameters.
6193  */
6194 void
6195 lpfc_parse_fcoe_conf(struct lpfc_hba *phba,
6196                 uint8_t *buff,
6197                 uint32_t size)
6198 {
6199         uint32_t offset = 0, rec_length;
6200         uint8_t *rec_ptr;
6201
6202         /*
6203          * If data size is less than 2 words signature and version cannot be
6204          * verified.
6205          */
6206         if (size < 2*sizeof(uint32_t))
6207                 return;
6208
6209         /* Check the region signature first */
6210         if (memcmp(buff, LPFC_REGION23_SIGNATURE, 4)) {
6211                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6212                         "2567 Config region 23 has bad signature\n");
6213                 return;
6214         }
6215
6216         offset += 4;
6217
6218         /* Check the data structure version */
6219         if (buff[offset] != LPFC_REGION23_VERSION) {
6220                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6221                         "2568 Config region 23 has bad version\n");
6222                 return;
6223         }
6224         offset += 4;
6225
6226         rec_length = buff[offset + 1];
6227
6228         /* Read FCoE param record */
6229         rec_ptr = lpfc_get_rec_conf23(&buff[offset],
6230                         size - offset, FCOE_PARAM_TYPE);
6231         if (rec_ptr)
6232                 lpfc_read_fcoe_param(phba, rec_ptr);
6233
6234         /* Read FCF connection table */
6235         rec_ptr = lpfc_get_rec_conf23(&buff[offset],
6236                 size - offset, FCOE_CONN_TBL_TYPE);
6237         if (rec_ptr)
6238                 lpfc_read_fcf_conn_tbl(phba, rec_ptr);
6239
6240 }