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