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