drivers/scsi/lpfc/lpfc_init.c

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2017 Broadcom. All Rights Reserved. The term      *
   5  * “Broadcom” refers to Broadcom Limited and/or its subsidiaries.  *
   6  * Copyright (C) 2004-2016 Emulex.  All rights reserved.           *
   7  * EMULEX and SLI are trademarks of Emulex.                        *
   8  * www.broadcom.com                                                *
   9  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
  10  *                                                                 *
  11  * This program is free software; you can redistribute it and/or   *
  12  * modify it under the terms of version 2 of the GNU General       *
  13  * Public License as published by the Free Software Foundation.    *
  14  * This program is distributed in the hope that it will be useful. *
  15  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  16  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  17  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  18  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  19  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  20  * more details, a copy of which can be found in the file COPYING  *
  21  * included with this package.                                     *
  22  *******************************************************************/
  23
  24 #include <linux/blkdev.h>
  25 #include <linux/delay.h>
  26 #include <linux/dma-mapping.h>
  27 #include <linux/idr.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/module.h>
  30 #include <linux/kthread.h>
  31 #include <linux/pci.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/ctype.h>
  34 #include <linux/aer.h>
  35 #include <linux/slab.h>
  36 #include <linux/firmware.h>
  37 #include <linux/miscdevice.h>
  38 #include <linux/percpu.h>
  39 #include <linux/msi.h>
  40
  41 #include <scsi/scsi.h>
  42 #include <scsi/scsi_device.h>
  43 #include <scsi/scsi_host.h>
  44 #include <scsi/scsi_transport_fc.h>
  45
  46 #include "lpfc_hw4.h"
  47 #include "lpfc_hw.h"
  48 #include "lpfc_sli.h"
  49 #include "lpfc_sli4.h"
  50 #include "lpfc_nl.h"
  51 #include "lpfc_disc.h"
  52 #include "lpfc.h"
  53 #include "lpfc_scsi.h"
  54 #include "lpfc_nvme.h"
  55 #include "lpfc_logmsg.h"
  56 #include "lpfc_crtn.h"
  57 #include "lpfc_vport.h"
  58 #include "lpfc_version.h"
  59 #include "lpfc_ids.h"
  60
  61 char *_dump_buf_data;
  62 unsigned long _dump_buf_data_order;
  63 char *_dump_buf_dif;
  64 unsigned long _dump_buf_dif_order;
  65 spinlock_t _dump_buf_lock;
  66
  67 /* Used when mapping IRQ vectors in a driver centric manner */
  68 uint16_t *lpfc_used_cpu;
  69 uint32_t lpfc_present_cpu;
  70
  71 static void lpfc_get_hba_model_desc(struct lpfc_hba *, uint8_t *, uint8_t *);
  72 static int lpfc_post_rcv_buf(struct lpfc_hba *);
  73 static int lpfc_sli4_queue_verify(struct lpfc_hba *);
  74 static int lpfc_create_bootstrap_mbox(struct lpfc_hba *);
  75 static int lpfc_setup_endian_order(struct lpfc_hba *);
  76 static void lpfc_destroy_bootstrap_mbox(struct lpfc_hba *);
  77 static void lpfc_free_els_sgl_list(struct lpfc_hba *);
  78 static void lpfc_free_nvmet_sgl_list(struct lpfc_hba *);
  79 static void lpfc_init_sgl_list(struct lpfc_hba *);
  80 static int lpfc_init_active_sgl_array(struct lpfc_hba *);
  81 static void lpfc_free_active_sgl(struct lpfc_hba *);
  82 static int lpfc_hba_down_post_s3(struct lpfc_hba *phba);
  83 static int lpfc_hba_down_post_s4(struct lpfc_hba *phba);
  84 static int lpfc_sli4_cq_event_pool_create(struct lpfc_hba *);
  85 static void lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *);
  86 static void lpfc_sli4_cq_event_release_all(struct lpfc_hba *);
  87 static void lpfc_sli4_disable_intr(struct lpfc_hba *);
  88 static uint32_t lpfc_sli4_enable_intr(struct lpfc_hba *, uint32_t);
  89 static void lpfc_sli4_oas_verify(struct lpfc_hba *phba);
  90
  91 static struct scsi_transport_template *lpfc_transport_template = NULL;
  92 static struct scsi_transport_template *lpfc_vport_transport_template = NULL;
  93 static DEFINE_IDR(lpfc_hba_index);
  94 #define LPFC_NVMET_BUF_POST 254
  95
  96 /**
  97  * lpfc_config_port_prep - Perform lpfc initialization prior to config port
  98  * @phba: pointer to lpfc hba data structure.
  99  *
 100  * This routine will do LPFC initialization prior to issuing the CONFIG_PORT
 101  * mailbox command. It retrieves the revision information from the HBA and
 102  * collects the Vital Product Data (VPD) about the HBA for preparing the
 103  * configuration of the HBA.
 104  *
 105  * Return codes:
 106  *   0 - success.
 107  *   -ERESTART - requests the SLI layer to reset the HBA and try again.
 108  *   Any other value - indicates an error.
 109  **/
 110 int
 111 lpfc_config_port_prep(struct lpfc_hba *phba)
 112 {
 113         lpfc_vpd_t *vp = &phba->vpd;
 114         int i = 0, rc;
 115         LPFC_MBOXQ_t *pmb;
 116         MAILBOX_t *mb;
 117         char *lpfc_vpd_data = NULL;
 118         uint16_t offset = 0;
 119         static char licensed[56] =
 120                     "key unlock for use with gnu public licensed code only\0";
 121         static int init_key = 1;
 122
 123         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 124         if (!pmb) {
 125                 phba->link_state = LPFC_HBA_ERROR;
 126                 return -ENOMEM;
 127         }
 128
 129         mb = &pmb->u.mb;
 130         phba->link_state = LPFC_INIT_MBX_CMDS;
 131
 132         if (lpfc_is_LC_HBA(phba->pcidev->device)) {
 133                 if (init_key) {
 134                         uint32_t *ptext = (uint32_t *) licensed;
 135
 136                         for (i = 0; i < 56; i += sizeof (uint32_t), ptext++)
 137                                 *ptext = cpu_to_be32(*ptext);
 138                         init_key = 0;
 139                 }
 140
 141                 lpfc_read_nv(phba, pmb);
 142                 memset((char*)mb->un.varRDnvp.rsvd3, 0,
 143                         sizeof (mb->un.varRDnvp.rsvd3));
 144                 memcpy((char*)mb->un.varRDnvp.rsvd3, licensed,
 145                          sizeof (licensed));
 146
 147                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 148
 149                 if (rc != MBX_SUCCESS) {
 150                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
 151                                         "0324 Config Port initialization "
 152                                         "error, mbxCmd x%x READ_NVPARM, "
 153                                         "mbxStatus x%x\n",
 154                                         mb->mbxCommand, mb->mbxStatus);
 155                         mempool_free(pmb, phba->mbox_mem_pool);
 156                         return -ERESTART;
 157                 }
 158                 memcpy(phba->wwnn, (char *)mb->un.varRDnvp.nodename,
 159                        sizeof(phba->wwnn));
 160                 memcpy(phba->wwpn, (char *)mb->un.varRDnvp.portname,
 161                        sizeof(phba->wwpn));
 162         }
 163
 164         phba->sli3_options = 0x0;
 165
 166         /* Setup and issue mailbox READ REV command */
 167         lpfc_read_rev(phba, pmb);
 168         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 169         if (rc != MBX_SUCCESS) {
 170                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 171                                 "0439 Adapter failed to init, mbxCmd x%x "
 172                                 "READ_REV, mbxStatus x%x\n",
 173                                 mb->mbxCommand, mb->mbxStatus);
 174                 mempool_free( pmb, phba->mbox_mem_pool);
 175                 return -ERESTART;
 176         }
 177
 178
 179         /*
 180          * The value of rr must be 1 since the driver set the cv field to 1.
 181          * This setting requires the FW to set all revision fields.
 182          */
 183         if (mb->un.varRdRev.rr == 0) {
 184                 vp->rev.rBit = 0;
 185                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 186                                 "0440 Adapter failed to init, READ_REV has "
 187                                 "missing revision information.\n");
 188                 mempool_free(pmb, phba->mbox_mem_pool);
 189                 return -ERESTART;
 190         }
 191
 192         if (phba->sli_rev == 3 && !mb->un.varRdRev.v3rsp) {
 193                 mempool_free(pmb, phba->mbox_mem_pool);
 194                 return -EINVAL;
 195         }
 196
 197         /* Save information as VPD data */
 198         vp->rev.rBit = 1;
 199         memcpy(&vp->sli3Feat, &mb->un.varRdRev.sli3Feat, sizeof(uint32_t));
 200         vp->rev.sli1FwRev = mb->un.varRdRev.sli1FwRev;
 201         memcpy(vp->rev.sli1FwName, (char*) mb->un.varRdRev.sli1FwName, 16);
 202         vp->rev.sli2FwRev = mb->un.varRdRev.sli2FwRev;
 203         memcpy(vp->rev.sli2FwName, (char *) mb->un.varRdRev.sli2FwName, 16);
 204         vp->rev.biuRev = mb->un.varRdRev.biuRev;
 205         vp->rev.smRev = mb->un.varRdRev.smRev;
 206         vp->rev.smFwRev = mb->un.varRdRev.un.smFwRev;
 207         vp->rev.endecRev = mb->un.varRdRev.endecRev;
 208         vp->rev.fcphHigh = mb->un.varRdRev.fcphHigh;
 209         vp->rev.fcphLow = mb->un.varRdRev.fcphLow;
 210         vp->rev.feaLevelHigh = mb->un.varRdRev.feaLevelHigh;
 211         vp->rev.feaLevelLow = mb->un.varRdRev.feaLevelLow;
 212         vp->rev.postKernRev = mb->un.varRdRev.postKernRev;
 213         vp->rev.opFwRev = mb->un.varRdRev.opFwRev;
 214
 215         /* If the sli feature level is less then 9, we must
 216          * tear down all RPIs and VPIs on link down if NPIV
 217          * is enabled.
 218          */
 219         if (vp->rev.feaLevelHigh < 9)
 220                 phba->sli3_options |= LPFC_SLI3_VPORT_TEARDOWN;
 221
 222         if (lpfc_is_LC_HBA(phba->pcidev->device))
 223                 memcpy(phba->RandomData, (char *)&mb->un.varWords[24],
 224                                                 sizeof (phba->RandomData));
 225
 226         /* Get adapter VPD information */
 227         lpfc_vpd_data = kmalloc(DMP_VPD_SIZE, GFP_KERNEL);
 228         if (!lpfc_vpd_data)
 229                 goto out_free_mbox;
 230         do {
 231                 lpfc_dump_mem(phba, pmb, offset, DMP_REGION_VPD);
 232                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 233
 234                 if (rc != MBX_SUCCESS) {
 235                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
 236                                         "0441 VPD not present on adapter, "
 237                                         "mbxCmd x%x DUMP VPD, mbxStatus x%x\n",
 238                                         mb->mbxCommand, mb->mbxStatus);
 239                         mb->un.varDmp.word_cnt = 0;
 240                 }
 241                 /* dump mem may return a zero when finished or we got a
 242                  * mailbox error, either way we are done.
 243                  */
 244                 if (mb->un.varDmp.word_cnt == 0)
 245                         break;
 246                 if (mb->un.varDmp.word_cnt > DMP_VPD_SIZE - offset)
 247                         mb->un.varDmp.word_cnt = DMP_VPD_SIZE - offset;
 248                 lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
 249                                       lpfc_vpd_data + offset,
 250                                       mb->un.varDmp.word_cnt);
 251                 offset += mb->un.varDmp.word_cnt;
 252         } while (mb->un.varDmp.word_cnt && offset < DMP_VPD_SIZE);
 253         lpfc_parse_vpd(phba, lpfc_vpd_data, offset);
 254
 255         kfree(lpfc_vpd_data);
 256 out_free_mbox:
 257         mempool_free(pmb, phba->mbox_mem_pool);
 258         return 0;
 259 }
 260
 261 /**
 262  * lpfc_config_async_cmpl - Completion handler for config async event mbox cmd
 263  * @phba: pointer to lpfc hba data structure.
 264  * @pmboxq: pointer to the driver internal queue element for mailbox command.
 265  *
 266  * This is the completion handler for driver's configuring asynchronous event
 267  * mailbox command to the device. If the mailbox command returns successfully,
 268  * it will set internal async event support flag to 1; otherwise, it will
 269  * set internal async event support flag to 0.
 270  **/
 271 static void
 272 lpfc_config_async_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
 273 {
 274         if (pmboxq->u.mb.mbxStatus == MBX_SUCCESS)
 275                 phba->temp_sensor_support = 1;
 276         else
 277                 phba->temp_sensor_support = 0;
 278         mempool_free(pmboxq, phba->mbox_mem_pool);
 279         return;
 280 }
 281
 282 /**
 283  * lpfc_dump_wakeup_param_cmpl - dump memory mailbox command completion handler
 284  * @phba: pointer to lpfc hba data structure.
 285  * @pmboxq: pointer to the driver internal queue element for mailbox command.
 286  *
 287  * This is the completion handler for dump mailbox command for getting
 288  * wake up parameters. When this command complete, the response contain
 289  * Option rom version of the HBA. This function translate the version number
 290  * into a human readable string and store it in OptionROMVersion.
 291  **/
 292 static void
 293 lpfc_dump_wakeup_param_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
 294 {
 295         struct prog_id *prg;
 296         uint32_t prog_id_word;
 297         char dist = ' ';
 298         /* character array used for decoding dist type. */
 299         char dist_char[] = "nabx";
 300
 301         if (pmboxq->u.mb.mbxStatus != MBX_SUCCESS) {
 302                 mempool_free(pmboxq, phba->mbox_mem_pool);
 303                 return;
 304         }
 305
 306         prg = (struct prog_id *) &prog_id_word;
 307
 308         /* word 7 contain option rom version */
 309         prog_id_word = pmboxq->u.mb.un.varWords[7];
 310
 311         /* Decode the Option rom version word to a readable string */
 312         if (prg->dist < 4)
 313                 dist = dist_char[prg->dist];
 314
 315         if ((prg->dist == 3) && (prg->num == 0))
 316                 snprintf(phba->OptionROMVersion, 32, "%d.%d%d",
 317                         prg->ver, prg->rev, prg->lev);
 318         else
 319                 snprintf(phba->OptionROMVersion, 32, "%d.%d%d%c%d",
 320                         prg->ver, prg->rev, prg->lev,
 321                         dist, prg->num);
 322         mempool_free(pmboxq, phba->mbox_mem_pool);
 323         return;
 324 }
 325
 326 /**
 327  * lpfc_update_vport_wwn - Updates the fc_nodename, fc_portname,
 328  *      cfg_soft_wwnn, cfg_soft_wwpn
 329  * @vport: pointer to lpfc vport data structure.
 330  *
 331  *
 332  * Return codes
 333  *   None.
 334  **/
 335 void
 336 lpfc_update_vport_wwn(struct lpfc_vport *vport)
 337 {
 338         /* If the soft name exists then update it using the service params */
 339         if (vport->phba->cfg_soft_wwnn)
 340                 u64_to_wwn(vport->phba->cfg_soft_wwnn,
 341                            vport->fc_sparam.nodeName.u.wwn);
 342         if (vport->phba->cfg_soft_wwpn)
 343                 u64_to_wwn(vport->phba->cfg_soft_wwpn,
 344                            vport->fc_sparam.portName.u.wwn);
 345
 346         /*
 347          * If the name is empty or there exists a soft name
 348          * then copy the service params name, otherwise use the fc name
 349          */
 350         if (vport->fc_nodename.u.wwn[0] == 0 || vport->phba->cfg_soft_wwnn)
 351                 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
 352                         sizeof(struct lpfc_name));
 353         else
 354                 memcpy(&vport->fc_sparam.nodeName, &vport->fc_nodename,
 355                         sizeof(struct lpfc_name));
 356
 357         if (vport->fc_portname.u.wwn[0] == 0 || vport->phba->cfg_soft_wwpn)
 358                 memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
 359                         sizeof(struct lpfc_name));
 360         else
 361                 memcpy(&vport->fc_sparam.portName, &vport->fc_portname,
 362                         sizeof(struct lpfc_name));
 363 }
 364
 365 /**
 366  * lpfc_config_port_post - Perform lpfc initialization after config port
 367  * @phba: pointer to lpfc hba data structure.
 368  *
 369  * This routine will do LPFC initialization after the CONFIG_PORT mailbox
 370  * command call. It performs all internal resource and state setups on the
 371  * port: post IOCB buffers, enable appropriate host interrupt attentions,
 372  * ELS ring timers, etc.
 373  *
 374  * Return codes
 375  *   0 - success.
 376  *   Any other value - error.
 377  **/
 378 int
 379 lpfc_config_port_post(struct lpfc_hba *phba)
 380 {
 381         struct lpfc_vport *vport = phba->pport;
 382         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 383         LPFC_MBOXQ_t *pmb;
 384         MAILBOX_t *mb;
 385         struct lpfc_dmabuf *mp;
 386         struct lpfc_sli *psli = &phba->sli;
 387         uint32_t status, timeout;
 388         int i, j;
 389         int rc;
 390
 391         spin_lock_irq(&phba->hbalock);
 392         /*
 393          * If the Config port completed correctly the HBA is not
 394          * over heated any more.
 395          */
 396         if (phba->over_temp_state == HBA_OVER_TEMP)
 397                 phba->over_temp_state = HBA_NORMAL_TEMP;
 398         spin_unlock_irq(&phba->hbalock);
 399
 400         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 401         if (!pmb) {
 402                 phba->link_state = LPFC_HBA_ERROR;
 403                 return -ENOMEM;
 404         }
 405         mb = &pmb->u.mb;
 406
 407         /* Get login parameters for NID.  */
 408         rc = lpfc_read_sparam(phba, pmb, 0);
 409         if (rc) {
 410                 mempool_free(pmb, phba->mbox_mem_pool);
 411                 return -ENOMEM;
 412         }
 413
 414         pmb->vport = vport;
 415         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
 416                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 417                                 "0448 Adapter failed init, mbxCmd x%x "
 418                                 "READ_SPARM mbxStatus x%x\n",
 419                                 mb->mbxCommand, mb->mbxStatus);
 420                 phba->link_state = LPFC_HBA_ERROR;
 421                 mp = (struct lpfc_dmabuf *) pmb->context1;
 422                 mempool_free(pmb, phba->mbox_mem_pool);
 423                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
 424                 kfree(mp);
 425                 return -EIO;
 426         }
 427
 428         mp = (struct lpfc_dmabuf *) pmb->context1;
 429
 430         memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
 431         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 432         kfree(mp);
 433         pmb->context1 = NULL;
 434         lpfc_update_vport_wwn(vport);
 435
 436         /* Update the fc_host data structures with new wwn. */
 437         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
 438         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
 439         fc_host_max_npiv_vports(shost) = phba->max_vpi;
 440
 441         /* If no serial number in VPD data, use low 6 bytes of WWNN */
 442         /* This should be consolidated into parse_vpd ? - mr */
 443         if (phba->SerialNumber[0] == 0) {
 444                 uint8_t *outptr;
 445
 446                 outptr = &vport->fc_nodename.u.s.IEEE[0];
 447                 for (i = 0; i < 12; i++) {
 448                         status = *outptr++;
 449                         j = ((status & 0xf0) >> 4);
 450                         if (j <= 9)
 451                                 phba->SerialNumber[i] =
 452                                     (char)((uint8_t) 0x30 + (uint8_t) j);
 453                         else
 454                                 phba->SerialNumber[i] =
 455                                     (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
 456                         i++;
 457                         j = (status & 0xf);
 458                         if (j <= 9)
 459                                 phba->SerialNumber[i] =
 460                                     (char)((uint8_t) 0x30 + (uint8_t) j);
 461                         else
 462                                 phba->SerialNumber[i] =
 463                                     (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
 464                 }
 465         }
 466
 467         lpfc_read_config(phba, pmb);
 468         pmb->vport = vport;
 469         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
 470                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 471                                 "0453 Adapter failed to init, mbxCmd x%x "
 472                                 "READ_CONFIG, mbxStatus x%x\n",
 473                                 mb->mbxCommand, mb->mbxStatus);
 474                 phba->link_state = LPFC_HBA_ERROR;
 475                 mempool_free( pmb, phba->mbox_mem_pool);
 476                 return -EIO;
 477         }
 478
 479         /* Check if the port is disabled */
 480         lpfc_sli_read_link_ste(phba);
 481
 482         /* Reset the DFT_HBA_Q_DEPTH to the max xri  */
 483         i = (mb->un.varRdConfig.max_xri + 1);
 484         if (phba->cfg_hba_queue_depth > i) {
 485                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
 486                                 "3359 HBA queue depth changed from %d to %d\n",
 487                                 phba->cfg_hba_queue_depth, i);
 488                 phba->cfg_hba_queue_depth = i;
 489         }
 490
 491         /* Reset the DFT_LUN_Q_DEPTH to (max xri >> 3)  */
 492         i = (mb->un.varRdConfig.max_xri >> 3);
 493         if (phba->pport->cfg_lun_queue_depth > i) {
 494                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
 495                                 "3360 LUN queue depth changed from %d to %d\n",
 496                                 phba->pport->cfg_lun_queue_depth, i);
 497                 phba->pport->cfg_lun_queue_depth = i;
 498         }
 499
 500         phba->lmt = mb->un.varRdConfig.lmt;
 501
 502         /* Get the default values for Model Name and Description */
 503         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
 504
 505         phba->link_state = LPFC_LINK_DOWN;
 506
 507         /* Only process IOCBs on ELS ring till hba_state is READY */
 508         if (psli->sli3_ring[LPFC_EXTRA_RING].sli.sli3.cmdringaddr)
 509                 psli->sli3_ring[LPFC_EXTRA_RING].flag |= LPFC_STOP_IOCB_EVENT;
 510         if (psli->sli3_ring[LPFC_FCP_RING].sli.sli3.cmdringaddr)
 511                 psli->sli3_ring[LPFC_FCP_RING].flag |= LPFC_STOP_IOCB_EVENT;
 512
 513         /* Post receive buffers for desired rings */
 514         if (phba->sli_rev != 3)
 515                 lpfc_post_rcv_buf(phba);
 516
 517         /*
 518          * Configure HBA MSI-X attention conditions to messages if MSI-X mode
 519          */
 520         if (phba->intr_type == MSIX) {
 521                 rc = lpfc_config_msi(phba, pmb);
 522                 if (rc) {
 523                         mempool_free(pmb, phba->mbox_mem_pool);
 524                         return -EIO;
 525                 }
 526                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 527                 if (rc != MBX_SUCCESS) {
 528                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
 529                                         "0352 Config MSI mailbox command "
 530                                         "failed, mbxCmd x%x, mbxStatus x%x\n",
 531                                         pmb->u.mb.mbxCommand,
 532                                         pmb->u.mb.mbxStatus);
 533                         mempool_free(pmb, phba->mbox_mem_pool);
 534                         return -EIO;
 535                 }
 536         }
 537
 538         spin_lock_irq(&phba->hbalock);
 539         /* Initialize ERATT handling flag */
 540         phba->hba_flag &= ~HBA_ERATT_HANDLED;
 541
 542         /* Enable appropriate host interrupts */
 543         if (lpfc_readl(phba->HCregaddr, &status)) {
 544                 spin_unlock_irq(&phba->hbalock);
 545                 return -EIO;
 546         }
 547         status |= HC_MBINT_ENA | HC_ERINT_ENA | HC_LAINT_ENA;
 548         if (psli->num_rings > 0)
 549                 status |= HC_R0INT_ENA;
 550         if (psli->num_rings > 1)
 551                 status |= HC_R1INT_ENA;
 552         if (psli->num_rings > 2)
 553                 status |= HC_R2INT_ENA;
 554         if (psli->num_rings > 3)
 555                 status |= HC_R3INT_ENA;
 556
 557         if ((phba->cfg_poll & ENABLE_FCP_RING_POLLING) &&
 558             (phba->cfg_poll & DISABLE_FCP_RING_INT))
 559                 status &= ~(HC_R0INT_ENA);
 560
 561         writel(status, phba->HCregaddr);
 562         readl(phba->HCregaddr); /* flush */
 563         spin_unlock_irq(&phba->hbalock);
 564
 565         /* Set up ring-0 (ELS) timer */
 566         timeout = phba->fc_ratov * 2;
 567         mod_timer(&vport->els_tmofunc,
 568                   jiffies + msecs_to_jiffies(1000 * timeout));
 569         /* Set up heart beat (HB) timer */
 570         mod_timer(&phba->hb_tmofunc,
 571                   jiffies + msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
 572         phba->hb_outstanding = 0;
 573         phba->last_completion_time = jiffies;
 574         /* Set up error attention (ERATT) polling timer */
 575         mod_timer(&phba->eratt_poll,
 576                   jiffies + msecs_to_jiffies(1000 * phba->eratt_poll_interval));
 577
 578         if (phba->hba_flag & LINK_DISABLED) {
 579                 lpfc_printf_log(phba,
 580                         KERN_ERR, LOG_INIT,
 581                         "2598 Adapter Link is disabled.\n");
 582                 lpfc_down_link(phba, pmb);
 583                 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 584                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 585                 if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
 586                         lpfc_printf_log(phba,
 587                         KERN_ERR, LOG_INIT,
 588                         "2599 Adapter failed to issue DOWN_LINK"
 589                         " mbox command rc 0x%x\n", rc);
 590
 591                         mempool_free(pmb, phba->mbox_mem_pool);
 592                         return -EIO;
 593                 }
 594         } else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) {
 595                 mempool_free(pmb, phba->mbox_mem_pool);
 596                 rc = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
 597                 if (rc)
 598                         return rc;
 599         }
 600         /* MBOX buffer will be freed in mbox compl */
 601         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 602         if (!pmb) {
 603                 phba->link_state = LPFC_HBA_ERROR;
 604                 return -ENOMEM;
 605         }
 606
 607         lpfc_config_async(phba, pmb, LPFC_ELS_RING);
 608         pmb->mbox_cmpl = lpfc_config_async_cmpl;
 609         pmb->vport = phba->pport;
 610         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 611
 612         if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
 613                 lpfc_printf_log(phba,
 614                                 KERN_ERR,
 615                                 LOG_INIT,
 616                                 "0456 Adapter failed to issue "
 617                                 "ASYNCEVT_ENABLE mbox status x%x\n",
 618                                 rc);
 619                 mempool_free(pmb, phba->mbox_mem_pool);
 620         }
 621
 622         /* Get Option rom version */
 623         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 624         if (!pmb) {
 625                 phba->link_state = LPFC_HBA_ERROR;
 626                 return -ENOMEM;
 627         }
 628
 629         lpfc_dump_wakeup_param(phba, pmb);
 630         pmb->mbox_cmpl = lpfc_dump_wakeup_param_cmpl;
 631         pmb->vport = phba->pport;
 632         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 633
 634         if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
 635                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, "0435 Adapter failed "
 636                                 "to get Option ROM version status x%x\n", rc);
 637                 mempool_free(pmb, phba->mbox_mem_pool);
 638         }
 639
 640         return 0;
 641 }
 642
 643 /**
 644  * lpfc_hba_init_link - Initialize the FC link
 645  * @phba: pointer to lpfc hba data structure.
 646  * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
 647  *
 648  * This routine will issue the INIT_LINK mailbox command call.
 649  * It is available to other drivers through the lpfc_hba data
 650  * structure for use as a delayed link up mechanism with the
 651  * module parameter lpfc_suppress_link_up.
 652  *
 653  * Return code
 654  *              0 - success
 655  *              Any other value - error
 656  **/
 657 static int
 658 lpfc_hba_init_link(struct lpfc_hba *phba, uint32_t flag)
 659 {
 660         return lpfc_hba_init_link_fc_topology(phba, phba->cfg_topology, flag);
 661 }
 662
 663 /**
 664  * lpfc_hba_init_link_fc_topology - Initialize FC link with desired topology
 665  * @phba: pointer to lpfc hba data structure.
 666  * @fc_topology: desired fc topology.
 667  * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
 668  *
 669  * This routine will issue the INIT_LINK mailbox command call.
 670  * It is available to other drivers through the lpfc_hba data
 671  * structure for use as a delayed link up mechanism with the
 672  * module parameter lpfc_suppress_link_up.
 673  *
 674  * Return code
 675  *              0 - success
 676  *              Any other value - error
 677  **/
 678 int
 679 lpfc_hba_init_link_fc_topology(struct lpfc_hba *phba, uint32_t fc_topology,
 680                                uint32_t flag)
 681 {
 682         struct lpfc_vport *vport = phba->pport;
 683         LPFC_MBOXQ_t *pmb;
 684         MAILBOX_t *mb;
 685         int rc;
 686
 687         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 688         if (!pmb) {
 689                 phba->link_state = LPFC_HBA_ERROR;
 690                 return -ENOMEM;
 691         }
 692         mb = &pmb->u.mb;
 693         pmb->vport = vport;
 694
 695         if ((phba->cfg_link_speed > LPFC_USER_LINK_SPEED_MAX) ||
 696             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_1G) &&
 697              !(phba->lmt & LMT_1Gb)) ||
 698             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_2G) &&
 699              !(phba->lmt & LMT_2Gb)) ||
 700             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_4G) &&
 701              !(phba->lmt & LMT_4Gb)) ||
 702             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_8G) &&
 703              !(phba->lmt & LMT_8Gb)) ||
 704             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_10G) &&
 705              !(phba->lmt & LMT_10Gb)) ||
 706             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G) &&
 707              !(phba->lmt & LMT_16Gb)) ||
 708             ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_32G) &&
 709              !(phba->lmt & LMT_32Gb))) {
 710                 /* Reset link speed to auto */
 711                 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
 712                         "1302 Invalid speed for this board:%d "
 713                         "Reset link speed to auto.\n",
 714                         phba->cfg_link_speed);
 715                         phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
 716         }
 717         lpfc_init_link(phba, pmb, fc_topology, phba->cfg_link_speed);
 718         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 719         if (phba->sli_rev < LPFC_SLI_REV4)
 720                 lpfc_set_loopback_flag(phba);
 721         rc = lpfc_sli_issue_mbox(phba, pmb, flag);
 722         if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
 723                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 724                         "0498 Adapter failed to init, mbxCmd x%x "
 725                         "INIT_LINK, mbxStatus x%x\n",
 726                         mb->mbxCommand, mb->mbxStatus);
 727                 if (phba->sli_rev <= LPFC_SLI_REV3) {
 728                         /* Clear all interrupt enable conditions */
 729                         writel(0, phba->HCregaddr);
 730                         readl(phba->HCregaddr); /* flush */
 731                         /* Clear all pending interrupts */
 732                         writel(0xffffffff, phba->HAregaddr);
 733                         readl(phba->HAregaddr); /* flush */
 734                 }
 735                 phba->link_state = LPFC_HBA_ERROR;
 736                 if (rc != MBX_BUSY || flag == MBX_POLL)
 737                         mempool_free(pmb, phba->mbox_mem_pool);
 738                 return -EIO;
 739         }
 740         phba->cfg_suppress_link_up = LPFC_INITIALIZE_LINK;
 741         if (flag == MBX_POLL)
 742                 mempool_free(pmb, phba->mbox_mem_pool);
 743
 744         return 0;
 745 }
 746
 747 /**
 748  * lpfc_hba_down_link - this routine downs the FC link
 749  * @phba: pointer to lpfc hba data structure.
 750  * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT
 751  *
 752  * This routine will issue the DOWN_LINK mailbox command call.
 753  * It is available to other drivers through the lpfc_hba data
 754  * structure for use to stop the link.
 755  *
 756  * Return code
 757  *              0 - success
 758  *              Any other value - error
 759  **/
 760 static int
 761 lpfc_hba_down_link(struct lpfc_hba *phba, uint32_t flag)
 762 {
 763         LPFC_MBOXQ_t *pmb;
 764         int rc;
 765
 766         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 767         if (!pmb) {
 768                 phba->link_state = LPFC_HBA_ERROR;
 769                 return -ENOMEM;
 770         }
 771
 772         lpfc_printf_log(phba,
 773                 KERN_ERR, LOG_INIT,
 774                 "0491 Adapter Link is disabled.\n");
 775         lpfc_down_link(phba, pmb);
 776         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 777         rc = lpfc_sli_issue_mbox(phba, pmb, flag);
 778         if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
 779                 lpfc_printf_log(phba,
 780                 KERN_ERR, LOG_INIT,
 781                 "2522 Adapter failed to issue DOWN_LINK"
 782                 " mbox command rc 0x%x\n", rc);
 783
 784                 mempool_free(pmb, phba->mbox_mem_pool);
 785                 return -EIO;
 786         }
 787         if (flag == MBX_POLL)
 788                 mempool_free(pmb, phba->mbox_mem_pool);
 789
 790         return 0;
 791 }
 792
 793 /**
 794  * lpfc_hba_down_prep - Perform lpfc uninitialization prior to HBA reset
 795  * @phba: pointer to lpfc HBA data structure.
 796  *
 797  * This routine will do LPFC uninitialization before the HBA is reset when
 798  * bringing down the SLI Layer.
 799  *
 800  * Return codes
 801  *   0 - success.
 802  *   Any other value - error.
 803  **/
 804 int
 805 lpfc_hba_down_prep(struct lpfc_hba *phba)
 806 {
 807         struct lpfc_vport **vports;
 808         int i;
 809
 810         if (phba->sli_rev <= LPFC_SLI_REV3) {
 811                 /* Disable interrupts */
 812                 writel(0, phba->HCregaddr);
 813                 readl(phba->HCregaddr); /* flush */
 814         }
 815
 816         if (phba->pport->load_flag & FC_UNLOADING)
 817                 lpfc_cleanup_discovery_resources(phba->pport);
 818         else {
 819                 vports = lpfc_create_vport_work_array(phba);
 820                 if (vports != NULL)
 821                         for (i = 0; i <= phba->max_vports &&
 822                                 vports[i] != NULL; i++)
 823                                 lpfc_cleanup_discovery_resources(vports[i]);
 824                 lpfc_destroy_vport_work_array(phba, vports);
 825         }
 826         return 0;
 827 }
 828
 829 /**
 830  * lpfc_sli4_free_sp_events - Cleanup sp_queue_events to free
 831  * rspiocb which got deferred
 832  *
 833  * @phba: pointer to lpfc HBA data structure.
 834  *
 835  * This routine will cleanup completed slow path events after HBA is reset
 836  * when bringing down the SLI Layer.
 837  *
 838  *
 839  * Return codes
 840  *   void.
 841  **/
 842 static void
 843 lpfc_sli4_free_sp_events(struct lpfc_hba *phba)
 844 {
 845         struct lpfc_iocbq *rspiocbq;
 846         struct hbq_dmabuf *dmabuf;
 847         struct lpfc_cq_event *cq_event;
 848
 849         spin_lock_irq(&phba->hbalock);
 850         phba->hba_flag &= ~HBA_SP_QUEUE_EVT;
 851         spin_unlock_irq(&phba->hbalock);
 852
 853         while (!list_empty(&phba->sli4_hba.sp_queue_event)) {
 854                 /* Get the response iocb from the head of work queue */
 855                 spin_lock_irq(&phba->hbalock);
 856                 list_remove_head(&phba->sli4_hba.sp_queue_event,
 857                                  cq_event, struct lpfc_cq_event, list);
 858                 spin_unlock_irq(&phba->hbalock);
 859
 860                 switch (bf_get(lpfc_wcqe_c_code, &cq_event->cqe.wcqe_cmpl)) {
 861                 case CQE_CODE_COMPL_WQE:
 862                         rspiocbq = container_of(cq_event, struct lpfc_iocbq,
 863                                                  cq_event);
 864                         lpfc_sli_release_iocbq(phba, rspiocbq);
 865                         break;
 866                 case CQE_CODE_RECEIVE:
 867                 case CQE_CODE_RECEIVE_V1:
 868                         dmabuf = container_of(cq_event, struct hbq_dmabuf,
 869                                               cq_event);
 870                         lpfc_in_buf_free(phba, &dmabuf->dbuf);
 871                 }
 872         }
 873 }
 874
 875 /**
 876  * lpfc_hba_free_post_buf - Perform lpfc uninitialization after HBA reset
 877  * @phba: pointer to lpfc HBA data structure.
 878  *
 879  * This routine will cleanup posted ELS buffers after the HBA is reset
 880  * when bringing down the SLI Layer.
 881  *
 882  *
 883  * Return codes
 884  *   void.
 885  **/
 886 static void
 887 lpfc_hba_free_post_buf(struct lpfc_hba *phba)
 888 {
 889         struct lpfc_sli *psli = &phba->sli;
 890         struct lpfc_sli_ring *pring;
 891         struct lpfc_dmabuf *mp, *next_mp;
 892         LIST_HEAD(buflist);
 893         int count;
 894
 895         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
 896                 lpfc_sli_hbqbuf_free_all(phba);
 897         else {
 898                 /* Cleanup preposted buffers on the ELS ring */
 899                 pring = &psli->sli3_ring[LPFC_ELS_RING];
 900                 spin_lock_irq(&phba->hbalock);
 901                 list_splice_init(&pring->postbufq, &buflist);
 902                 spin_unlock_irq(&phba->hbalock);
 903
 904                 count = 0;
 905                 list_for_each_entry_safe(mp, next_mp, &buflist, list) {
 906                         list_del(&mp->list);
 907                         count++;
 908                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 909                         kfree(mp);
 910                 }
 911
 912                 spin_lock_irq(&phba->hbalock);
 913                 pring->postbufq_cnt -= count;
 914                 spin_unlock_irq(&phba->hbalock);
 915         }
 916 }
 917
 918 /**
 919  * lpfc_hba_clean_txcmplq - Perform lpfc uninitialization after HBA reset
 920  * @phba: pointer to lpfc HBA data structure.
 921  *
 922  * This routine will cleanup the txcmplq after the HBA is reset when bringing
 923  * down the SLI Layer.
 924  *
 925  * Return codes
 926  *   void
 927  **/
 928 static void
 929 lpfc_hba_clean_txcmplq(struct lpfc_hba *phba)
 930 {
 931         struct lpfc_sli *psli = &phba->sli;
 932         struct lpfc_queue *qp = NULL;
 933         struct lpfc_sli_ring *pring;
 934         LIST_HEAD(completions);
 935         int i;
 936
 937         if (phba->sli_rev != LPFC_SLI_REV4) {
 938                 for (i = 0; i < psli->num_rings; i++) {
 939                         pring = &psli->sli3_ring[i];
 940                         spin_lock_irq(&phba->hbalock);
 941                         /* At this point in time the HBA is either reset or DOA
 942                          * Nothing should be on txcmplq as it will
 943                          * NEVER complete.
 944                          */
 945                         list_splice_init(&pring->txcmplq, &completions);
 946                         pring->txcmplq_cnt = 0;
 947                         spin_unlock_irq(&phba->hbalock);
 948
 949                         lpfc_sli_abort_iocb_ring(phba, pring);
 950                 }
 951                 /* Cancel all the IOCBs from the completions list */
 952                 lpfc_sli_cancel_iocbs(phba, &completions,
 953                                       IOSTAT_LOCAL_REJECT, IOERR_SLI_ABORTED);
 954                 return;
 955         }
 956         list_for_each_entry(qp, &phba->sli4_hba.lpfc_wq_list, wq_list) {
 957                 pring = qp->pring;
 958                 if (!pring)
 959                         continue;
 960                 spin_lock_irq(&pring->ring_lock);
 961                 list_splice_init(&pring->txcmplq, &completions);
 962                 pring->txcmplq_cnt = 0;
 963                 spin_unlock_irq(&pring->ring_lock);
 964                 lpfc_sli_abort_iocb_ring(phba, pring);
 965         }
 966         /* Cancel all the IOCBs from the completions list */
 967         lpfc_sli_cancel_iocbs(phba, &completions,
 968                               IOSTAT_LOCAL_REJECT, IOERR_SLI_ABORTED);
 969 }
 970
 971 /**
 972  * lpfc_hba_down_post_s3 - Perform lpfc uninitialization after HBA reset
 973         int i;
 974  * @phba: pointer to lpfc HBA data structure.
 975  *
 976  * This routine will do uninitialization after the HBA is reset when bring
 977  * down the SLI Layer.
 978  *
 979  * Return codes
 980  *   0 - success.
 981  *   Any other value - error.
 982  **/
 983 static int
 984 lpfc_hba_down_post_s3(struct lpfc_hba *phba)
 985 {
 986         lpfc_hba_free_post_buf(phba);
 987         lpfc_hba_clean_txcmplq(phba);
 988         return 0;
 989 }
 990
 991 /**
 992  * lpfc_hba_down_post_s4 - Perform lpfc uninitialization after HBA reset
 993  * @phba: pointer to lpfc HBA data structure.
 994  *
 995  * This routine will do uninitialization after the HBA is reset when bring
 996  * down the SLI Layer.
 997  *
 998  * Return codes
 999  *   0 - success.
1000  *   Any other value - error.
1001  **/
1002 static int
1003 lpfc_hba_down_post_s4(struct lpfc_hba *phba)
1004 {
1005         struct lpfc_scsi_buf *psb, *psb_next;
1006         LIST_HEAD(aborts);
1007         LIST_HEAD(nvme_aborts);
1008         unsigned long iflag = 0;
1009         struct lpfc_sglq *sglq_entry = NULL;
1010
1011
1012         lpfc_sli_hbqbuf_free_all(phba);
1013         lpfc_hba_clean_txcmplq(phba);
1014
1015         /* At this point in time the HBA is either reset or DOA. Either
1016          * way, nothing should be on lpfc_abts_els_sgl_list, it needs to be
1017          * on the lpfc_els_sgl_list so that it can either be freed if the
1018          * driver is unloading or reposted if the driver is restarting
1019          * the port.
1020          */
1021         spin_lock_irq(&phba->hbalock);  /* required for lpfc_els_sgl_list and */
1022                                         /* scsl_buf_list */
1023         /* sgl_list_lock required because worker thread uses this
1024          * list.
1025          */
1026         spin_lock(&phba->sli4_hba.sgl_list_lock);
1027         list_for_each_entry(sglq_entry,
1028                 &phba->sli4_hba.lpfc_abts_els_sgl_list, list)
1029                 sglq_entry->state = SGL_FREED;
1030         list_for_each_entry(sglq_entry,
1031                 &phba->sli4_hba.lpfc_abts_nvmet_sgl_list, list)
1032                 sglq_entry->state = SGL_FREED;
1033
1034         list_splice_init(&phba->sli4_hba.lpfc_abts_els_sgl_list,
1035                         &phba->sli4_hba.lpfc_els_sgl_list);
1036
1037         if (phba->sli4_hba.nvme_wq)
1038                 list_splice_init(&phba->sli4_hba.lpfc_abts_nvmet_sgl_list,
1039                                  &phba->sli4_hba.lpfc_nvmet_sgl_list);
1040
1041         spin_unlock(&phba->sli4_hba.sgl_list_lock);
1042         /* abts_scsi_buf_list_lock required because worker thread uses this
1043          * list.
1044          */
1045         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP) {
1046                 spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock);
1047                 list_splice_init(&phba->sli4_hba.lpfc_abts_scsi_buf_list,
1048                                  &aborts);
1049                 spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock);
1050         }
1051
1052         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
1053                 spin_lock(&phba->sli4_hba.abts_nvme_buf_list_lock);
1054                 list_splice_init(&phba->sli4_hba.lpfc_abts_nvme_buf_list,
1055                                  &nvme_aborts);
1056                 spin_unlock(&phba->sli4_hba.abts_nvme_buf_list_lock);
1057         }
1058
1059         spin_unlock_irq(&phba->hbalock);
1060
1061         list_for_each_entry_safe(psb, psb_next, &aborts, list) {
1062                 psb->pCmd = NULL;
1063                 psb->status = IOSTAT_SUCCESS;
1064         }
1065         spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag);
1066         list_splice(&aborts, &phba->lpfc_scsi_buf_list_put);
1067         spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag);
1068
1069         list_for_each_entry_safe(psb, psb_next, &nvme_aborts, list) {
1070                 psb->pCmd = NULL;
1071                 psb->status = IOSTAT_SUCCESS;
1072         }
1073         spin_lock_irqsave(&phba->nvme_buf_list_put_lock, iflag);
1074         list_splice(&nvme_aborts, &phba->lpfc_nvme_buf_list_put);
1075         spin_unlock_irqrestore(&phba->nvme_buf_list_put_lock, iflag);
1076
1077         lpfc_sli4_free_sp_events(phba);
1078         return 0;
1079 }
1080
1081 /**
1082  * lpfc_hba_down_post - Wrapper func for hba down post routine
1083  * @phba: pointer to lpfc HBA data structure.
1084  *
1085  * This routine wraps the actual SLI3 or SLI4 routine for performing
1086  * uninitialization after the HBA is reset when bring down the SLI Layer.
1087  *
1088  * Return codes
1089  *   0 - success.
1090  *   Any other value - error.
1091  **/
1092 int
1093 lpfc_hba_down_post(struct lpfc_hba *phba)
1094 {
1095         return (*phba->lpfc_hba_down_post)(phba);
1096 }
1097
1098 /**
1099  * lpfc_hb_timeout - The HBA-timer timeout handler
1100  * @ptr: unsigned long holds the pointer to lpfc hba data structure.
1101  *
1102  * This is the HBA-timer timeout handler registered to the lpfc driver. When
1103  * this timer fires, a HBA timeout event shall be posted to the lpfc driver
1104  * work-port-events bitmap and the worker thread is notified. This timeout
1105  * event will be used by the worker thread to invoke the actual timeout
1106  * handler routine, lpfc_hb_timeout_handler. Any periodical operations will
1107  * be performed in the timeout handler and the HBA timeout event bit shall
1108  * be cleared by the worker thread after it has taken the event bitmap out.
1109  **/
1110 static void
1111 lpfc_hb_timeout(unsigned long ptr)
1112 {
1113         struct lpfc_hba *phba;
1114         uint32_t tmo_posted;
1115         unsigned long iflag;
1116
1117         phba = (struct lpfc_hba *)ptr;
1118
1119         /* Check for heart beat timeout conditions */
1120         spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
1121         tmo_posted = phba->pport->work_port_events & WORKER_HB_TMO;
1122         if (!tmo_posted)
1123                 phba->pport->work_port_events |= WORKER_HB_TMO;
1124         spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
1125
1126         /* Tell the worker thread there is work to do */
1127         if (!tmo_posted)
1128                 lpfc_worker_wake_up(phba);
1129         return;
1130 }
1131
1132 /**
1133  * lpfc_rrq_timeout - The RRQ-timer timeout handler
1134  * @ptr: unsigned long holds the pointer to lpfc hba data structure.
1135  *
1136  * This is the RRQ-timer timeout handler registered to the lpfc driver. When
1137  * this timer fires, a RRQ timeout event shall be posted to the lpfc driver
1138  * work-port-events bitmap and the worker thread is notified. This timeout
1139  * event will be used by the worker thread to invoke the actual timeout
1140  * handler routine, lpfc_rrq_handler. Any periodical operations will
1141  * be performed in the timeout handler and the RRQ timeout event bit shall
1142  * be cleared by the worker thread after it has taken the event bitmap out.
1143  **/
1144 static void
1145 lpfc_rrq_timeout(unsigned long ptr)
1146 {
1147         struct lpfc_hba *phba;
1148         unsigned long iflag;
1149
1150         phba = (struct lpfc_hba *)ptr;
1151         spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
1152         if (!(phba->pport->load_flag & FC_UNLOADING))
1153                 phba->hba_flag |= HBA_RRQ_ACTIVE;
1154         else
1155                 phba->hba_flag &= ~HBA_RRQ_ACTIVE;
1156         spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
1157
1158         if (!(phba->pport->load_flag & FC_UNLOADING))
1159                 lpfc_worker_wake_up(phba);
1160 }
1161
1162 /**
1163  * lpfc_hb_mbox_cmpl - The lpfc heart-beat mailbox command callback function
1164  * @phba: pointer to lpfc hba data structure.
1165  * @pmboxq: pointer to the driver internal queue element for mailbox command.
1166  *
1167  * This is the callback function to the lpfc heart-beat mailbox command.
1168  * If configured, the lpfc driver issues the heart-beat mailbox command to
1169  * the HBA every LPFC_HB_MBOX_INTERVAL (current 5) seconds. At the time the
1170  * heart-beat mailbox command is issued, the driver shall set up heart-beat
1171  * timeout timer to LPFC_HB_MBOX_TIMEOUT (current 30) seconds and marks
1172  * heart-beat outstanding state. Once the mailbox command comes back and
1173  * no error conditions detected, the heart-beat mailbox command timer is
1174  * reset to LPFC_HB_MBOX_INTERVAL seconds and the heart-beat outstanding
1175  * state is cleared for the next heart-beat. If the timer expired with the
1176  * heart-beat outstanding state set, the driver will put the HBA offline.
1177  **/
1178 static void
1179 lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
1180 {
1181         unsigned long drvr_flag;
1182
1183         spin_lock_irqsave(&phba->hbalock, drvr_flag);
1184         phba->hb_outstanding = 0;
1185         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
1186
1187         /* Check and reset heart-beat timer is necessary */
1188         mempool_free(pmboxq, phba->mbox_mem_pool);
1189         if (!(phba->pport->fc_flag & FC_OFFLINE_MODE) &&
1190                 !(phba->link_state == LPFC_HBA_ERROR) &&
1191                 !(phba->pport->load_flag & FC_UNLOADING))
1192                 mod_timer(&phba->hb_tmofunc,
1193                           jiffies +
1194                           msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
1195         return;
1196 }
1197
1198 /**
1199  * lpfc_hb_timeout_handler - The HBA-timer timeout handler
1200  * @phba: pointer to lpfc hba data structure.
1201  *
1202  * This is the actual HBA-timer timeout handler to be invoked by the worker
1203  * thread whenever the HBA timer fired and HBA-timeout event posted. This
1204  * handler performs any periodic operations needed for the device. If such
1205  * periodic event has already been attended to either in the interrupt handler
1206  * or by processing slow-ring or fast-ring events within the HBA-timer
1207  * timeout window (LPFC_HB_MBOX_INTERVAL), this handler just simply resets
1208  * the timer for the next timeout period. If lpfc heart-beat mailbox command
1209  * is configured and there is no heart-beat mailbox command outstanding, a
1210  * heart-beat mailbox is issued and timer set properly. Otherwise, if there
1211  * has been a heart-beat mailbox command outstanding, the HBA shall be put
1212  * to offline.
1213  **/
1214 void
1215 lpfc_hb_timeout_handler(struct lpfc_hba *phba)
1216 {
1217         struct lpfc_vport **vports;
1218         LPFC_MBOXQ_t *pmboxq;
1219         struct lpfc_dmabuf *buf_ptr;
1220         int retval, i;
1221         struct lpfc_sli *psli = &phba->sli;
1222         LIST_HEAD(completions);
1223
1224         vports = lpfc_create_vport_work_array(phba);
1225         if (vports != NULL)
1226                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
1227                         lpfc_rcv_seq_check_edtov(vports[i]);
1228                         lpfc_fdmi_num_disc_check(vports[i]);
1229                 }
1230         lpfc_destroy_vport_work_array(phba, vports);
1231
1232         if ((phba->link_state == LPFC_HBA_ERROR) ||
1233                 (phba->pport->load_flag & FC_UNLOADING) ||
1234                 (phba->pport->fc_flag & FC_OFFLINE_MODE))
1235                 return;
1236
1237         spin_lock_irq(&phba->pport->work_port_lock);
1238
1239         if (time_after(phba->last_completion_time +
1240                         msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL),
1241                         jiffies)) {
1242                 spin_unlock_irq(&phba->pport->work_port_lock);
1243                 if (!phba->hb_outstanding)
1244                         mod_timer(&phba->hb_tmofunc,
1245                                 jiffies +
1246                                 msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
1247                 else
1248                         mod_timer(&phba->hb_tmofunc,
1249                                 jiffies +
1250                                 msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
1251                 return;
1252         }
1253         spin_unlock_irq(&phba->pport->work_port_lock);
1254
1255         if (phba->elsbuf_cnt &&
1256                 (phba->elsbuf_cnt == phba->elsbuf_prev_cnt)) {
1257                 spin_lock_irq(&phba->hbalock);
1258                 list_splice_init(&phba->elsbuf, &completions);
1259                 phba->elsbuf_cnt = 0;
1260                 phba->elsbuf_prev_cnt = 0;
1261                 spin_unlock_irq(&phba->hbalock);
1262
1263                 while (!list_empty(&completions)) {
1264                         list_remove_head(&completions, buf_ptr,
1265                                 struct lpfc_dmabuf, list);
1266                         lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
1267                         kfree(buf_ptr);
1268                 }
1269         }
1270         phba->elsbuf_prev_cnt = phba->elsbuf_cnt;
1271
1272         /* If there is no heart beat outstanding, issue a heartbeat command */
1273         if (phba->cfg_enable_hba_heartbeat) {
1274                 if (!phba->hb_outstanding) {
1275                         if ((!(psli->sli_flag & LPFC_SLI_MBOX_ACTIVE)) &&
1276                                 (list_empty(&psli->mboxq))) {
1277                                 pmboxq = mempool_alloc(phba->mbox_mem_pool,
1278                                                         GFP_KERNEL);
1279                                 if (!pmboxq) {
1280                                         mod_timer(&phba->hb_tmofunc,
1281                                                  jiffies +
1282                                                  msecs_to_jiffies(1000 *
1283                                                  LPFC_HB_MBOX_INTERVAL));
1284                                         return;
1285                                 }
1286
1287                                 lpfc_heart_beat(phba, pmboxq);
1288                                 pmboxq->mbox_cmpl = lpfc_hb_mbox_cmpl;
1289                                 pmboxq->vport = phba->pport;
1290                                 retval = lpfc_sli_issue_mbox(phba, pmboxq,
1291                                                 MBX_NOWAIT);
1292
1293                                 if (retval != MBX_BUSY &&
1294                                         retval != MBX_SUCCESS) {
1295                                         mempool_free(pmboxq,
1296                                                         phba->mbox_mem_pool);
1297                                         mod_timer(&phba->hb_tmofunc,
1298                                                 jiffies +
1299                                                 msecs_to_jiffies(1000 *
1300                                                 LPFC_HB_MBOX_INTERVAL));
1301                                         return;
1302                                 }
1303                                 phba->skipped_hb = 0;
1304                                 phba->hb_outstanding = 1;
1305                         } else if (time_before_eq(phba->last_completion_time,
1306                                         phba->skipped_hb)) {
1307                                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1308                                         "2857 Last completion time not "
1309                                         " updated in %d ms\n",
1310                                         jiffies_to_msecs(jiffies
1311                                                  - phba->last_completion_time));
1312                         } else
1313                                 phba->skipped_hb = jiffies;
1314
1315                         mod_timer(&phba->hb_tmofunc,
1316                                  jiffies +
1317                                  msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
1318                         return;
1319                 } else {
1320                         /*
1321                         * If heart beat timeout called with hb_outstanding set
1322                         * we need to give the hb mailbox cmd a chance to
1323                         * complete or TMO.
1324                         */
1325                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1326                                         "0459 Adapter heartbeat still out"
1327                                         "standing:last compl time was %d ms.\n",
1328                                         jiffies_to_msecs(jiffies
1329                                                  - phba->last_completion_time));
1330                         mod_timer(&phba->hb_tmofunc,
1331                                 jiffies +
1332                                 msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
1333                 }
1334         } else {
1335                         mod_timer(&phba->hb_tmofunc,
1336                                 jiffies +
1337                                 msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
1338         }
1339 }
1340
1341 /**
1342  * lpfc_offline_eratt - Bring lpfc offline on hardware error attention
1343  * @phba: pointer to lpfc hba data structure.
1344  *
1345  * This routine is called to bring the HBA offline when HBA hardware error
1346  * other than Port Error 6 has been detected.
1347  **/
1348 static void
1349 lpfc_offline_eratt(struct lpfc_hba *phba)
1350 {
1351         struct lpfc_sli   *psli = &phba->sli;
1352
1353         spin_lock_irq(&phba->hbalock);
1354         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1355         spin_unlock_irq(&phba->hbalock);
1356         lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
1357
1358         lpfc_offline(phba);
1359         lpfc_reset_barrier(phba);
1360         spin_lock_irq(&phba->hbalock);
1361         lpfc_sli_brdreset(phba);
1362         spin_unlock_irq(&phba->hbalock);
1363         lpfc_hba_down_post(phba);
1364         lpfc_sli_brdready(phba, HS_MBRDY);
1365         lpfc_unblock_mgmt_io(phba);
1366         phba->link_state = LPFC_HBA_ERROR;
1367         return;
1368 }
1369
1370 /**
1371  * lpfc_sli4_offline_eratt - Bring lpfc offline on SLI4 hardware error attention
1372  * @phba: pointer to lpfc hba data structure.
1373  *
1374  * This routine is called to bring a SLI4 HBA offline when HBA hardware error
1375  * other than Port Error 6 has been detected.
1376  **/
1377 void
1378 lpfc_sli4_offline_eratt(struct lpfc_hba *phba)
1379 {
1380         spin_lock_irq(&phba->hbalock);
1381         phba->link_state = LPFC_HBA_ERROR;
1382         spin_unlock_irq(&phba->hbalock);
1383
1384         lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
1385         lpfc_offline(phba);
1386         lpfc_hba_down_post(phba);
1387         lpfc_unblock_mgmt_io(phba);
1388 }
1389
1390 /**
1391  * lpfc_handle_deferred_eratt - The HBA hardware deferred error handler
1392  * @phba: pointer to lpfc hba data structure.
1393  *
1394  * This routine is invoked to handle the deferred HBA hardware error
1395  * conditions. This type of error is indicated by HBA by setting ER1
1396  * and another ER bit in the host status register. The driver will
1397  * wait until the ER1 bit clears before handling the error condition.
1398  **/
1399 static void
1400 lpfc_handle_deferred_eratt(struct lpfc_hba *phba)
1401 {
1402         uint32_t old_host_status = phba->work_hs;
1403         struct lpfc_sli *psli = &phba->sli;
1404
1405         /* If the pci channel is offline, ignore possible errors,
1406          * since we cannot communicate with the pci card anyway.
1407          */
1408         if (pci_channel_offline(phba->pcidev)) {
1409                 spin_lock_irq(&phba->hbalock);
1410                 phba->hba_flag &= ~DEFER_ERATT;
1411                 spin_unlock_irq(&phba->hbalock);
1412                 return;
1413         }
1414
1415         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1416                 "0479 Deferred Adapter Hardware Error "
1417                 "Data: x%x x%x x%x\n",
1418                 phba->work_hs,
1419                 phba->work_status[0], phba->work_status[1]);
1420
1421         spin_lock_irq(&phba->hbalock);
1422         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1423         spin_unlock_irq(&phba->hbalock);
1424
1425
1426         /*
1427          * Firmware stops when it triggred erratt. That could cause the I/Os
1428          * dropped by the firmware. Error iocb (I/O) on txcmplq and let the
1429          * SCSI layer retry it after re-establishing link.
1430          */
1431         lpfc_sli_abort_fcp_rings(phba);
1432
1433         /*
1434          * There was a firmware error. Take the hba offline and then
1435          * attempt to restart it.
1436          */
1437         lpfc_offline_prep(phba, LPFC_MBX_WAIT);
1438         lpfc_offline(phba);
1439
1440         /* Wait for the ER1 bit to clear.*/
1441         while (phba->work_hs & HS_FFER1) {
1442                 msleep(100);
1443                 if (lpfc_readl(phba->HSregaddr, &phba->work_hs)) {
1444                         phba->work_hs = UNPLUG_ERR ;
1445                         break;
1446                 }
1447                 /* If driver is unloading let the worker thread continue */
1448                 if (phba->pport->load_flag & FC_UNLOADING) {
1449                         phba->work_hs = 0;
1450                         break;
1451                 }
1452         }
1453
1454         /*
1455          * This is to ptrotect against a race condition in which
1456          * first write to the host attention register clear the
1457          * host status register.
1458          */
1459         if ((!phba->work_hs) && (!(phba->pport->load_flag & FC_UNLOADING)))
1460                 phba->work_hs = old_host_status & ~HS_FFER1;
1461
1462         spin_lock_irq(&phba->hbalock);
1463         phba->hba_flag &= ~DEFER_ERATT;
1464         spin_unlock_irq(&phba->hbalock);
1465         phba->work_status[0] = readl(phba->MBslimaddr + 0xa8);
1466         phba->work_status[1] = readl(phba->MBslimaddr + 0xac);
1467 }
1468
1469 static void
1470 lpfc_board_errevt_to_mgmt(struct lpfc_hba *phba)
1471 {
1472         struct lpfc_board_event_header board_event;
1473         struct Scsi_Host *shost;
1474
1475         board_event.event_type = FC_REG_BOARD_EVENT;
1476         board_event.subcategory = LPFC_EVENT_PORTINTERR;
1477         shost = lpfc_shost_from_vport(phba->pport);
1478         fc_host_post_vendor_event(shost, fc_get_event_number(),
1479                                   sizeof(board_event),
1480                                   (char *) &board_event,
1481                                   LPFC_NL_VENDOR_ID);
1482 }
1483
1484 /**
1485  * lpfc_handle_eratt_s3 - The SLI3 HBA hardware error handler
1486  * @phba: pointer to lpfc hba data structure.
1487  *
1488  * This routine is invoked to handle the following HBA hardware error
1489  * conditions:
1490  * 1 - HBA error attention interrupt
1491  * 2 - DMA ring index out of range
1492  * 3 - Mailbox command came back as unknown
1493  **/
1494 static void
1495 lpfc_handle_eratt_s3(struct lpfc_hba *phba)
1496 {
1497         struct lpfc_vport *vport = phba->pport;
1498         struct lpfc_sli   *psli = &phba->sli;
1499         uint32_t event_data;
1500         unsigned long temperature;
1501         struct temp_event temp_event_data;
1502         struct Scsi_Host  *shost;
1503
1504         /* If the pci channel is offline, ignore possible errors,
1505          * since we cannot communicate with the pci card anyway.
1506          */
1507         if (pci_channel_offline(phba->pcidev)) {
1508                 spin_lock_irq(&phba->hbalock);
1509                 phba->hba_flag &= ~DEFER_ERATT;
1510                 spin_unlock_irq(&phba->hbalock);
1511                 return;
1512         }
1513
1514         /* If resets are disabled then leave the HBA alone and return */
1515         if (!phba->cfg_enable_hba_reset)
1516                 return;
1517
1518         /* Send an internal error event to mgmt application */
1519         lpfc_board_errevt_to_mgmt(phba);
1520
1521         if (phba->hba_flag & DEFER_ERATT)
1522                 lpfc_handle_deferred_eratt(phba);
1523
1524         if ((phba->work_hs & HS_FFER6) || (phba->work_hs & HS_FFER8)) {
1525                 if (phba->work_hs & HS_FFER6)
1526                         /* Re-establishing Link */
1527                         lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
1528                                         "1301 Re-establishing Link "
1529                                         "Data: x%x x%x x%x\n",
1530                                         phba->work_hs, phba->work_status[0],
1531                                         phba->work_status[1]);
1532                 if (phba->work_hs & HS_FFER8)
1533                         /* Device Zeroization */
1534                         lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
1535                                         "2861 Host Authentication device "
1536                                         "zeroization Data:x%x x%x x%x\n",
1537                                         phba->work_hs, phba->work_status[0],
1538                                         phba->work_status[1]);
1539
1540                 spin_lock_irq(&phba->hbalock);
1541                 psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1542                 spin_unlock_irq(&phba->hbalock);
1543
1544                 /*
1545                 * Firmware stops when it triggled erratt with HS_FFER6.
1546                 * That could cause the I/Os dropped by the firmware.
1547                 * Error iocb (I/O) on txcmplq and let the SCSI layer
1548                 * retry it after re-establishing link.
1549                 */
1550                 lpfc_sli_abort_fcp_rings(phba);
1551
1552                 /*
1553                  * There was a firmware error.  Take the hba offline and then
1554                  * attempt to restart it.
1555                  */
1556                 lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
1557                 lpfc_offline(phba);
1558                 lpfc_sli_brdrestart(phba);
1559                 if (lpfc_online(phba) == 0) {   /* Initialize the HBA */
1560                         lpfc_unblock_mgmt_io(phba);
1561                         return;
1562                 }
1563                 lpfc_unblock_mgmt_io(phba);
1564         } else if (phba->work_hs & HS_CRIT_TEMP) {
1565                 temperature = readl(phba->MBslimaddr + TEMPERATURE_OFFSET);
1566                 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
1567                 temp_event_data.event_code = LPFC_CRIT_TEMP;
1568                 temp_event_data.data = (uint32_t)temperature;
1569
1570                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1571                                 "0406 Adapter maximum temperature exceeded "
1572                                 "(%ld), taking this port offline "
1573                                 "Data: x%x x%x x%x\n",
1574                                 temperature, phba->work_hs,
1575                                 phba->work_status[0], phba->work_status[1]);
1576
1577                 shost = lpfc_shost_from_vport(phba->pport);
1578                 fc_host_post_vendor_event(shost, fc_get_event_number(),
1579                                           sizeof(temp_event_data),
1580                                           (char *) &temp_event_data,
1581                                           SCSI_NL_VID_TYPE_PCI
1582                                           | PCI_VENDOR_ID_EMULEX);
1583
1584                 spin_lock_irq(&phba->hbalock);
1585                 phba->over_temp_state = HBA_OVER_TEMP;
1586                 spin_unlock_irq(&phba->hbalock);
1587                 lpfc_offline_eratt(phba);
1588
1589         } else {
1590                 /* The if clause above forces this code path when the status
1591                  * failure is a value other than FFER6. Do not call the offline
1592                  * twice. This is the adapter hardware error path.
1593                  */
1594                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1595                                 "0457 Adapter Hardware Error "
1596                                 "Data: x%x x%x x%x\n",
1597                                 phba->work_hs,
1598                                 phba->work_status[0], phba->work_status[1]);
1599
1600                 event_data = FC_REG_DUMP_EVENT;
1601                 shost = lpfc_shost_from_vport(vport);
1602                 fc_host_post_vendor_event(shost, fc_get_event_number(),
1603                                 sizeof(event_data), (char *) &event_data,
1604                                 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1605
1606                 lpfc_offline_eratt(phba);
1607         }
1608         return;
1609 }
1610
1611 /**
1612  * lpfc_sli4_port_sta_fn_reset - The SLI4 function reset due to port status reg
1613  * @phba: pointer to lpfc hba data structure.
1614  * @mbx_action: flag for mailbox shutdown action.
1615  *
1616  * This routine is invoked to perform an SLI4 port PCI function reset in
1617  * response to port status register polling attention. It waits for port
1618  * status register (ERR, RDY, RN) bits before proceeding with function reset.
1619  * During this process, interrupt vectors are freed and later requested
1620  * for handling possible port resource change.
1621  **/
1622 static int
1623 lpfc_sli4_port_sta_fn_reset(struct lpfc_hba *phba, int mbx_action,
1624                             bool en_rn_msg)
1625 {
1626         int rc;
1627         uint32_t intr_mode;
1628
1629         if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
1630             LPFC_SLI_INTF_IF_TYPE_2) {
1631                 /*
1632                  * On error status condition, driver need to wait for port
1633                  * ready before performing reset.
1634                  */
1635                 rc = lpfc_sli4_pdev_status_reg_wait(phba);
1636                 if (rc)
1637                         return rc;
1638         }
1639
1640         /* need reset: attempt for port recovery */
1641         if (en_rn_msg)
1642                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1643                                 "2887 Reset Needed: Attempting Port "
1644                                 "Recovery...\n");
1645         lpfc_offline_prep(phba, mbx_action);
1646         lpfc_offline(phba);
1647         /* release interrupt for possible resource change */
1648         lpfc_sli4_disable_intr(phba);
1649         lpfc_sli_brdrestart(phba);
1650         /* request and enable interrupt */
1651         intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
1652         if (intr_mode == LPFC_INTR_ERROR) {
1653                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1654                                 "3175 Failed to enable interrupt\n");
1655                 return -EIO;
1656         }
1657         phba->intr_mode = intr_mode;
1658         rc = lpfc_online(phba);
1659         if (rc == 0)
1660                 lpfc_unblock_mgmt_io(phba);
1661
1662         return rc;
1663 }
1664
1665 /**
1666  * lpfc_handle_eratt_s4 - The SLI4 HBA hardware error handler
1667  * @phba: pointer to lpfc hba data structure.
1668  *
1669  * This routine is invoked to handle the SLI4 HBA hardware error attention
1670  * conditions.
1671  **/
1672 static void
1673 lpfc_handle_eratt_s4(struct lpfc_hba *phba)
1674 {
1675         struct lpfc_vport *vport = phba->pport;
1676         uint32_t event_data;
1677         struct Scsi_Host *shost;
1678         uint32_t if_type;
1679         struct lpfc_register portstat_reg = {0};
1680         uint32_t reg_err1, reg_err2;
1681         uint32_t uerrlo_reg, uemasklo_reg;
1682         uint32_t smphr_port_status = 0, pci_rd_rc1, pci_rd_rc2;
1683         bool en_rn_msg = true;
1684         struct temp_event temp_event_data;
1685         struct lpfc_register portsmphr_reg;
1686         int rc, i;
1687
1688         /* If the pci channel is offline, ignore possible errors, since
1689          * we cannot communicate with the pci card anyway.
1690          */
1691         if (pci_channel_offline(phba->pcidev))
1692                 return;
1693
1694         memset(&portsmphr_reg, 0, sizeof(portsmphr_reg));
1695         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
1696         switch (if_type) {
1697         case LPFC_SLI_INTF_IF_TYPE_0:
1698                 pci_rd_rc1 = lpfc_readl(
1699                                 phba->sli4_hba.u.if_type0.UERRLOregaddr,
1700                                 &uerrlo_reg);
1701                 pci_rd_rc2 = lpfc_readl(
1702                                 phba->sli4_hba.u.if_type0.UEMASKLOregaddr,
1703                                 &uemasklo_reg);
1704                 /* consider PCI bus read error as pci_channel_offline */
1705                 if (pci_rd_rc1 == -EIO && pci_rd_rc2 == -EIO)
1706                         return;
1707                 if (!(phba->hba_flag & HBA_RECOVERABLE_UE)) {
1708                         lpfc_sli4_offline_eratt(phba);
1709                         return;
1710                 }
1711                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1712                                 "7623 Checking UE recoverable");
1713
1714                 for (i = 0; i < phba->sli4_hba.ue_to_sr / 1000; i++) {
1715                         if (lpfc_readl(phba->sli4_hba.PSMPHRregaddr,
1716                                        &portsmphr_reg.word0))
1717                                 continue;
1718
1719                         smphr_port_status = bf_get(lpfc_port_smphr_port_status,
1720                                                    &portsmphr_reg);
1721                         if ((smphr_port_status & LPFC_PORT_SEM_MASK) ==
1722                             LPFC_PORT_SEM_UE_RECOVERABLE)
1723                                 break;
1724                         /*Sleep for 1Sec, before checking SEMAPHORE */
1725                         msleep(1000);
1726                 }
1727
1728                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1729                                 "4827 smphr_port_status x%x : Waited %dSec",
1730                                 smphr_port_status, i);
1731
1732                 /* Recoverable UE, reset the HBA device */
1733                 if ((smphr_port_status & LPFC_PORT_SEM_MASK) ==
1734                     LPFC_PORT_SEM_UE_RECOVERABLE) {
1735                         for (i = 0; i < 20; i++) {
1736                                 msleep(1000);
1737                                 if (!lpfc_readl(phba->sli4_hba.PSMPHRregaddr,
1738                                     &portsmphr_reg.word0) &&
1739                                     (LPFC_POST_STAGE_PORT_READY ==
1740                                      bf_get(lpfc_port_smphr_port_status,
1741                                      &portsmphr_reg))) {
1742                                         rc = lpfc_sli4_port_sta_fn_reset(phba,
1743                                                 LPFC_MBX_NO_WAIT, en_rn_msg);
1744                                         if (rc == 0)
1745                                                 return;
1746                                         lpfc_printf_log(phba,
1747                                                 KERN_ERR, LOG_INIT,
1748                                                 "4215 Failed to recover UE");
1749                                         break;
1750                                 }
1751                         }
1752                 }
1753                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1754                                 "7624 Firmware not ready: Failing UE recovery,"
1755                                 " waited %dSec", i);
1756                 lpfc_sli4_offline_eratt(phba);
1757                 break;
1758
1759         case LPFC_SLI_INTF_IF_TYPE_2:
1760                 pci_rd_rc1 = lpfc_readl(
1761                                 phba->sli4_hba.u.if_type2.STATUSregaddr,
1762                                 &portstat_reg.word0);
1763                 /* consider PCI bus read error as pci_channel_offline */
1764                 if (pci_rd_rc1 == -EIO) {
1765                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1766                                 "3151 PCI bus read access failure: x%x\n",
1767                                 readl(phba->sli4_hba.u.if_type2.STATUSregaddr));
1768                         return;
1769                 }
1770                 reg_err1 = readl(phba->sli4_hba.u.if_type2.ERR1regaddr);
1771                 reg_err2 = readl(phba->sli4_hba.u.if_type2.ERR2regaddr);
1772                 if (bf_get(lpfc_sliport_status_oti, &portstat_reg)) {
1773                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1774                                 "2889 Port Overtemperature event, "
1775                                 "taking port offline Data: x%x x%x\n",
1776                                 reg_err1, reg_err2);
1777
1778                         phba->sfp_alarm |= LPFC_TRANSGRESSION_HIGH_TEMPERATURE;
1779                         temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
1780                         temp_event_data.event_code = LPFC_CRIT_TEMP;
1781                         temp_event_data.data = 0xFFFFFFFF;
1782
1783                         shost = lpfc_shost_from_vport(phba->pport);
1784                         fc_host_post_vendor_event(shost, fc_get_event_number(),
1785                                                   sizeof(temp_event_data),
1786                                                   (char *)&temp_event_data,
1787                                                   SCSI_NL_VID_TYPE_PCI
1788                                                   | PCI_VENDOR_ID_EMULEX);
1789
1790                         spin_lock_irq(&phba->hbalock);
1791                         phba->over_temp_state = HBA_OVER_TEMP;
1792                         spin_unlock_irq(&phba->hbalock);
1793                         lpfc_sli4_offline_eratt(phba);
1794                         return;
1795                 }
1796                 if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1797                     reg_err2 == SLIPORT_ERR2_REG_FW_RESTART) {
1798                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1799                                         "3143 Port Down: Firmware Update "
1800                                         "Detected\n");
1801                         en_rn_msg = false;
1802                 } else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1803                          reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP)
1804                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1805                                         "3144 Port Down: Debug Dump\n");
1806                 else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1807                          reg_err2 == SLIPORT_ERR2_REG_FUNC_PROVISON)
1808                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1809                                         "3145 Port Down: Provisioning\n");
1810
1811                 /* If resets are disabled then leave the HBA alone and return */
1812                 if (!phba->cfg_enable_hba_reset)
1813                         return;
1814
1815                 /* Check port status register for function reset */
1816                 rc = lpfc_sli4_port_sta_fn_reset(phba, LPFC_MBX_NO_WAIT,
1817                                 en_rn_msg);
1818                 if (rc == 0) {
1819                         /* don't report event on forced debug dump */
1820                         if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 &&
1821                             reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP)
1822                                 return;
1823                         else
1824                                 break;
1825                 }
1826                 /* fall through for not able to recover */
1827                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1828                                 "3152 Unrecoverable error, bring the port "
1829                                 "offline\n");
1830                 lpfc_sli4_offline_eratt(phba);
1831                 break;
1832         case LPFC_SLI_INTF_IF_TYPE_1:
1833         default:
1834                 break;
1835         }
1836         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1837                         "3123 Report dump event to upper layer\n");
1838         /* Send an internal error event to mgmt application */
1839         lpfc_board_errevt_to_mgmt(phba);
1840
1841         event_data = FC_REG_DUMP_EVENT;
1842         shost = lpfc_shost_from_vport(vport);
1843         fc_host_post_vendor_event(shost, fc_get_event_number(),
1844                                   sizeof(event_data), (char *) &event_data,
1845                                   SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1846 }
1847
1848 /**
1849  * lpfc_handle_eratt - Wrapper func for handling hba error attention
1850  * @phba: pointer to lpfc HBA data structure.
1851  *
1852  * This routine wraps the actual SLI3 or SLI4 hba error attention handling
1853  * routine from the API jump table function pointer from the lpfc_hba struct.
1854  *
1855  * Return codes
1856  *   0 - success.
1857  *   Any other value - error.
1858  **/
1859 void
1860 lpfc_handle_eratt(struct lpfc_hba *phba)
1861 {
1862         (*phba->lpfc_handle_eratt)(phba);
1863 }
1864
1865 /**
1866  * lpfc_handle_latt - The HBA link event handler
1867  * @phba: pointer to lpfc hba data structure.
1868  *
1869  * This routine is invoked from the worker thread to handle a HBA host
1870  * attention link event. SLI3 only.
1871  **/
1872 void
1873 lpfc_handle_latt(struct lpfc_hba *phba)
1874 {
1875         struct lpfc_vport *vport = phba->pport;
1876         struct lpfc_sli   *psli = &phba->sli;
1877         LPFC_MBOXQ_t *pmb;
1878         volatile uint32_t control;
1879         struct lpfc_dmabuf *mp;
1880         int rc = 0;
1881
1882         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1883         if (!pmb) {
1884                 rc = 1;
1885                 goto lpfc_handle_latt_err_exit;
1886         }
1887
1888         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1889         if (!mp) {
1890                 rc = 2;
1891                 goto lpfc_handle_latt_free_pmb;
1892         }
1893
1894         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
1895         if (!mp->virt) {
1896                 rc = 3;
1897                 goto lpfc_handle_latt_free_mp;
1898         }
1899
1900         /* Cleanup any outstanding ELS commands */
1901         lpfc_els_flush_all_cmd(phba);
1902
1903         psli->slistat.link_event++;
1904         lpfc_read_topology(phba, pmb, mp);
1905         pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
1906         pmb->vport = vport;
1907         /* Block ELS IOCBs until we have processed this mbox command */
1908         phba->sli.sli3_ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
1909         rc = lpfc_sli_issue_mbox (phba, pmb, MBX_NOWAIT);
1910         if (rc == MBX_NOT_FINISHED) {
1911                 rc = 4;
1912                 goto lpfc_handle_latt_free_mbuf;
1913         }
1914
1915         /* Clear Link Attention in HA REG */
1916         spin_lock_irq(&phba->hbalock);
1917         writel(HA_LATT, phba->HAregaddr);
1918         readl(phba->HAregaddr); /* flush */
1919         spin_unlock_irq(&phba->hbalock);
1920
1921         return;
1922
1923 lpfc_handle_latt_free_mbuf:
1924         phba->sli.sli3_ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT;
1925         lpfc_mbuf_free(phba, mp->virt, mp->phys);
1926 lpfc_handle_latt_free_mp:
1927         kfree(mp);
1928 lpfc_handle_latt_free_pmb:
1929         mempool_free(pmb, phba->mbox_mem_pool);
1930 lpfc_handle_latt_err_exit:
1931         /* Enable Link attention interrupts */
1932         spin_lock_irq(&phba->hbalock);
1933         psli->sli_flag |= LPFC_PROCESS_LA;
1934         control = readl(phba->HCregaddr);
1935         control |= HC_LAINT_ENA;
1936         writel(control, phba->HCregaddr);
1937         readl(phba->HCregaddr); /* flush */
1938
1939         /* Clear Link Attention in HA REG */
1940         writel(HA_LATT, phba->HAregaddr);
1941         readl(phba->HAregaddr); /* flush */
1942         spin_unlock_irq(&phba->hbalock);
1943         lpfc_linkdown(phba);
1944         phba->link_state = LPFC_HBA_ERROR;
1945
1946         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1947                      "0300 LATT: Cannot issue READ_LA: Data:%d\n", rc);
1948
1949         return;
1950 }
1951
1952 /**
1953  * lpfc_parse_vpd - Parse VPD (Vital Product Data)
1954  * @phba: pointer to lpfc hba data structure.
1955  * @vpd: pointer to the vital product data.
1956  * @len: length of the vital product data in bytes.
1957  *
1958  * This routine parses the Vital Product Data (VPD). The VPD is treated as
1959  * an array of characters. In this routine, the ModelName, ProgramType, and
1960  * ModelDesc, etc. fields of the phba data structure will be populated.
1961  *
1962  * Return codes
1963  *   0 - pointer to the VPD passed in is NULL
1964  *   1 - success
1965  **/
1966 int
1967 lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len)
1968 {
1969         uint8_t lenlo, lenhi;
1970         int Length;
1971         int i, j;
1972         int finished = 0;
1973         int index = 0;
1974
1975         if (!vpd)
1976                 return 0;
1977
1978         /* Vital Product */
1979         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1980                         "0455 Vital Product Data: x%x x%x x%x x%x\n",
1981                         (uint32_t) vpd[0], (uint32_t) vpd[1], (uint32_t) vpd[2],
1982                         (uint32_t) vpd[3]);
1983         while (!finished && (index < (len - 4))) {
1984                 switch (vpd[index]) {
1985                 case 0x82:
1986                 case 0x91:
1987                         index += 1;
1988                         lenlo = vpd[index];
1989                         index += 1;
1990                         lenhi = vpd[index];
1991                         index += 1;
1992                         i = ((((unsigned short)lenhi) << 8) + lenlo);
1993                         index += i;
1994                         break;
1995                 case 0x90:
1996                         index += 1;
1997                         lenlo = vpd[index];
1998                         index += 1;
1999                         lenhi = vpd[index];
2000                         index += 1;
2001                         Length = ((((unsigned short)lenhi) << 8) + lenlo);
2002                         if (Length > len - index)
2003                                 Length = len - index;
2004                         while (Length > 0) {
2005                         /* Look for Serial Number */
2006                         if ((vpd[index] == 'S') && (vpd[index+1] == 'N')) {
2007                                 index += 2;
2008                                 i = vpd[index];
2009                                 index += 1;
2010                                 j = 0;
2011                                 Length -= (3+i);
2012                                 while(i--) {
2013                                         phba->SerialNumber[j++] = vpd[index++];
2014                                         if (j == 31)
2015                                                 break;
2016                                 }
2017                                 phba->SerialNumber[j] = 0;
2018                                 continue;
2019                         }
2020                         else if ((vpd[index] == 'V') && (vpd[index+1] == '1')) {
2021                                 phba->vpd_flag |= VPD_MODEL_DESC;
2022                                 index += 2;
2023                                 i = vpd[index];
2024                                 index += 1;
2025                                 j = 0;
2026                                 Length -= (3+i);
2027                                 while(i--) {
2028                                         phba->ModelDesc[j++] = vpd[index++];
2029                                         if (j == 255)
2030                                                 break;
2031                                 }
2032                                 phba->ModelDesc[j] = 0;
2033                                 continue;
2034                         }
2035                         else if ((vpd[index] == 'V') && (vpd[index+1] == '2')) {
2036                                 phba->vpd_flag |= VPD_MODEL_NAME;
2037                                 index += 2;
2038                                 i = vpd[index];
2039                                 index += 1;
2040                                 j = 0;
2041                                 Length -= (3+i);
2042                                 while(i--) {
2043                                         phba->ModelName[j++] = vpd[index++];
2044                                         if (j == 79)
2045                                                 break;
2046                                 }
2047                                 phba->ModelName[j] = 0;
2048                                 continue;
2049                         }
2050                         else if ((vpd[index] == 'V') && (vpd[index+1] == '3')) {
2051                                 phba->vpd_flag |= VPD_PROGRAM_TYPE;
2052                                 index += 2;
2053                                 i = vpd[index];
2054                                 index += 1;
2055                                 j = 0;
2056                                 Length -= (3+i);
2057                                 while(i--) {
2058                                         phba->ProgramType[j++] = vpd[index++];
2059                                         if (j == 255)
2060                                                 break;
2061                                 }
2062                                 phba->ProgramType[j] = 0;
2063                                 continue;
2064                         }
2065                         else if ((vpd[index] == 'V') && (vpd[index+1] == '4')) {
2066                                 phba->vpd_flag |= VPD_PORT;
2067                                 index += 2;
2068                                 i = vpd[index];
2069                                 index += 1;
2070                                 j = 0;
2071                                 Length -= (3+i);
2072                                 while(i--) {
2073                                         if ((phba->sli_rev == LPFC_SLI_REV4) &&
2074                                             (phba->sli4_hba.pport_name_sta ==
2075                                              LPFC_SLI4_PPNAME_GET)) {
2076                                                 j++;
2077                                                 index++;
2078                                         } else
2079                                                 phba->Port[j++] = vpd[index++];
2080                                         if (j == 19)
2081                                                 break;
2082                                 }
2083                                 if ((phba->sli_rev != LPFC_SLI_REV4) ||
2084                                     (phba->sli4_hba.pport_name_sta ==
2085                                      LPFC_SLI4_PPNAME_NON))
2086                                         phba->Port[j] = 0;
2087                                 continue;
2088                         }
2089                         else {
2090                                 index += 2;
2091                                 i = vpd[index];
2092                                 index += 1;
2093                                 index += i;
2094                                 Length -= (3 + i);
2095                         }
2096                 }
2097                 finished = 0;
2098                 break;
2099                 case 0x78:
2100                         finished = 1;
2101                         break;
2102                 default:
2103                         index ++;
2104                         break;
2105                 }
2106         }
2107
2108         return(1);
2109 }
2110
2111 /**
2112  * lpfc_get_hba_model_desc - Retrieve HBA device model name and description
2113  * @phba: pointer to lpfc hba data structure.
2114  * @mdp: pointer to the data structure to hold the derived model name.
2115  * @descp: pointer to the data structure to hold the derived description.
2116  *
2117  * This routine retrieves HBA's description based on its registered PCI device
2118  * ID. The @descp passed into this function points to an array of 256 chars. It
2119  * shall be returned with the model name, maximum speed, and the host bus type.
2120  * The @mdp passed into this function points to an array of 80 chars. When the
2121  * function returns, the @mdp will be filled with the model name.
2122  **/
2123 static void
2124 lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
2125 {
2126         lpfc_vpd_t *vp;
2127         uint16_t dev_id = phba->pcidev->device;
2128         int max_speed;
2129         int GE = 0;
2130         int oneConnect = 0; /* default is not a oneConnect */
2131         struct {
2132                 char *name;
2133                 char *bus;
2134                 char *function;
2135         } m = {"<Unknown>", "", ""};
2136
2137         if (mdp && mdp[0] != '\0'
2138                 && descp && descp[0] != '\0')
2139                 return;
2140
2141         if (phba->lmt & LMT_32Gb)
2142                 max_speed = 32;
2143         else if (phba->lmt & LMT_16Gb)
2144                 max_speed = 16;
2145         else if (phba->lmt & LMT_10Gb)
2146                 max_speed = 10;
2147         else if (phba->lmt & LMT_8Gb)
2148                 max_speed = 8;
2149         else if (phba->lmt & LMT_4Gb)
2150                 max_speed = 4;
2151         else if (phba->lmt & LMT_2Gb)
2152                 max_speed = 2;
2153         else if (phba->lmt & LMT_1Gb)
2154                 max_speed = 1;
2155         else
2156                 max_speed = 0;
2157
2158         vp = &phba->vpd;
2159
2160         switch (dev_id) {
2161         case PCI_DEVICE_ID_FIREFLY:
2162                 m = (typeof(m)){"LP6000", "PCI",
2163                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2164                 break;
2165         case PCI_DEVICE_ID_SUPERFLY:
2166                 if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3)
2167                         m = (typeof(m)){"LP7000", "PCI", ""};
2168                 else
2169                         m = (typeof(m)){"LP7000E", "PCI", ""};
2170                 m.function = "Obsolete, Unsupported Fibre Channel Adapter";
2171                 break;
2172         case PCI_DEVICE_ID_DRAGONFLY:
2173                 m = (typeof(m)){"LP8000", "PCI",
2174                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2175                 break;
2176         case PCI_DEVICE_ID_CENTAUR:
2177                 if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID)
2178                         m = (typeof(m)){"LP9002", "PCI", ""};
2179                 else
2180                         m = (typeof(m)){"LP9000", "PCI", ""};
2181                 m.function = "Obsolete, Unsupported Fibre Channel Adapter";
2182                 break;
2183         case PCI_DEVICE_ID_RFLY:
2184                 m = (typeof(m)){"LP952", "PCI",
2185                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2186                 break;
2187         case PCI_DEVICE_ID_PEGASUS:
2188                 m = (typeof(m)){"LP9802", "PCI-X",
2189                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2190                 break;
2191         case PCI_DEVICE_ID_THOR:
2192                 m = (typeof(m)){"LP10000", "PCI-X",
2193                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2194                 break;
2195         case PCI_DEVICE_ID_VIPER:
2196                 m = (typeof(m)){"LPX1000",  "PCI-X",
2197                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2198                 break;
2199         case PCI_DEVICE_ID_PFLY:
2200                 m = (typeof(m)){"LP982", "PCI-X",
2201                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2202                 break;
2203         case PCI_DEVICE_ID_TFLY:
2204                 m = (typeof(m)){"LP1050", "PCI-X",
2205                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2206                 break;
2207         case PCI_DEVICE_ID_HELIOS:
2208                 m = (typeof(m)){"LP11000", "PCI-X2",
2209                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2210                 break;
2211         case PCI_DEVICE_ID_HELIOS_SCSP:
2212                 m = (typeof(m)){"LP11000-SP", "PCI-X2",
2213                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2214                 break;
2215         case PCI_DEVICE_ID_HELIOS_DCSP:
2216                 m = (typeof(m)){"LP11002-SP",  "PCI-X2",
2217                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2218                 break;
2219         case PCI_DEVICE_ID_NEPTUNE:
2220                 m = (typeof(m)){"LPe1000", "PCIe",
2221                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2222                 break;
2223         case PCI_DEVICE_ID_NEPTUNE_SCSP:
2224                 m = (typeof(m)){"LPe1000-SP", "PCIe",
2225                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2226                 break;
2227         case PCI_DEVICE_ID_NEPTUNE_DCSP:
2228                 m = (typeof(m)){"LPe1002-SP", "PCIe",
2229                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2230                 break;
2231         case PCI_DEVICE_ID_BMID:
2232                 m = (typeof(m)){"LP1150", "PCI-X2", "Fibre Channel Adapter"};
2233                 break;
2234         case PCI_DEVICE_ID_BSMB:
2235                 m = (typeof(m)){"LP111", "PCI-X2",
2236                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2237                 break;
2238         case PCI_DEVICE_ID_ZEPHYR:
2239                 m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
2240                 break;
2241         case PCI_DEVICE_ID_ZEPHYR_SCSP:
2242                 m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
2243                 break;
2244         case PCI_DEVICE_ID_ZEPHYR_DCSP:
2245                 m = (typeof(m)){"LP2105", "PCIe", "FCoE Adapter"};
2246                 GE = 1;
2247                 break;
2248         case PCI_DEVICE_ID_ZMID:
2249                 m = (typeof(m)){"LPe1150", "PCIe", "Fibre Channel Adapter"};
2250                 break;
2251         case PCI_DEVICE_ID_ZSMB:
2252                 m = (typeof(m)){"LPe111", "PCIe", "Fibre Channel Adapter"};
2253                 break;
2254         case PCI_DEVICE_ID_LP101:
2255                 m = (typeof(m)){"LP101", "PCI-X",
2256                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2257                 break;
2258         case PCI_DEVICE_ID_LP10000S:
2259                 m = (typeof(m)){"LP10000-S", "PCI",
2260                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2261                 break;
2262         case PCI_DEVICE_ID_LP11000S:
2263                 m = (typeof(m)){"LP11000-S", "PCI-X2",
2264                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2265                 break;
2266         case PCI_DEVICE_ID_LPE11000S:
2267                 m = (typeof(m)){"LPe11000-S", "PCIe",
2268                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2269                 break;
2270         case PCI_DEVICE_ID_SAT:
2271                 m = (typeof(m)){"LPe12000", "PCIe", "Fibre Channel Adapter"};
2272                 break;
2273         case PCI_DEVICE_ID_SAT_MID:
2274                 m = (typeof(m)){"LPe1250", "PCIe", "Fibre Channel Adapter"};
2275                 break;
2276         case PCI_DEVICE_ID_SAT_SMB:
2277                 m = (typeof(m)){"LPe121", "PCIe", "Fibre Channel Adapter"};
2278                 break;
2279         case PCI_DEVICE_ID_SAT_DCSP:
2280                 m = (typeof(m)){"LPe12002-SP", "PCIe", "Fibre Channel Adapter"};
2281                 break;
2282         case PCI_DEVICE_ID_SAT_SCSP:
2283                 m = (typeof(m)){"LPe12000-SP", "PCIe", "Fibre Channel Adapter"};
2284                 break;
2285         case PCI_DEVICE_ID_SAT_S:
2286                 m = (typeof(m)){"LPe12000-S", "PCIe", "Fibre Channel Adapter"};
2287                 break;
2288         case PCI_DEVICE_ID_HORNET:
2289                 m = (typeof(m)){"LP21000", "PCIe",
2290                                 "Obsolete, Unsupported FCoE Adapter"};
2291                 GE = 1;
2292                 break;
2293         case PCI_DEVICE_ID_PROTEUS_VF:
2294                 m = (typeof(m)){"LPev12000", "PCIe IOV",
2295                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2296                 break;
2297         case PCI_DEVICE_ID_PROTEUS_PF:
2298                 m = (typeof(m)){"LPev12000", "PCIe IOV",
2299                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2300                 break;
2301         case PCI_DEVICE_ID_PROTEUS_S:
2302                 m = (typeof(m)){"LPemv12002-S", "PCIe IOV",
2303                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2304                 break;
2305         case PCI_DEVICE_ID_TIGERSHARK:
2306                 oneConnect = 1;
2307                 m = (typeof(m)){"OCe10100", "PCIe", "FCoE"};
2308                 break;
2309         case PCI_DEVICE_ID_TOMCAT:
2310                 oneConnect = 1;
2311                 m = (typeof(m)){"OCe11100", "PCIe", "FCoE"};
2312                 break;
2313         case PCI_DEVICE_ID_FALCON:
2314                 m = (typeof(m)){"LPSe12002-ML1-E", "PCIe",
2315                                 "EmulexSecure Fibre"};
2316                 break;
2317         case PCI_DEVICE_ID_BALIUS:
2318                 m = (typeof(m)){"LPVe12002", "PCIe Shared I/O",
2319                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2320                 break;
2321         case PCI_DEVICE_ID_LANCER_FC:
2322                 m = (typeof(m)){"LPe16000", "PCIe", "Fibre Channel Adapter"};
2323                 break;
2324         case PCI_DEVICE_ID_LANCER_FC_VF:
2325                 m = (typeof(m)){"LPe16000", "PCIe",
2326                                 "Obsolete, Unsupported Fibre Channel Adapter"};
2327                 break;
2328         case PCI_DEVICE_ID_LANCER_FCOE:
2329                 oneConnect = 1;
2330                 m = (typeof(m)){"OCe15100", "PCIe", "FCoE"};
2331                 break;
2332         case PCI_DEVICE_ID_LANCER_FCOE_VF:
2333                 oneConnect = 1;
2334                 m = (typeof(m)){"OCe15100", "PCIe",
2335                                 "Obsolete, Unsupported FCoE"};
2336                 break;
2337         case PCI_DEVICE_ID_LANCER_G6_FC:
2338                 m = (typeof(m)){"LPe32000", "PCIe", "Fibre Channel Adapter"};
2339                 break;
2340         case PCI_DEVICE_ID_SKYHAWK:
2341         case PCI_DEVICE_ID_SKYHAWK_VF:
2342                 oneConnect = 1;
2343                 m = (typeof(m)){"OCe14000", "PCIe", "FCoE"};
2344                 break;
2345         default:
2346                 m = (typeof(m)){"Unknown", "", ""};
2347                 break;
2348         }
2349
2350         if (mdp && mdp[0] == '\0')
2351                 snprintf(mdp, 79,"%s", m.name);
2352         /*
2353          * oneConnect hba requires special processing, they are all initiators
2354          * and we put the port number on the end
2355          */
2356         if (descp && descp[0] == '\0') {
2357                 if (oneConnect)
2358                         snprintf(descp, 255,
2359                                 "Emulex OneConnect %s, %s Initiator %s",
2360                                 m.name, m.function,
2361                                 phba->Port);
2362                 else if (max_speed == 0)
2363                         snprintf(descp, 255,
2364                                 "Emulex %s %s %s",
2365                                 m.name, m.bus, m.function);
2366                 else
2367                         snprintf(descp, 255,
2368                                 "Emulex %s %d%s %s %s",
2369                                 m.name, max_speed, (GE) ? "GE" : "Gb",
2370                                 m.bus, m.function);
2371         }
2372 }
2373
2374 /**
2375  * lpfc_post_buffer - Post IOCB(s) with DMA buffer descriptor(s) to a IOCB ring
2376  * @phba: pointer to lpfc hba data structure.
2377  * @pring: pointer to a IOCB ring.
2378  * @cnt: the number of IOCBs to be posted to the IOCB ring.
2379  *
2380  * This routine posts a given number of IOCBs with the associated DMA buffer
2381  * descriptors specified by the cnt argument to the given IOCB ring.
2382  *
2383  * Return codes
2384  *   The number of IOCBs NOT able to be posted to the IOCB ring.
2385  **/
2386 int
2387 lpfc_post_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, int cnt)
2388 {
2389         IOCB_t *icmd;
2390         struct lpfc_iocbq *iocb;
2391         struct lpfc_dmabuf *mp1, *mp2;
2392
2393         cnt += pring->missbufcnt;
2394
2395         /* While there are buffers to post */
2396         while (cnt > 0) {
2397                 /* Allocate buffer for  command iocb */
2398                 iocb = lpfc_sli_get_iocbq(phba);
2399                 if (iocb == NULL) {
2400                         pring->missbufcnt = cnt;
2401                         return cnt;
2402                 }
2403                 icmd = &iocb->iocb;
2404
2405                 /* 2 buffers can be posted per command */
2406                 /* Allocate buffer to post */
2407                 mp1 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
2408                 if (mp1)
2409                     mp1->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp1->phys);
2410                 if (!mp1 || !mp1->virt) {
2411                         kfree(mp1);
2412                         lpfc_sli_release_iocbq(phba, iocb);
2413                         pring->missbufcnt = cnt;
2414                         return cnt;
2415                 }
2416
2417                 INIT_LIST_HEAD(&mp1->list);
2418                 /* Allocate buffer to post */
2419                 if (cnt > 1) {
2420                         mp2 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
2421                         if (mp2)
2422                                 mp2->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
2423                                                             &mp2->phys);
2424                         if (!mp2 || !mp2->virt) {
2425                                 kfree(mp2);
2426                                 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
2427                                 kfree(mp1);
2428                                 lpfc_sli_release_iocbq(phba, iocb);
2429                                 pring->missbufcnt = cnt;
2430                                 return cnt;
2431                         }
2432
2433                         INIT_LIST_HEAD(&mp2->list);
2434                 } else {
2435                         mp2 = NULL;
2436                 }
2437
2438                 icmd->un.cont64[0].addrHigh = putPaddrHigh(mp1->phys);
2439                 icmd->un.cont64[0].addrLow = putPaddrLow(mp1->phys);
2440                 icmd->un.cont64[0].tus.f.bdeSize = FCELSSIZE;
2441                 icmd->ulpBdeCount = 1;
2442                 cnt--;
2443                 if (mp2) {
2444                         icmd->un.cont64[1].addrHigh = putPaddrHigh(mp2->phys);
2445                         icmd->un.cont64[1].addrLow = putPaddrLow(mp2->phys);
2446                         icmd->un.cont64[1].tus.f.bdeSize = FCELSSIZE;
2447                         cnt--;
2448                         icmd->ulpBdeCount = 2;
2449                 }
2450
2451                 icmd->ulpCommand = CMD_QUE_RING_BUF64_CN;
2452                 icmd->ulpLe = 1;
2453
2454                 if (lpfc_sli_issue_iocb(phba, pring->ringno, iocb, 0) ==
2455                     IOCB_ERROR) {
2456                         lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
2457                         kfree(mp1);
2458                         cnt++;
2459                         if (mp2) {
2460                                 lpfc_mbuf_free(phba, mp2->virt, mp2->phys);
2461                                 kfree(mp2);
2462                                 cnt++;
2463                         }
2464                         lpfc_sli_release_iocbq(phba, iocb);
2465                         pring->missbufcnt = cnt;
2466                         return cnt;
2467                 }
2468                 lpfc_sli_ringpostbuf_put(phba, pring, mp1);
2469                 if (mp2)
2470                         lpfc_sli_ringpostbuf_put(phba, pring, mp2);
2471         }
2472         pring->missbufcnt = 0;
2473         return 0;
2474 }
2475
2476 /**
2477  * lpfc_post_rcv_buf - Post the initial receive IOCB buffers to ELS ring
2478  * @phba: pointer to lpfc hba data structure.
2479  *
2480  * This routine posts initial receive IOCB buffers to the ELS ring. The
2481  * current number of initial IOCB buffers specified by LPFC_BUF_RING0 is
2482  * set to 64 IOCBs. SLI3 only.
2483  *
2484  * Return codes
2485  *   0 - success (currently always success)
2486  **/
2487 static int
2488 lpfc_post_rcv_buf(struct lpfc_hba *phba)
2489 {
2490         struct lpfc_sli *psli = &phba->sli;
2491
2492         /* Ring 0, ELS / CT buffers */
2493         lpfc_post_buffer(phba, &psli->sli3_ring[LPFC_ELS_RING], LPFC_BUF_RING0);
2494         /* Ring 2 - FCP no buffers needed */
2495
2496         return 0;
2497 }
2498
2499 #define S(N,V) (((V)<<(N))|((V)>>(32-(N))))
2500
2501 /**
2502  * lpfc_sha_init - Set up initial array of hash table entries
2503  * @HashResultPointer: pointer to an array as hash table.
2504  *
2505  * This routine sets up the initial values to the array of hash table entries
2506  * for the LC HBAs.
2507  **/
2508 static void
2509 lpfc_sha_init(uint32_t * HashResultPointer)
2510 {
2511         HashResultPointer[0] = 0x67452301;
2512         HashResultPointer[1] = 0xEFCDAB89;
2513         HashResultPointer[2] = 0x98BADCFE;
2514         HashResultPointer[3] = 0x10325476;
2515         HashResultPointer[4] = 0xC3D2E1F0;
2516 }
2517
2518 /**
2519  * lpfc_sha_iterate - Iterate initial hash table with the working hash table
2520  * @HashResultPointer: pointer to an initial/result hash table.
2521  * @HashWorkingPointer: pointer to an working hash table.
2522  *
2523  * This routine iterates an initial hash table pointed by @HashResultPointer
2524  * with the values from the working hash table pointeed by @HashWorkingPointer.
2525  * The results are putting back to the initial hash table, returned through
2526  * the @HashResultPointer as the result hash table.
2527  **/
2528 static void
2529 lpfc_sha_iterate(uint32_t * HashResultPointer, uint32_t * HashWorkingPointer)
2530 {
2531         int t;
2532         uint32_t TEMP;
2533         uint32_t A, B, C, D, E;
2534         t = 16;
2535         do {
2536                 HashWorkingPointer[t] =
2537                     S(1,
2538                       HashWorkingPointer[t - 3] ^ HashWorkingPointer[t -
2539                                                                      8] ^
2540                       HashWorkingPointer[t - 14] ^ HashWorkingPointer[t - 16]);
2541         } while (++t <= 79);
2542         t = 0;
2543         A = HashResultPointer[0];
2544         B = HashResultPointer[1];
2545         C = HashResultPointer[2];
2546         D = HashResultPointer[3];
2547         E = HashResultPointer[4];
2548
2549         do {
2550                 if (t < 20) {
2551                         TEMP = ((B & C) | ((~B) & D)) + 0x5A827999;
2552                 } else if (t < 40) {
2553                         TEMP = (B ^ C ^ D) + 0x6ED9EBA1;
2554                 } else if (t < 60) {
2555                         TEMP = ((B & C) | (B & D) | (C & D)) + 0x8F1BBCDC;
2556                 } else {
2557                         TEMP = (B ^ C ^ D) + 0xCA62C1D6;
2558                 }
2559                 TEMP += S(5, A) + E + HashWorkingPointer[t];
2560                 E = D;
2561                 D = C;
2562                 C = S(30, B);
2563                 B = A;
2564                 A = TEMP;
2565         } while (++t <= 79);
2566
2567         HashResultPointer[0] += A;
2568         HashResultPointer[1] += B;
2569         HashResultPointer[2] += C;
2570         HashResultPointer[3] += D;
2571         HashResultPointer[4] += E;
2572
2573 }
2574
2575 /**
2576  * lpfc_challenge_key - Create challenge key based on WWPN of the HBA
2577  * @RandomChallenge: pointer to the entry of host challenge random number array.
2578  * @HashWorking: pointer to the entry of the working hash array.
2579  *
2580  * This routine calculates the working hash array referred by @HashWorking
2581  * from the challenge random numbers associated with the host, referred by
2582  * @RandomChallenge. The result is put into the entry of the working hash
2583  * array and returned by reference through @HashWorking.
2584  **/
2585 static void
2586 lpfc_challenge_key(uint32_t * RandomChallenge, uint32_t * HashWorking)
2587 {
2588         *HashWorking = (*RandomChallenge ^ *HashWorking);
2589 }
2590
2591 /**
2592  * lpfc_hba_init - Perform special handling for LC HBA initialization
2593  * @phba: pointer to lpfc hba data structure.
2594  * @hbainit: pointer to an array of unsigned 32-bit integers.
2595  *
2596  * This routine performs the special handling for LC HBA initialization.
2597  **/
2598 void
2599 lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit)
2600 {
2601         int t;
2602         uint32_t *HashWorking;
2603         uint32_t *pwwnn = (uint32_t *) phba->wwnn;
2604
2605         HashWorking = kcalloc(80, sizeof(uint32_t), GFP_KERNEL);
2606         if (!HashWorking)
2607                 return;
2608
2609         HashWorking[0] = HashWorking[78] = *pwwnn++;
2610         HashWorking[1] = HashWorking[79] = *pwwnn;
2611
2612         for (t = 0; t < 7; t++)
2613                 lpfc_challenge_key(phba->RandomData + t, HashWorking + t);
2614
2615         lpfc_sha_init(hbainit);
2616         lpfc_sha_iterate(hbainit, HashWorking);
2617         kfree(HashWorking);
2618 }
2619
2620 /**
2621  * lpfc_cleanup - Performs vport cleanups before deleting a vport
2622  * @vport: pointer to a virtual N_Port data structure.
2623  *
2624  * This routine performs the necessary cleanups before deleting the @vport.
2625  * It invokes the discovery state machine to perform necessary state
2626  * transitions and to release the ndlps associated with the @vport. Note,
2627  * the physical port is treated as @vport 0.
2628  **/
2629 void
2630 lpfc_cleanup(struct lpfc_vport *vport)
2631 {
2632         struct lpfc_hba   *phba = vport->phba;
2633         struct lpfc_nodelist *ndlp, *next_ndlp;
2634         int i = 0;
2635
2636         if (phba->link_state > LPFC_LINK_DOWN)
2637                 lpfc_port_link_failure(vport);
2638
2639         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2640                 if (!NLP_CHK_NODE_ACT(ndlp)) {
2641                         ndlp = lpfc_enable_node(vport, ndlp,
2642                                                 NLP_STE_UNUSED_NODE);
2643                         if (!ndlp)
2644                                 continue;
2645                         spin_lock_irq(&phba->ndlp_lock);
2646                         NLP_SET_FREE_REQ(ndlp);
2647                         spin_unlock_irq(&phba->ndlp_lock);
2648                         /* Trigger the release of the ndlp memory */
2649                         lpfc_nlp_put(ndlp);
2650                         continue;
2651                 }
2652                 spin_lock_irq(&phba->ndlp_lock);
2653                 if (NLP_CHK_FREE_REQ(ndlp)) {
2654                         /* The ndlp should not be in memory free mode already */
2655                         spin_unlock_irq(&phba->ndlp_lock);
2656                         continue;
2657                 } else
2658                         /* Indicate request for freeing ndlp memory */
2659                         NLP_SET_FREE_REQ(ndlp);
2660                 spin_unlock_irq(&phba->ndlp_lock);
2661
2662                 if (vport->port_type != LPFC_PHYSICAL_PORT &&
2663                     ndlp->nlp_DID == Fabric_DID) {
2664                         /* Just free up ndlp with Fabric_DID for vports */
2665                         lpfc_nlp_put(ndlp);
2666                         continue;
2667                 }
2668
2669                 /* take care of nodes in unused state before the state
2670                  * machine taking action.
2671                  */
2672                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) {
2673                         lpfc_nlp_put(ndlp);
2674                         continue;
2675                 }
2676
2677                 if (ndlp->nlp_type & NLP_FABRIC)
2678                         lpfc_disc_state_machine(vport, ndlp, NULL,
2679                                         NLP_EVT_DEVICE_RECOVERY);
2680
2681                 if (ndlp->nlp_fc4_type & NLP_FC4_NVME) {
2682                         /* Remove the NVME transport reference now and
2683                          * continue to remove the node.
2684                          */
2685                         lpfc_nlp_put(ndlp);
2686                 }
2687
2688                 lpfc_disc_state_machine(vport, ndlp, NULL,
2689                                              NLP_EVT_DEVICE_RM);
2690         }
2691
2692         /* At this point, ALL ndlp's should be gone
2693          * because of the previous NLP_EVT_DEVICE_RM.
2694          * Lets wait for this to happen, if needed.
2695          */
2696         while (!list_empty(&vport->fc_nodes)) {
2697                 if (i++ > 3000) {
2698                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2699                                 "0233 Nodelist not empty\n");
2700                         list_for_each_entry_safe(ndlp, next_ndlp,
2701                                                 &vport->fc_nodes, nlp_listp) {
2702                                 lpfc_printf_vlog(ndlp->vport, KERN_ERR,
2703                                                 LOG_NODE,
2704                                                 "0282 did:x%x ndlp:x%p "
2705                                                 "usgmap:x%x refcnt:%d\n",
2706                                                 ndlp->nlp_DID, (void *)ndlp,
2707                                                 ndlp->nlp_usg_map,
2708                                                 kref_read(&ndlp->kref));
2709                         }
2710                         break;
2711                 }
2712
2713                 /* Wait for any activity on ndlps to settle */
2714                 msleep(10);
2715         }
2716         lpfc_cleanup_vports_rrqs(vport, NULL);
2717 }
2718
2719 /**
2720  * lpfc_stop_vport_timers - Stop all the timers associated with a vport
2721  * @vport: pointer to a virtual N_Port data structure.
2722  *
2723  * This routine stops all the timers associated with a @vport. This function
2724  * is invoked before disabling or deleting a @vport. Note that the physical
2725  * port is treated as @vport 0.
2726  **/
2727 void
2728 lpfc_stop_vport_timers(struct lpfc_vport *vport)
2729 {
2730         del_timer_sync(&vport->els_tmofunc);
2731         del_timer_sync(&vport->delayed_disc_tmo);
2732         lpfc_can_disctmo(vport);
2733         return;
2734 }
2735
2736 /**
2737  * __lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2738  * @phba: pointer to lpfc hba data structure.
2739  *
2740  * This routine stops the SLI4 FCF rediscover wait timer if it's on. The
2741  * caller of this routine should already hold the host lock.
2742  **/
2743 void
2744 __lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
2745 {
2746         /* Clear pending FCF rediscovery wait flag */
2747         phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
2748
2749         /* Now, try to stop the timer */
2750         del_timer(&phba->fcf.redisc_wait);
2751 }
2752
2753 /**
2754  * lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2755  * @phba: pointer to lpfc hba data structure.
2756  *
2757  * This routine stops the SLI4 FCF rediscover wait timer if it's on. It
2758  * checks whether the FCF rediscovery wait timer is pending with the host
2759  * lock held before proceeding with disabling the timer and clearing the
2760  * wait timer pendig flag.
2761  **/
2762 void
2763 lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
2764 {
2765         spin_lock_irq(&phba->hbalock);
2766         if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
2767                 /* FCF rediscovery timer already fired or stopped */
2768                 spin_unlock_irq(&phba->hbalock);
2769                 return;
2770         }
2771         __lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2772         /* Clear failover in progress flags */
2773         phba->fcf.fcf_flag &= ~(FCF_DEAD_DISC | FCF_ACVL_DISC);
2774         spin_unlock_irq(&phba->hbalock);
2775 }
2776
2777 /**
2778  * lpfc_stop_hba_timers - Stop all the timers associated with an HBA
2779  * @phba: pointer to lpfc hba data structure.
2780  *
2781  * This routine stops all the timers associated with a HBA. This function is
2782  * invoked before either putting a HBA offline or unloading the driver.
2783  **/
2784 void
2785 lpfc_stop_hba_timers(struct lpfc_hba *phba)
2786 {
2787         lpfc_stop_vport_timers(phba->pport);
2788         del_timer_sync(&phba->sli.mbox_tmo);
2789         del_timer_sync(&phba->fabric_block_timer);
2790         del_timer_sync(&phba->eratt_poll);
2791         del_timer_sync(&phba->hb_tmofunc);
2792         if (phba->sli_rev == LPFC_SLI_REV4) {
2793                 del_timer_sync(&phba->rrq_tmr);
2794                 phba->hba_flag &= ~HBA_RRQ_ACTIVE;
2795         }
2796         phba->hb_outstanding = 0;
2797
2798         switch (phba->pci_dev_grp) {
2799         case LPFC_PCI_DEV_LP:
2800                 /* Stop any LightPulse device specific driver timers */
2801                 del_timer_sync(&phba->fcp_poll_timer);
2802                 break;
2803         case LPFC_PCI_DEV_OC:
2804                 /* Stop any OneConnect device sepcific driver timers */
2805                 lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2806                 break;
2807         default:
2808                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2809                                 "0297 Invalid device group (x%x)\n",
2810                                 phba->pci_dev_grp);
2811                 break;
2812         }
2813         return;
2814 }
2815
2816 /**
2817  * lpfc_block_mgmt_io - Mark a HBA's management interface as blocked
2818  * @phba: pointer to lpfc hba data structure.
2819  *
2820  * This routine marks a HBA's management interface as blocked. Once the HBA's
2821  * management interface is marked as blocked, all the user space access to
2822  * the HBA, whether they are from sysfs interface or libdfc interface will
2823  * all be blocked. The HBA is set to block the management interface when the
2824  * driver prepares the HBA interface for online or offline.
2825  **/
2826 static void
2827 lpfc_block_mgmt_io(struct lpfc_hba *phba, int mbx_action)
2828 {
2829         unsigned long iflag;
2830         uint8_t actcmd = MBX_HEARTBEAT;
2831         unsigned long timeout;
2832
2833         spin_lock_irqsave(&phba->hbalock, iflag);
2834         phba->sli.sli_flag |= LPFC_BLOCK_MGMT_IO;
2835         spin_unlock_irqrestore(&phba->hbalock, iflag);
2836         if (mbx_action == LPFC_MBX_NO_WAIT)
2837                 return;
2838         timeout = msecs_to_jiffies(LPFC_MBOX_TMO * 1000) + jiffies;
2839         spin_lock_irqsave(&phba->hbalock, iflag);
2840         if (phba->sli.mbox_active) {
2841                 actcmd = phba->sli.mbox_active->u.mb.mbxCommand;
2842                 /* Determine how long we might wait for the active mailbox
2843                  * command to be gracefully completed by firmware.
2844                  */
2845                 timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba,
2846                                 phba->sli.mbox_active) * 1000) + jiffies;
2847         }
2848         spin_unlock_irqrestore(&phba->hbalock, iflag);
2849
2850         /* Wait for the outstnading mailbox command to complete */
2851         while (phba->sli.mbox_active) {
2852                 /* Check active mailbox complete status every 2ms */
2853                 msleep(2);
2854                 if (time_after(jiffies, timeout)) {
2855                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2856                                 "2813 Mgmt IO is Blocked %x "
2857                                 "- mbox cmd %x still active\n",
2858                                 phba->sli.sli_flag, actcmd);
2859                         break;
2860                 }
2861         }
2862 }
2863
2864 /**
2865  * lpfc_sli4_node_prep - Assign RPIs for active nodes.
2866  * @phba: pointer to lpfc hba data structure.
2867  *
2868  * Allocate RPIs for all active remote nodes. This is needed whenever
2869  * an SLI4 adapter is reset and the driver is not unloading. Its purpose
2870  * is to fixup the temporary rpi assignments.
2871  **/
2872 void
2873 lpfc_sli4_node_prep(struct lpfc_hba *phba)
2874 {
2875         struct lpfc_nodelist  *ndlp, *next_ndlp;
2876         struct lpfc_vport **vports;
2877         int i;
2878
2879         if (phba->sli_rev != LPFC_SLI_REV4)
2880                 return;
2881
2882         vports = lpfc_create_vport_work_array(phba);
2883         if (vports != NULL) {
2884                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2885                         if (vports[i]->load_flag & FC_UNLOADING)
2886                                 continue;
2887
2888                         list_for_each_entry_safe(ndlp, next_ndlp,
2889                                                  &vports[i]->fc_nodes,
2890                                                  nlp_listp) {
2891                                 if (NLP_CHK_NODE_ACT(ndlp)) {
2892                                         ndlp->nlp_rpi =
2893                                                 lpfc_sli4_alloc_rpi(phba);
2894                                         lpfc_printf_vlog(ndlp->vport, KERN_INFO,
2895                                                          LOG_NODE,
2896                                                          "0009 rpi:%x DID:%x "
2897                                                          "flg:%x map:%x %p\n",
2898                                                          ndlp->nlp_rpi,
2899                                                          ndlp->nlp_DID,
2900                                                          ndlp->nlp_flag,
2901                                                          ndlp->nlp_usg_map,
2902                                                          ndlp);
2903                                 }
2904                         }
2905                 }
2906         }
2907         lpfc_destroy_vport_work_array(phba, vports);
2908 }
2909
2910 /**
2911  * lpfc_online - Initialize and bring a HBA online
2912  * @phba: pointer to lpfc hba data structure.
2913  *
2914  * This routine initializes the HBA and brings a HBA online. During this
2915  * process, the management interface is blocked to prevent user space access
2916  * to the HBA interfering with the driver initialization.
2917  *
2918  * Return codes
2919  *   0 - successful
2920  *   1 - failed
2921  **/
2922 int
2923 lpfc_online(struct lpfc_hba *phba)
2924 {
2925         struct lpfc_vport *vport;
2926         struct lpfc_vport **vports;
2927         int i;
2928         bool vpis_cleared = false;
2929
2930         if (!phba)
2931                 return 0;
2932         vport = phba->pport;
2933
2934         if (!(vport->fc_flag & FC_OFFLINE_MODE))
2935                 return 0;
2936
2937         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
2938                         "0458 Bring Adapter online\n");
2939
2940         lpfc_block_mgmt_io(phba, LPFC_MBX_WAIT);
2941
2942         if (phba->sli_rev == LPFC_SLI_REV4) {
2943                 if (lpfc_sli4_hba_setup(phba)) { /* Initialize SLI4 HBA */
2944                         lpfc_unblock_mgmt_io(phba);
2945                         return 1;
2946                 }
2947                 spin_lock_irq(&phba->hbalock);
2948                 if (!phba->sli4_hba.max_cfg_param.vpi_used)
2949                         vpis_cleared = true;
2950                 spin_unlock_irq(&phba->hbalock);
2951         } else {
2952                 lpfc_sli_queue_init(phba);
2953                 if (lpfc_sli_hba_setup(phba)) { /* Initialize SLI2/SLI3 HBA */
2954                         lpfc_unblock_mgmt_io(phba);
2955                         return 1;
2956                 }
2957         }
2958
2959         vports = lpfc_create_vport_work_array(phba);
2960         if (vports != NULL) {
2961                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2962                         struct Scsi_Host *shost;
2963                         shost = lpfc_shost_from_vport(vports[i]);
2964                         spin_lock_irq(shost->host_lock);
2965                         vports[i]->fc_flag &= ~FC_OFFLINE_MODE;
2966                         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
2967                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
2968                         if (phba->sli_rev == LPFC_SLI_REV4) {
2969                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
2970                                 if ((vpis_cleared) &&
2971                                     (vports[i]->port_type !=
2972                                         LPFC_PHYSICAL_PORT))
2973                                         vports[i]->vpi = 0;
2974                         }
2975                         spin_unlock_irq(shost->host_lock);
2976                 }
2977         }
2978         lpfc_destroy_vport_work_array(phba, vports);
2979
2980         lpfc_unblock_mgmt_io(phba);
2981         return 0;
2982 }
2983
2984 /**
2985  * lpfc_unblock_mgmt_io - Mark a HBA's management interface to be not blocked
2986  * @phba: pointer to lpfc hba data structure.
2987  *
2988  * This routine marks a HBA's management interface as not blocked. Once the
2989  * HBA's management interface is marked as not blocked, all the user space
2990  * access to the HBA, whether they are from sysfs interface or libdfc
2991  * interface will be allowed. The HBA is set to block the management interface
2992  * when the driver prepares the HBA interface for online or offline and then
2993  * set to unblock the management interface afterwards.
2994  **/
2995 void
2996 lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
2997 {
2998         unsigned long iflag;
2999
3000         spin_lock_irqsave(&phba->hbalock, iflag);
3001         phba->sli.sli_flag &= ~LPFC_BLOCK_MGMT_IO;
3002         spin_unlock_irqrestore(&phba->hbalock, iflag);
3003 }
3004
3005 /**
3006  * lpfc_offline_prep - Prepare a HBA to be brought offline
3007  * @phba: pointer to lpfc hba data structure.
3008  *
3009  * This routine is invoked to prepare a HBA to be brought offline. It performs
3010  * unregistration login to all the nodes on all vports and flushes the mailbox
3011  * queue to make it ready to be brought offline.
3012  **/
3013 void
3014 lpfc_offline_prep(struct lpfc_hba *phba, int mbx_action)
3015 {
3016         struct lpfc_vport *vport = phba->pport;
3017         struct lpfc_nodelist  *ndlp, *next_ndlp;
3018         struct lpfc_vport **vports;
3019         struct Scsi_Host *shost;
3020         int i;
3021
3022         if (vport->fc_flag & FC_OFFLINE_MODE)
3023                 return;
3024
3025         lpfc_block_mgmt_io(phba, mbx_action);
3026
3027         lpfc_linkdown(phba);
3028
3029         /* Issue an unreg_login to all nodes on all vports */
3030         vports = lpfc_create_vport_work_array(phba);
3031         if (vports != NULL) {
3032                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3033                         if (vports[i]->load_flag & FC_UNLOADING)
3034                                 continue;
3035                         shost = lpfc_shost_from_vport(vports[i]);
3036                         spin_lock_irq(shost->host_lock);
3037                         vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
3038                         vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
3039                         vports[i]->fc_flag &= ~FC_VFI_REGISTERED;
3040                         spin_unlock_irq(shost->host_lock);
3041
3042                         shost = lpfc_shost_from_vport(vports[i]);
3043                         list_for_each_entry_safe(ndlp, next_ndlp,
3044                                                  &vports[i]->fc_nodes,
3045                                                  nlp_listp) {
3046                                 if (!NLP_CHK_NODE_ACT(ndlp))
3047                                         continue;
3048                                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
3049                                         continue;
3050                                 if (ndlp->nlp_type & NLP_FABRIC) {
3051                                         lpfc_disc_state_machine(vports[i], ndlp,
3052                                                 NULL, NLP_EVT_DEVICE_RECOVERY);
3053                                         lpfc_disc_state_machine(vports[i], ndlp,
3054                                                 NULL, NLP_EVT_DEVICE_RM);
3055                                 }
3056                                 spin_lock_irq(shost->host_lock);
3057                                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
3058                                 spin_unlock_irq(shost->host_lock);
3059                                 /*
3060                                  * Whenever an SLI4 port goes offline, free the
3061                                  * RPI. Get a new RPI when the adapter port
3062                                  * comes back online.
3063                                  */
3064                                 if (phba->sli_rev == LPFC_SLI_REV4) {
3065                                         lpfc_printf_vlog(ndlp->vport,
3066                                                          KERN_INFO, LOG_NODE,
3067                                                          "0011 lpfc_offline: "
3068                                                          "ndlp:x%p did %x "
3069                                                          "usgmap:x%x rpi:%x\n",
3070                                                          ndlp, ndlp->nlp_DID,
3071                                                          ndlp->nlp_usg_map,
3072                                                          ndlp->nlp_rpi);
3073
3074                                         lpfc_sli4_free_rpi(phba, ndlp->nlp_rpi);
3075                                 }
3076                                 lpfc_unreg_rpi(vports[i], ndlp);
3077                         }
3078                 }
3079         }
3080         lpfc_destroy_vport_work_array(phba, vports);
3081
3082         lpfc_sli_mbox_sys_shutdown(phba, mbx_action);
3083 }
3084
3085 /**
3086  * lpfc_offline - Bring a HBA offline
3087  * @phba: pointer to lpfc hba data structure.
3088  *
3089  * This routine actually brings a HBA offline. It stops all the timers
3090  * associated with the HBA, brings down the SLI layer, and eventually
3091  * marks the HBA as in offline state for the upper layer protocol.
3092  **/
3093 void
3094 lpfc_offline(struct lpfc_hba *phba)
3095 {
3096         struct Scsi_Host  *shost;
3097         struct lpfc_vport **vports;
3098         int i;
3099
3100         if (phba->pport->fc_flag & FC_OFFLINE_MODE)
3101                 return;
3102
3103         /* stop port and all timers associated with this hba */
3104         lpfc_stop_port(phba);
3105         vports = lpfc_create_vport_work_array(phba);
3106         if (vports != NULL)
3107                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
3108                         lpfc_stop_vport_timers(vports[i]);
3109         lpfc_destroy_vport_work_array(phba, vports);
3110         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
3111                         "0460 Bring Adapter offline\n");
3112         /* Bring down the SLI Layer and cleanup.  The HBA is offline
3113            now.  */
3114         lpfc_sli_hba_down(phba);
3115         spin_lock_irq(&phba->hbalock);
3116         phba->work_ha = 0;
3117         spin_unlock_irq(&phba->hbalock);
3118         vports = lpfc_create_vport_work_array(phba);
3119         if (vports != NULL)
3120                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3121                         shost = lpfc_shost_from_vport(vports[i]);
3122                         spin_lock_irq(shost->host_lock);
3123                         vports[i]->work_port_events = 0;
3124                         vports[i]->fc_flag |= FC_OFFLINE_MODE;
3125                         spin_unlock_irq(shost->host_lock);
3126                 }
3127         lpfc_destroy_vport_work_array(phba, vports);
3128 }
3129
3130 /**
3131  * lpfc_scsi_free - Free all the SCSI buffers and IOCBs from driver lists
3132  * @phba: pointer to lpfc hba data structure.
3133  *
3134  * This routine is to free all the SCSI buffers and IOCBs from the driver
3135  * list back to kernel. It is called from lpfc_pci_remove_one to free
3136  * the internal resources before the device is removed from the system.
3137  **/
3138 static void
3139 lpfc_scsi_free(struct lpfc_hba *phba)
3140 {
3141         struct lpfc_scsi_buf *sb, *sb_next;
3142
3143         if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
3144                 return;
3145
3146         spin_lock_irq(&phba->hbalock);
3147
3148         /* Release all the lpfc_scsi_bufs maintained by this host. */
3149
3150         spin_lock(&phba->scsi_buf_list_put_lock);
3151         list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list_put,
3152                                  list) {
3153                 list_del(&sb->list);
3154                 pci_pool_free(phba->lpfc_sg_dma_buf_pool, sb->data,
3155                               sb->dma_handle);
3156                 kfree(sb);
3157                 phba->total_scsi_bufs--;
3158         }
3159         spin_unlock(&phba->scsi_buf_list_put_lock);
3160
3161         spin_lock(&phba->scsi_buf_list_get_lock);
3162         list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list_get,
3163                                  list) {
3164                 list_del(&sb->list);
3165                 pci_pool_free(phba->lpfc_sg_dma_buf_pool, sb->data,
3166                               sb->dma_handle);
3167                 kfree(sb);
3168                 phba->total_scsi_bufs--;
3169         }
3170         spin_unlock(&phba->scsi_buf_list_get_lock);
3171         spin_unlock_irq(&phba->hbalock);
3172 }
3173 /**
3174  * lpfc_nvme_free - Free all the NVME buffers and IOCBs from driver lists
3175  * @phba: pointer to lpfc hba data structure.
3176  *
3177  * This routine is to free all the NVME buffers and IOCBs from the driver
3178  * list back to kernel. It is called from lpfc_pci_remove_one to free
3179  * the internal resources before the device is removed from the system.
3180  **/
3181 static void
3182 lpfc_nvme_free(struct lpfc_hba *phba)
3183 {
3184         struct lpfc_nvme_buf *lpfc_ncmd, *lpfc_ncmd_next;
3185
3186         if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME))
3187                 return;
3188
3189         spin_lock_irq(&phba->hbalock);
3190
3191         /* Release all the lpfc_nvme_bufs maintained by this host. */
3192         spin_lock(&phba->nvme_buf_list_put_lock);
3193         list_for_each_entry_safe(lpfc_ncmd, lpfc_ncmd_next,
3194                                  &phba->lpfc_nvme_buf_list_put, list) {
3195                 list_del(&lpfc_ncmd->list);
3196                 pci_pool_free(phba->lpfc_sg_dma_buf_pool, lpfc_ncmd->data,
3197                               lpfc_ncmd->dma_handle);
3198                 kfree(lpfc_ncmd);
3199                 phba->total_nvme_bufs--;
3200         }
3201         spin_unlock(&phba->nvme_buf_list_put_lock);
3202
3203         spin_lock(&phba->nvme_buf_list_get_lock);
3204         list_for_each_entry_safe(lpfc_ncmd, lpfc_ncmd_next,
3205                                  &phba->lpfc_nvme_buf_list_get, list) {
3206                 list_del(&lpfc_ncmd->list);
3207                 pci_pool_free(phba->lpfc_sg_dma_buf_pool, lpfc_ncmd->data,
3208                               lpfc_ncmd->dma_handle);
3209                 kfree(lpfc_ncmd);
3210                 phba->total_nvme_bufs--;
3211         }
3212         spin_unlock(&phba->nvme_buf_list_get_lock);
3213         spin_unlock_irq(&phba->hbalock);
3214 }
3215 /**
3216  * lpfc_sli4_els_sgl_update - update ELS xri-sgl sizing and mapping
3217  * @phba: pointer to lpfc hba data structure.
3218  *
3219  * This routine first calculates the sizes of the current els and allocated
3220  * scsi sgl lists, and then goes through all sgls to updates the physical
3221  * XRIs assigned due to port function reset. During port initialization, the
3222  * current els and allocated scsi sgl lists are 0s.
3223  *
3224  * Return codes
3225  *   0 - successful (for now, it always returns 0)
3226  **/
3227 int
3228 lpfc_sli4_els_sgl_update(struct lpfc_hba *phba)
3229 {
3230         struct lpfc_sglq *sglq_entry = NULL, *sglq_entry_next = NULL;
3231         uint16_t i, lxri, xri_cnt, els_xri_cnt;
3232         LIST_HEAD(els_sgl_list);
3233         int rc;
3234
3235         /*
3236          * update on pci function's els xri-sgl list
3237          */
3238         els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
3239
3240         if (els_xri_cnt > phba->sli4_hba.els_xri_cnt) {
3241                 /* els xri-sgl expanded */
3242                 xri_cnt = els_xri_cnt - phba->sli4_hba.els_xri_cnt;
3243                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3244                                 "3157 ELS xri-sgl count increased from "
3245                                 "%d to %d\n", phba->sli4_hba.els_xri_cnt,
3246                                 els_xri_cnt);
3247                 /* allocate the additional els sgls */
3248                 for (i = 0; i < xri_cnt; i++) {
3249                         sglq_entry = kzalloc(sizeof(struct lpfc_sglq),
3250                                              GFP_KERNEL);
3251                         if (sglq_entry == NULL) {
3252                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3253                                                 "2562 Failure to allocate an "
3254                                                 "ELS sgl entry:%d\n", i);
3255                                 rc = -ENOMEM;
3256                                 goto out_free_mem;
3257                         }
3258                         sglq_entry->buff_type = GEN_BUFF_TYPE;
3259                         sglq_entry->virt = lpfc_mbuf_alloc(phba, 0,
3260                                                            &sglq_entry->phys);
3261                         if (sglq_entry->virt == NULL) {
3262                                 kfree(sglq_entry);
3263                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3264                                                 "2563 Failure to allocate an "
3265                                                 "ELS mbuf:%d\n", i);
3266                                 rc = -ENOMEM;
3267                                 goto out_free_mem;
3268                         }
3269                         sglq_entry->sgl = sglq_entry->virt;
3270                         memset(sglq_entry->sgl, 0, LPFC_BPL_SIZE);
3271                         sglq_entry->state = SGL_FREED;
3272                         list_add_tail(&sglq_entry->list, &els_sgl_list);
3273                 }
3274                 spin_lock_irq(&phba->hbalock);
3275                 spin_lock(&phba->sli4_hba.sgl_list_lock);
3276                 list_splice_init(&els_sgl_list,
3277                                  &phba->sli4_hba.lpfc_els_sgl_list);
3278                 spin_unlock(&phba->sli4_hba.sgl_list_lock);
3279                 spin_unlock_irq(&phba->hbalock);
3280         } else if (els_xri_cnt < phba->sli4_hba.els_xri_cnt) {
3281                 /* els xri-sgl shrinked */
3282                 xri_cnt = phba->sli4_hba.els_xri_cnt - els_xri_cnt;
3283                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3284                                 "3158 ELS xri-sgl count decreased from "
3285                                 "%d to %d\n", phba->sli4_hba.els_xri_cnt,
3286                                 els_xri_cnt);
3287                 spin_lock_irq(&phba->hbalock);
3288                 spin_lock(&phba->sli4_hba.sgl_list_lock);
3289                 list_splice_init(&phba->sli4_hba.lpfc_els_sgl_list,
3290                                  &els_sgl_list);
3291                 /* release extra els sgls from list */
3292                 for (i = 0; i < xri_cnt; i++) {
3293                         list_remove_head(&els_sgl_list,
3294                                          sglq_entry, struct lpfc_sglq, list);
3295                         if (sglq_entry) {
3296                                 __lpfc_mbuf_free(phba, sglq_entry->virt,
3297                                                  sglq_entry->phys);
3298                                 kfree(sglq_entry);
3299                         }
3300                 }
3301                 list_splice_init(&els_sgl_list,
3302                                  &phba->sli4_hba.lpfc_els_sgl_list);
3303                 spin_unlock(&phba->sli4_hba.sgl_list_lock);
3304                 spin_unlock_irq(&phba->hbalock);
3305         } else
3306                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3307                                 "3163 ELS xri-sgl count unchanged: %d\n",
3308                                 els_xri_cnt);
3309         phba->sli4_hba.els_xri_cnt = els_xri_cnt;
3310
3311         /* update xris to els sgls on the list */
3312         sglq_entry = NULL;
3313         sglq_entry_next = NULL;
3314         list_for_each_entry_safe(sglq_entry, sglq_entry_next,
3315                                  &phba->sli4_hba.lpfc_els_sgl_list, list) {
3316                 lxri = lpfc_sli4_next_xritag(phba);
3317                 if (lxri == NO_XRI) {
3318                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3319                                         "2400 Failed to allocate xri for "
3320                                         "ELS sgl\n");
3321                         rc = -ENOMEM;
3322                         goto out_free_mem;
3323                 }
3324                 sglq_entry->sli4_lxritag = lxri;
3325                 sglq_entry->sli4_xritag = phba->sli4_hba.xri_ids[lxri];
3326         }
3327         return 0;
3328
3329 out_free_mem:
3330         lpfc_free_els_sgl_list(phba);
3331         return rc;
3332 }
3333
3334 /**
3335  * lpfc_sli4_nvmet_sgl_update - update xri-sgl sizing and mapping
3336  * @phba: pointer to lpfc hba data structure.
3337  *
3338  * This routine first calculates the sizes of the current els and allocated
3339  * scsi sgl lists, and then goes through all sgls to updates the physical
3340  * XRIs assigned due to port function reset. During port initialization, the
3341  * current els and allocated scsi sgl lists are 0s.
3342  *
3343  * Return codes
3344  *   0 - successful (for now, it always returns 0)
3345  **/
3346 int
3347 lpfc_sli4_nvmet_sgl_update(struct lpfc_hba *phba)
3348 {
3349         struct lpfc_sglq *sglq_entry = NULL, *sglq_entry_next = NULL;
3350         uint16_t i, lxri, xri_cnt, els_xri_cnt;
3351         uint16_t nvmet_xri_cnt, tot_cnt;
3352         LIST_HEAD(nvmet_sgl_list);
3353         int rc;
3354
3355         /*
3356          * update on pci function's nvmet xri-sgl list
3357          */
3358         els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
3359         nvmet_xri_cnt = phba->cfg_nvmet_mrq * phba->cfg_nvmet_mrq_post;
3360         tot_cnt = phba->sli4_hba.max_cfg_param.max_xri - els_xri_cnt;
3361         if (nvmet_xri_cnt > tot_cnt) {
3362                 phba->cfg_nvmet_mrq_post = tot_cnt / phba->cfg_nvmet_mrq;
3363                 nvmet_xri_cnt = phba->cfg_nvmet_mrq * phba->cfg_nvmet_mrq_post;
3364                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3365                                 "6301 NVMET post-sgl count changed to %d\n",
3366                                 phba->cfg_nvmet_mrq_post);
3367         }
3368
3369         if (nvmet_xri_cnt > phba->sli4_hba.nvmet_xri_cnt) {
3370                 /* els xri-sgl expanded */
3371                 xri_cnt = nvmet_xri_cnt - phba->sli4_hba.nvmet_xri_cnt;
3372                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3373                                 "6302 NVMET xri-sgl cnt grew from %d to %d\n",
3374                                 phba->sli4_hba.nvmet_xri_cnt, nvmet_xri_cnt);
3375                 /* allocate the additional nvmet sgls */
3376                 for (i = 0; i < xri_cnt; i++) {
3377                         sglq_entry = kzalloc(sizeof(struct lpfc_sglq),
3378                                              GFP_KERNEL);
3379                         if (sglq_entry == NULL) {
3380                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3381                                                 "6303 Failure to allocate an "
3382                                                 "NVMET sgl entry:%d\n", i);
3383                                 rc = -ENOMEM;
3384                                 goto out_free_mem;
3385                         }
3386                         sglq_entry->buff_type = NVMET_BUFF_TYPE;
3387                         sglq_entry->virt = lpfc_nvmet_buf_alloc(phba, 0,
3388                                                            &sglq_entry->phys);
3389                         if (sglq_entry->virt == NULL) {
3390                                 kfree(sglq_entry);
3391                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3392                                                 "6304 Failure to allocate an "
3393                                                 "NVMET buf:%d\n", i);
3394                                 rc = -ENOMEM;
3395                                 goto out_free_mem;
3396                         }
3397                         sglq_entry->sgl = sglq_entry->virt;
3398                         memset(sglq_entry->sgl, 0,
3399                                phba->cfg_sg_dma_buf_size);
3400                         sglq_entry->state = SGL_FREED;
3401                         list_add_tail(&sglq_entry->list, &nvmet_sgl_list);
3402                 }
3403                 spin_lock_irq(&phba->hbalock);
3404                 spin_lock(&phba->sli4_hba.sgl_list_lock);
3405                 list_splice_init(&nvmet_sgl_list,
3406                                  &phba->sli4_hba.lpfc_nvmet_sgl_list);
3407                 spin_unlock(&phba->sli4_hba.sgl_list_lock);
3408                 spin_unlock_irq(&phba->hbalock);
3409         } else if (nvmet_xri_cnt < phba->sli4_hba.nvmet_xri_cnt) {
3410                 /* nvmet xri-sgl shrunk */
3411                 xri_cnt = phba->sli4_hba.nvmet_xri_cnt - nvmet_xri_cnt;
3412                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3413                                 "6305 NVMET xri-sgl count decreased from "
3414                                 "%d to %d\n", phba->sli4_hba.nvmet_xri_cnt,
3415                                 nvmet_xri_cnt);
3416                 spin_lock_irq(&phba->hbalock);
3417                 spin_lock(&phba->sli4_hba.sgl_list_lock);
3418                 list_splice_init(&phba->sli4_hba.lpfc_nvmet_sgl_list,
3419                                  &nvmet_sgl_list);
3420                 /* release extra nvmet sgls from list */
3421                 for (i = 0; i < xri_cnt; i++) {
3422                         list_remove_head(&nvmet_sgl_list,
3423                                          sglq_entry, struct lpfc_sglq, list);
3424                         if (sglq_entry) {
3425                                 lpfc_nvmet_buf_free(phba, sglq_entry->virt,
3426                                                     sglq_entry->phys);
3427                                 kfree(sglq_entry);
3428                         }
3429                 }
3430                 list_splice_init(&nvmet_sgl_list,
3431                                  &phba->sli4_hba.lpfc_nvmet_sgl_list);
3432                 spin_unlock(&phba->sli4_hba.sgl_list_lock);
3433                 spin_unlock_irq(&phba->hbalock);
3434         } else
3435                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3436                                 "6306 NVMET xri-sgl count unchanged: %d\n",
3437                                 nvmet_xri_cnt);
3438         phba->sli4_hba.nvmet_xri_cnt = nvmet_xri_cnt;
3439
3440         /* update xris to nvmet sgls on the list */
3441         sglq_entry = NULL;
3442         sglq_entry_next = NULL;
3443         list_for_each_entry_safe(sglq_entry, sglq_entry_next,
3444                                  &phba->sli4_hba.lpfc_nvmet_sgl_list, list) {
3445                 lxri = lpfc_sli4_next_xritag(phba);
3446                 if (lxri == NO_XRI) {
3447                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3448                                         "6307 Failed to allocate xri for "
3449                                         "NVMET sgl\n");
3450                         rc = -ENOMEM;
3451                         goto out_free_mem;
3452                 }
3453                 sglq_entry->sli4_lxritag = lxri;
3454                 sglq_entry->sli4_xritag = phba->sli4_hba.xri_ids[lxri];
3455         }
3456         return 0;
3457
3458 out_free_mem:
3459         lpfc_free_nvmet_sgl_list(phba);
3460         return rc;
3461 }
3462
3463 /**
3464  * lpfc_sli4_scsi_sgl_update - update xri-sgl sizing and mapping
3465  * @phba: pointer to lpfc hba data structure.
3466  *
3467  * This routine first calculates the sizes of the current els and allocated
3468  * scsi sgl lists, and then goes through all sgls to updates the physical
3469  * XRIs assigned due to port function reset. During port initialization, the
3470  * current els and allocated scsi sgl lists are 0s.
3471  *
3472  * Return codes
3473  *   0 - successful (for now, it always returns 0)
3474  **/
3475 int
3476 lpfc_sli4_scsi_sgl_update(struct lpfc_hba *phba)
3477 {
3478         struct lpfc_scsi_buf *psb, *psb_next;
3479         uint16_t i, lxri, els_xri_cnt, scsi_xri_cnt;
3480         LIST_HEAD(scsi_sgl_list);
3481         int rc;
3482
3483         /*
3484          * update on pci function's els xri-sgl list
3485          */
3486         els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
3487         phba->total_scsi_bufs = 0;
3488
3489         /*
3490          * update on pci function's allocated scsi xri-sgl list
3491          */
3492         /* maximum number of xris available for scsi buffers */
3493         phba->sli4_hba.scsi_xri_max = phba->sli4_hba.max_cfg_param.max_xri -
3494                                       els_xri_cnt;
3495
3496         if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
3497                 return 0;
3498
3499         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
3500                 phba->sli4_hba.scsi_xri_max =  /* Split them up */
3501                         (phba->sli4_hba.scsi_xri_max *
3502                          phba->cfg_xri_split) / 100;
3503
3504         spin_lock_irq(&phba->scsi_buf_list_get_lock);
3505         spin_lock(&phba->scsi_buf_list_put_lock);
3506         list_splice_init(&phba->lpfc_scsi_buf_list_get, &scsi_sgl_list);
3507         list_splice(&phba->lpfc_scsi_buf_list_put, &scsi_sgl_list);
3508         spin_unlock(&phba->scsi_buf_list_put_lock);
3509         spin_unlock_irq(&phba->scsi_buf_list_get_lock);
3510
3511         if (phba->sli4_hba.scsi_xri_cnt > phba->sli4_hba.scsi_xri_max) {
3512                 /* max scsi xri shrinked below the allocated scsi buffers */
3513                 scsi_xri_cnt = phba->sli4_hba.scsi_xri_cnt -
3514                                         phba->sli4_hba.scsi_xri_max;
3515                 /* release the extra allocated scsi buffers */
3516                 for (i = 0; i < scsi_xri_cnt; i++) {
3517                         list_remove_head(&scsi_sgl_list, psb,
3518                                          struct lpfc_scsi_buf, list);
3519                         if (psb) {
3520                                 pci_pool_free(phba->lpfc_sg_dma_buf_pool,
3521                                               psb->data, psb->dma_handle);
3522                                 kfree(psb);
3523                         }
3524                 }
3525                 spin_lock_irq(&phba->scsi_buf_list_get_lock);
3526                 phba->sli4_hba.scsi_xri_cnt -= scsi_xri_cnt;
3527                 spin_unlock_irq(&phba->scsi_buf_list_get_lock);
3528         }
3529
3530         /* update xris associated to remaining allocated scsi buffers */
3531         psb = NULL;
3532         psb_next = NULL;
3533         list_for_each_entry_safe(psb, psb_next, &scsi_sgl_list, list) {
3534                 lxri = lpfc_sli4_next_xritag(phba);
3535                 if (lxri == NO_XRI) {
3536                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3537                                         "2560 Failed to allocate xri for "
3538                                         "scsi buffer\n");
3539                         rc = -ENOMEM;
3540                         goto out_free_mem;
3541                 }
3542                 psb->cur_iocbq.sli4_lxritag = lxri;
3543                 psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
3544         }
3545         spin_lock_irq(&phba->scsi_buf_list_get_lock);
3546         spin_lock(&phba->scsi_buf_list_put_lock);
3547         list_splice_init(&scsi_sgl_list, &phba->lpfc_scsi_buf_list_get);
3548         INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
3549         spin_unlock(&phba->scsi_buf_list_put_lock);
3550         spin_unlock_irq(&phba->scsi_buf_list_get_lock);
3551         return 0;
3552
3553 out_free_mem:
3554         lpfc_scsi_free(phba);
3555         return rc;
3556 }
3557
3558 static uint64_t
3559 lpfc_get_wwpn(struct lpfc_hba *phba)
3560 {
3561         uint64_t wwn;
3562         int rc;
3563         LPFC_MBOXQ_t *mboxq;
3564         MAILBOX_t *mb;
3565
3566
3567         mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
3568                                                 GFP_KERNEL);
3569         if (!mboxq)
3570                 return (uint64_t)-1;
3571
3572         /* First get WWN of HBA instance */
3573         lpfc_read_nv(phba, mboxq);
3574         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
3575         if (rc != MBX_SUCCESS) {
3576                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3577                                 "6019 Mailbox failed , mbxCmd x%x "
3578                                 "READ_NV, mbxStatus x%x\n",
3579                                 bf_get(lpfc_mqe_command, &mboxq->u.mqe),
3580                                 bf_get(lpfc_mqe_status, &mboxq->u.mqe));
3581                 mempool_free(mboxq, phba->mbox_mem_pool);
3582                 return (uint64_t) -1;
3583         }
3584         mb = &mboxq->u.mb;
3585         memcpy(&wwn, (char *)mb->un.varRDnvp.portname, sizeof(uint64_t));
3586         /* wwn is WWPN of HBA instance */
3587         mempool_free(mboxq, phba->mbox_mem_pool);
3588         if (phba->sli_rev == LPFC_SLI_REV4)
3589                 return be64_to_cpu(wwn);
3590         else
3591                 return (((wwn & 0xffffffff00000000) >> 32) |
3592                         ((wwn & 0x00000000ffffffff) << 32));
3593
3594 }
3595
3596 /**
3597  * lpfc_sli4_nvme_sgl_update - update xri-sgl sizing and mapping
3598  * @phba: pointer to lpfc hba data structure.
3599  *
3600  * This routine first calculates the sizes of the current els and allocated
3601  * scsi sgl lists, and then goes through all sgls to updates the physical
3602  * XRIs assigned due to port function reset. During port initialization, the
3603  * current els and allocated scsi sgl lists are 0s.
3604  *
3605  * Return codes
3606  *   0 - successful (for now, it always returns 0)
3607  **/
3608 int
3609 lpfc_sli4_nvme_sgl_update(struct lpfc_hba *phba)
3610 {
3611         struct lpfc_nvme_buf *lpfc_ncmd = NULL, *lpfc_ncmd_next = NULL;
3612         uint16_t i, lxri, els_xri_cnt;
3613         uint16_t nvme_xri_cnt, nvme_xri_max;
3614         LIST_HEAD(nvme_sgl_list);
3615         int rc;
3616
3617         phba->total_nvme_bufs = 0;
3618
3619         if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME))
3620                 return 0;
3621         /*
3622          * update on pci function's allocated nvme xri-sgl list
3623          */
3624
3625         /* maximum number of xris available for nvme buffers */
3626         els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
3627         nvme_xri_max = phba->sli4_hba.max_cfg_param.max_xri - els_xri_cnt;
3628         phba->sli4_hba.nvme_xri_max = nvme_xri_max;
3629         phba->sli4_hba.nvme_xri_max -= phba->sli4_hba.scsi_xri_max;
3630
3631         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
3632                         "6074 Current allocated NVME xri-sgl count:%d, "
3633                         "maximum  NVME xri count:%d\n",
3634                         phba->sli4_hba.nvme_xri_cnt,
3635                         phba->sli4_hba.nvme_xri_max);
3636
3637         spin_lock_irq(&phba->nvme_buf_list_get_lock);
3638         spin_lock(&phba->nvme_buf_list_put_lock);
3639         list_splice_init(&phba->lpfc_nvme_buf_list_get, &nvme_sgl_list);
3640         list_splice(&phba->lpfc_nvme_buf_list_put, &nvme_sgl_list);
3641         spin_unlock(&phba->nvme_buf_list_put_lock);
3642         spin_unlock_irq(&phba->nvme_buf_list_get_lock);
3643
3644         if (phba->sli4_hba.nvme_xri_cnt > phba->sli4_hba.nvme_xri_max) {
3645                 /* max nvme xri shrunk below the allocated nvme buffers */
3646                 spin_lock_irq(&phba->nvme_buf_list_get_lock);
3647                 nvme_xri_cnt = phba->sli4_hba.nvme_xri_cnt -
3648                                         phba->sli4_hba.nvme_xri_max;
3649                 spin_unlock_irq(&phba->nvme_buf_list_get_lock);
3650                 /* release the extra allocated nvme buffers */
3651                 for (i = 0; i < nvme_xri_cnt; i++) {
3652                         list_remove_head(&nvme_sgl_list, lpfc_ncmd,
3653                                          struct lpfc_nvme_buf, list);
3654                         if (lpfc_ncmd) {
3655                                 pci_pool_free(phba->lpfc_sg_dma_buf_pool,
3656                                               lpfc_ncmd->data,
3657                                               lpfc_ncmd->dma_handle);
3658                                 kfree(lpfc_ncmd);
3659                         }
3660                 }
3661                 spin_lock_irq(&phba->nvme_buf_list_get_lock);
3662                 phba->sli4_hba.nvme_xri_cnt -= nvme_xri_cnt;
3663                 spin_unlock_irq(&phba->nvme_buf_list_get_lock);
3664         }
3665
3666         /* update xris associated to remaining allocated nvme buffers */
3667         lpfc_ncmd = NULL;
3668         lpfc_ncmd_next = NULL;
3669         list_for_each_entry_safe(lpfc_ncmd, lpfc_ncmd_next,
3670                                  &nvme_sgl_list, list) {
3671                 lxri = lpfc_sli4_next_xritag(phba);
3672                 if (lxri == NO_XRI) {
3673                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3674                                         "6075 Failed to allocate xri for "
3675                                         "nvme buffer\n");
3676                         rc = -ENOMEM;
3677                         goto out_free_mem;
3678                 }
3679                 lpfc_ncmd->cur_iocbq.sli4_lxritag = lxri;
3680                 lpfc_ncmd->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
3681         }
3682         spin_lock_irq(&phba->nvme_buf_list_get_lock);
3683         spin_lock(&phba->nvme_buf_list_put_lock);
3684         list_splice_init(&nvme_sgl_list, &phba->lpfc_nvme_buf_list_get);
3685         INIT_LIST_HEAD(&phba->lpfc_nvme_buf_list_put);
3686         spin_unlock(&phba->nvme_buf_list_put_lock);
3687         spin_unlock_irq(&phba->nvme_buf_list_get_lock);
3688         return 0;
3689
3690 out_free_mem:
3691         lpfc_nvme_free(phba);
3692         return rc;
3693 }
3694
3695 /**
3696  * lpfc_create_port - Create an FC port
3697  * @phba: pointer to lpfc hba data structure.
3698  * @instance: a unique integer ID to this FC port.
3699  * @dev: pointer to the device data structure.
3700  *
3701  * This routine creates a FC port for the upper layer protocol. The FC port
3702  * can be created on top of either a physical port or a virtual port provided
3703  * by the HBA. This routine also allocates a SCSI host data structure (shost)
3704  * and associates the FC port created before adding the shost into the SCSI
3705  * layer.
3706  *
3707  * Return codes
3708  *   @vport - pointer to the virtual N_Port data structure.
3709  *   NULL - port create failed.
3710  **/
3711 struct lpfc_vport *
3712 lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
3713 {
3714         struct lpfc_vport *vport;
3715         struct Scsi_Host  *shost = NULL;
3716         int error = 0;
3717         int i;
3718         uint64_t wwn;
3719         bool use_no_reset_hba = false;
3720
3721         wwn = lpfc_get_wwpn(phba);
3722
3723         for (i = 0; i < lpfc_no_hba_reset_cnt; i++) {
3724                 if (wwn == lpfc_no_hba_reset[i]) {
3725                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3726                                         "6020 Setting use_no_reset port=%llx\n",
3727                                         wwn);
3728                         use_no_reset_hba = true;
3729                         break;
3730                 }
3731         }
3732
3733         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP) {
3734                 if (dev != &phba->pcidev->dev) {
3735                         shost = scsi_host_alloc(&lpfc_vport_template,
3736                                                 sizeof(struct lpfc_vport));
3737                 } else {
3738                         if (!use_no_reset_hba)
3739                                 shost = scsi_host_alloc(&lpfc_template,
3740                                                 sizeof(struct lpfc_vport));
3741                         else
3742                                 shost = scsi_host_alloc(&lpfc_template_no_hr,
3743                                                 sizeof(struct lpfc_vport));
3744                 }
3745         } else if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
3746                 shost = scsi_host_alloc(&lpfc_template_nvme,
3747                                         sizeof(struct lpfc_vport));
3748         }
3749         if (!shost)
3750                 goto out;
3751
3752         vport = (struct lpfc_vport *) shost->hostdata;
3753         vport->phba = phba;
3754         vport->load_flag |= FC_LOADING;
3755         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
3756         vport->fc_rscn_flush = 0;
3757         lpfc_get_vport_cfgparam(vport);
3758
3759         shost->unique_id = instance;
3760         shost->max_id = LPFC_MAX_TARGET;
3761         shost->max_lun = vport->cfg_max_luns;
3762         shost->this_id = -1;
3763         shost->max_cmd_len = 16;
3764         shost->nr_hw_queues = phba->cfg_fcp_io_channel;
3765         if (phba->sli_rev == LPFC_SLI_REV4) {
3766                 shost->dma_boundary =
3767                         phba->sli4_hba.pc_sli4_params.sge_supp_len-1;
3768                 shost->sg_tablesize = phba->cfg_sg_seg_cnt;
3769         }
3770
3771         /*
3772          * Set initial can_queue value since 0 is no longer supported and
3773          * scsi_add_host will fail. This will be adjusted later based on the
3774          * max xri value determined in hba setup.
3775          */
3776         shost->can_queue = phba->cfg_hba_queue_depth - 10;
3777         if (dev != &phba->pcidev->dev) {
3778                 shost->transportt = lpfc_vport_transport_template;
3779                 vport->port_type = LPFC_NPIV_PORT;
3780         } else {
3781                 shost->transportt = lpfc_transport_template;
3782                 vport->port_type = LPFC_PHYSICAL_PORT;
3783         }
3784
3785         /* Initialize all internally managed lists. */
3786         INIT_LIST_HEAD(&vport->fc_nodes);
3787         INIT_LIST_HEAD(&vport->rcv_buffer_list);
3788         spin_lock_init(&vport->work_port_lock);
3789
3790         setup_timer(&vport->fc_disctmo, lpfc_disc_timeout,
3791                         (unsigned long)vport);
3792
3793         setup_timer(&vport->els_tmofunc, lpfc_els_timeout,
3794                         (unsigned long)vport);
3795
3796         setup_timer(&vport->delayed_disc_tmo, lpfc_delayed_disc_tmo,
3797                         (unsigned long)vport);
3798
3799         error = scsi_add_host_with_dma(shost, dev, &phba->pcidev->dev);
3800         if (error)
3801                 goto out_put_shost;
3802
3803         spin_lock_irq(&phba->hbalock);
3804         list_add_tail(&vport->listentry, &phba->port_list);
3805         spin_unlock_irq(&phba->hbalock);
3806         return vport;
3807
3808 out_put_shost:
3809         scsi_host_put(shost);
3810 out:
3811         return NULL;
3812 }
3813
3814 /**
3815  * destroy_port -  destroy an FC port
3816  * @vport: pointer to an lpfc virtual N_Port data structure.
3817  *
3818  * This routine destroys a FC port from the upper layer protocol. All the
3819  * resources associated with the port are released.
3820  **/
3821 void
3822 destroy_port(struct lpfc_vport *vport)
3823 {
3824         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3825         struct lpfc_hba  *phba = vport->phba;
3826
3827         lpfc_debugfs_terminate(vport);
3828         fc_remove_host(shost);
3829         scsi_remove_host(shost);
3830
3831         spin_lock_irq(&phba->hbalock);
3832         list_del_init(&vport->listentry);
3833         spin_unlock_irq(&phba->hbalock);
3834
3835         lpfc_cleanup(vport);
3836         return;
3837 }
3838
3839 /**
3840  * lpfc_get_instance - Get a unique integer ID
3841  *
3842  * This routine allocates a unique integer ID from lpfc_hba_index pool. It
3843  * uses the kernel idr facility to perform the task.
3844  *
3845  * Return codes:
3846  *   instance - a unique integer ID allocated as the new instance.
3847  *   -1 - lpfc get instance failed.
3848  **/
3849 int
3850 lpfc_get_instance(void)
3851 {
3852         int ret;
3853
3854         ret = idr_alloc(&lpfc_hba_index, NULL, 0, 0, GFP_KERNEL);
3855         return ret < 0 ? -1 : ret;
3856 }
3857
3858 /**
3859  * lpfc_scan_finished - method for SCSI layer to detect whether scan is done
3860  * @shost: pointer to SCSI host data structure.
3861  * @time: elapsed time of the scan in jiffies.
3862  *
3863  * This routine is called by the SCSI layer with a SCSI host to determine
3864  * whether the scan host is finished.
3865  *
3866  * Note: there is no scan_start function as adapter initialization will have
3867  * asynchronously kicked off the link initialization.
3868  *
3869  * Return codes
3870  *   0 - SCSI host scan is not over yet.
3871  *   1 - SCSI host scan is over.
3872  **/
3873 int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
3874 {
3875         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3876         struct lpfc_hba   *phba = vport->phba;
3877         int stat = 0;
3878
3879         spin_lock_irq(shost->host_lock);
3880
3881         if (vport->load_flag & FC_UNLOADING) {
3882                 stat = 1;
3883                 goto finished;
3884         }
3885         if (time >= msecs_to_jiffies(30 * 1000)) {
3886                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3887                                 "0461 Scanning longer than 30 "
3888                                 "seconds.  Continuing initialization\n");
3889                 stat = 1;
3890                 goto finished;
3891         }
3892         if (time >= msecs_to_jiffies(15 * 1000) &&
3893             phba->link_state <= LPFC_LINK_DOWN) {
3894                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3895                                 "0465 Link down longer than 15 "
3896                                 "seconds.  Continuing initialization\n");
3897                 stat = 1;
3898                 goto finished;
3899         }
3900
3901         if (vport->port_state != LPFC_VPORT_READY)
3902                 goto finished;
3903         if (vport->num_disc_nodes || vport->fc_prli_sent)
3904                 goto finished;
3905         if (vport->fc_map_cnt == 0 && time < msecs_to_jiffies(2 * 1000))
3906                 goto finished;
3907         if ((phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) != 0)
3908                 goto finished;
3909
3910         stat = 1;
3911
3912 finished:
3913         spin_unlock_irq(shost->host_lock);
3914         return stat;
3915 }
3916
3917 /**
3918  * lpfc_host_attrib_init - Initialize SCSI host attributes on a FC port
3919  * @shost: pointer to SCSI host data structure.
3920  *
3921  * This routine initializes a given SCSI host attributes on a FC port. The
3922  * SCSI host can be either on top of a physical port or a virtual port.
3923  **/
3924 void lpfc_host_attrib_init(struct Scsi_Host *shost)
3925 {
3926         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3927         struct lpfc_hba   *phba = vport->phba;
3928         /*
3929          * Set fixed host attributes.  Must done after lpfc_sli_hba_setup().
3930          */
3931
3932         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
3933         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
3934         fc_host_supported_classes(shost) = FC_COS_CLASS3;
3935
3936         memset(fc_host_supported_fc4s(shost), 0,
3937                sizeof(fc_host_supported_fc4s(shost)));
3938         fc_host_supported_fc4s(shost)[2] = 1;
3939         fc_host_supported_fc4s(shost)[7] = 1;
3940
3941         lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
3942                                  sizeof fc_host_symbolic_name(shost));
3943
3944         fc_host_supported_speeds(shost) = 0;
3945         if (phba->lmt & LMT_32Gb)
3946                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_32GBIT;
3947         if (phba->lmt & LMT_16Gb)
3948                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_16GBIT;
3949         if (phba->lmt & LMT_10Gb)
3950                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT;
3951         if (phba->lmt & LMT_8Gb)
3952                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_8GBIT;
3953         if (phba->lmt & LMT_4Gb)
3954                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_4GBIT;
3955         if (phba->lmt & LMT_2Gb)
3956                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_2GBIT;
3957         if (phba->lmt & LMT_1Gb)
3958                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_1GBIT;
3959
3960         fc_host_maxframe_size(shost) =
3961                 (((uint32_t) vport->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
3962                 (uint32_t) vport->fc_sparam.cmn.bbRcvSizeLsb;
3963
3964         fc_host_dev_loss_tmo(shost) = vport->cfg_devloss_tmo;
3965
3966         /* This value is also unchanging */
3967         memset(fc_host_active_fc4s(shost), 0,
3968                sizeof(fc_host_active_fc4s(shost)));
3969         fc_host_active_fc4s(shost)[2] = 1;
3970         fc_host_active_fc4s(shost)[7] = 1;
3971
3972         fc_host_max_npiv_vports(shost) = phba->max_vpi;
3973         spin_lock_irq(shost->host_lock);
3974         vport->load_flag &= ~FC_LOADING;
3975         spin_unlock_irq(shost->host_lock);
3976 }
3977
3978 /**
3979  * lpfc_stop_port_s3 - Stop SLI3 device port
3980  * @phba: pointer to lpfc hba data structure.
3981  *
3982  * This routine is invoked to stop an SLI3 device port, it stops the device
3983  * from generating interrupts and stops the device driver's timers for the
3984  * device.
3985  **/
3986 static void
3987 lpfc_stop_port_s3(struct lpfc_hba *phba)
3988 {
3989         /* Clear all interrupt enable conditions */
3990         writel(0, phba->HCregaddr);
3991         readl(phba->HCregaddr); /* flush */
3992         /* Clear all pending interrupts */
3993         writel(0xffffffff, phba->HAregaddr);
3994         readl(phba->HAregaddr); /* flush */
3995
3996         /* Reset some HBA SLI setup states */
3997         lpfc_stop_hba_timers(phba);
3998         phba->pport->work_port_events = 0;
3999 }
4000
4001 /**
4002  * lpfc_stop_port_s4 - Stop SLI4 device port
4003  * @phba: pointer to lpfc hba data structure.
4004  *
4005  * This routine is invoked to stop an SLI4 device port, it stops the device
4006  * from generating interrupts and stops the device driver's timers for the
4007  * device.
4008  **/
4009 static void
4010 lpfc_stop_port_s4(struct lpfc_hba *phba)
4011 {
4012         /* Reset some HBA SLI4 setup states */
4013         lpfc_stop_hba_timers(phba);
4014         phba->pport->work_port_events = 0;
4015         phba->sli4_hba.intr_enable = 0;
4016 }
4017
4018 /**
4019  * lpfc_stop_port - Wrapper function for stopping hba port
4020  * @phba: Pointer to HBA context object.
4021  *
4022  * This routine wraps the actual SLI3 or SLI4 hba stop port routine from
4023  * the API jump table function pointer from the lpfc_hba struct.
4024  **/
4025 void
4026 lpfc_stop_port(struct lpfc_hba *phba)
4027 {
4028         phba->lpfc_stop_port(phba);
4029 }
4030
4031 /**
4032  * lpfc_fcf_redisc_wait_start_timer - Start fcf rediscover wait timer
4033  * @phba: Pointer to hba for which this call is being executed.
4034  *
4035  * This routine starts the timer waiting for the FCF rediscovery to complete.
4036  **/
4037 void
4038 lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *phba)
4039 {
4040         unsigned long fcf_redisc_wait_tmo =
4041                 (jiffies + msecs_to_jiffies(LPFC_FCF_REDISCOVER_WAIT_TMO));
4042         /* Start fcf rediscovery wait period timer */
4043         mod_timer(&phba->fcf.redisc_wait, fcf_redisc_wait_tmo);
4044         spin_lock_irq(&phba->hbalock);
4045         /* Allow action to new fcf asynchronous event */
4046         phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
4047         /* Mark the FCF rediscovery pending state */
4048         phba->fcf.fcf_flag |= FCF_REDISC_PEND;
4049         spin_unlock_irq(&phba->hbalock);
4050 }
4051
4052 /**
4053  * lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout
4054  * @ptr: Map to lpfc_hba data structure pointer.
4055  *
4056  * This routine is invoked when waiting for FCF table rediscover has been
4057  * timed out. If new FCF record(s) has (have) been discovered during the
4058  * wait period, a new FCF event shall be added to the FCOE async event
4059  * list, and then worker thread shall be waked up for processing from the
4060  * worker thread context.
4061  **/
4062 static void
4063 lpfc_sli4_fcf_redisc_wait_tmo(unsigned long ptr)
4064 {
4065         struct lpfc_hba *phba = (struct lpfc_hba *)ptr;
4066
4067         /* Don't send FCF rediscovery event if timer cancelled */
4068         spin_lock_irq(&phba->hbalock);
4069         if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
4070                 spin_unlock_irq(&phba->hbalock);
4071                 return;
4072         }
4073         /* Clear FCF rediscovery timer pending flag */
4074         phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
4075         /* FCF rediscovery event to worker thread */
4076         phba->fcf.fcf_flag |= FCF_REDISC_EVT;
4077         spin_unlock_irq(&phba->hbalock);
4078         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
4079                         "2776 FCF rediscover quiescent timer expired\n");
4080         /* wake up worker thread */
4081         lpfc_worker_wake_up(phba);
4082 }
4083
4084 /**
4085  * lpfc_sli4_parse_latt_fault - Parse sli4 link-attention link fault code
4086  * @phba: pointer to lpfc hba data structure.
4087  * @acqe_link: pointer to the async link completion queue entry.
4088  *
4089  * This routine is to parse the SLI4 link-attention link fault code and
4090  * translate it into the base driver's read link attention mailbox command
4091  * status.
4092  *
4093  * Return: Link-attention status in terms of base driver's coding.
4094  **/
4095 static uint16_t
4096 lpfc_sli4_parse_latt_fault(struct lpfc_hba *phba,
4097                            struct lpfc_acqe_link *acqe_link)
4098 {
4099         uint16_t latt_fault;
4100
4101         switch (bf_get(lpfc_acqe_link_fault, acqe_link)) {
4102         case LPFC_ASYNC_LINK_FAULT_NONE:
4103         case LPFC_ASYNC_LINK_FAULT_LOCAL:
4104         case LPFC_ASYNC_LINK_FAULT_REMOTE:
4105                 latt_fault = 0;
4106                 break;
4107         default:
4108                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4109                                 "0398 Invalid link fault code: x%x\n",
4110                                 bf_get(lpfc_acqe_link_fault, acqe_link));
4111                 latt_fault = MBXERR_ERROR;
4112                 break;
4113         }
4114         return latt_fault;
4115 }
4116
4117 /**
4118  * lpfc_sli4_parse_latt_type - Parse sli4 link attention type
4119  * @phba: pointer to lpfc hba data structure.
4120  * @acqe_link: pointer to the async link completion queue entry.
4121  *
4122  * This routine is to parse the SLI4 link attention type and translate it
4123  * into the base driver's link attention type coding.
4124  *
4125  * Return: Link attention type in terms of base driver's coding.
4126  **/
4127 static uint8_t
4128 lpfc_sli4_parse_latt_type(struct lpfc_hba *phba,
4129                           struct lpfc_acqe_link *acqe_link)
4130 {
4131         uint8_t att_type;
4132
4133         switch (bf_get(lpfc_acqe_link_status, acqe_link)) {
4134         case LPFC_ASYNC_LINK_STATUS_DOWN:
4135         case LPFC_ASYNC_LINK_STATUS_LOGICAL_DOWN:
4136                 att_type = LPFC_ATT_LINK_DOWN;
4137                 break;
4138         case LPFC_ASYNC_LINK_STATUS_UP:
4139                 /* Ignore physical link up events - wait for logical link up */
4140                 att_type = LPFC_ATT_RESERVED;
4141                 break;
4142         case LPFC_ASYNC_LINK_STATUS_LOGICAL_UP:
4143                 att_type = LPFC_ATT_LINK_UP;
4144                 break;
4145         default:
4146                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4147                                 "0399 Invalid link attention type: x%x\n",
4148                                 bf_get(lpfc_acqe_link_status, acqe_link));
4149                 att_type = LPFC_ATT_RESERVED;
4150                 break;
4151         }
4152         return att_type;
4153 }
4154
4155 /**
4156  * lpfc_sli_port_speed_get - Get sli3 link speed code to link speed
4157  * @phba: pointer to lpfc hba data structure.
4158  *
4159  * This routine is to get an SLI3 FC port's link speed in Mbps.
4160  *
4161  * Return: link speed in terms of Mbps.
4162  **/
4163 uint32_t
4164 lpfc_sli_port_speed_get(struct lpfc_hba *phba)
4165 {
4166         uint32_t link_speed;
4167
4168         if (!lpfc_is_link_up(phba))
4169                 return 0;
4170
4171         if (phba->sli_rev <= LPFC_SLI_REV3) {
4172                 switch (phba->fc_linkspeed) {
4173                 case LPFC_LINK_SPEED_1GHZ:
4174                         link_speed = 1000;
4175                         break;
4176                 case LPFC_LINK_SPEED_2GHZ:
4177                         link_speed = 2000;
4178                         break;
4179                 case LPFC_LINK_SPEED_4GHZ:
4180                         link_speed = 4000;
4181                         break;
4182                 case LPFC_LINK_SPEED_8GHZ:
4183                         link_speed = 8000;
4184                         break;
4185                 case LPFC_LINK_SPEED_10GHZ:
4186                         link_speed = 10000;
4187                         break;
4188                 case LPFC_LINK_SPEED_16GHZ:
4189                         link_speed = 16000;
4190                         break;
4191                 default:
4192                         link_speed = 0;
4193                 }
4194         } else {
4195                 if (phba->sli4_hba.link_state.logical_speed)
4196                         link_speed =
4197                               phba->sli4_hba.link_state.logical_speed;
4198                 else
4199                         link_speed = phba->sli4_hba.link_state.speed;
4200         }
4201         return link_speed;
4202 }
4203
4204 /**
4205  * lpfc_sli4_port_speed_parse - Parse async evt link speed code to link speed
4206  * @phba: pointer to lpfc hba data structure.
4207  * @evt_code: asynchronous event code.
4208  * @speed_code: asynchronous event link speed code.
4209  *
4210  * This routine is to parse the giving SLI4 async event link speed code into
4211  * value of Mbps for the link speed.
4212  *
4213  * Return: link speed in terms of Mbps.
4214  **/
4215 static uint32_t
4216 lpfc_sli4_port_speed_parse(struct lpfc_hba *phba, uint32_t evt_code,
4217                            uint8_t speed_code)
4218 {
4219         uint32_t port_speed;
4220
4221         switch (evt_code) {
4222         case LPFC_TRAILER_CODE_LINK:
4223                 switch (speed_code) {
4224                 case LPFC_ASYNC_LINK_SPEED_ZERO:
4225                         port_speed = 0;
4226                         break;
4227                 case LPFC_ASYNC_LINK_SPEED_10MBPS:
4228                         port_speed = 10;
4229                         break;
4230                 case LPFC_ASYNC_LINK_SPEED_100MBPS:
4231                         port_speed = 100;
4232                         break;
4233                 case LPFC_ASYNC_LINK_SPEED_1GBPS:
4234                         port_speed = 1000;
4235                         break;
4236                 case LPFC_ASYNC_LINK_SPEED_10GBPS:
4237                         port_speed = 10000;
4238                         break;
4239                 case LPFC_ASYNC_LINK_SPEED_20GBPS:
4240                         port_speed = 20000;
4241                         break;
4242                 case LPFC_ASYNC_LINK_SPEED_25GBPS:
4243                         port_speed = 25000;
4244                         break;
4245                 case LPFC_ASYNC_LINK_SPEED_40GBPS:
4246                         port_speed = 40000;
4247                         break;
4248                 default:
4249                         port_speed = 0;
4250                 }
4251                 break;
4252         case LPFC_TRAILER_CODE_FC:
4253                 switch (speed_code) {
4254                 case LPFC_FC_LA_SPEED_UNKNOWN:
4255                         port_speed = 0;
4256                         break;
4257                 case LPFC_FC_LA_SPEED_1G:
4258                         port_speed = 1000;
4259                         break;
4260                 case LPFC_FC_LA_SPEED_2G:
4261                         port_speed = 2000;
4262                         break;
4263                 case LPFC_FC_LA_SPEED_4G:
4264                         port_speed = 4000;
4265                         break;
4266                 case LPFC_FC_LA_SPEED_8G:
4267                         port_speed = 8000;
4268                         break;
4269                 case LPFC_FC_LA_SPEED_10G:
4270                         port_speed = 10000;
4271                         break;
4272                 case LPFC_FC_LA_SPEED_16G:
4273                         port_speed = 16000;
4274                         break;
4275                 case LPFC_FC_LA_SPEED_32G:
4276                         port_speed = 32000;
4277                         break;
4278                 default:
4279                         port_speed = 0;
4280                 }
4281                 break;
4282         default:
4283                 port_speed = 0;
4284         }
4285         return port_speed;
4286 }
4287
4288 /**
4289  * lpfc_sli4_async_link_evt - Process the asynchronous FCoE link event
4290  * @phba: pointer to lpfc hba data structure.
4291  * @acqe_link: pointer to the async link completion queue entry.
4292  *
4293  * This routine is to handle the SLI4 asynchronous FCoE link event.
4294  **/
4295 static void
4296 lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
4297                          struct lpfc_acqe_link *acqe_link)
4298 {
4299         struct lpfc_dmabuf *mp;
4300         LPFC_MBOXQ_t *pmb;
4301         MAILBOX_t *mb;
4302         struct lpfc_mbx_read_top *la;
4303         uint8_t att_type;
4304         int rc;
4305
4306         att_type = lpfc_sli4_parse_latt_type(phba, acqe_link);
4307         if (att_type != LPFC_ATT_LINK_DOWN && att_type != LPFC_ATT_LINK_UP)
4308                 return;
4309         phba->fcoe_eventtag = acqe_link->event_tag;
4310         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4311         if (!pmb) {
4312                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4313                                 "0395 The mboxq allocation failed\n");
4314                 return;
4315         }
4316         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
4317         if (!mp) {
4318                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4319                                 "0396 The lpfc_dmabuf allocation failed\n");
4320                 goto out_free_pmb;
4321         }
4322         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
4323         if (!mp->virt) {
4324                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4325                                 "0397 The mbuf allocation failed\n");
4326                 goto out_free_dmabuf;
4327         }
4328
4329         /* Cleanup any outstanding ELS commands */
4330         lpfc_els_flush_all_cmd(phba);
4331
4332         /* Block ELS IOCBs until we have done process link event */
4333         phba->sli4_hba.els_wq->pring->flag |= LPFC_STOP_IOCB_EVENT;
4334
4335         /* Update link event statistics */
4336         phba->sli.slistat.link_event++;
4337
4338         /* Create lpfc_handle_latt mailbox command from link ACQE */
4339         lpfc_read_topology(phba, pmb, mp);
4340         pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
4341         pmb->vport = phba->pport;
4342
4343         /* Keep the link status for extra SLI4 state machine reference */
4344         phba->sli4_hba.link_state.speed =
4345                         lpfc_sli4_port_speed_parse(phba, LPFC_TRAILER_CODE_LINK,
4346                                 bf_get(lpfc_acqe_link_speed, acqe_link));
4347         phba->sli4_hba.link_state.duplex =
4348                                 bf_get(lpfc_acqe_link_duplex, acqe_link);
4349         phba->sli4_hba.link_state.status =
4350                                 bf_get(lpfc_acqe_link_status, acqe_link);
4351         phba->sli4_hba.link_state.type =
4352                                 bf_get(lpfc_acqe_link_type, acqe_link);
4353         phba->sli4_hba.link_state.number =
4354                                 bf_get(lpfc_acqe_link_number, acqe_link);
4355         phba->sli4_hba.link_state.fault =
4356                                 bf_get(lpfc_acqe_link_fault, acqe_link);
4357         phba->sli4_hba.link_state.logical_speed =
4358                         bf_get(lpfc_acqe_logical_link_speed, acqe_link) * 10;
4359
4360         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4361                         "2900 Async FC/FCoE Link event - Speed:%dGBit "
4362                         "duplex:x%x LA Type:x%x Port Type:%d Port Number:%d "
4363                         "Logical speed:%dMbps Fault:%d\n",
4364                         phba->sli4_hba.link_state.speed,
4365                         phba->sli4_hba.link_state.topology,
4366                         phba->sli4_hba.link_state.status,
4367                         phba->sli4_hba.link_state.type,
4368                         phba->sli4_hba.link_state.number,
4369                         phba->sli4_hba.link_state.logical_speed,
4370                         phba->sli4_hba.link_state.fault);
4371         /*
4372          * For FC Mode: issue the READ_TOPOLOGY mailbox command to fetch
4373          * topology info. Note: Optional for non FC-AL ports.
4374          */
4375         if (!(phba->hba_flag & HBA_FCOE_MODE)) {
4376                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
4377                 if (rc == MBX_NOT_FINISHED)
4378                         goto out_free_dmabuf;
4379                 return;
4380         }
4381         /*
4382          * For FCoE Mode: fill in all the topology information we need and call
4383          * the READ_TOPOLOGY completion routine to continue without actually
4384          * sending the READ_TOPOLOGY mailbox command to the port.
4385          */
4386         /* Parse and translate status field */
4387         mb = &pmb->u.mb;
4388         mb->mbxStatus = lpfc_sli4_parse_latt_fault(phba, acqe_link);
4389
4390         /* Parse and translate link attention fields */
4391         la = (struct lpfc_mbx_read_top *) &pmb->u.mb.un.varReadTop;
4392         la->eventTag = acqe_link->event_tag;
4393         bf_set(lpfc_mbx_read_top_att_type, la, att_type);
4394         bf_set(lpfc_mbx_read_top_link_spd, la,
4395                (bf_get(lpfc_acqe_link_speed, acqe_link)));
4396
4397         /* Fake the the following irrelvant fields */
4398         bf_set(lpfc_mbx_read_top_topology, la, LPFC_TOPOLOGY_PT_PT);
4399         bf_set(lpfc_mbx_read_top_alpa_granted, la, 0);
4400         bf_set(lpfc_mbx_read_top_il, la, 0);
4401         bf_set(lpfc_mbx_read_top_pb, la, 0);
4402         bf_set(lpfc_mbx_read_top_fa, la, 0);
4403         bf_set(lpfc_mbx_read_top_mm, la, 0);
4404
4405         /* Invoke the lpfc_handle_latt mailbox command callback function */
4406         lpfc_mbx_cmpl_read_topology(phba, pmb);
4407
4408         return;
4409
4410 out_free_dmabuf:
4411         kfree(mp);
4412 out_free_pmb:
4413         mempool_free(pmb, phba->mbox_mem_pool);
4414 }
4415
4416 /**
4417  * lpfc_sli4_async_fc_evt - Process the asynchronous FC link event
4418  * @phba: pointer to lpfc hba data structure.
4419  * @acqe_fc: pointer to the async fc completion queue entry.
4420  *
4421  * This routine is to handle the SLI4 asynchronous FC event. It will simply log
4422  * that the event was received and then issue a read_topology mailbox command so
4423  * that the rest of the driver will treat it the same as SLI3.
4424  **/
4425 static void
4426 lpfc_sli4_async_fc_evt(struct lpfc_hba *phba, struct lpfc_acqe_fc_la *acqe_fc)
4427 {
4428         struct lpfc_dmabuf *mp;
4429         LPFC_MBOXQ_t *pmb;
4430         MAILBOX_t *mb;
4431         struct lpfc_mbx_read_top *la;
4432         int rc;
4433
4434         if (bf_get(lpfc_trailer_type, acqe_fc) !=
4435             LPFC_FC_LA_EVENT_TYPE_FC_LINK) {
4436                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4437                                 "2895 Non FC link Event detected.(%d)\n",
4438                                 bf_get(lpfc_trailer_type, acqe_fc));
4439                 return;
4440         }
4441         /* Keep the link status for extra SLI4 state machine reference */
4442         phba->sli4_hba.link_state.speed =
4443                         lpfc_sli4_port_speed_parse(phba, LPFC_TRAILER_CODE_FC,
4444                                 bf_get(lpfc_acqe_fc_la_speed, acqe_fc));
4445         phba->sli4_hba.link_state.duplex = LPFC_ASYNC_LINK_DUPLEX_FULL;
4446         phba->sli4_hba.link_state.topology =
4447                                 bf_get(lpfc_acqe_fc_la_topology, acqe_fc);
4448         phba->sli4_hba.link_state.status =
4449                                 bf_get(lpfc_acqe_fc_la_att_type, acqe_fc);
4450         phba->sli4_hba.link_state.type =
4451                                 bf_get(lpfc_acqe_fc_la_port_type, acqe_fc);
4452         phba->sli4_hba.link_state.number =
4453                                 bf_get(lpfc_acqe_fc_la_port_number, acqe_fc);
4454         phba->sli4_hba.link_state.fault =
4455                                 bf_get(lpfc_acqe_link_fault, acqe_fc);
4456         phba->sli4_hba.link_state.logical_speed =
4457                                 bf_get(lpfc_acqe_fc_la_llink_spd, acqe_fc) * 10;
4458         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4459                         "2896 Async FC event - Speed:%dGBaud Topology:x%x "
4460                         "LA Type:x%x Port Type:%d Port Number:%d Logical speed:"
4461                         "%dMbps Fault:%d\n",
4462                         phba->sli4_hba.link_state.speed,
4463                         phba->sli4_hba.link_state.topology,
4464                         phba->sli4_hba.link_state.status,
4465                         phba->sli4_hba.link_state.type,
4466                         phba->sli4_hba.link_state.number,
4467                         phba->sli4_hba.link_state.logical_speed,
4468                         phba->sli4_hba.link_state.fault);
4469         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4470         if (!pmb) {
4471                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4472                                 "2897 The mboxq allocation failed\n");
4473                 return;
4474         }
4475         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
4476         if (!mp) {
4477                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4478                                 "2898 The lpfc_dmabuf allocation failed\n");
4479                 goto out_free_pmb;
4480         }
4481         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
4482         if (!mp->virt) {
4483                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4484                                 "2899 The mbuf allocation failed\n");
4485                 goto out_free_dmabuf;
4486         }
4487
4488         /* Cleanup any outstanding ELS commands */
4489         lpfc_els_flush_all_cmd(phba);
4490
4491         /* Block ELS IOCBs until we have done process link event */
4492         phba->sli4_hba.els_wq->pring->flag |= LPFC_STOP_IOCB_EVENT;
4493
4494         /* Update link event statistics */
4495         phba->sli.slistat.link_event++;
4496
4497         /* Create lpfc_handle_latt mailbox command from link ACQE */
4498         lpfc_read_topology(phba, pmb, mp);
4499         pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology;
4500         pmb->vport = phba->pport;
4501
4502         if (phba->sli4_hba.link_state.status != LPFC_FC_LA_TYPE_LINK_UP) {
4503                 /* Parse and translate status field */
4504                 mb = &pmb->u.mb;
4505                 mb->mbxStatus = lpfc_sli4_parse_latt_fault(phba,
4506                                                            (void *)acqe_fc);
4507
4508                 /* Parse and translate link attention fields */
4509                 la = (struct lpfc_mbx_read_top *)&pmb->u.mb.un.varReadTop;
4510                 la->eventTag = acqe_fc->event_tag;
4511                 bf_set(lpfc_mbx_read_top_att_type, la,
4512                        LPFC_FC_LA_TYPE_LINK_DOWN);
4513
4514                 /* Invoke the mailbox command callback function */
4515                 lpfc_mbx_cmpl_read_topology(phba, pmb);
4516
4517                 return;
4518         }
4519
4520         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
4521         if (rc == MBX_NOT_FINISHED)
4522                 goto out_free_dmabuf;
4523         return;
4524
4525 out_free_dmabuf:
4526         kfree(mp);
4527 out_free_pmb:
4528         mempool_free(pmb, phba->mbox_mem_pool);
4529 }
4530
4531 /**
4532  * lpfc_sli4_async_sli_evt - Process the asynchronous SLI link event
4533  * @phba: pointer to lpfc hba data structure.
4534  * @acqe_fc: pointer to the async SLI completion queue entry.
4535  *
4536  * This routine is to handle the SLI4 asynchronous SLI events.
4537  **/
4538 static void
4539 lpfc_sli4_async_sli_evt(struct lpfc_hba *phba, struct lpfc_acqe_sli *acqe_sli)
4540 {
4541         char port_name;
4542         char message[128];
4543         uint8_t status;
4544         uint8_t evt_type;
4545         uint8_t operational = 0;
4546         struct temp_event temp_event_data;
4547         struct lpfc_acqe_misconfigured_event *misconfigured;
4548         struct Scsi_Host  *shost;
4549
4550         evt_type = bf_get(lpfc_trailer_type, acqe_sli);
4551
4552         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4553                         "2901 Async SLI event - Event Data1:x%08x Event Data2:"
4554                         "x%08x SLI Event Type:%d\n",
4555                         acqe_sli->event_data1, acqe_sli->event_data2,
4556                         evt_type);
4557
4558         port_name = phba->Port[0];
4559         if (port_name == 0x00)
4560                 port_name = '?'; /* get port name is empty */
4561
4562         switch (evt_type) {
4563         case LPFC_SLI_EVENT_TYPE_OVER_TEMP:
4564                 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
4565                 temp_event_data.event_code = LPFC_THRESHOLD_TEMP;
4566                 temp_event_data.data = (uint32_t)acqe_sli->event_data1;
4567
4568                 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
4569                                 "3190 Over Temperature:%d Celsius- Port Name %c\n",
4570                                 acqe_sli->event_data1, port_name);
4571
4572                 phba->sfp_warning |= LPFC_TRANSGRESSION_HIGH_TEMPERATURE;
4573                 shost = lpfc_shost_from_vport(phba->pport);
4574                 fc_host_post_vendor_event(shost, fc_get_event_number(),
4575                                           sizeof(temp_event_data),
4576                                           (char *)&temp_event_data,
4577                                           SCSI_NL_VID_TYPE_PCI
4578                                           | PCI_VENDOR_ID_EMULEX);
4579                 break;
4580         case LPFC_SLI_EVENT_TYPE_NORM_TEMP:
4581                 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
4582                 temp_event_data.event_code = LPFC_NORMAL_TEMP;
4583                 temp_event_data.data = (uint32_t)acqe_sli->event_data1;
4584
4585                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4586                                 "3191 Normal Temperature:%d Celsius - Port Name %c\n",
4587                                 acqe_sli->event_data1, port_name);
4588
4589                 shost = lpfc_shost_from_vport(phba->pport);
4590                 fc_host_post_vendor_event(shost, fc_get_event_number(),
4591                                           sizeof(temp_event_data),
4592                                           (char *)&temp_event_data,
4593                                           SCSI_NL_VID_TYPE_PCI
4594                                           | PCI_VENDOR_ID_EMULEX);
4595                 break;
4596         case LPFC_SLI_EVENT_TYPE_MISCONFIGURED:
4597                 misconfigured = (struct lpfc_acqe_misconfigured_event *)
4598                                         &acqe_sli->event_data1;
4599
4600                 /* fetch the status for this port */
4601                 switch (phba->sli4_hba.lnk_info.lnk_no) {
4602                 case LPFC_LINK_NUMBER_0:
4603                         status = bf_get(lpfc_sli_misconfigured_port0_state,
4604                                         &misconfigured->theEvent);
4605                         operational = bf_get(lpfc_sli_misconfigured_port0_op,
4606                                         &misconfigured->theEvent);
4607                         break;
4608                 case LPFC_LINK_NUMBER_1:
4609                         status = bf_get(lpfc_sli_misconfigured_port1_state,
4610                                         &misconfigured->theEvent);
4611                         operational = bf_get(lpfc_sli_misconfigured_port1_op,
4612                                         &misconfigured->theEvent);
4613                         break;
4614                 case LPFC_LINK_NUMBER_2:
4615                         status = bf_get(lpfc_sli_misconfigured_port2_state,
4616                                         &misconfigured->theEvent);
4617                         operational = bf_get(lpfc_sli_misconfigured_port2_op,
4618                                         &misconfigured->theEvent);
4619                         break;
4620                 case LPFC_LINK_NUMBER_3:
4621                         status = bf_get(lpfc_sli_misconfigured_port3_state,
4622                                         &misconfigured->theEvent);
4623                         operational = bf_get(lpfc_sli_misconfigured_port3_op,
4624                                         &misconfigured->theEvent);
4625                         break;
4626                 default:
4627                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4628                                         "3296 "
4629                                         "LPFC_SLI_EVENT_TYPE_MISCONFIGURED "
4630                                         "event: Invalid link %d",
4631                                         phba->sli4_hba.lnk_info.lnk_no);
4632                         return;
4633                 }
4634
4635                 /* Skip if optic state unchanged */
4636                 if (phba->sli4_hba.lnk_info.optic_state == status)
4637                         return;
4638
4639                 switch (status) {
4640                 case LPFC_SLI_EVENT_STATUS_VALID:
4641                         sprintf(message, "Physical Link is functional");
4642                         break;
4643                 case LPFC_SLI_EVENT_STATUS_NOT_PRESENT:
4644                         sprintf(message, "Optics faulted/incorrectly "
4645                                 "installed/not installed - Reseat optics, "
4646                                 "if issue not resolved, replace.");
4647                         break;
4648                 case LPFC_SLI_EVENT_STATUS_WRONG_TYPE:
4649                         sprintf(message,
4650                                 "Optics of two types installed - Remove one "
4651                                 "optic or install matching pair of optics.");
4652                         break;
4653                 case LPFC_SLI_EVENT_STATUS_UNSUPPORTED:
4654                         sprintf(message, "Incompatible optics - Replace with "
4655                                 "compatible optics for card to function.");
4656                         break;
4657                 case LPFC_SLI_EVENT_STATUS_UNQUALIFIED:
4658                         sprintf(message, "Unqualified optics - Replace with "
4659                                 "Avago optics for Warranty and Technical "
4660                                 "Support - Link is%s operational",
4661                                 (operational) ? " not" : "");
4662                         break;
4663                 case LPFC_SLI_EVENT_STATUS_UNCERTIFIED:
4664                         sprintf(message, "Uncertified optics - Replace with "
4665                                 "Avago-certified optics to enable link "
4666                                 "operation - Link is%s operational",
4667                                 (operational) ? " not" : "");
4668                         break;
4669                 default:
4670                         /* firmware is reporting a status we don't know about */
4671                         sprintf(message, "Unknown event status x%02x", status);
4672                         break;
4673                 }
4674                 phba->sli4_hba.lnk_info.optic_state = status;
4675                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4676                                 "3176 Port Name %c %s\n", port_name, message);
4677                 break;
4678         case LPFC_SLI_EVENT_TYPE_REMOTE_DPORT:
4679                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4680                                 "3192 Remote DPort Test Initiated - "
4681                                 "Event Data1:x%08x Event Data2: x%08x\n",
4682                                 acqe_sli->event_data1, acqe_sli->event_data2);
4683                 break;
4684         default:
4685                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4686                                 "3193 Async SLI event - Event Data1:x%08x Event Data2:"
4687                                 "x%08x SLI Event Type:%d\n",
4688                                 acqe_sli->event_data1, acqe_sli->event_data2,
4689                                 evt_type);
4690                 break;
4691         }
4692 }
4693
4694 /**
4695  * lpfc_sli4_perform_vport_cvl - Perform clear virtual link on a vport
4696  * @vport: pointer to vport data structure.
4697  *
4698  * This routine is to perform Clear Virtual Link (CVL) on a vport in
4699  * response to a CVL event.
4700  *
4701  * Return the pointer to the ndlp with the vport if successful, otherwise
4702  * return NULL.
4703  **/
4704 static struct lpfc_nodelist *
4705 lpfc_sli4_perform_vport_cvl(struct lpfc_vport *vport)
4706 {
4707         struct lpfc_nodelist *ndlp;
4708         struct Scsi_Host *shost;
4709         struct lpfc_hba *phba;
4710
4711         if (!vport)
4712                 return NULL;
4713         phba = vport->phba;
4714         if (!phba)
4715                 return NULL;
4716         ndlp = lpfc_findnode_did(vport, Fabric_DID);
4717         if (!ndlp) {
4718                 /* Cannot find existing Fabric ndlp, so allocate a new one */
4719                 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
4720                 if (!ndlp)
4721                         return 0;
4722                 lpfc_nlp_init(vport, ndlp, Fabric_DID);
4723                 /* Set the node type */
4724                 ndlp->nlp_type |= NLP_FABRIC;
4725                 /* Put ndlp onto node list */
4726                 lpfc_enqueue_node(vport, ndlp);
4727         } else if (!NLP_CHK_NODE_ACT(ndlp)) {
4728                 /* re-setup ndlp without removing from node list */
4729                 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE);
4730                 if (!ndlp)
4731                         return 0;
4732         }
4733         if ((phba->pport->port_state < LPFC_FLOGI) &&
4734                 (phba->pport->port_state != LPFC_VPORT_FAILED))
4735                 return NULL;
4736         /* If virtual link is not yet instantiated ignore CVL */
4737         if ((vport != phba->pport) && (vport->port_state < LPFC_FDISC)
4738                 && (vport->port_state != LPFC_VPORT_FAILED))
4739                 return NULL;
4740         shost = lpfc_shost_from_vport(vport);
4741         if (!shost)
4742                 return NULL;
4743         lpfc_linkdown_port(vport);
4744         lpfc_cleanup_pending_mbox(vport);
4745         spin_lock_irq(shost->host_lock);
4746         vport->fc_flag |= FC_VPORT_CVL_RCVD;
4747         spin_unlock_irq(shost->host_lock);
4748
4749         return ndlp;
4750 }
4751
4752 /**
4753  * lpfc_sli4_perform_all_vport_cvl - Perform clear virtual link on all vports
4754  * @vport: pointer to lpfc hba data structure.
4755  *
4756  * This routine is to perform Clear Virtual Link (CVL) on all vports in
4757  * response to a FCF dead event.
4758  **/
4759 static void
4760 lpfc_sli4_perform_all_vport_cvl(struct lpfc_hba *phba)
4761 {
4762         struct lpfc_vport **vports;
4763         int i;
4764
4765         vports = lpfc_create_vport_work_array(phba);
4766         if (vports)
4767                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
4768                         lpfc_sli4_perform_vport_cvl(vports[i]);
4769         lpfc_destroy_vport_work_array(phba, vports);
4770 }
4771
4772 /**
4773  * lpfc_sli4_async_fip_evt - Process the asynchronous FCoE FIP event
4774  * @phba: pointer to lpfc hba data structure.
4775  * @acqe_link: pointer to the async fcoe completion queue entry.
4776  *
4777  * This routine is to handle the SLI4 asynchronous fcoe event.
4778  **/
4779 static void
4780 lpfc_sli4_async_fip_evt(struct lpfc_hba *phba,
4781                         struct lpfc_acqe_fip *acqe_fip)
4782 {
4783         uint8_t event_type = bf_get(lpfc_trailer_type, acqe_fip);
4784         int rc;
4785         struct lpfc_vport *vport;
4786         struct lpfc_nodelist *ndlp;
4787         struct Scsi_Host  *shost;
4788         int active_vlink_present;
4789         struct lpfc_vport **vports;
4790         int i;
4791
4792         phba->fc_eventTag = acqe_fip->event_tag;
4793         phba->fcoe_eventtag = acqe_fip->event_tag;
4794         switch (event_type) {
4795         case LPFC_FIP_EVENT_TYPE_NEW_FCF:
4796         case LPFC_FIP_EVENT_TYPE_FCF_PARAM_MOD:
4797                 if (event_type == LPFC_FIP_EVENT_TYPE_NEW_FCF)
4798                         lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
4799                                         LOG_DISCOVERY,
4800                                         "2546 New FCF event, evt_tag:x%x, "
4801                                         "index:x%x\n",
4802                                         acqe_fip->event_tag,
4803                                         acqe_fip->index);
4804                 else
4805                         lpfc_printf_log(phba, KERN_WARNING, LOG_FIP |
4806                                         LOG_DISCOVERY,
4807                                         "2788 FCF param modified event, "
4808                                         "evt_tag:x%x, index:x%x\n",
4809                                         acqe_fip->event_tag,
4810                                         acqe_fip->index);
4811                 if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
4812                         /*
4813                          * During period of FCF discovery, read the FCF
4814                          * table record indexed by the event to update
4815                          * FCF roundrobin failover eligible FCF bmask.
4816                          */
4817                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
4818                                         LOG_DISCOVERY,
4819                                         "2779 Read FCF (x%x) for updating "
4820                                         "roundrobin FCF failover bmask\n",
4821                                         acqe_fip->index);
4822                         rc = lpfc_sli4_read_fcf_rec(phba, acqe_fip->index);
4823                 }
4824
4825                 /* If the FCF discovery is in progress, do nothing. */
4826                 spin_lock_irq(&phba->hbalock);
4827                 if (phba->hba_flag & FCF_TS_INPROG) {
4828                         spin_unlock_irq(&phba->hbalock);
4829                         break;
4830                 }
4831                 /* If fast FCF failover rescan event is pending, do nothing */
4832                 if (phba->fcf.fcf_flag & FCF_REDISC_EVT) {
4833                         spin_unlock_irq(&phba->hbalock);
4834                         break;
4835                 }
4836
4837                 /* If the FCF has been in discovered state, do nothing. */
4838                 if (phba->fcf.fcf_flag & FCF_SCAN_DONE) {
4839                         spin_unlock_irq(&phba->hbalock);
4840                         break;
4841                 }
4842                 spin_unlock_irq(&phba->hbalock);
4843
4844                 /* Otherwise, scan the entire FCF table and re-discover SAN */
4845                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
4846                                 "2770 Start FCF table scan per async FCF "
4847                                 "event, evt_tag:x%x, index:x%x\n",
4848                                 acqe_fip->event_tag, acqe_fip->index);
4849                 rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,
4850                                                      LPFC_FCOE_FCF_GET_FIRST);
4851                 if (rc)
4852                         lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
4853                                         "2547 Issue FCF scan read FCF mailbox "
4854                                         "command failed (x%x)\n", rc);
4855                 break;
4856
4857         case LPFC_FIP_EVENT_TYPE_FCF_TABLE_FULL:
4858                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4859                         "2548 FCF Table full count 0x%x tag 0x%x\n",
4860                         bf_get(lpfc_acqe_fip_fcf_count, acqe_fip),
4861                         acqe_fip->event_tag);
4862                 break;
4863
4864         case LPFC_FIP_EVENT_TYPE_FCF_DEAD:
4865                 phba->fcoe_cvl_eventtag = acqe_fip->event_tag;
4866                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
4867                         "2549 FCF (x%x) disconnected from network, "
4868                         "tag:x%x\n", acqe_fip->index, acqe_fip->event_tag);
4869                 /*
4870                  * If we are in the middle of FCF failover process, clear
4871                  * the corresponding FCF bit in the roundrobin bitmap.
4872                  */
4873                 spin_lock_irq(&phba->hbalock);
4874                 if ((phba->fcf.fcf_flag & FCF_DISCOVERY) &&
4875                     (phba->fcf.current_rec.fcf_indx != acqe_fip->index)) {
4876                         spin_unlock_irq(&phba->hbalock);
4877                         /* Update FLOGI FCF failover eligible FCF bmask */
4878                         lpfc_sli4_fcf_rr_index_clear(phba, acqe_fip->index);
4879                         break;
4880                 }
4881                 spin_unlock_irq(&phba->hbalock);
4882
4883                 /* If the event is not for currently used fcf do nothing */
4884                 if (phba->fcf.current_rec.fcf_indx != acqe_fip->index)
4885                         break;
4886
4887                 /*
4888                  * Otherwise, request the port to rediscover the entire FCF
4889                  * table for a fast recovery from case that the current FCF
4890                  * is no longer valid as we are not in the middle of FCF
4891                  * failover process already.
4892                  */
4893                 spin_lock_irq(&phba->hbalock);
4894                 /* Mark the fast failover process in progress */
4895                 phba->fcf.fcf_flag |= FCF_DEAD_DISC;
4896                 spin_unlock_irq(&phba->hbalock);
4897
4898                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
4899                                 "2771 Start FCF fast failover process due to "
4900                                 "FCF DEAD event: evt_tag:x%x, fcf_index:x%x "
4901                                 "\n", acqe_fip->event_tag, acqe_fip->index);
4902                 rc = lpfc_sli4_redisc_fcf_table(phba);
4903                 if (rc) {
4904                         lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
4905                                         LOG_DISCOVERY,
4906                                         "2772 Issue FCF rediscover mabilbox "
4907                                         "command failed, fail through to FCF "
4908                                         "dead event\n");
4909                         spin_lock_irq(&phba->hbalock);
4910                         phba->fcf.fcf_flag &= ~FCF_DEAD_DISC;
4911                         spin_unlock_irq(&phba->hbalock);
4912                         /*
4913                          * Last resort will fail over by treating this
4914                          * as a link down to FCF registration.
4915                          */
4916                         lpfc_sli4_fcf_dead_failthrough(phba);
4917                 } else {
4918                         /* Reset FCF roundrobin bmask for new discovery */
4919                         lpfc_sli4_clear_fcf_rr_bmask(phba);
4920                         /*
4921                          * Handling fast FCF failover to a DEAD FCF event is
4922                          * considered equalivant to receiving CVL to all vports.
4923                          */
4924                         lpfc_sli4_perform_all_vport_cvl(phba);
4925                 }
4926                 break;
4927         case LPFC_FIP_EVENT_TYPE_CVL:
4928                 phba->fcoe_cvl_eventtag = acqe_fip->event_tag;
4929                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
4930                         "2718 Clear Virtual Link Received for VPI 0x%x"
4931                         " tag 0x%x\n", acqe_fip->index, acqe_fip->event_tag);
4932
4933                 vport = lpfc_find_vport_by_vpid(phba,
4934                                                 acqe_fip->index);
4935                 ndlp = lpfc_sli4_perform_vport_cvl(vport);
4936                 if (!ndlp)
4937                         break;
4938                 active_vlink_present = 0;
4939
4940                 vports = lpfc_create_vport_work_array(phba);
4941                 if (vports) {
4942                         for (i = 0; i <= phba->max_vports && vports[i] != NULL;
4943                                         i++) {
4944                                 if ((!(vports[i]->fc_flag &
4945                                         FC_VPORT_CVL_RCVD)) &&
4946                                         (vports[i]->port_state > LPFC_FDISC)) {
4947                                         active_vlink_present = 1;
4948                                         break;
4949                                 }
4950                         }
4951                         lpfc_destroy_vport_work_array(phba, vports);
4952                 }
4953
4954                 /*
4955                  * Don't re-instantiate if vport is marked for deletion.
4956                  * If we are here first then vport_delete is going to wait
4957                  * for discovery to complete.
4958                  */
4959                 if (!(vport->load_flag & FC_UNLOADING) &&
4960                                         active_vlink_present) {
4961                         /*
4962                          * If there are other active VLinks present,
4963                          * re-instantiate the Vlink using FDISC.
4964                          */
4965                         mod_timer(&ndlp->nlp_delayfunc,
4966                                   jiffies + msecs_to_jiffies(1000));
4967                         shost = lpfc_shost_from_vport(vport);
4968                         spin_lock_irq(shost->host_lock);
4969                         ndlp->nlp_flag |= NLP_DELAY_TMO;
4970                         spin_unlock_irq(shost->host_lock);
4971                         ndlp->nlp_last_elscmd = ELS_CMD_FDISC;
4972                         vport->port_state = LPFC_FDISC;
4973                 } else {
4974                         /*
4975                          * Otherwise, we request port to rediscover
4976                          * the entire FCF table for a fast recovery
4977                          * from possible case that the current FCF
4978                          * is no longer valid if we are not already
4979                          * in the FCF failover process.
4980                          */
4981                         spin_lock_irq(&phba->hbalock);
4982                         if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
4983                                 spin_unlock_irq(&phba->hbalock);
4984                                 break;
4985                         }
4986                         /* Mark the fast failover process in progress */
4987                         phba->fcf.fcf_flag |= FCF_ACVL_DISC;
4988                         spin_unlock_irq(&phba->hbalock);
4989                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
4990                                         LOG_DISCOVERY,
4991                                         "2773 Start FCF failover per CVL, "
4992                                         "evt_tag:x%x\n", acqe_fip->event_tag);
4993                         rc = lpfc_sli4_redisc_fcf_table(phba);
4994                         if (rc) {
4995                                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
4996                                                 LOG_DISCOVERY,
4997                                                 "2774 Issue FCF rediscover "
4998                                                 "mabilbox command failed, "
4999                                                 "through to CVL event\n");
5000                                 spin_lock_irq(&phba->hbalock);
5001                                 phba->fcf.fcf_flag &= ~FCF_ACVL_DISC;
5002                                 spin_unlock_irq(&phba->hbalock);
5003                                 /*
5004                                  * Last resort will be re-try on the
5005                                  * the current registered FCF entry.
5006                                  */
5007                                 lpfc_retry_pport_discovery(phba);
5008                         } else
5009                                 /*
5010                                  * Reset FCF roundrobin bmask for new
5011                                  * discovery.
5012                                  */
5013                                 lpfc_sli4_clear_fcf_rr_bmask(phba);
5014                 }
5015                 break;
5016         default:
5017                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5018                         "0288 Unknown FCoE event type 0x%x event tag "
5019                         "0x%x\n", event_type, acqe_fip->event_tag);
5020                 break;
5021         }
5022 }
5023
5024 /**
5025  * lpfc_sli4_async_dcbx_evt - Process the asynchronous dcbx event
5026  * @phba: pointer to lpfc hba data structure.
5027  * @acqe_link: pointer to the async dcbx completion queue entry.
5028  *
5029  * This routine is to handle the SLI4 asynchronous dcbx event.
5030  **/
5031 static void
5032 lpfc_sli4_async_dcbx_evt(struct lpfc_hba *phba,
5033                          struct lpfc_acqe_dcbx *acqe_dcbx)
5034 {
5035         phba->fc_eventTag = acqe_dcbx->event_tag;
5036         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5037                         "0290 The SLI4 DCBX asynchronous event is not "
5038                         "handled yet\n");
5039 }
5040
5041 /**
5042  * lpfc_sli4_async_grp5_evt - Process the asynchronous group5 event
5043  * @phba: pointer to lpfc hba data structure.
5044  * @acqe_link: pointer to the async grp5 completion queue entry.
5045  *
5046  * This routine is to handle the SLI4 asynchronous grp5 event. A grp5 event
5047  * is an asynchronous notified of a logical link speed change.  The Port
5048  * reports the logical link speed in units of 10Mbps.
5049  **/
5050 static void
5051 lpfc_sli4_async_grp5_evt(struct lpfc_hba *phba,
5052                          struct lpfc_acqe_grp5 *acqe_grp5)
5053 {
5054         uint16_t prev_ll_spd;
5055
5056         phba->fc_eventTag = acqe_grp5->event_tag;
5057         phba->fcoe_eventtag = acqe_grp5->event_tag;
5058         prev_ll_spd = phba->sli4_hba.link_state.logical_speed;
5059         phba->sli4_hba.link_state.logical_speed =
5060                 (bf_get(lpfc_acqe_grp5_llink_spd, acqe_grp5)) * 10;
5061         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
5062                         "2789 GRP5 Async Event: Updating logical link speed "
5063                         "from %dMbps to %dMbps\n", prev_ll_spd,
5064                         phba->sli4_hba.link_state.logical_speed);
5065 }
5066
5067 /**
5068  * lpfc_sli4_async_event_proc - Process all the pending asynchronous event
5069  * @phba: pointer to lpfc hba data structure.
5070  *
5071  * This routine is invoked by the worker thread to process all the pending
5072  * SLI4 asynchronous events.
5073  **/
5074 void lpfc_sli4_async_event_proc(struct lpfc_hba *phba)
5075 {
5076         struct lpfc_cq_event *cq_event;
5077
5078         /* First, declare the async event has been handled */
5079         spin_lock_irq(&phba->hbalock);
5080         phba->hba_flag &= ~ASYNC_EVENT;
5081         spin_unlock_irq(&phba->hbalock);
5082         /* Now, handle all the async events */
5083         while (!list_empty(&phba->sli4_hba.sp_asynce_work_queue)) {
5084                 /* Get the first event from the head of the event queue */
5085                 spin_lock_irq(&phba->hbalock);
5086                 list_remove_head(&phba->sli4_hba.sp_asynce_work_queue,
5087                                  cq_event, struct lpfc_cq_event, list);
5088                 spin_unlock_irq(&phba->hbalock);
5089                 /* Process the asynchronous event */
5090                 switch (bf_get(lpfc_trailer_code, &cq_event->cqe.mcqe_cmpl)) {
5091                 case LPFC_TRAILER_CODE_LINK:
5092                         lpfc_sli4_async_link_evt(phba,
5093                                                  &cq_event->cqe.acqe_link);
5094                         break;
5095                 case LPFC_TRAILER_CODE_FCOE:
5096                         lpfc_sli4_async_fip_evt(phba, &cq_event->cqe.acqe_fip);
5097                         break;
5098                 case LPFC_TRAILER_CODE_DCBX:
5099                         lpfc_sli4_async_dcbx_evt(phba,
5100                                                  &cq_event->cqe.acqe_dcbx);
5101                         break;
5102                 case LPFC_TRAILER_CODE_GRP5:
5103                         lpfc_sli4_async_grp5_evt(phba,
5104                                                  &cq_event->cqe.acqe_grp5);
5105                         break;
5106                 case LPFC_TRAILER_CODE_FC:
5107                         lpfc_sli4_async_fc_evt(phba, &cq_event->cqe.acqe_fc);
5108                         break;
5109                 case LPFC_TRAILER_CODE_SLI:
5110                         lpfc_sli4_async_sli_evt(phba, &cq_event->cqe.acqe_sli);
5111                         break;
5112                 default:
5113                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5114                                         "1804 Invalid asynchrous event code: "
5115                                         "x%x\n", bf_get(lpfc_trailer_code,
5116                                         &cq_event->cqe.mcqe_cmpl));
5117                         break;
5118                 }
5119                 /* Free the completion event processed to the free pool */
5120                 lpfc_sli4_cq_event_release(phba, cq_event);
5121         }
5122 }
5123
5124 /**
5125  * lpfc_sli4_fcf_redisc_event_proc - Process fcf table rediscovery event
5126  * @phba: pointer to lpfc hba data structure.
5127  *
5128  * This routine is invoked by the worker thread to process FCF table
5129  * rediscovery pending completion event.
5130  **/
5131 void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *phba)
5132 {
5133         int rc;
5134
5135         spin_lock_irq(&phba->hbalock);
5136         /* Clear FCF rediscovery timeout event */
5137         phba->fcf.fcf_flag &= ~FCF_REDISC_EVT;
5138         /* Clear driver fast failover FCF record flag */
5139         phba->fcf.failover_rec.flag = 0;
5140         /* Set state for FCF fast failover */
5141         phba->fcf.fcf_flag |= FCF_REDISC_FOV;
5142         spin_unlock_irq(&phba->hbalock);
5143
5144         /* Scan FCF table from the first entry to re-discover SAN */
5145         lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
5146                         "2777 Start post-quiescent FCF table scan\n");
5147         rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
5148         if (rc)
5149                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
5150                                 "2747 Issue FCF scan read FCF mailbox "
5151                                 "command failed 0x%x\n", rc);
5152 }
5153
5154 /**
5155  * lpfc_api_table_setup - Set up per hba pci-device group func api jump table
5156  * @phba: pointer to lpfc hba data structure.
5157  * @dev_grp: The HBA PCI-Device group number.
5158  *
5159  * This routine is invoked to set up the per HBA PCI-Device group function
5160  * API jump table entries.
5161  *
5162  * Return: 0 if success, otherwise -ENODEV
5163  **/
5164 int
5165 lpfc_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
5166 {
5167         int rc;
5168
5169         /* Set up lpfc PCI-device group */
5170         phba->pci_dev_grp = dev_grp;
5171
5172         /* The LPFC_PCI_DEV_OC uses SLI4 */
5173         if (dev_grp == LPFC_PCI_DEV_OC)
5174                 phba->sli_rev = LPFC_SLI_REV4;
5175
5176         /* Set up device INIT API function jump table */
5177         rc = lpfc_init_api_table_setup(phba, dev_grp);
5178         if (rc)
5179                 return -ENODEV;
5180         /* Set up SCSI API function jump table */
5181         rc = lpfc_scsi_api_table_setup(phba, dev_grp);
5182         if (rc)
5183                 return -ENODEV;
5184         /* Set up SLI API function jump table */
5185         rc = lpfc_sli_api_table_setup(phba, dev_grp);
5186         if (rc)
5187                 return -ENODEV;
5188         /* Set up MBOX API function jump table */
5189         rc = lpfc_mbox_api_table_setup(phba, dev_grp);
5190         if (rc)
5191                 return -ENODEV;
5192
5193         return 0;
5194 }
5195
5196 /**
5197  * lpfc_log_intr_mode - Log the active interrupt mode
5198  * @phba: pointer to lpfc hba data structure.
5199  * @intr_mode: active interrupt mode adopted.
5200  *
5201  * This routine it invoked to log the currently used active interrupt mode
5202  * to the device.
5203  **/
5204 static void lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode)
5205 {
5206         switch (intr_mode) {
5207         case 0:
5208                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5209                                 "0470 Enable INTx interrupt mode.\n");
5210                 break;
5211         case 1:
5212                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5213                                 "0481 Enabled MSI interrupt mode.\n");
5214                 break;
5215         case 2:
5216                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5217                                 "0480 Enabled MSI-X interrupt mode.\n");
5218                 break;
5219         default:
5220                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5221                                 "0482 Illegal interrupt mode.\n");
5222                 break;
5223         }
5224         return;
5225 }
5226
5227 /**
5228  * lpfc_enable_pci_dev - Enable a generic PCI device.
5229  * @phba: pointer to lpfc hba data structure.
5230  *
5231  * This routine is invoked to enable the PCI device that is common to all
5232  * PCI devices.
5233  *
5234  * Return codes
5235  *      0 - successful
5236  *      other values - error
5237  **/
5238 static int
5239 lpfc_enable_pci_dev(struct lpfc_hba *phba)
5240 {
5241         struct pci_dev *pdev;
5242
5243         /* Obtain PCI device reference */
5244         if (!phba->pcidev)
5245                 goto out_error;
5246         else
5247                 pdev = phba->pcidev;
5248         /* Enable PCI device */
5249         if (pci_enable_device_mem(pdev))
5250                 goto out_error;
5251         /* Request PCI resource for the device */
5252         if (pci_request_mem_regions(pdev, LPFC_DRIVER_NAME))
5253                 goto out_disable_device;
5254         /* Set up device as PCI master and save state for EEH */
5255         pci_set_master(pdev);
5256         pci_try_set_mwi(pdev);
5257         pci_save_state(pdev);
5258
5259         /* PCIe EEH recovery on powerpc platforms needs fundamental reset */
5260         if (pci_is_pcie(pdev))
5261                 pdev->needs_freset = 1;
5262
5263         return 0;
5264
5265 out_disable_device:
5266         pci_disable_device(pdev);
5267 out_error:
5268         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5269                         "1401 Failed to enable pci device\n");
5270         return -ENODEV;
5271 }
5272
5273 /**
5274  * lpfc_disable_pci_dev - Disable a generic PCI device.
5275  * @phba: pointer to lpfc hba data structure.
5276  *
5277  * This routine is invoked to disable the PCI device that is common to all
5278  * PCI devices.
5279  **/
5280 static void
5281 lpfc_disable_pci_dev(struct lpfc_hba *phba)
5282 {
5283         struct pci_dev *pdev;
5284
5285         /* Obtain PCI device reference */
5286         if (!phba->pcidev)
5287                 return;
5288         else
5289                 pdev = phba->pcidev;
5290         /* Release PCI resource and disable PCI device */
5291         pci_release_mem_regions(pdev);
5292         pci_disable_device(pdev);
5293
5294         return;
5295 }
5296
5297 /**
5298  * lpfc_reset_hba - Reset a hba
5299  * @phba: pointer to lpfc hba data structure.
5300  *
5301  * This routine is invoked to reset a hba device. It brings the HBA
5302  * offline, performs a board restart, and then brings the board back
5303  * online. The lpfc_offline calls lpfc_sli_hba_down which will clean up
5304  * on outstanding mailbox commands.
5305  **/
5306 void
5307 lpfc_reset_hba(struct lpfc_hba *phba)
5308 {
5309         /* If resets are disabled then set error state and return. */
5310         if (!phba->cfg_enable_hba_reset) {
5311                 phba->link_state = LPFC_HBA_ERROR;
5312                 return;
5313         }
5314         if (phba->sli.sli_flag & LPFC_SLI_ACTIVE)
5315                 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
5316         else
5317                 lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
5318         lpfc_offline(phba);
5319         lpfc_sli_brdrestart(phba);
5320         lpfc_online(phba);
5321         lpfc_unblock_mgmt_io(phba);
5322 }
5323
5324 /**
5325  * lpfc_sli_sriov_nr_virtfn_get - Get the number of sr-iov virtual functions
5326  * @phba: pointer to lpfc hba data structure.
5327  *
5328  * This function enables the PCI SR-IOV virtual functions to a physical
5329  * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to
5330  * enable the number of virtual functions to the physical function. As
5331  * not all devices support SR-IOV, the return code from the pci_enable_sriov()
5332  * API call does not considered as an error condition for most of the device.
5333  **/
5334 uint16_t
5335 lpfc_sli_sriov_nr_virtfn_get(struct lpfc_hba *phba)
5336 {
5337         struct pci_dev *pdev = phba->pcidev;
5338         uint16_t nr_virtfn;
5339         int pos;
5340
5341         pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
5342         if (pos == 0)
5343                 return 0;
5344
5345         pci_read_config_word(pdev, pos + PCI_SRIOV_TOTAL_VF, &nr_virtfn);
5346         return nr_virtfn;
5347 }
5348
5349 /**
5350  * lpfc_sli_probe_sriov_nr_virtfn - Enable a number of sr-iov virtual functions
5351  * @phba: pointer to lpfc hba data structure.
5352  * @nr_vfn: number of virtual functions to be enabled.
5353  *
5354  * This function enables the PCI SR-IOV virtual functions to a physical
5355  * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to
5356  * enable the number of virtual functions to the physical function. As
5357  * not all devices support SR-IOV, the return code from the pci_enable_sriov()
5358  * API call does not considered as an error condition for most of the device.
5359  **/
5360 int
5361 lpfc_sli_probe_sriov_nr_virtfn(struct lpfc_hba *phba, int nr_vfn)
5362 {
5363         struct pci_dev *pdev = phba->pcidev;
5364         uint16_t max_nr_vfn;
5365         int rc;
5366
5367         max_nr_vfn = lpfc_sli_sriov_nr_virtfn_get(phba);
5368         if (nr_vfn > max_nr_vfn) {
5369                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5370                                 "3057 Requested vfs (%d) greater than "
5371                                 "supported vfs (%d)", nr_vfn, max_nr_vfn);
5372                 return -EINVAL;
5373         }
5374
5375         rc = pci_enable_sriov(pdev, nr_vfn);
5376         if (rc) {
5377                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5378                                 "2806 Failed to enable sriov on this device "
5379                                 "with vfn number nr_vf:%d, rc:%d\n",
5380                                 nr_vfn, rc);
5381         } else
5382                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5383                                 "2807 Successful enable sriov on this device "
5384                                 "with vfn number nr_vf:%d\n", nr_vfn);
5385         return rc;
5386 }
5387
5388 /**
5389  * lpfc_setup_driver_resource_phase1 - Phase1 etup driver internal resources.
5390  * @phba: pointer to lpfc hba data structure.
5391  *
5392  * This routine is invoked to set up the driver internal resources before the
5393  * device specific resource setup to support the HBA device it attached to.
5394  *
5395  * Return codes
5396  *      0 - successful
5397  *      other values - error
5398  **/
5399 static int
5400 lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba)
5401 {
5402         struct lpfc_sli *psli = &phba->sli;
5403
5404         /*
5405          * Driver resources common to all SLI revisions
5406          */
5407         atomic_set(&phba->fast_event_count, 0);
5408         spin_lock_init(&phba->hbalock);
5409
5410         /* Initialize ndlp management spinlock */
5411         spin_lock_init(&phba->ndlp_lock);
5412
5413         INIT_LIST_HEAD(&phba->port_list);
5414         INIT_LIST_HEAD(&phba->work_list);
5415         init_waitqueue_head(&phba->wait_4_mlo_m_q);
5416
5417         /* Initialize the wait queue head for the kernel thread */
5418         init_waitqueue_head(&phba->work_waitq);
5419
5420         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5421                         "1403 Protocols supported %s %s %s\n",
5422                         ((phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP) ?
5423                                 "SCSI" : " "),
5424                         ((phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) ?
5425                                 "NVME" : " "),
5426                         (phba->nvmet_support ? "NVMET" : " "));
5427
5428         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP) {
5429                 /* Initialize the scsi buffer list used by driver for scsi IO */
5430                 spin_lock_init(&phba->scsi_buf_list_get_lock);
5431                 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_get);
5432                 spin_lock_init(&phba->scsi_buf_list_put_lock);
5433                 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
5434         }
5435
5436         if ((phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) &&
5437                 (phba->nvmet_support == 0)) {
5438                 /* Initialize the NVME buffer list used by driver for NVME IO */
5439                 spin_lock_init(&phba->nvme_buf_list_get_lock);
5440                 INIT_LIST_HEAD(&phba->lpfc_nvme_buf_list_get);
5441                 spin_lock_init(&phba->nvme_buf_list_put_lock);
5442                 INIT_LIST_HEAD(&phba->lpfc_nvme_buf_list_put);
5443         }
5444
5445         /* Initialize the fabric iocb list */
5446         INIT_LIST_HEAD(&phba->fabric_iocb_list);
5447
5448         /* Initialize list to save ELS buffers */
5449         INIT_LIST_HEAD(&phba->elsbuf);
5450
5451         /* Initialize FCF connection rec list */
5452         INIT_LIST_HEAD(&phba->fcf_conn_rec_list);
5453
5454         /* Initialize OAS configuration list */
5455         spin_lock_init(&phba->devicelock);
5456         INIT_LIST_HEAD(&phba->luns);
5457
5458         /* MBOX heartbeat timer */
5459         setup_timer(&psli->mbox_tmo, lpfc_mbox_timeout, (unsigned long)phba);
5460         /* Fabric block timer */
5461         setup_timer(&phba->fabric_block_timer, lpfc_fabric_block_timeout,
5462                         (unsigned long)phba);
5463         /* EA polling mode timer */
5464         setup_timer(&phba->eratt_poll, lpfc_poll_eratt,
5465                         (unsigned long)phba);
5466         /* Heartbeat timer */
5467         setup_timer(&phba->hb_tmofunc, lpfc_hb_timeout, (unsigned long)phba);
5468
5469         return 0;
5470 }
5471
5472 /**
5473  * lpfc_sli_driver_resource_setup - Setup driver internal resources for SLI3 dev
5474  * @phba: pointer to lpfc hba data structure.
5475  *
5476  * This routine is invoked to set up the driver internal resources specific to
5477  * support the SLI-3 HBA device it attached to.
5478  *
5479  * Return codes
5480  * 0 - successful
5481  * other values - error
5482  **/
5483 static int
5484 lpfc_sli_driver_resource_setup(struct lpfc_hba *phba)
5485 {
5486         int rc;
5487
5488         /*
5489          * Initialize timers used by driver
5490          */
5491
5492         /* FCP polling mode timer */
5493         setup_timer(&phba->fcp_poll_timer, lpfc_poll_timeout,
5494                         (unsigned long)phba);
5495
5496         /* Host attention work mask setup */
5497         phba->work_ha_mask = (HA_ERATT | HA_MBATT | HA_LATT);
5498         phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4));
5499
5500         /* Get all the module params for configuring this host */
5501         lpfc_get_cfgparam(phba);
5502         /* Set up phase-1 common device driver resources */
5503
5504         rc = lpfc_setup_driver_resource_phase1(phba);
5505         if (rc)
5506                 return -ENODEV;
5507
5508         if (phba->pcidev->device == PCI_DEVICE_ID_HORNET) {
5509                 phba->menlo_flag |= HBA_MENLO_SUPPORT;
5510                 /* check for menlo minimum sg count */
5511                 if (phba->cfg_sg_seg_cnt < LPFC_DEFAULT_MENLO_SG_SEG_CNT)
5512                         phba->cfg_sg_seg_cnt = LPFC_DEFAULT_MENLO_SG_SEG_CNT;
5513         }
5514
5515         if (!phba->sli.sli3_ring)
5516                 phba->sli.sli3_ring = kzalloc(LPFC_SLI3_MAX_RING *
5517                         sizeof(struct lpfc_sli_ring), GFP_KERNEL);
5518         if (!phba->sli.sli3_ring)
5519                 return -ENOMEM;
5520
5521         /*
5522          * Since lpfc_sg_seg_cnt is module parameter, the sg_dma_buf_size
5523          * used to create the sg_dma_buf_pool must be dynamically calculated.
5524          */
5525
5526         /* Initialize the host templates the configured values. */
5527         lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5528         lpfc_template_no_hr.sg_tablesize = phba->cfg_sg_seg_cnt;
5529         lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5530
5531         /* There are going to be 2 reserved BDEs: 1 FCP cmnd + 1 FCP rsp */
5532         if (phba->cfg_enable_bg) {
5533                 /*
5534                  * The scsi_buf for a T10-DIF I/O will hold the FCP cmnd,
5535                  * the FCP rsp, and a BDE for each. Sice we have no control
5536                  * over how many protection data segments the SCSI Layer
5537                  * will hand us (ie: there could be one for every block
5538                  * in the IO), we just allocate enough BDEs to accomidate
5539                  * our max amount and we need to limit lpfc_sg_seg_cnt to
5540                  * minimize the risk of running out.
5541                  */
5542                 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5543                         sizeof(struct fcp_rsp) +
5544                         (LPFC_MAX_SG_SEG_CNT * sizeof(struct ulp_bde64));
5545
5546                 if (phba->cfg_sg_seg_cnt > LPFC_MAX_SG_SEG_CNT_DIF)
5547                         phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SEG_CNT_DIF;
5548
5549                 /* Total BDEs in BPL for scsi_sg_list and scsi_sg_prot_list */
5550                 phba->cfg_total_seg_cnt = LPFC_MAX_SG_SEG_CNT;
5551         } else {
5552                 /*
5553                  * The scsi_buf for a regular I/O will hold the FCP cmnd,
5554                  * the FCP rsp, a BDE for each, and a BDE for up to
5555                  * cfg_sg_seg_cnt data segments.
5556                  */
5557                 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5558                         sizeof(struct fcp_rsp) +
5559                         ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
5560
5561                 /* Total BDEs in BPL for scsi_sg_list */
5562                 phba->cfg_total_seg_cnt = phba->cfg_sg_seg_cnt + 2;
5563         }
5564
5565         lpfc_printf_log(phba, KERN_INFO, LOG_INIT | LOG_FCP,
5566                         "9088 sg_tablesize:%d dmabuf_size:%d total_bde:%d\n",
5567                         phba->cfg_sg_seg_cnt, phba->cfg_sg_dma_buf_size,
5568                         phba->cfg_total_seg_cnt);
5569
5570         phba->max_vpi = LPFC_MAX_VPI;
5571         /* This will be set to correct value after config_port mbox */
5572         phba->max_vports = 0;
5573
5574         /*
5575          * Initialize the SLI Layer to run with lpfc HBAs.
5576          */
5577         lpfc_sli_setup(phba);
5578         lpfc_sli_queue_init(phba);
5579
5580         /* Allocate device driver memory */
5581         if (lpfc_mem_alloc(phba, BPL_ALIGN_SZ))
5582                 return -ENOMEM;
5583
5584         /*
5585          * Enable sr-iov virtual functions if supported and configured
5586          * through the module parameter.
5587          */
5588         if (phba->cfg_sriov_nr_virtfn > 0) {
5589                 rc = lpfc_sli_probe_sriov_nr_virtfn(phba,
5590                                                  phba->cfg_sriov_nr_virtfn);
5591                 if (rc) {
5592                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5593                                         "2808 Requested number of SR-IOV "
5594                                         "virtual functions (%d) is not "
5595                                         "supported\n",
5596                                         phba->cfg_sriov_nr_virtfn);
5597                         phba->cfg_sriov_nr_virtfn = 0;
5598                 }
5599         }
5600
5601         return 0;
5602 }
5603
5604 /**
5605  * lpfc_sli_driver_resource_unset - Unset drvr internal resources for SLI3 dev
5606  * @phba: pointer to lpfc hba data structure.
5607  *
5608  * This routine is invoked to unset the driver internal resources set up
5609  * specific for supporting the SLI-3 HBA device it attached to.
5610  **/
5611 static void
5612 lpfc_sli_driver_resource_unset(struct lpfc_hba *phba)
5613 {
5614         /* Free device driver memory allocated */
5615         lpfc_mem_free_all(phba);
5616
5617         return;
5618 }
5619
5620 /**
5621  * lpfc_sli4_driver_resource_setup - Setup drvr internal resources for SLI4 dev
5622  * @phba: pointer to lpfc hba data structure.
5623  *
5624  * This routine is invoked to set up the driver internal resources specific to
5625  * support the SLI-4 HBA device it attached to.
5626  *
5627  * Return codes
5628  *      0 - successful
5629  *      other values - error
5630  **/
5631 static int
5632 lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
5633 {
5634         LPFC_MBOXQ_t *mboxq;
5635         MAILBOX_t *mb;
5636         int rc, i, max_buf_size;
5637         uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0};
5638         struct lpfc_mqe *mqe;
5639         int longs;
5640         int fof_vectors = 0;
5641         uint64_t wwn;
5642
5643         phba->sli4_hba.num_online_cpu = num_online_cpus();
5644         phba->sli4_hba.num_present_cpu = lpfc_present_cpu;
5645         phba->sli4_hba.curr_disp_cpu = 0;
5646
5647         /* Get all the module params for configuring this host */
5648         lpfc_get_cfgparam(phba);
5649
5650         /* Set up phase-1 common device driver resources */
5651         rc = lpfc_setup_driver_resource_phase1(phba);
5652         if (rc)
5653                 return -ENODEV;
5654
5655         /* Before proceed, wait for POST done and device ready */
5656         rc = lpfc_sli4_post_status_check(phba);
5657         if (rc)
5658                 return -ENODEV;
5659
5660         /*
5661          * Initialize timers used by driver
5662          */
5663
5664         setup_timer(&phba->rrq_tmr, lpfc_rrq_timeout, (unsigned long)phba);
5665
5666         /* FCF rediscover timer */
5667         setup_timer(&phba->fcf.redisc_wait, lpfc_sli4_fcf_redisc_wait_tmo,
5668                         (unsigned long)phba);
5669
5670         /*
5671          * Control structure for handling external multi-buffer mailbox
5672          * command pass-through.
5673          */
5674         memset((uint8_t *)&phba->mbox_ext_buf_ctx, 0,
5675                 sizeof(struct lpfc_mbox_ext_buf_ctx));
5676         INIT_LIST_HEAD(&phba->mbox_ext_buf_ctx.ext_dmabuf_list);
5677
5678         phba->max_vpi = LPFC_MAX_VPI;
5679
5680         /* This will be set to correct value after the read_config mbox */
5681         phba->max_vports = 0;
5682
5683         /* Program the default value of vlan_id and fc_map */
5684         phba->valid_vlan = 0;
5685         phba->fc_map[0] = LPFC_FCOE_FCF_MAP0;
5686         phba->fc_map[1] = LPFC_FCOE_FCF_MAP1;
5687         phba->fc_map[2] = LPFC_FCOE_FCF_MAP2;
5688
5689         /*
5690          * For SLI4, instead of using ring 0 (LPFC_FCP_RING) for FCP commands
5691          * we will associate a new ring, for each EQ/CQ/WQ tuple.
5692          * The WQ create will allocate the ring.
5693          */
5694
5695         /*
5696          * It doesn't matter what family our adapter is in, we are
5697          * limited to 2 Pages, 512 SGEs, for our SGL.
5698          * There are going to be 2 reserved SGEs: 1 FCP cmnd + 1 FCP rsp
5699          */
5700         max_buf_size = (2 * SLI4_PAGE_SIZE);
5701         if (phba->cfg_sg_seg_cnt > LPFC_MAX_SGL_SEG_CNT - 2)
5702                 phba->cfg_sg_seg_cnt = LPFC_MAX_SGL_SEG_CNT - 2;
5703
5704         /*
5705          * Since lpfc_sg_seg_cnt is module param, the sg_dma_buf_size
5706          * used to create the sg_dma_buf_pool must be calculated.
5707          */
5708         if (phba->cfg_enable_bg) {
5709                 /*
5710                  * The scsi_buf for a T10-DIF I/O holds the FCP cmnd,
5711                  * the FCP rsp, and a SGE. Sice we have no control
5712                  * over how many protection segments the SCSI Layer
5713                  * will hand us (ie: there could be one for every block
5714                  * in the IO), just allocate enough SGEs to accomidate
5715                  * our max amount and we need to limit lpfc_sg_seg_cnt
5716                  * to minimize the risk of running out.
5717                  */
5718                 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5719                                 sizeof(struct fcp_rsp) + max_buf_size;
5720
5721                 /* Total SGEs for scsi_sg_list and scsi_sg_prot_list */
5722                 phba->cfg_total_seg_cnt = LPFC_MAX_SGL_SEG_CNT;
5723
5724                 if (phba->cfg_sg_seg_cnt > LPFC_MAX_SG_SLI4_SEG_CNT_DIF)
5725                         phba->cfg_sg_seg_cnt =
5726                                 LPFC_MAX_SG_SLI4_SEG_CNT_DIF;
5727         } else {
5728                 /*
5729                  * The scsi_buf for a regular I/O holds the FCP cmnd,
5730                  * the FCP rsp, a SGE for each, and a SGE for up to
5731                  * cfg_sg_seg_cnt data segments.
5732                  */
5733                 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
5734                                 sizeof(struct fcp_rsp) +
5735                                 ((phba->cfg_sg_seg_cnt + 2) *
5736                                 sizeof(struct sli4_sge));
5737
5738                 /* Total SGEs for scsi_sg_list */
5739                 phba->cfg_total_seg_cnt = phba->cfg_sg_seg_cnt + 2;
5740
5741                 /*
5742                  * NOTE: if (phba->cfg_sg_seg_cnt + 2) <= 256 we only
5743                  * need to post 1 page for the SGL.
5744                  */
5745         }
5746
5747         /* Initialize the host templates with the updated values. */
5748         lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5749         lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
5750         lpfc_template_no_hr.sg_tablesize = phba->cfg_sg_seg_cnt;
5751
5752         if (phba->cfg_sg_dma_buf_size  <= LPFC_MIN_SG_SLI4_BUF_SZ)
5753                 phba->cfg_sg_dma_buf_size = LPFC_MIN_SG_SLI4_BUF_SZ;
5754         else
5755                 phba->cfg_sg_dma_buf_size =
5756                         SLI4_PAGE_ALIGN(phba->cfg_sg_dma_buf_size);
5757
5758         lpfc_printf_log(phba, KERN_INFO, LOG_INIT | LOG_FCP,
5759                         "9087 sg_tablesize:%d dmabuf_size:%d total_sge:%d\n",
5760                         phba->cfg_sg_seg_cnt, phba->cfg_sg_dma_buf_size,
5761                         phba->cfg_total_seg_cnt);
5762
5763         /* Initialize buffer queue management fields */
5764         INIT_LIST_HEAD(&phba->hbqs[LPFC_ELS_HBQ].hbq_buffer_list);
5765         phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_sli4_rb_alloc;
5766         phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_sli4_rb_free;
5767
5768         /*
5769          * Initialize the SLI Layer to run with lpfc SLI4 HBAs.
5770          */
5771         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP) {
5772                 /* Initialize the Abort scsi buffer list used by driver */
5773                 spin_lock_init(&phba->sli4_hba.abts_scsi_buf_list_lock);
5774                 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_scsi_buf_list);
5775         }
5776
5777         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
5778                 /* Initialize the Abort nvme buffer list used by driver */
5779                 spin_lock_init(&phba->sli4_hba.abts_nvme_buf_list_lock);
5780                 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_nvme_buf_list);
5781                 /* Fast-path XRI aborted CQ Event work queue list */
5782                 INIT_LIST_HEAD(&phba->sli4_hba.sp_nvme_xri_aborted_work_queue);
5783         }
5784
5785         /* This abort list used by worker thread */
5786         spin_lock_init(&phba->sli4_hba.sgl_list_lock);
5787         spin_lock_init(&phba->sli4_hba.nvmet_io_lock);
5788
5789         /*
5790          * Initialize driver internal slow-path work queues
5791          */
5792
5793         /* Driver internel slow-path CQ Event pool */
5794         INIT_LIST_HEAD(&phba->sli4_hba.sp_cqe_event_pool);
5795         /* Response IOCB work queue list */
5796         INIT_LIST_HEAD(&phba->sli4_hba.sp_queue_event);
5797         /* Asynchronous event CQ Event work queue list */
5798         INIT_LIST_HEAD(&phba->sli4_hba.sp_asynce_work_queue);
5799         /* Fast-path XRI aborted CQ Event work queue list */
5800         INIT_LIST_HEAD(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue);
5801         /* Slow-path XRI aborted CQ Event work queue list */
5802         INIT_LIST_HEAD(&phba->sli4_hba.sp_els_xri_aborted_work_queue);
5803         /* Receive queue CQ Event work queue list */
5804         INIT_LIST_HEAD(&phba->sli4_hba.sp_unsol_work_queue);
5805
5806         /* Initialize extent block lists. */
5807         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_blk_list);
5808         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_xri_blk_list);
5809         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_vfi_blk_list);
5810         INIT_LIST_HEAD(&phba->lpfc_vpi_blk_list);
5811
5812         /* initialize optic_state to 0xFF */
5813         phba->sli4_hba.lnk_info.optic_state = 0xff;
5814
5815         /* Allocate device driver memory */
5816         rc = lpfc_mem_alloc(phba, SGL_ALIGN_SZ);
5817         if (rc)
5818                 return -ENOMEM;
5819
5820         /* IF Type 2 ports get initialized now. */
5821         if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
5822             LPFC_SLI_INTF_IF_TYPE_2) {
5823                 rc = lpfc_pci_function_reset(phba);
5824                 if (unlikely(rc)) {
5825                         rc = -ENODEV;
5826                         goto out_free_mem;
5827                 }
5828                 phba->temp_sensor_support = 1;
5829         }
5830
5831         /* Create the bootstrap mailbox command */
5832         rc = lpfc_create_bootstrap_mbox(phba);
5833         if (unlikely(rc))
5834                 goto out_free_mem;
5835
5836         /* Set up the host's endian order with the device. */
5837         rc = lpfc_setup_endian_order(phba);
5838         if (unlikely(rc))
5839                 goto out_free_bsmbx;
5840
5841         /* Set up the hba's configuration parameters. */
5842         rc = lpfc_sli4_read_config(phba);
5843         if (unlikely(rc))
5844                 goto out_free_bsmbx;
5845         rc = lpfc_mem_alloc_active_rrq_pool_s4(phba);
5846         if (unlikely(rc))
5847                 goto out_free_bsmbx;
5848
5849         /* IF Type 0 ports get initialized now. */
5850         if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
5851             LPFC_SLI_INTF_IF_TYPE_0) {
5852                 rc = lpfc_pci_function_reset(phba);
5853                 if (unlikely(rc))
5854                         goto out_free_bsmbx;
5855         }
5856
5857         mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
5858                                                        GFP_KERNEL);
5859         if (!mboxq) {
5860                 rc = -ENOMEM;
5861                 goto out_free_bsmbx;
5862         }
5863
5864         /* Check for NVMET being configured */
5865         phba->nvmet_support = 0;
5866         if (lpfc_enable_nvmet_cnt) {
5867
5868                 /* First get WWN of HBA instance */
5869                 lpfc_read_nv(phba, mboxq);
5870                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
5871                 if (rc != MBX_SUCCESS) {
5872                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5873                                         "6016 Mailbox failed , mbxCmd x%x "
5874                                         "READ_NV, mbxStatus x%x\n",
5875                                         bf_get(lpfc_mqe_command, &mboxq->u.mqe),
5876                                         bf_get(lpfc_mqe_status, &mboxq->u.mqe));
5877                         rc = -EIO;
5878                         goto out_free_bsmbx;
5879                 }
5880                 mb = &mboxq->u.mb;
5881                 memcpy(&wwn, (char *)mb->un.varRDnvp.nodename,
5882                        sizeof(uint64_t));
5883                 wwn = cpu_to_be64(wwn);
5884                 phba->sli4_hba.wwnn.u.name = wwn;
5885                 memcpy(&wwn, (char *)mb->un.varRDnvp.portname,
5886                        sizeof(uint64_t));
5887                 /* wwn is WWPN of HBA instance */
5888                 wwn = cpu_to_be64(wwn);
5889                 phba->sli4_hba.wwpn.u.name = wwn;
5890
5891                 /* Check to see if it matches any module parameter */
5892                 for (i = 0; i < lpfc_enable_nvmet_cnt; i++) {
5893                         if (wwn == lpfc_enable_nvmet[i]) {
5894                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5895                                                 "6017 NVME Target %016llx\n",
5896                                                 wwn);
5897                                 phba->nvmet_support = 1; /* a match */
5898                         }
5899                 }
5900         }
5901
5902         lpfc_nvme_mod_param_dep(phba);
5903
5904         /* Get the Supported Pages if PORT_CAPABILITIES is supported by port. */
5905         lpfc_supported_pages(mboxq);
5906         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
5907         if (!rc) {
5908                 mqe = &mboxq->u.mqe;
5909                 memcpy(&pn_page[0], ((uint8_t *)&mqe->un.supp_pages.word3),
5910                        LPFC_MAX_SUPPORTED_PAGES);
5911                 for (i = 0; i < LPFC_MAX_SUPPORTED_PAGES; i++) {
5912                         switch (pn_page[i]) {
5913                         case LPFC_SLI4_PARAMETERS:
5914                                 phba->sli4_hba.pc_sli4_params.supported = 1;
5915                                 break;
5916                         default:
5917                                 break;
5918                         }
5919                 }
5920                 /* Read the port's SLI4 Parameters capabilities if supported. */
5921                 if (phba->sli4_hba.pc_sli4_params.supported)
5922                         rc = lpfc_pc_sli4_params_get(phba, mboxq);
5923                 if (rc) {
5924                         mempool_free(mboxq, phba->mbox_mem_pool);
5925                         rc = -EIO;
5926                         goto out_free_bsmbx;
5927                 }
5928         }
5929
5930         /*
5931          * Get sli4 parameters that override parameters from Port capabilities.
5932          * If this call fails, it isn't critical unless the SLI4 parameters come
5933          * back in conflict.
5934          */
5935         rc = lpfc_get_sli4_parameters(phba, mboxq);
5936         if (rc) {
5937                 if (phba->sli4_hba.extents_in_use &&
5938                     phba->sli4_hba.rpi_hdrs_in_use) {
5939                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5940                                 "2999 Unsupported SLI4 Parameters "
5941                                 "Extents and RPI headers enabled.\n");
5942                 }
5943                 mempool_free(mboxq, phba->mbox_mem_pool);
5944                 goto out_free_bsmbx;
5945         }
5946
5947         mempool_free(mboxq, phba->mbox_mem_pool);
5948
5949         /* Verify OAS is supported */
5950         lpfc_sli4_oas_verify(phba);
5951         if (phba->cfg_fof)
5952                 fof_vectors = 1;
5953
5954         /* Verify all the SLI4 queues */
5955         rc = lpfc_sli4_queue_verify(phba);
5956         if (rc)
5957                 goto out_free_bsmbx;
5958
5959         /* Create driver internal CQE event pool */
5960         rc = lpfc_sli4_cq_event_pool_create(phba);
5961         if (rc)
5962                 goto out_free_bsmbx;
5963
5964         /* Initialize sgl lists per host */
5965         lpfc_init_sgl_list(phba);
5966
5967         /* Allocate and initialize active sgl array */
5968         rc = lpfc_init_active_sgl_array(phba);
5969         if (rc) {
5970                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5971                                 "1430 Failed to initialize sgl list.\n");
5972                 goto out_destroy_cq_event_pool;
5973         }
5974         rc = lpfc_sli4_init_rpi_hdrs(phba);
5975         if (rc) {
5976                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5977                                 "1432 Failed to initialize rpi headers.\n");
5978                 goto out_free_active_sgl;
5979         }
5980
5981         /* Allocate eligible FCF bmask memory for FCF roundrobin failover */
5982         longs = (LPFC_SLI4_FCF_TBL_INDX_MAX + BITS_PER_LONG - 1)/BITS_PER_LONG;
5983         phba->fcf.fcf_rr_bmask = kzalloc(longs * sizeof(unsigned long),
5984                                          GFP_KERNEL);
5985         if (!phba->fcf.fcf_rr_bmask) {
5986                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5987                                 "2759 Failed allocate memory for FCF round "
5988                                 "robin failover bmask\n");
5989                 rc = -ENOMEM;
5990                 goto out_remove_rpi_hdrs;
5991         }
5992
5993         phba->sli4_hba.hba_eq_hdl = kcalloc(fof_vectors + phba->io_channel_irqs,
5994                                                 sizeof(struct lpfc_hba_eq_hdl),
5995                                                 GFP_KERNEL);
5996         if (!phba->sli4_hba.hba_eq_hdl) {
5997                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5998                                 "2572 Failed allocate memory for "
5999                                 "fast-path per-EQ handle array\n");
6000                 rc = -ENOMEM;
6001                 goto out_free_fcf_rr_bmask;
6002         }
6003
6004         phba->sli4_hba.cpu_map = kcalloc(phba->sli4_hba.num_present_cpu,
6005                                         sizeof(struct lpfc_vector_map_info),
6006                                         GFP_KERNEL);
6007         if (!phba->sli4_hba.cpu_map) {
6008                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6009                                 "3327 Failed allocate memory for msi-x "
6010                                 "interrupt vector mapping\n");
6011                 rc = -ENOMEM;
6012                 goto out_free_hba_eq_hdl;
6013         }
6014         if (lpfc_used_cpu == NULL) {
6015                 lpfc_used_cpu = kcalloc(lpfc_present_cpu, sizeof(uint16_t),
6016                                                 GFP_KERNEL);
6017                 if (!lpfc_used_cpu) {
6018                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6019                                         "3335 Failed allocate memory for msi-x "
6020                                         "interrupt vector mapping\n");
6021                         kfree(phba->sli4_hba.cpu_map);
6022                         rc = -ENOMEM;
6023                         goto out_free_hba_eq_hdl;
6024                 }
6025                 for (i = 0; i < lpfc_present_cpu; i++)
6026                         lpfc_used_cpu[i] = LPFC_VECTOR_MAP_EMPTY;
6027         }
6028
6029         /*
6030          * Enable sr-iov virtual functions if supported and configured
6031          * through the module parameter.
6032          */
6033         if (phba->cfg_sriov_nr_virtfn > 0) {
6034                 rc = lpfc_sli_probe_sriov_nr_virtfn(phba,
6035                                                  phba->cfg_sriov_nr_virtfn);
6036                 if (rc) {
6037                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6038                                         "3020 Requested number of SR-IOV "
6039                                         "virtual functions (%d) is not "
6040                                         "supported\n",
6041                                         phba->cfg_sriov_nr_virtfn);
6042                         phba->cfg_sriov_nr_virtfn = 0;
6043                 }
6044         }
6045
6046         return 0;
6047
6048 out_free_hba_eq_hdl:
6049         kfree(phba->sli4_hba.hba_eq_hdl);
6050 out_free_fcf_rr_bmask:
6051         kfree(phba->fcf.fcf_rr_bmask);
6052 out_remove_rpi_hdrs:
6053         lpfc_sli4_remove_rpi_hdrs(phba);
6054 out_free_active_sgl:
6055         lpfc_free_active_sgl(phba);
6056 out_destroy_cq_event_pool:
6057         lpfc_sli4_cq_event_pool_destroy(phba);
6058 out_free_bsmbx:
6059         lpfc_destroy_bootstrap_mbox(phba);
6060 out_free_mem:
6061         lpfc_mem_free(phba);
6062         return rc;
6063 }
6064
6065 /**
6066  * lpfc_sli4_driver_resource_unset - Unset drvr internal resources for SLI4 dev
6067  * @phba: pointer to lpfc hba data structure.
6068  *
6069  * This routine is invoked to unset the driver internal resources set up
6070  * specific for supporting the SLI-4 HBA device it attached to.
6071  **/
6072 static void
6073 lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
6074 {
6075         struct lpfc_fcf_conn_entry *conn_entry, *next_conn_entry;
6076
6077         /* Free memory allocated for msi-x interrupt vector to CPU mapping */
6078         kfree(phba->sli4_hba.cpu_map);
6079         phba->sli4_hba.num_present_cpu = 0;
6080         phba->sli4_hba.num_online_cpu = 0;
6081         phba->sli4_hba.curr_disp_cpu = 0;
6082
6083         /* Free memory allocated for fast-path work queue handles */
6084         kfree(phba->sli4_hba.hba_eq_hdl);
6085
6086         /* Free the allocated rpi headers. */
6087         lpfc_sli4_remove_rpi_hdrs(phba);
6088         lpfc_sli4_remove_rpis(phba);
6089
6090         /* Free eligible FCF index bmask */
6091         kfree(phba->fcf.fcf_rr_bmask);
6092
6093         /* Free the ELS sgl list */
6094         lpfc_free_active_sgl(phba);
6095         lpfc_free_els_sgl_list(phba);
6096         lpfc_free_nvmet_sgl_list(phba);
6097
6098         /* Free the completion queue EQ event pool */
6099         lpfc_sli4_cq_event_release_all(phba);
6100         lpfc_sli4_cq_event_pool_destroy(phba);
6101
6102         /* Release resource identifiers. */
6103         lpfc_sli4_dealloc_resource_identifiers(phba);
6104
6105         /* Free the bsmbx region. */
6106         lpfc_destroy_bootstrap_mbox(phba);
6107
6108         /* Free the SLI Layer memory with SLI4 HBAs */
6109         lpfc_mem_free_all(phba);
6110
6111         /* Free the current connect table */
6112         list_for_each_entry_safe(conn_entry, next_conn_entry,
6113                 &phba->fcf_conn_rec_list, list) {
6114                 list_del_init(&conn_entry->list);
6115                 kfree(conn_entry);
6116         }
6117
6118         return;
6119 }
6120
6121 /**
6122  * lpfc_init_api_table_setup - Set up init api function jump table
6123  * @phba: The hba struct for which this call is being executed.
6124  * @dev_grp: The HBA PCI-Device group number.
6125  *
6126  * This routine sets up the device INIT interface API function jump table
6127  * in @phba struct.
6128  *
6129  * Returns: 0 - success, -ENODEV - failure.
6130  **/
6131 int
6132 lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
6133 {
6134         phba->lpfc_hba_init_link = lpfc_hba_init_link;
6135         phba->lpfc_hba_down_link = lpfc_hba_down_link;
6136         phba->lpfc_selective_reset = lpfc_selective_reset;
6137         switch (dev_grp) {
6138         case LPFC_PCI_DEV_LP:
6139                 phba->lpfc_hba_down_post = lpfc_hba_down_post_s3;
6140                 phba->lpfc_handle_eratt = lpfc_handle_eratt_s3;
6141                 phba->lpfc_stop_port = lpfc_stop_port_s3;
6142                 break;
6143         case LPFC_PCI_DEV_OC:
6144                 phba->lpfc_hba_down_post = lpfc_hba_down_post_s4;
6145                 phba->lpfc_handle_eratt = lpfc_handle_eratt_s4;
6146                 phba->lpfc_stop_port = lpfc_stop_port_s4;
6147                 break;
6148         default:
6149                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6150                                 "1431 Invalid HBA PCI-device group: 0x%x\n",
6151                                 dev_grp);
6152                 return -ENODEV;
6153                 break;
6154         }
6155         return 0;
6156 }
6157
6158 /**
6159  * lpfc_setup_driver_resource_phase2 - Phase2 setup driver internal resources.
6160  * @phba: pointer to lpfc hba data structure.
6161  *
6162  * This routine is invoked to set up the driver internal resources after the
6163  * device specific resource setup to support the HBA device it attached to.
6164  *
6165  * Return codes
6166  *      0 - successful
6167  *      other values - error
6168  **/
6169 static int
6170 lpfc_setup_driver_resource_phase2(struct lpfc_hba *phba)
6171 {
6172         int error;
6173
6174         /* Startup the kernel thread for this host adapter. */
6175         phba->worker_thread = kthread_run(lpfc_do_work, phba,
6176                                           "lpfc_worker_%d", phba->brd_no);
6177         if (IS_ERR(phba->worker_thread)) {
6178                 error = PTR_ERR(phba->worker_thread);
6179                 return error;
6180         }
6181
6182         return 0;
6183 }
6184
6185 /**
6186  * lpfc_unset_driver_resource_phase2 - Phase2 unset driver internal resources.
6187  * @phba: pointer to lpfc hba data structure.
6188  *
6189  * This routine is invoked to unset the driver internal resources set up after
6190  * the device specific resource setup for supporting the HBA device it
6191  * attached to.
6192  **/
6193 static void
6194 lpfc_unset_driver_resource_phase2(struct lpfc_hba *phba)
6195 {
6196         /* Stop kernel worker thread */
6197         kthread_stop(phba->worker_thread);
6198 }
6199
6200 /**
6201  * lpfc_free_iocb_list - Free iocb list.
6202  * @phba: pointer to lpfc hba data structure.
6203  *
6204  * This routine is invoked to free the driver's IOCB list and memory.
6205  **/
6206 static void
6207 lpfc_free_iocb_list(struct lpfc_hba *phba)
6208 {
6209         struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL;
6210
6211         spin_lock_irq(&phba->hbalock);
6212         list_for_each_entry_safe(iocbq_entry, iocbq_next,
6213                                  &phba->lpfc_iocb_list, list) {
6214                 list_del(&iocbq_entry->list);
6215                 kfree(iocbq_entry);
6216                 phba->total_iocbq_bufs--;
6217         }
6218         spin_unlock_irq(&phba->hbalock);
6219
6220         return;
6221 }
6222
6223 /**
6224  * lpfc_init_iocb_list - Allocate and initialize iocb list.
6225  * @phba: pointer to lpfc hba data structure.
6226  *
6227  * This routine is invoked to allocate and initizlize the driver's IOCB
6228  * list and set up the IOCB tag array accordingly.
6229  *
6230  * Return codes
6231  *      0 - successful
6232  *      other values - error
6233  **/
6234 static int
6235 lpfc_init_iocb_list(struct lpfc_hba *phba, int iocb_count)
6236 {
6237         struct lpfc_iocbq *iocbq_entry = NULL;
6238         uint16_t iotag;
6239         int i;
6240
6241         /* Initialize and populate the iocb list per host.  */
6242         INIT_LIST_HEAD(&phba->lpfc_iocb_list);
6243         for (i = 0; i < iocb_count; i++) {
6244                 iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL);
6245                 if (iocbq_entry == NULL) {
6246                         printk(KERN_ERR "%s: only allocated %d iocbs of "
6247                                 "expected %d count. Unloading driver.\n",
6248                                 __func__, i, LPFC_IOCB_LIST_CNT);
6249                         goto out_free_iocbq;
6250                 }
6251
6252                 iotag = lpfc_sli_next_iotag(phba, iocbq_entry);
6253                 if (iotag == 0) {
6254                         kfree(iocbq_entry);
6255                         printk(KERN_ERR "%s: failed to allocate IOTAG. "
6256                                 "Unloading driver.\n", __func__);
6257                         goto out_free_iocbq;
6258                 }
6259                 iocbq_entry->sli4_lxritag = NO_XRI;
6260                 iocbq_entry->sli4_xritag = NO_XRI;
6261
6262                 spin_lock_irq(&phba->hbalock);
6263                 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list);
6264                 phba->total_iocbq_bufs++;
6265                 spin_unlock_irq(&phba->hbalock);
6266         }
6267
6268         return 0;
6269
6270 out_free_iocbq:
6271         lpfc_free_iocb_list(phba);
6272
6273         return -ENOMEM;
6274 }
6275
6276 /**
6277  * lpfc_free_sgl_list - Free a given sgl list.
6278  * @phba: pointer to lpfc hba data structure.
6279  * @sglq_list: pointer to the head of sgl list.
6280  *
6281  * This routine is invoked to free a give sgl list and memory.
6282  **/
6283 void
6284 lpfc_free_sgl_list(struct lpfc_hba *phba, struct list_head *sglq_list)
6285 {
6286         struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
6287
6288         list_for_each_entry_safe(sglq_entry, sglq_next, sglq_list, list) {
6289                 list_del(&sglq_entry->list);
6290                 lpfc_mbuf_free(phba, sglq_entry->virt, sglq_entry->phys);
6291                 kfree(sglq_entry);
6292         }
6293 }
6294
6295 /**
6296  * lpfc_free_els_sgl_list - Free els sgl list.
6297  * @phba: pointer to lpfc hba data structure.
6298  *
6299  * This routine is invoked to free the driver's els sgl list and memory.
6300  **/
6301 static void
6302 lpfc_free_els_sgl_list(struct lpfc_hba *phba)
6303 {
6304         LIST_HEAD(sglq_list);
6305
6306         /* Retrieve all els sgls from driver list */
6307         spin_lock_irq(&phba->hbalock);
6308         spin_lock(&phba->sli4_hba.sgl_list_lock);
6309         list_splice_init(&phba->sli4_hba.lpfc_els_sgl_list, &sglq_list);
6310         spin_unlock(&phba->sli4_hba.sgl_list_lock);
6311         spin_unlock_irq(&phba->hbalock);
6312
6313         /* Now free the sgl list */
6314         lpfc_free_sgl_list(phba, &sglq_list);
6315 }
6316
6317 /**
6318  * lpfc_free_nvmet_sgl_list - Free nvmet sgl list.
6319  * @phba: pointer to lpfc hba data structure.
6320  *
6321  * This routine is invoked to free the driver's nvmet sgl list and memory.
6322  **/
6323 static void
6324 lpfc_free_nvmet_sgl_list(struct lpfc_hba *phba)
6325 {
6326         struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
6327         LIST_HEAD(sglq_list);
6328
6329         /* Retrieve all nvmet sgls from driver list */
6330         spin_lock_irq(&phba->hbalock);
6331         spin_lock(&phba->sli4_hba.sgl_list_lock);
6332         list_splice_init(&phba->sli4_hba.lpfc_nvmet_sgl_list, &sglq_list);
6333         spin_unlock(&phba->sli4_hba.sgl_list_lock);
6334         spin_unlock_irq(&phba->hbalock);
6335
6336         /* Now free the sgl list */
6337         list_for_each_entry_safe(sglq_entry, sglq_next, &sglq_list, list) {
6338                 list_del(&sglq_entry->list);
6339                 lpfc_nvmet_buf_free(phba, sglq_entry->virt, sglq_entry->phys);
6340                 kfree(sglq_entry);
6341         }
6342 }
6343
6344 /**
6345  * lpfc_init_active_sgl_array - Allocate the buf to track active ELS XRIs.
6346  * @phba: pointer to lpfc hba data structure.
6347  *
6348  * This routine is invoked to allocate the driver's active sgl memory.
6349  * This array will hold the sglq_entry's for active IOs.
6350  **/
6351 static int
6352 lpfc_init_active_sgl_array(struct lpfc_hba *phba)
6353 {
6354         int size;
6355         size = sizeof(struct lpfc_sglq *);
6356         size *= phba->sli4_hba.max_cfg_param.max_xri;
6357
6358         phba->sli4_hba.lpfc_sglq_active_list =
6359                 kzalloc(size, GFP_KERNEL);
6360         if (!phba->sli4_hba.lpfc_sglq_active_list)
6361                 return -ENOMEM;
6362         return 0;
6363 }
6364
6365 /**
6366  * lpfc_free_active_sgl - Free the buf that tracks active ELS XRIs.
6367  * @phba: pointer to lpfc hba data structure.
6368  *
6369  * This routine is invoked to walk through the array of active sglq entries
6370  * and free all of the resources.
6371  * This is just a place holder for now.
6372  **/
6373 static void
6374 lpfc_free_active_sgl(struct lpfc_hba *phba)
6375 {
6376         kfree(phba->sli4_hba.lpfc_sglq_active_list);
6377 }
6378
6379 /**
6380  * lpfc_init_sgl_list - Allocate and initialize sgl list.
6381  * @phba: pointer to lpfc hba data structure.
6382  *
6383  * This routine is invoked to allocate and initizlize the driver's sgl
6384  * list and set up the sgl xritag tag array accordingly.
6385  *
6386  **/
6387 static void
6388 lpfc_init_sgl_list(struct lpfc_hba *phba)
6389 {
6390         /* Initialize and populate the sglq list per host/VF. */
6391         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_els_sgl_list);
6392         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_els_sgl_list);
6393         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_nvmet_sgl_list);
6394         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_nvmet_sgl_list);
6395
6396         /* els xri-sgl book keeping */
6397         phba->sli4_hba.els_xri_cnt = 0;
6398
6399         /* scsi xri-buffer book keeping */
6400         phba->sli4_hba.scsi_xri_cnt = 0;
6401
6402         /* nvme xri-buffer book keeping */
6403         phba->sli4_hba.nvme_xri_cnt = 0;
6404 }
6405
6406 /**
6407  * lpfc_sli4_init_rpi_hdrs - Post the rpi header memory region to the port
6408  * @phba: pointer to lpfc hba data structure.
6409  *
6410  * This routine is invoked to post rpi header templates to the
6411  * port for those SLI4 ports that do not support extents.  This routine
6412  * posts a PAGE_SIZE memory region to the port to hold up to
6413  * PAGE_SIZE modulo 64 rpi context headers.  This is an initialization routine
6414  * and should be called only when interrupts are disabled.
6415  *
6416  * Return codes
6417  *      0 - successful
6418  *      -ERROR - otherwise.
6419  **/
6420 int
6421 lpfc_sli4_init_rpi_hdrs(struct lpfc_hba *phba)
6422 {
6423         int rc = 0;
6424         struct lpfc_rpi_hdr *rpi_hdr;
6425
6426         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_hdr_list);
6427         if (!phba->sli4_hba.rpi_hdrs_in_use)
6428                 return rc;
6429         if (phba->sli4_hba.extents_in_use)
6430                 return -EIO;
6431
6432         rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
6433         if (!rpi_hdr) {
6434                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
6435                                 "0391 Error during rpi post operation\n");
6436                 lpfc_sli4_remove_rpis(phba);
6437                 rc = -ENODEV;
6438         }
6439
6440         return rc;
6441 }
6442
6443 /**
6444  * lpfc_sli4_create_rpi_hdr - Allocate an rpi header memory region
6445  * @phba: pointer to lpfc hba data structure.
6446  *
6447  * This routine is invoked to allocate a single 4KB memory region to
6448  * support rpis and stores them in the phba.  This single region
6449  * provides support for up to 64 rpis.  The region is used globally
6450  * by the device.
6451  *
6452  * Returns:
6453  *   A valid rpi hdr on success.
6454  *   A NULL pointer on any failure.
6455  **/
6456 struct lpfc_rpi_hdr *
6457 lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
6458 {
6459         uint16_t rpi_limit, curr_rpi_range;
6460         struct lpfc_dmabuf *dmabuf;
6461         struct lpfc_rpi_hdr *rpi_hdr;
6462         uint32_t rpi_count;
6463
6464         /*
6465          * If the SLI4 port supports extents, posting the rpi header isn't
6466          * required.  Set the expected maximum count and let the actual value
6467          * get set when extents are fully allocated.
6468          */
6469         if (!phba->sli4_hba.rpi_hdrs_in_use)
6470                 return NULL;
6471         if (phba->sli4_hba.extents_in_use)
6472                 return NULL;
6473
6474         /* The limit on the logical index is just the max_rpi count. */
6475         rpi_limit = phba->sli4_hba.max_cfg_param.rpi_base +
6476         phba->sli4_hba.max_cfg_param.max_rpi - 1;
6477
6478         spin_lock_irq(&phba->hbalock);
6479         /*
6480          * Establish the starting RPI in this header block.  The starting
6481          * rpi is normalized to a zero base because the physical rpi is
6482          * port based.
6483          */
6484         curr_rpi_range = phba->sli4_hba.next_rpi;
6485         spin_unlock_irq(&phba->hbalock);
6486
6487         /*
6488          * The port has a limited number of rpis. The increment here
6489          * is LPFC_RPI_HDR_COUNT - 1 to account for the starting value
6490          * and to allow the full max_rpi range per port.
6491          */
6492         if ((curr_rpi_range + (LPFC_RPI_HDR_COUNT - 1)) > rpi_limit)
6493                 rpi_count = rpi_limit - curr_rpi_range;
6494         else
6495                 rpi_count = LPFC_RPI_HDR_COUNT;
6496
6497         if (!rpi_count)
6498                 return NULL;
6499         /*
6500          * First allocate the protocol header region for the port.  The
6501          * port expects a 4KB DMA-mapped memory region that is 4K aligned.
6502          */
6503         dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
6504         if (!dmabuf)
6505                 return NULL;
6506
6507         dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev,
6508                                            LPFC_HDR_TEMPLATE_SIZE,
6509                                            &dmabuf->phys, GFP_KERNEL);
6510         if (!dmabuf->virt) {
6511                 rpi_hdr = NULL;
6512                 goto err_free_dmabuf;
6513         }
6514
6515         if (!IS_ALIGNED(dmabuf->phys, LPFC_HDR_TEMPLATE_SIZE)) {
6516                 rpi_hdr = NULL;
6517                 goto err_free_coherent;
6518         }
6519
6520         /* Save the rpi header data for cleanup later. */
6521         rpi_hdr = kzalloc(sizeof(struct lpfc_rpi_hdr), GFP_KERNEL);
6522         if (!rpi_hdr)
6523                 goto err_free_coherent;
6524
6525         rpi_hdr->dmabuf = dmabuf;
6526         rpi_hdr->len = LPFC_HDR_TEMPLATE_SIZE;
6527         rpi_hdr->page_count = 1;
6528         spin_lock_irq(&phba->hbalock);
6529
6530         /* The rpi_hdr stores the logical index only. */
6531         rpi_hdr->start_rpi = curr_rpi_range;
6532         list_add_tail(&rpi_hdr->list, &phba->sli4_hba.lpfc_rpi_hdr_list);
6533
6534         /*
6535          * The next_rpi stores the next logical module-64 rpi value used
6536          * to post physical rpis in subsequent rpi postings.
6537          */
6538         phba->sli4_hba.next_rpi += rpi_count;
6539         spin_unlock_irq(&phba->hbalock);
6540         return rpi_hdr;
6541
6542  err_free_coherent:
6543         dma_free_coherent(&phba->pcidev->dev, LPFC_HDR_TEMPLATE_SIZE,
6544                           dmabuf->virt, dmabuf->phys);
6545  err_free_dmabuf:
6546         kfree(dmabuf);
6547         return NULL;
6548 }
6549
6550 /**
6551  * lpfc_sli4_remove_rpi_hdrs - Remove all rpi header memory regions
6552  * @phba: pointer to lpfc hba data structure.
6553  *
6554  * This routine is invoked to remove all memory resources allocated
6555  * to support rpis for SLI4 ports not supporting extents. This routine
6556  * presumes the caller has released all rpis consumed by fabric or port
6557  * logins and is prepared to have the header pages removed.
6558  **/
6559 void
6560 lpfc_sli4_remove_rpi_hdrs(struct lpfc_hba *phba)
6561 {
6562         struct lpfc_rpi_hdr *rpi_hdr, *next_rpi_hdr;
6563
6564         if (!phba->sli4_hba.rpi_hdrs_in_use)
6565                 goto exit;
6566
6567         list_for_each_entry_safe(rpi_hdr, next_rpi_hdr,
6568                                  &phba->sli4_hba.lpfc_rpi_hdr_list, list) {
6569                 list_del(&rpi_hdr->list);
6570                 dma_free_coherent(&phba->pcidev->dev, rpi_hdr->len,
6571                                   rpi_hdr->dmabuf->virt, rpi_hdr->dmabuf->phys);
6572                 kfree(rpi_hdr->dmabuf);
6573                 kfree(rpi_hdr);
6574         }
6575  exit:
6576         /* There are no rpis available to the port now. */
6577         phba->sli4_hba.next_rpi = 0;
6578 }
6579
6580 /**
6581  * lpfc_hba_alloc - Allocate driver hba data structure for a device.
6582  * @pdev: pointer to pci device data structure.
6583  *
6584  * This routine is invoked to allocate the driver hba data structure for an
6585  * HBA device. If the allocation is successful, the phba reference to the
6586  * PCI device data structure is set.
6587  *
6588  * Return codes
6589  *      pointer to @phba - successful
6590  *      NULL - error
6591  **/
6592 static struct lpfc_hba *
6593 lpfc_hba_alloc(struct pci_dev *pdev)
6594 {
6595         struct lpfc_hba *phba;
6596
6597         /* Allocate memory for HBA structure */
6598         phba = kzalloc(sizeof(struct lpfc_hba), GFP_KERNEL);
6599         if (!phba) {
6600                 dev_err(&pdev->dev, "failed to allocate hba struct\n");
6601                 return NULL;
6602         }
6603
6604         /* Set reference to PCI device in HBA structure */
6605         phba->pcidev = pdev;
6606
6607         /* Assign an unused board number */
6608         phba->brd_no = lpfc_get_instance();
6609         if (phba->brd_no < 0) {
6610                 kfree(phba);
6611                 return NULL;
6612         }
6613         phba->eratt_poll_interval = LPFC_ERATT_POLL_INTERVAL;
6614
6615         spin_lock_init(&phba->ct_ev_lock);
6616         INIT_LIST_HEAD(&phba->ct_ev_waiters);
6617
6618         return phba;
6619 }
6620
6621 /**
6622  * lpfc_hba_free - Free driver hba data structure with a device.
6623  * @phba: pointer to lpfc hba data structure.
6624  *
6625  * This routine is invoked to free the driver hba data structure with an
6626  * HBA device.
6627  **/
6628 static void
6629 lpfc_hba_free(struct lpfc_hba *phba)
6630 {
6631         /* Release the driver assigned board number */
6632         idr_remove(&lpfc_hba_index, phba->brd_no);
6633
6634         /* Free memory allocated with sli3 rings */
6635         kfree(phba->sli.sli3_ring);
6636         phba->sli.sli3_ring = NULL;
6637
6638         kfree(phba);
6639         return;
6640 }
6641
6642 /**
6643  * lpfc_create_shost - Create hba physical port with associated scsi host.
6644  * @phba: pointer to lpfc hba data structure.
6645  *
6646  * This routine is invoked to create HBA physical port and associate a SCSI
6647  * host with it.
6648  *
6649  * Return codes
6650  *      0 - successful
6651  *      other values - error
6652  **/
6653 static int
6654 lpfc_create_shost(struct lpfc_hba *phba)
6655 {
6656         struct lpfc_vport *vport;
6657         struct Scsi_Host  *shost;
6658
6659         /* Initialize HBA FC structure */
6660         phba->fc_edtov = FF_DEF_EDTOV;
6661         phba->fc_ratov = FF_DEF_RATOV;
6662         phba->fc_altov = FF_DEF_ALTOV;
6663         phba->fc_arbtov = FF_DEF_ARBTOV;
6664
6665         atomic_set(&phba->sdev_cnt, 0);
6666         vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev);
6667         if (!vport)
6668                 return -ENODEV;
6669
6670         shost = lpfc_shost_from_vport(vport);
6671         phba->pport = vport;
6672
6673         if (phba->nvmet_support) {
6674                 /* Only 1 vport (pport) will support NVME target */
6675                 if (phba->txrdy_payload_pool == NULL) {
6676                         phba->txrdy_payload_pool = pci_pool_create(
6677                                 "txrdy_pool", phba->pcidev,
6678                                 TXRDY_PAYLOAD_LEN, 16, 0);
6679                         if (phba->txrdy_payload_pool) {
6680                                 phba->targetport = NULL;
6681                                 phba->cfg_enable_fc4_type = LPFC_ENABLE_NVME;
6682                                 lpfc_printf_log(phba, KERN_INFO,
6683                                                 LOG_INIT | LOG_NVME_DISC,
6684                                                 "6076 NVME Target Found\n");
6685                         }
6686                 }
6687         }
6688
6689         lpfc_debugfs_initialize(vport);
6690         /* Put reference to SCSI host to driver's device private data */
6691         pci_set_drvdata(phba->pcidev, shost);
6692
6693         /*
6694          * At this point we are fully registered with PSA. In addition,
6695          * any initial discovery should be completed.
6696          */
6697         vport->load_flag |= FC_ALLOW_FDMI;
6698         if (phba->cfg_enable_SmartSAN ||
6699             (phba->cfg_fdmi_on == LPFC_FDMI_SUPPORT)) {
6700
6701                 /* Setup appropriate attribute masks */
6702                 vport->fdmi_hba_mask = LPFC_FDMI2_HBA_ATTR;
6703                 if (phba->cfg_enable_SmartSAN)
6704                         vport->fdmi_port_mask = LPFC_FDMI2_SMART_ATTR;
6705                 else
6706                         vport->fdmi_port_mask = LPFC_FDMI2_PORT_ATTR;
6707         }
6708         return 0;
6709 }
6710
6711 /**
6712  * lpfc_destroy_shost - Destroy hba physical port with associated scsi host.
6713  * @phba: pointer to lpfc hba data structure.
6714  *
6715  * This routine is invoked to destroy HBA physical port and the associated
6716  * SCSI host.
6717  **/
6718 static void
6719 lpfc_destroy_shost(struct lpfc_hba *phba)
6720 {
6721         struct lpfc_vport *vport = phba->pport;
6722
6723         /* Destroy physical port that associated with the SCSI host */
6724         destroy_port(vport);
6725
6726         return;
6727 }
6728
6729 /**
6730  * lpfc_setup_bg - Setup Block guard structures and debug areas.
6731  * @phba: pointer to lpfc hba data structure.
6732  * @shost: the shost to be used to detect Block guard settings.
6733  *
6734  * This routine sets up the local Block guard protocol settings for @shost.
6735  * This routine also allocates memory for debugging bg buffers.
6736  **/
6737 static void
6738 lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost)
6739 {
6740         uint32_t old_mask;
6741         uint32_t old_guard;
6742
6743         int pagecnt = 10;
6744         if (phba->cfg_prot_mask && phba->cfg_prot_guard) {
6745                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6746                                 "1478 Registering BlockGuard with the "
6747                                 "SCSI layer\n");
6748
6749                 old_mask = phba->cfg_prot_mask;
6750                 old_guard = phba->cfg_prot_guard;
6751
6752                 /* Only allow supported values */
6753                 phba->cfg_prot_mask &= (SHOST_DIF_TYPE1_PROTECTION |
6754                         SHOST_DIX_TYPE0_PROTECTION |
6755                         SHOST_DIX_TYPE1_PROTECTION);
6756                 phba->cfg_prot_guard &= (SHOST_DIX_GUARD_IP |
6757                                          SHOST_DIX_GUARD_CRC);
6758
6759                 /* DIF Type 1 protection for profiles AST1/C1 is end to end */
6760                 if (phba->cfg_prot_mask == SHOST_DIX_TYPE1_PROTECTION)
6761                         phba->cfg_prot_mask |= SHOST_DIF_TYPE1_PROTECTION;
6762
6763                 if (phba->cfg_prot_mask && phba->cfg_prot_guard) {
6764                         if ((old_mask != phba->cfg_prot_mask) ||
6765                                 (old_guard != phba->cfg_prot_guard))
6766                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6767                                         "1475 Registering BlockGuard with the "
6768                                         "SCSI layer: mask %d  guard %d\n",
6769                                         phba->cfg_prot_mask,
6770                                         phba->cfg_prot_guard);
6771
6772                         scsi_host_set_prot(shost, phba->cfg_prot_mask);
6773                         scsi_host_set_guard(shost, phba->cfg_prot_guard);
6774                 } else
6775                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6776                                 "1479 Not Registering BlockGuard with the SCSI "
6777                                 "layer, Bad protection parameters: %d %d\n",
6778                                 old_mask, old_guard);
6779         }
6780
6781         if (!_dump_buf_data) {
6782                 while (pagecnt) {
6783                         spin_lock_init(&_dump_buf_lock);
6784                         _dump_buf_data =
6785                                 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
6786                         if (_dump_buf_data) {
6787                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6788                                         "9043 BLKGRD: allocated %d pages for "
6789                                        "_dump_buf_data at 0x%p\n",
6790                                        (1 << pagecnt), _dump_buf_data);
6791                                 _dump_buf_data_order = pagecnt;
6792                                 memset(_dump_buf_data, 0,
6793                                        ((1 << PAGE_SHIFT) << pagecnt));
6794                                 break;
6795                         } else
6796                                 --pagecnt;
6797                 }
6798                 if (!_dump_buf_data_order)
6799                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6800                                 "9044 BLKGRD: ERROR unable to allocate "
6801                                "memory for hexdump\n");
6802         } else
6803                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6804                         "9045 BLKGRD: already allocated _dump_buf_data=0x%p"
6805                        "\n", _dump_buf_data);
6806         if (!_dump_buf_dif) {
6807                 while (pagecnt) {
6808                         _dump_buf_dif =
6809                                 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
6810                         if (_dump_buf_dif) {
6811                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6812                                         "9046 BLKGRD: allocated %d pages for "
6813                                        "_dump_buf_dif at 0x%p\n",
6814                                        (1 << pagecnt), _dump_buf_dif);
6815                                 _dump_buf_dif_order = pagecnt;
6816                                 memset(_dump_buf_dif, 0,
6817                                        ((1 << PAGE_SHIFT) << pagecnt));
6818                                 break;
6819                         } else
6820                                 --pagecnt;
6821                 }
6822                 if (!_dump_buf_dif_order)
6823                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6824                         "9047 BLKGRD: ERROR unable to allocate "
6825                                "memory for hexdump\n");
6826         } else
6827                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
6828                         "9048 BLKGRD: already allocated _dump_buf_dif=0x%p\n",
6829                        _dump_buf_dif);
6830 }
6831
6832 /**
6833  * lpfc_post_init_setup - Perform necessary device post initialization setup.
6834  * @phba: pointer to lpfc hba data structure.
6835  *
6836  * This routine is invoked to perform all the necessary post initialization
6837  * setup for the device.
6838  **/
6839 static void
6840 lpfc_post_init_setup(struct lpfc_hba *phba)
6841 {
6842         struct Scsi_Host  *shost;
6843         struct lpfc_adapter_event_header adapter_event;
6844
6845         /* Get the default values for Model Name and Description */
6846         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
6847
6848         /*
6849          * hba setup may have changed the hba_queue_depth so we need to
6850          * adjust the value of can_queue.
6851          */
6852         shost = pci_get_drvdata(phba->pcidev);
6853         shost->can_queue = phba->cfg_hba_queue_depth - 10;
6854         if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
6855                 lpfc_setup_bg(phba, shost);
6856
6857         lpfc_host_attrib_init(shost);
6858
6859         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
6860                 spin_lock_irq(shost->host_lock);
6861                 lpfc_poll_start_timer(phba);
6862                 spin_unlock_irq(shost->host_lock);
6863         }
6864
6865         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6866                         "0428 Perform SCSI scan\n");
6867         /* Send board arrival event to upper layer */
6868         adapter_event.event_type = FC_REG_ADAPTER_EVENT;
6869         adapter_event.subcategory = LPFC_EVENT_ARRIVAL;
6870         fc_host_post_vendor_event(shost, fc_get_event_number(),
6871                                   sizeof(adapter_event),
6872                                   (char *) &adapter_event,
6873                                   LPFC_NL_VENDOR_ID);
6874         return;
6875 }
6876
6877 /**
6878  * lpfc_sli_pci_mem_setup - Setup SLI3 HBA PCI memory space.
6879  * @phba: pointer to lpfc hba data structure.
6880  *
6881  * This routine is invoked to set up the PCI device memory space for device
6882  * with SLI-3 interface spec.
6883  *
6884  * Return codes
6885  *      0 - successful
6886  *      other values - error
6887  **/
6888 static int
6889 lpfc_sli_pci_mem_setup(struct lpfc_hba *phba)
6890 {
6891         struct pci_dev *pdev;
6892         unsigned long bar0map_len, bar2map_len;
6893         int i, hbq_count;
6894         void *ptr;
6895         int error = -ENODEV;
6896
6897         /* Obtain PCI device reference */
6898         if (!phba->pcidev)
6899                 return error;
6900         else
6901                 pdev = phba->pcidev;
6902
6903         /* Set the device DMA mask size */
6904         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
6905          || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
6906                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
6907                  || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
6908                         return error;
6909                 }
6910         }
6911
6912         /* Get the bus address of Bar0 and Bar2 and the number of bytes
6913          * required by each mapping.
6914          */
6915         phba->pci_bar0_map = pci_resource_start(pdev, 0);
6916         bar0map_len = pci_resource_len(pdev, 0);
6917
6918         phba->pci_bar2_map = pci_resource_start(pdev, 2);
6919         bar2map_len = pci_resource_len(pdev, 2);
6920
6921         /* Map HBA SLIM to a kernel virtual address. */
6922         phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len);
6923         if (!phba->slim_memmap_p) {
6924                 dev_printk(KERN_ERR, &pdev->dev,
6925                            "ioremap failed for SLIM memory.\n");
6926                 goto out;
6927         }
6928
6929         /* Map HBA Control Registers to a kernel virtual address. */
6930         phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len);
6931         if (!phba->ctrl_regs_memmap_p) {
6932                 dev_printk(KERN_ERR, &pdev->dev,
6933                            "ioremap failed for HBA control registers.\n");
6934                 goto out_iounmap_slim;
6935         }
6936
6937         /* Allocate memory for SLI-2 structures */
6938         phba->slim2p.virt = dma_zalloc_coherent(&pdev->dev, SLI2_SLIM_SIZE,
6939                                                 &phba->slim2p.phys, GFP_KERNEL);
6940         if (!phba->slim2p.virt)
6941                 goto out_iounmap;
6942
6943         phba->mbox = phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, mbx);
6944         phba->mbox_ext = (phba->slim2p.virt +
6945                 offsetof(struct lpfc_sli2_slim, mbx_ext_words));
6946         phba->pcb = (phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, pcb));
6947         phba->IOCBs = (phba->slim2p.virt +
6948                        offsetof(struct lpfc_sli2_slim, IOCBs));
6949
6950         phba->hbqslimp.virt = dma_alloc_coherent(&pdev->dev,
6951                                                  lpfc_sli_hbq_size(),
6952                                                  &phba->hbqslimp.phys,
6953                                                  GFP_KERNEL);
6954         if (!phba->hbqslimp.virt)
6955                 goto out_free_slim;
6956
6957         hbq_count = lpfc_sli_hbq_count();
6958         ptr = phba->hbqslimp.virt;
6959         for (i = 0; i < hbq_count; ++i) {
6960                 phba->hbqs[i].hbq_virt = ptr;
6961                 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
6962                 ptr += (lpfc_hbq_defs[i]->entry_count *
6963                         sizeof(struct lpfc_hbq_entry));
6964         }
6965         phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc;
6966         phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_els_hbq_free;
6967
6968         memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size());
6969
6970         phba->MBslimaddr = phba->slim_memmap_p;
6971         phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
6972         phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
6973         phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
6974         phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
6975
6976         return 0;
6977
6978 out_free_slim:
6979         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
6980                           phba->slim2p.virt, phba->slim2p.phys);
6981 out_iounmap:
6982         iounmap(phba->ctrl_regs_memmap_p);
6983 out_iounmap_slim:
6984         iounmap(phba->slim_memmap_p);
6985 out:
6986         return error;
6987 }
6988
6989 /**
6990  * lpfc_sli_pci_mem_unset - Unset SLI3 HBA PCI memory space.
6991  * @phba: pointer to lpfc hba data structure.
6992  *
6993  * This routine is invoked to unset the PCI device memory space for device
6994  * with SLI-3 interface spec.
6995  **/
6996 static void
6997 lpfc_sli_pci_mem_unset(struct lpfc_hba *phba)
6998 {
6999         struct pci_dev *pdev;
7000
7001         /* Obtain PCI device reference */
7002         if (!phba->pcidev)
7003                 return;
7004         else
7005                 pdev = phba->pcidev;
7006
7007         /* Free coherent DMA memory allocated */
7008         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
7009                           phba->hbqslimp.virt, phba->hbqslimp.phys);
7010         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
7011                           phba->slim2p.virt, phba->slim2p.phys);
7012
7013         /* I/O memory unmap */
7014         iounmap(phba->ctrl_regs_memmap_p);
7015         iounmap(phba->slim_memmap_p);
7016
7017         return;
7018 }
7019
7020 /**
7021  * lpfc_sli4_post_status_check - Wait for SLI4 POST done and check status
7022  * @phba: pointer to lpfc hba data structure.
7023  *
7024  * This routine is invoked to wait for SLI4 device Power On Self Test (POST)
7025  * done and check status.
7026  *
7027  * Return 0 if successful, otherwise -ENODEV.
7028  **/
7029 int
7030 lpfc_sli4_post_status_check(struct lpfc_hba *phba)
7031 {
7032         struct lpfc_register portsmphr_reg, uerrlo_reg, uerrhi_reg;
7033         struct lpfc_register reg_data;
7034         int i, port_error = 0;
7035         uint32_t if_type;
7036
7037         memset(&portsmphr_reg, 0, sizeof(portsmphr_reg));
7038         memset(&reg_data, 0, sizeof(reg_data));
7039         if (!phba->sli4_hba.PSMPHRregaddr)
7040                 return -ENODEV;
7041
7042         /* Wait up to 30 seconds for the SLI Port POST done and ready */
7043         for (i = 0; i < 3000; i++) {
7044                 if (lpfc_readl(phba->sli4_hba.PSMPHRregaddr,
7045                         &portsmphr_reg.word0) ||
7046                         (bf_get(lpfc_port_smphr_perr, &portsmphr_reg))) {
7047                         /* Port has a fatal POST error, break out */
7048                         port_error = -ENODEV;
7049                         break;
7050                 }
7051                 if (LPFC_POST_STAGE_PORT_READY ==
7052                     bf_get(lpfc_port_smphr_port_status, &portsmphr_reg))
7053                         break;
7054                 msleep(10);
7055         }
7056
7057         /*
7058          * If there was a port error during POST, then don't proceed with
7059          * other register reads as the data may not be valid.  Just exit.
7060          */
7061         if (port_error) {
7062                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7063                         "1408 Port Failed POST - portsmphr=0x%x, "
7064                         "perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, scr1=x%x, "
7065                         "scr2=x%x, hscratch=x%x, pstatus=x%x\n",
7066                         portsmphr_reg.word0,
7067                         bf_get(lpfc_port_smphr_perr, &portsmphr_reg),
7068                         bf_get(lpfc_port_smphr_sfi, &portsmphr_reg),
7069                         bf_get(lpfc_port_smphr_nip, &portsmphr_reg),
7070                         bf_get(lpfc_port_smphr_ipc, &portsmphr_reg),
7071                         bf_get(lpfc_port_smphr_scr1, &portsmphr_reg),
7072                         bf_get(lpfc_port_smphr_scr2, &portsmphr_reg),
7073                         bf_get(lpfc_port_smphr_host_scratch, &portsmphr_reg),
7074                         bf_get(lpfc_port_smphr_port_status, &portsmphr_reg));
7075         } else {
7076                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7077                                 "2534 Device Info: SLIFamily=0x%x, "
7078                                 "SLIRev=0x%x, IFType=0x%x, SLIHint_1=0x%x, "
7079                                 "SLIHint_2=0x%x, FT=0x%x\n",
7080                                 bf_get(lpfc_sli_intf_sli_family,
7081                                        &phba->sli4_hba.sli_intf),
7082                                 bf_get(lpfc_sli_intf_slirev,
7083                                        &phba->sli4_hba.sli_intf),
7084                                 bf_get(lpfc_sli_intf_if_type,
7085                                        &phba->sli4_hba.sli_intf),
7086                                 bf_get(lpfc_sli_intf_sli_hint1,
7087                                        &phba->sli4_hba.sli_intf),
7088                                 bf_get(lpfc_sli_intf_sli_hint2,
7089                                        &phba->sli4_hba.sli_intf),
7090                                 bf_get(lpfc_sli_intf_func_type,
7091                                        &phba->sli4_hba.sli_intf));
7092                 /*
7093                  * Check for other Port errors during the initialization
7094                  * process.  Fail the load if the port did not come up
7095                  * correctly.
7096                  */
7097                 if_type = bf_get(lpfc_sli_intf_if_type,
7098                                  &phba->sli4_hba.sli_intf);
7099                 switch (if_type) {
7100                 case LPFC_SLI_INTF_IF_TYPE_0:
7101                         phba->sli4_hba.ue_mask_lo =
7102                               readl(phba->sli4_hba.u.if_type0.UEMASKLOregaddr);
7103                         phba->sli4_hba.ue_mask_hi =
7104                               readl(phba->sli4_hba.u.if_type0.UEMASKHIregaddr);
7105                         uerrlo_reg.word0 =
7106                               readl(phba->sli4_hba.u.if_type0.UERRLOregaddr);
7107                         uerrhi_reg.word0 =
7108                                 readl(phba->sli4_hba.u.if_type0.UERRHIregaddr);
7109                         if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) ||
7110                             (~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) {
7111                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7112                                                 "1422 Unrecoverable Error "
7113                                                 "Detected during POST "
7114                                                 "uerr_lo_reg=0x%x, "
7115                                                 "uerr_hi_reg=0x%x, "
7116                                                 "ue_mask_lo_reg=0x%x, "
7117                                                 "ue_mask_hi_reg=0x%x\n",
7118                                                 uerrlo_reg.word0,
7119                                                 uerrhi_reg.word0,
7120                                                 phba->sli4_hba.ue_mask_lo,
7121                                                 phba->sli4_hba.ue_mask_hi);
7122                                 port_error = -ENODEV;
7123                         }
7124                         break;
7125                 case LPFC_SLI_INTF_IF_TYPE_2:
7126                         /* Final checks.  The port status should be clean. */
7127                         if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
7128                                 &reg_data.word0) ||
7129                                 (bf_get(lpfc_sliport_status_err, &reg_data) &&
7130                                  !bf_get(lpfc_sliport_status_rn, &reg_data))) {
7131                                 phba->work_status[0] =
7132                                         readl(phba->sli4_hba.u.if_type2.
7133                                               ERR1regaddr);
7134                                 phba->work_status[1] =
7135                                         readl(phba->sli4_hba.u.if_type2.
7136                                               ERR2regaddr);
7137                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7138                                         "2888 Unrecoverable port error "
7139                                         "following POST: port status reg "
7140                                         "0x%x, port_smphr reg 0x%x, "
7141                                         "error 1=0x%x, error 2=0x%x\n",
7142                                         reg_data.word0,
7143                                         portsmphr_reg.word0,
7144                                         phba->work_status[0],
7145                                         phba->work_status[1]);
7146                                 port_error = -ENODEV;
7147                         }
7148                         break;
7149                 case LPFC_SLI_INTF_IF_TYPE_1:
7150                 default:
7151                         break;
7152                 }
7153         }
7154         return port_error;
7155 }
7156
7157 /**
7158  * lpfc_sli4_bar0_register_memmap - Set up SLI4 BAR0 register memory map.
7159  * @phba: pointer to lpfc hba data structure.
7160  * @if_type:  The SLI4 interface type getting configured.
7161  *
7162  * This routine is invoked to set up SLI4 BAR0 PCI config space register
7163  * memory map.
7164  **/
7165 static void
7166 lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba, uint32_t if_type)
7167 {
7168         switch (if_type) {
7169         case LPFC_SLI_INTF_IF_TYPE_0:
7170                 phba->sli4_hba.u.if_type0.UERRLOregaddr =
7171                         phba->sli4_hba.conf_regs_memmap_p + LPFC_UERR_STATUS_LO;
7172                 phba->sli4_hba.u.if_type0.UERRHIregaddr =
7173                         phba->sli4_hba.conf_regs_memmap_p + LPFC_UERR_STATUS_HI;
7174                 phba->sli4_hba.u.if_type0.UEMASKLOregaddr =
7175                         phba->sli4_hba.conf_regs_memmap_p + LPFC_UE_MASK_LO;
7176                 phba->sli4_hba.u.if_type0.UEMASKHIregaddr =
7177                         phba->sli4_hba.conf_regs_memmap_p + LPFC_UE_MASK_HI;
7178                 phba->sli4_hba.SLIINTFregaddr =
7179                         phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF;
7180                 break;
7181         case LPFC_SLI_INTF_IF_TYPE_2:
7182                 phba->sli4_hba.u.if_type2.ERR1regaddr =
7183                         phba->sli4_hba.conf_regs_memmap_p +
7184                                                 LPFC_CTL_PORT_ER1_OFFSET;
7185                 phba->sli4_hba.u.if_type2.ERR2regaddr =
7186                         phba->sli4_hba.conf_regs_memmap_p +
7187                                                 LPFC_CTL_PORT_ER2_OFFSET;
7188                 phba->sli4_hba.u.if_type2.CTRLregaddr =
7189                         phba->sli4_hba.conf_regs_memmap_p +
7190                                                 LPFC_CTL_PORT_CTL_OFFSET;
7191                 phba->sli4_hba.u.if_type2.STATUSregaddr =
7192                         phba->sli4_hba.conf_regs_memmap_p +
7193                                                 LPFC_CTL_PORT_STA_OFFSET;
7194                 phba->sli4_hba.SLIINTFregaddr =
7195                         phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF;
7196                 phba->sli4_hba.PSMPHRregaddr =
7197                         phba->sli4_hba.conf_regs_memmap_p +
7198                                                 LPFC_CTL_PORT_SEM_OFFSET;
7199                 phba->sli4_hba.RQDBregaddr =
7200                         phba->sli4_hba.conf_regs_memmap_p +
7201                                                 LPFC_ULP0_RQ_DOORBELL;
7202                 phba->sli4_hba.WQDBregaddr =
7203                         phba->sli4_hba.conf_regs_memmap_p +
7204                                                 LPFC_ULP0_WQ_DOORBELL;
7205                 phba->sli4_hba.EQCQDBregaddr =
7206                         phba->sli4_hba.conf_regs_memmap_p + LPFC_EQCQ_DOORBELL;
7207                 phba->sli4_hba.MQDBregaddr =
7208                         phba->sli4_hba.conf_regs_memmap_p + LPFC_MQ_DOORBELL;
7209                 phba->sli4_hba.BMBXregaddr =
7210                         phba->sli4_hba.conf_regs_memmap_p + LPFC_BMBX;
7211                 break;
7212         case LPFC_SLI_INTF_IF_TYPE_1:
7213         default:
7214                 dev_printk(KERN_ERR, &phba->pcidev->dev,
7215                            "FATAL - unsupported SLI4 interface type - %d\n",
7216                            if_type);
7217                 break;
7218         }
7219 }
7220
7221 /**
7222  * lpfc_sli4_bar1_register_memmap - Set up SLI4 BAR1 register memory map.
7223  * @phba: pointer to lpfc hba data structure.
7224  *
7225  * This routine is invoked to set up SLI4 BAR1 control status register (CSR)
7226  * memory map.
7227  **/
7228 static void
7229 lpfc_sli4_bar1_register_memmap(struct lpfc_hba *phba)
7230 {
7231         phba->sli4_hba.PSMPHRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
7232                 LPFC_SLIPORT_IF0_SMPHR;
7233         phba->sli4_hba.ISRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
7234                 LPFC_HST_ISR0;
7235         phba->sli4_hba.IMRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
7236                 LPFC_HST_IMR0;
7237         phba->sli4_hba.ISCRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
7238                 LPFC_HST_ISCR0;
7239 }
7240
7241 /**
7242  * lpfc_sli4_bar2_register_memmap - Set up SLI4 BAR2 register memory map.
7243  * @phba: pointer to lpfc hba data structure.
7244  * @vf: virtual function number
7245  *
7246  * This routine is invoked to set up SLI4 BAR2 doorbell register memory map
7247  * based on the given viftual function number, @vf.
7248  *
7249  * Return 0 if successful, otherwise -ENODEV.
7250  **/
7251 static int
7252 lpfc_sli4_bar2_register_memmap(struct lpfc_hba *phba, uint32_t vf)
7253 {
7254         if (vf > LPFC_VIR_FUNC_MAX)
7255                 return -ENODEV;
7256
7257         phba->sli4_hba.RQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
7258                                 vf * LPFC_VFR_PAGE_SIZE +
7259                                         LPFC_ULP0_RQ_DOORBELL);
7260         phba->sli4_hba.WQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
7261                                 vf * LPFC_VFR_PAGE_SIZE +
7262                                         LPFC_ULP0_WQ_DOORBELL);
7263         phba->sli4_hba.EQCQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
7264                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_EQCQ_DOORBELL);
7265         phba->sli4_hba.MQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
7266                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_MQ_DOORBELL);
7267         phba->sli4_hba.BMBXregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
7268                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_BMBX);
7269         return 0;
7270 }
7271
7272 /**
7273  * lpfc_create_bootstrap_mbox - Create the bootstrap mailbox
7274  * @phba: pointer to lpfc hba data structure.
7275  *
7276  * This routine is invoked to create the bootstrap mailbox
7277  * region consistent with the SLI-4 interface spec.  This
7278  * routine allocates all memory necessary to communicate
7279  * mailbox commands to the port and sets up all alignment
7280  * needs.  No locks are expected to be held when calling
7281  * this routine.
7282  *
7283  * Return codes
7284  *      0 - successful
7285  *      -ENOMEM - could not allocated memory.
7286  **/
7287 static int
7288 lpfc_create_bootstrap_mbox(struct lpfc_hba *phba)
7289 {
7290         uint32_t bmbx_size;
7291         struct lpfc_dmabuf *dmabuf;
7292         struct dma_address *dma_address;
7293         uint32_t pa_addr;
7294         uint64_t phys_addr;
7295
7296         dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
7297         if (!dmabuf)
7298                 return -ENOMEM;
7299
7300         /*
7301          * The bootstrap mailbox region is comprised of 2 parts
7302          * plus an alignment restriction of 16 bytes.
7303          */
7304         bmbx_size = sizeof(struct lpfc_bmbx_create) + (LPFC_ALIGN_16_BYTE - 1);
7305         dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev, bmbx_size,
7306                                            &dmabuf->phys, GFP_KERNEL);
7307         if (!dmabuf->virt) {
7308                 kfree(dmabuf);
7309                 return -ENOMEM;
7310         }
7311
7312         /*
7313          * Initialize the bootstrap mailbox pointers now so that the register
7314          * operations are simple later.  The mailbox dma address is required
7315          * to be 16-byte aligned.  Also align the virtual memory as each
7316          * maibox is copied into the bmbx mailbox region before issuing the
7317          * command to the port.
7318          */
7319         phba->sli4_hba.bmbx.dmabuf = dmabuf;
7320         phba->sli4_hba.bmbx.bmbx_size = bmbx_size;
7321
7322         phba->sli4_hba.bmbx.avirt = PTR_ALIGN(dmabuf->virt,
7323                                               LPFC_ALIGN_16_BYTE);
7324         phba->sli4_hba.bmbx.aphys = ALIGN(dmabuf->phys,
7325                                               LPFC_ALIGN_16_BYTE);
7326
7327         /*
7328          * Set the high and low physical addresses now.  The SLI4 alignment
7329          * requirement is 16 bytes and the mailbox is posted to the port
7330          * as two 30-bit addresses.  The other data is a bit marking whether
7331          * the 30-bit address is the high or low address.
7332          * Upcast bmbx aphys to 64bits so shift instruction compiles
7333          * clean on 32 bit machines.
7334          */
7335         dma_address = &phba->sli4_hba.bmbx.dma_address;
7336         phys_addr = (uint64_t)phba->sli4_hba.bmbx.aphys;
7337         pa_addr = (uint32_t) ((phys_addr >> 34) & 0x3fffffff);
7338         dma_address->addr_hi = (uint32_t) ((pa_addr << 2) |
7339                                            LPFC_BMBX_BIT1_ADDR_HI);
7340
7341         pa_addr = (uint32_t) ((phba->sli4_hba.bmbx.aphys >> 4) & 0x3fffffff);
7342         dma_address->addr_lo = (uint32_t) ((pa_addr << 2) |
7343                                            LPFC_BMBX_BIT1_ADDR_LO);
7344         return 0;
7345 }
7346
7347 /**
7348  * lpfc_destroy_bootstrap_mbox - Destroy all bootstrap mailbox resources
7349  * @phba: pointer to lpfc hba data structure.
7350  *
7351  * This routine is invoked to teardown the bootstrap mailbox
7352  * region and release all host resources. This routine requires
7353  * the caller to ensure all mailbox commands recovered, no
7354  * additional mailbox comands are sent, and interrupts are disabled
7355  * before calling this routine.
7356  *
7357  **/
7358 static void
7359 lpfc_destroy_bootstrap_mbox(struct lpfc_hba *phba)
7360 {
7361         dma_free_coherent(&phba->pcidev->dev,
7362                           phba->sli4_hba.bmbx.bmbx_size,
7363                           phba->sli4_hba.bmbx.dmabuf->virt,
7364                           phba->sli4_hba.bmbx.dmabuf->phys);
7365
7366         kfree(phba->sli4_hba.bmbx.dmabuf);
7367         memset(&phba->sli4_hba.bmbx, 0, sizeof(struct lpfc_bmbx));
7368 }
7369
7370 /**
7371  * lpfc_sli4_read_config - Get the config parameters.
7372  * @phba: pointer to lpfc hba data structure.
7373  *
7374  * This routine is invoked to read the configuration parameters from the HBA.
7375  * The configuration parameters are used to set the base and maximum values
7376  * for RPI's XRI's VPI's VFI's and FCFIs. These values also affect the resource
7377  * allocation for the port.
7378  *
7379  * Return codes
7380  *      0 - successful
7381  *      -ENOMEM - No available memory
7382  *      -EIO - The mailbox failed to complete successfully.
7383  **/
7384 int
7385 lpfc_sli4_read_config(struct lpfc_hba *phba)
7386 {
7387         LPFC_MBOXQ_t *pmb;
7388         struct lpfc_mbx_read_config *rd_config;
7389         union  lpfc_sli4_cfg_shdr *shdr;
7390         uint32_t shdr_status, shdr_add_status;
7391         struct lpfc_mbx_get_func_cfg *get_func_cfg;
7392         struct lpfc_rsrc_desc_fcfcoe *desc;
7393         char *pdesc_0;
7394         uint16_t forced_link_speed;
7395         uint32_t if_type;
7396         int length, i, rc = 0, rc2;
7397
7398         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
7399         if (!pmb) {
7400                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7401                                 "2011 Unable to allocate memory for issuing "
7402                                 "SLI_CONFIG_SPECIAL mailbox command\n");
7403                 return -ENOMEM;
7404         }
7405
7406         lpfc_read_config(phba, pmb);
7407
7408         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
7409         if (rc != MBX_SUCCESS) {
7410                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7411                         "2012 Mailbox failed , mbxCmd x%x "
7412                         "READ_CONFIG, mbxStatus x%x\n",
7413                         bf_get(lpfc_mqe_command, &pmb->u.mqe),
7414                         bf_get(lpfc_mqe_status, &pmb->u.mqe));
7415                 rc = -EIO;
7416         } else {
7417                 rd_config = &pmb->u.mqe.un.rd_config;
7418                 if (bf_get(lpfc_mbx_rd_conf_lnk_ldv, rd_config)) {
7419                         phba->sli4_hba.lnk_info.lnk_dv = LPFC_LNK_DAT_VAL;
7420                         phba->sli4_hba.lnk_info.lnk_tp =
7421                                 bf_get(lpfc_mbx_rd_conf_lnk_type, rd_config);
7422                         phba->sli4_hba.lnk_info.lnk_no =
7423                                 bf_get(lpfc_mbx_rd_conf_lnk_numb, rd_config);
7424                         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
7425                                         "3081 lnk_type:%d, lnk_numb:%d\n",
7426                                         phba->sli4_hba.lnk_info.lnk_tp,
7427                                         phba->sli4_hba.lnk_info.lnk_no);
7428                 } else
7429                         lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
7430                                         "3082 Mailbox (x%x) returned ldv:x0\n",
7431                                         bf_get(lpfc_mqe_command, &pmb->u.mqe));
7432                 phba->sli4_hba.extents_in_use =
7433                         bf_get(lpfc_mbx_rd_conf_extnts_inuse, rd_config);
7434                 phba->sli4_hba.max_cfg_param.max_xri =
7435                         bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
7436                 phba->sli4_hba.max_cfg_param.xri_base =
7437                         bf_get(lpfc_mbx_rd_conf_xri_base, rd_config);
7438                 phba->sli4_hba.max_cfg_param.max_vpi =
7439                         bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config);
7440                 phba->sli4_hba.max_cfg_param.vpi_base =
7441                         bf_get(lpfc_mbx_rd_conf_vpi_base, rd_config);
7442                 phba->sli4_hba.max_cfg_param.max_rpi =
7443                         bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
7444                 phba->sli4_hba.max_cfg_param.rpi_base =
7445                         bf_get(lpfc_mbx_rd_conf_rpi_base, rd_config);
7446                 phba->sli4_hba.max_cfg_param.max_vfi =
7447                         bf_get(lpfc_mbx_rd_conf_vfi_count, rd_config);
7448                 phba->sli4_hba.max_cfg_param.vfi_base =
7449                         bf_get(lpfc_mbx_rd_conf_vfi_base, rd_config);
7450                 phba->sli4_hba.max_cfg_param.max_fcfi =
7451                         bf_get(lpfc_mbx_rd_conf_fcfi_count, rd_config);
7452                 phba->sli4_hba.max_cfg_param.max_eq =
7453                         bf_get(lpfc_mbx_rd_conf_eq_count, rd_config);
7454                 phba->sli4_hba.max_cfg_param.max_rq =
7455                         bf_get(lpfc_mbx_rd_conf_rq_count, rd_config);
7456                 phba->sli4_hba.max_cfg_param.max_wq =
7457                         bf_get(lpfc_mbx_rd_conf_wq_count, rd_config);
7458                 phba->sli4_hba.max_cfg_param.max_cq =
7459                         bf_get(lpfc_mbx_rd_conf_cq_count, rd_config);
7460                 phba->lmt = bf_get(lpfc_mbx_rd_conf_lmt, rd_config);
7461                 phba->sli4_hba.next_xri = phba->sli4_hba.max_cfg_param.xri_base;
7462                 phba->vpi_base = phba->sli4_hba.max_cfg_param.vpi_base;
7463                 phba->vfi_base = phba->sli4_hba.max_cfg_param.vfi_base;
7464                 phba->max_vpi = (phba->sli4_hba.max_cfg_param.max_vpi > 0) ?
7465                                 (phba->sli4_hba.max_cfg_param.max_vpi - 1) : 0;
7466                 phba->max_vports = phba->max_vpi;
7467                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
7468                                 "2003 cfg params Extents? %d "
7469                                 "XRI(B:%d M:%d), "
7470                                 "VPI(B:%d M:%d) "
7471                                 "VFI(B:%d M:%d) "
7472                                 "RPI(B:%d M:%d) "
7473                                 "FCFI:%d EQ:%d CQ:%d WQ:%d RQ:%d\n",
7474                                 phba->sli4_hba.extents_in_use,
7475                                 phba->sli4_hba.max_cfg_param.xri_base,
7476                                 phba->sli4_hba.max_cfg_param.max_xri,
7477                                 phba->sli4_hba.max_cfg_param.vpi_base,
7478                                 phba->sli4_hba.max_cfg_param.max_vpi,
7479                                 phba->sli4_hba.max_cfg_param.vfi_base,
7480                                 phba->sli4_hba.max_cfg_param.max_vfi,
7481                                 phba->sli4_hba.max_cfg_param.rpi_base,
7482                                 phba->sli4_hba.max_cfg_param.max_rpi,
7483                                 phba->sli4_hba.max_cfg_param.max_fcfi,
7484                                 phba->sli4_hba.max_cfg_param.max_eq,
7485                                 phba->sli4_hba.max_cfg_param.max_cq,
7486                                 phba->sli4_hba.max_cfg_param.max_wq,
7487                                 phba->sli4_hba.max_cfg_param.max_rq);
7488
7489         }
7490
7491         if (rc)
7492                 goto read_cfg_out;
7493
7494         /* Update link speed if forced link speed is supported */
7495         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
7496         if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
7497                 forced_link_speed =
7498                         bf_get(lpfc_mbx_rd_conf_link_speed, rd_config);
7499                 if (forced_link_speed) {
7500                         phba->hba_flag |= HBA_FORCED_LINK_SPEED;
7501
7502                         switch (forced_link_speed) {
7503                         case LINK_SPEED_1G:
7504                                 phba->cfg_link_speed =
7505                                         LPFC_USER_LINK_SPEED_1G;
7506                                 break;
7507                         case LINK_SPEED_2G:
7508                                 phba->cfg_link_speed =
7509                                         LPFC_USER_LINK_SPEED_2G;
7510                                 break;
7511                         case LINK_SPEED_4G:
7512                                 phba->cfg_link_speed =
7513                                         LPFC_USER_LINK_SPEED_4G;
7514                                 break;
7515                         case LINK_SPEED_8G:
7516                                 phba->cfg_link_speed =
7517                                         LPFC_USER_LINK_SPEED_8G;
7518                                 break;
7519                         case LINK_SPEED_10G:
7520                                 phba->cfg_link_speed =
7521                                         LPFC_USER_LINK_SPEED_10G;
7522                                 break;
7523                         case LINK_SPEED_16G:
7524                                 phba->cfg_link_speed =
7525                                         LPFC_USER_LINK_SPEED_16G;
7526                                 break;
7527                         case LINK_SPEED_32G:
7528                                 phba->cfg_link_speed =
7529                                         LPFC_USER_LINK_SPEED_32G;
7530                                 break;
7531                         case 0xffff:
7532                                 phba->cfg_link_speed =
7533                                         LPFC_USER_LINK_SPEED_AUTO;
7534                                 break;
7535                         default:
7536                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7537                                                 "0047 Unrecognized link "
7538                                                 "speed : %d\n",
7539                                                 forced_link_speed);
7540                                 phba->cfg_link_speed =
7541                                         LPFC_USER_LINK_SPEED_AUTO;
7542                         }
7543                 }
7544         }
7545
7546         /* Reset the DFT_HBA_Q_DEPTH to the max xri  */
7547         length = phba->sli4_hba.max_cfg_param.max_xri -
7548                         lpfc_sli4_get_els_iocb_cnt(phba);
7549         if (phba->cfg_hba_queue_depth > length) {
7550                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
7551                                 "3361 HBA queue depth changed from %d to %d\n",
7552                                 phba->cfg_hba_queue_depth, length);
7553                 phba->cfg_hba_queue_depth = length;
7554         }
7555
7556         if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
7557             LPFC_SLI_INTF_IF_TYPE_2)
7558                 goto read_cfg_out;
7559
7560         /* get the pf# and vf# for SLI4 if_type 2 port */
7561         length = (sizeof(struct lpfc_mbx_get_func_cfg) -
7562                   sizeof(struct lpfc_sli4_cfg_mhdr));
7563         lpfc_sli4_config(phba, pmb, LPFC_MBOX_SUBSYSTEM_COMMON,
7564                          LPFC_MBOX_OPCODE_GET_FUNCTION_CONFIG,
7565                          length, LPFC_SLI4_MBX_EMBED);
7566
7567         rc2 = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
7568         shdr = (union lpfc_sli4_cfg_shdr *)
7569                                 &pmb->u.mqe.un.sli4_config.header.cfg_shdr;
7570         shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
7571         shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
7572         if (rc2 || shdr_status || shdr_add_status) {
7573                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7574                                 "3026 Mailbox failed , mbxCmd x%x "
7575                                 "GET_FUNCTION_CONFIG, mbxStatus x%x\n",
7576                                 bf_get(lpfc_mqe_command, &pmb->u.mqe),
7577                                 bf_get(lpfc_mqe_status, &pmb->u.mqe));
7578                 goto read_cfg_out;
7579         }
7580
7581         /* search for fc_fcoe resrouce descriptor */
7582         get_func_cfg = &pmb->u.mqe.un.get_func_cfg;
7583
7584         pdesc_0 = (char *)&get_func_cfg->func_cfg.desc[0];
7585         desc = (struct lpfc_rsrc_desc_fcfcoe *)pdesc_0;
7586         length = bf_get(lpfc_rsrc_desc_fcfcoe_length, desc);
7587         if (length == LPFC_RSRC_DESC_TYPE_FCFCOE_V0_RSVD)
7588                 length = LPFC_RSRC_DESC_TYPE_FCFCOE_V0_LENGTH;
7589         else if (length != LPFC_RSRC_DESC_TYPE_FCFCOE_V1_LENGTH)
7590                 goto read_cfg_out;
7591
7592         for (i = 0; i < LPFC_RSRC_DESC_MAX_NUM; i++) {
7593                 desc = (struct lpfc_rsrc_desc_fcfcoe *)(pdesc_0 + length * i);
7594                 if (LPFC_RSRC_DESC_TYPE_FCFCOE ==
7595                     bf_get(lpfc_rsrc_desc_fcfcoe_type, desc)) {
7596                         phba->sli4_hba.iov.pf_number =
7597                                 bf_get(lpfc_rsrc_desc_fcfcoe_pfnum, desc);
7598                         phba->sli4_hba.iov.vf_number =
7599                                 bf_get(lpfc_rsrc_desc_fcfcoe_vfnum, desc);
7600                         break;
7601                 }
7602         }
7603
7604         if (i < LPFC_RSRC_DESC_MAX_NUM)
7605                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
7606                                 "3027 GET_FUNCTION_CONFIG: pf_number:%d, "
7607                                 "vf_number:%d\n", phba->sli4_hba.iov.pf_number,
7608                                 phba->sli4_hba.iov.vf_number);
7609         else
7610                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7611                                 "3028 GET_FUNCTION_CONFIG: failed to find "
7612                                 "Resrouce Descriptor:x%x\n",
7613                                 LPFC_RSRC_DESC_TYPE_FCFCOE);
7614
7615 read_cfg_out:
7616         mempool_free(pmb, phba->mbox_mem_pool);
7617         return rc;
7618 }
7619
7620 /**
7621  * lpfc_setup_endian_order - Write endian order to an SLI4 if_type 0 port.
7622  * @phba: pointer to lpfc hba data structure.
7623  *
7624  * This routine is invoked to setup the port-side endian order when
7625  * the port if_type is 0.  This routine has no function for other
7626  * if_types.
7627  *
7628  * Return codes
7629  *      0 - successful
7630  *      -ENOMEM - No available memory
7631  *      -EIO - The mailbox failed to complete successfully.
7632  **/
7633 static int
7634 lpfc_setup_endian_order(struct lpfc_hba *phba)
7635 {
7636         LPFC_MBOXQ_t *mboxq;
7637         uint32_t if_type, rc = 0;
7638         uint32_t endian_mb_data[2] = {HOST_ENDIAN_LOW_WORD0,
7639                                       HOST_ENDIAN_HIGH_WORD1};
7640
7641         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
7642         switch (if_type) {
7643         case LPFC_SLI_INTF_IF_TYPE_0:
7644                 mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
7645                                                        GFP_KERNEL);
7646                 if (!mboxq) {
7647                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7648                                         "0492 Unable to allocate memory for "
7649                                         "issuing SLI_CONFIG_SPECIAL mailbox "
7650                                         "command\n");
7651                         return -ENOMEM;
7652                 }
7653
7654                 /*
7655                  * The SLI4_CONFIG_SPECIAL mailbox command requires the first
7656                  * two words to contain special data values and no other data.
7657                  */
7658                 memset(mboxq, 0, sizeof(LPFC_MBOXQ_t));
7659                 memcpy(&mboxq->u.mqe, &endian_mb_data, sizeof(endian_mb_data));
7660                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
7661                 if (rc != MBX_SUCCESS) {
7662                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7663                                         "0493 SLI_CONFIG_SPECIAL mailbox "
7664                                         "failed with status x%x\n",
7665                                         rc);
7666                         rc = -EIO;
7667                 }
7668                 mempool_free(mboxq, phba->mbox_mem_pool);
7669                 break;
7670         case LPFC_SLI_INTF_IF_TYPE_2:
7671         case LPFC_SLI_INTF_IF_TYPE_1:
7672         default:
7673                 break;
7674         }
7675         return rc;
7676 }
7677
7678 /**
7679  * lpfc_sli4_queue_verify - Verify and update EQ counts
7680  * @phba: pointer to lpfc hba data structure.
7681  *
7682  * This routine is invoked to check the user settable queue counts for EQs.
7683  * After this routine is called the counts will be set to valid values that
7684  * adhere to the constraints of the system's interrupt vectors and the port's
7685  * queue resources.
7686  *
7687  * Return codes
7688  *      0 - successful
7689  *      -ENOMEM - No available memory
7690  **/
7691 static int
7692 lpfc_sli4_queue_verify(struct lpfc_hba *phba)
7693 {
7694         int io_channel;
7695         int fof_vectors = phba->cfg_fof ? 1 : 0;
7696
7697         /*
7698          * Sanity check for configured queue parameters against the run-time
7699          * device parameters
7700          */
7701
7702         /* Sanity check on HBA EQ parameters */
7703         io_channel = phba->io_channel_irqs;
7704
7705         if (phba->sli4_hba.num_online_cpu < io_channel) {
7706                 lpfc_printf_log(phba,
7707                                 KERN_ERR, LOG_INIT,
7708                                 "3188 Reducing IO channels to match number of "
7709                                 "online CPUs: from %d to %d\n",
7710                                 io_channel, phba->sli4_hba.num_online_cpu);
7711                 io_channel = phba->sli4_hba.num_online_cpu;
7712         }
7713
7714         if (io_channel + fof_vectors > phba->sli4_hba.max_cfg_param.max_eq) {
7715                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7716                                 "2575 Reducing IO channels to match number of "
7717                                 "available EQs: from %d to %d\n",
7718                                 io_channel,
7719                                 phba->sli4_hba.max_cfg_param.max_eq);
7720                 io_channel = phba->sli4_hba.max_cfg_param.max_eq - fof_vectors;
7721         }
7722
7723         /* The actual number of FCP / NVME event queues adopted */
7724         if (io_channel != phba->io_channel_irqs)
7725                 phba->io_channel_irqs = io_channel;
7726         if (phba->cfg_fcp_io_channel > io_channel)
7727                 phba->cfg_fcp_io_channel = io_channel;
7728         if (phba->cfg_nvme_io_channel > io_channel)
7729                 phba->cfg_nvme_io_channel = io_channel;
7730         if (phba->cfg_nvme_io_channel < phba->cfg_nvmet_mrq)
7731                 phba->cfg_nvmet_mrq = phba->cfg_nvme_io_channel;
7732
7733         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7734                         "2574 IO channels: irqs %d fcp %d nvme %d MRQ: %d\n",
7735                         phba->io_channel_irqs, phba->cfg_fcp_io_channel,
7736                         phba->cfg_nvme_io_channel, phba->cfg_nvmet_mrq);
7737
7738         /* Get EQ depth from module parameter, fake the default for now */
7739         phba->sli4_hba.eq_esize = LPFC_EQE_SIZE_4B;
7740         phba->sli4_hba.eq_ecount = LPFC_EQE_DEF_COUNT;
7741
7742         /* Get CQ depth from module parameter, fake the default for now */
7743         phba->sli4_hba.cq_esize = LPFC_CQE_SIZE;
7744         phba->sli4_hba.cq_ecount = LPFC_CQE_DEF_COUNT;
7745         return 0;
7746 }
7747
7748 static int
7749 lpfc_alloc_nvme_wq_cq(struct lpfc_hba *phba, int wqidx)
7750 {
7751         struct lpfc_queue *qdesc;
7752         int cnt;
7753
7754         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
7755                                             phba->sli4_hba.cq_ecount);
7756         if (!qdesc) {
7757                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7758                                 "0508 Failed allocate fast-path NVME CQ (%d)\n",
7759                                 wqidx);
7760                 return 1;
7761         }
7762         phba->sli4_hba.nvme_cq[wqidx] = qdesc;
7763
7764         cnt = LPFC_NVME_WQSIZE;
7765         qdesc = lpfc_sli4_queue_alloc(phba, LPFC_WQE128_SIZE, cnt);
7766         if (!qdesc) {
7767                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7768                                 "0509 Failed allocate fast-path NVME WQ (%d)\n",
7769                                 wqidx);
7770                 return 1;
7771         }
7772         phba->sli4_hba.nvme_wq[wqidx] = qdesc;
7773         list_add_tail(&qdesc->wq_list, &phba->sli4_hba.lpfc_wq_list);
7774         return 0;
7775 }
7776
7777 static int
7778 lpfc_alloc_fcp_wq_cq(struct lpfc_hba *phba, int wqidx)
7779 {
7780         struct lpfc_queue *qdesc;
7781         uint32_t wqesize;
7782
7783         /* Create Fast Path FCP CQs */
7784         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
7785                                         phba->sli4_hba.cq_ecount);
7786         if (!qdesc) {
7787                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7788                         "0499 Failed allocate fast-path FCP CQ (%d)\n", wqidx);
7789                 return 1;
7790         }
7791         phba->sli4_hba.fcp_cq[wqidx] = qdesc;
7792
7793         /* Create Fast Path FCP WQs */
7794         wqesize = (phba->fcp_embed_io) ?
7795                                 LPFC_WQE128_SIZE : phba->sli4_hba.wq_esize;
7796         qdesc = lpfc_sli4_queue_alloc(phba, wqesize, phba->sli4_hba.wq_ecount);
7797         if (!qdesc) {
7798                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7799                                 "0503 Failed allocate fast-path FCP WQ (%d)\n",
7800                                 wqidx);
7801                 return 1;
7802         }
7803         phba->sli4_hba.fcp_wq[wqidx] = qdesc;
7804         list_add_tail(&qdesc->wq_list, &phba->sli4_hba.lpfc_wq_list);
7805         return 0;
7806 }
7807
7808 /**
7809  * lpfc_sli4_queue_create - Create all the SLI4 queues
7810  * @phba: pointer to lpfc hba data structure.
7811  *
7812  * This routine is invoked to allocate all the SLI4 queues for the FCoE HBA
7813  * operation. For each SLI4 queue type, the parameters such as queue entry
7814  * count (queue depth) shall be taken from the module parameter. For now,
7815  * we just use some constant number as place holder.
7816  *
7817  * Return codes
7818  *      0 - successful
7819  *      -ENOMEM - No availble memory
7820  *      -EIO - The mailbox failed to complete successfully.
7821  **/
7822 int
7823 lpfc_sli4_queue_create(struct lpfc_hba *phba)
7824 {
7825         struct lpfc_queue *qdesc;
7826         int idx, io_channel, max;
7827
7828         /*
7829          * Create HBA Record arrays.
7830          * Both NVME and FCP will share that same vectors / EQs
7831          */
7832         io_channel = phba->io_channel_irqs;
7833         if (!io_channel)
7834                 return -ERANGE;
7835
7836         phba->sli4_hba.mq_esize = LPFC_MQE_SIZE;
7837         phba->sli4_hba.mq_ecount = LPFC_MQE_DEF_COUNT;
7838         phba->sli4_hba.wq_esize = LPFC_WQE_SIZE;
7839         phba->sli4_hba.wq_ecount = LPFC_WQE_DEF_COUNT;
7840         phba->sli4_hba.rq_esize = LPFC_RQE_SIZE;
7841         phba->sli4_hba.rq_ecount = LPFC_RQE_DEF_COUNT;
7842         phba->sli4_hba.eq_esize = LPFC_EQE_SIZE_4B;
7843         phba->sli4_hba.eq_ecount = LPFC_EQE_DEF_COUNT;
7844         phba->sli4_hba.cq_esize = LPFC_CQE_SIZE;
7845         phba->sli4_hba.cq_ecount = LPFC_CQE_DEF_COUNT;
7846
7847         phba->sli4_hba.hba_eq =  kcalloc(io_channel,
7848                                         sizeof(struct lpfc_queue *),
7849                                         GFP_KERNEL);
7850         if (!phba->sli4_hba.hba_eq) {
7851                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7852                         "2576 Failed allocate memory for "
7853                         "fast-path EQ record array\n");
7854                 goto out_error;
7855         }
7856
7857         if (phba->cfg_fcp_io_channel) {
7858                 phba->sli4_hba.fcp_cq = kcalloc(phba->cfg_fcp_io_channel,
7859                                                 sizeof(struct lpfc_queue *),
7860                                                 GFP_KERNEL);
7861                 if (!phba->sli4_hba.fcp_cq) {
7862                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7863                                         "2577 Failed allocate memory for "
7864                                         "fast-path CQ record array\n");
7865                         goto out_error;
7866                 }
7867                 phba->sli4_hba.fcp_wq = kcalloc(phba->cfg_fcp_io_channel,
7868                                                 sizeof(struct lpfc_queue *),
7869                                                 GFP_KERNEL);
7870                 if (!phba->sli4_hba.fcp_wq) {
7871                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7872                                         "2578 Failed allocate memory for "
7873                                         "fast-path FCP WQ record array\n");
7874                         goto out_error;
7875                 }
7876                 /*
7877                  * Since the first EQ can have multiple CQs associated with it,
7878                  * this array is used to quickly see if we have a FCP fast-path
7879                  * CQ match.
7880                  */
7881                 phba->sli4_hba.fcp_cq_map = kcalloc(phba->cfg_fcp_io_channel,
7882                                                         sizeof(uint16_t),
7883                                                         GFP_KERNEL);
7884                 if (!phba->sli4_hba.fcp_cq_map) {
7885                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7886                                         "2545 Failed allocate memory for "
7887                                         "fast-path CQ map\n");
7888                         goto out_error;
7889                 }
7890         }
7891
7892         if (phba->cfg_nvme_io_channel) {
7893                 phba->sli4_hba.nvme_cq = kcalloc(phba->cfg_nvme_io_channel,
7894                                                 sizeof(struct lpfc_queue *),
7895                                                 GFP_KERNEL);
7896                 if (!phba->sli4_hba.nvme_cq) {
7897                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7898                                         "6077 Failed allocate memory for "
7899                                         "fast-path CQ record array\n");
7900                         goto out_error;
7901                 }
7902
7903                 phba->sli4_hba.nvme_wq = kcalloc(phba->cfg_nvme_io_channel,
7904                                                 sizeof(struct lpfc_queue *),
7905                                                 GFP_KERNEL);
7906                 if (!phba->sli4_hba.nvme_wq) {
7907                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7908                                         "2581 Failed allocate memory for "
7909                                         "fast-path NVME WQ record array\n");
7910                         goto out_error;
7911                 }
7912
7913                 /*
7914                  * Since the first EQ can have multiple CQs associated with it,
7915                  * this array is used to quickly see if we have a NVME fast-path
7916                  * CQ match.
7917                  */
7918                 phba->sli4_hba.nvme_cq_map = kcalloc(phba->cfg_nvme_io_channel,
7919                                                         sizeof(uint16_t),
7920                                                         GFP_KERNEL);
7921                 if (!phba->sli4_hba.nvme_cq_map) {
7922                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7923                                         "6078 Failed allocate memory for "
7924                                         "fast-path CQ map\n");
7925                         goto out_error;
7926                 }
7927
7928                 if (phba->nvmet_support) {
7929                         phba->sli4_hba.nvmet_cqset = kcalloc(
7930                                         phba->cfg_nvmet_mrq,
7931                                         sizeof(struct lpfc_queue *),
7932                                         GFP_KERNEL);
7933                         if (!phba->sli4_hba.nvmet_cqset) {
7934                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7935                                         "3121 Fail allocate memory for "
7936                                         "fast-path CQ set array\n");
7937                                 goto out_error;
7938                         }
7939                         phba->sli4_hba.nvmet_mrq_hdr = kcalloc(
7940                                         phba->cfg_nvmet_mrq,
7941                                         sizeof(struct lpfc_queue *),
7942                                         GFP_KERNEL);
7943                         if (!phba->sli4_hba.nvmet_mrq_hdr) {
7944                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7945                                         "3122 Fail allocate memory for "
7946                                         "fast-path RQ set hdr array\n");
7947                                 goto out_error;
7948                         }
7949                         phba->sli4_hba.nvmet_mrq_data = kcalloc(
7950                                         phba->cfg_nvmet_mrq,
7951                                         sizeof(struct lpfc_queue *),
7952                                         GFP_KERNEL);
7953                         if (!phba->sli4_hba.nvmet_mrq_data) {
7954                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7955                                         "3124 Fail allocate memory for "
7956                                         "fast-path RQ set data array\n");
7957                                 goto out_error;
7958                         }
7959                 }
7960         }
7961
7962         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_wq_list);
7963
7964         /* Create HBA Event Queues (EQs) */
7965         for (idx = 0; idx < io_channel; idx++) {
7966                 /* Create EQs */
7967                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize,
7968                                               phba->sli4_hba.eq_ecount);
7969                 if (!qdesc) {
7970                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7971                                         "0497 Failed allocate EQ (%d)\n", idx);
7972                         goto out_error;
7973                 }
7974                 phba->sli4_hba.hba_eq[idx] = qdesc;
7975         }
7976
7977         /* FCP and NVME io channels are not required to be balanced */
7978
7979         for (idx = 0; idx < phba->cfg_fcp_io_channel; idx++)
7980                 if (lpfc_alloc_fcp_wq_cq(phba, idx))
7981                         goto out_error;
7982
7983         for (idx = 0; idx < phba->cfg_nvme_io_channel; idx++)
7984                 if (lpfc_alloc_nvme_wq_cq(phba, idx))
7985                         goto out_error;
7986
7987         /* allocate MRQ CQs */
7988         max = phba->cfg_nvme_io_channel;
7989         if (max < phba->cfg_nvmet_mrq)
7990                 max = phba->cfg_nvmet_mrq;
7991
7992         for (idx = 0; idx < max; idx++)
7993                 if (lpfc_alloc_nvme_wq_cq(phba, idx))
7994                         goto out_error;
7995
7996         if (phba->nvmet_support) {
7997                 for (idx = 0; idx < phba->cfg_nvmet_mrq; idx++) {
7998                         qdesc = lpfc_sli4_queue_alloc(phba,
7999                                         phba->sli4_hba.cq_esize,
8000                                         phba->sli4_hba.cq_ecount);
8001                         if (!qdesc) {
8002                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8003                                         "3142 Failed allocate NVME "
8004                                         "CQ Set (%d)\n", idx);
8005                                 goto out_error;
8006                         }
8007                         phba->sli4_hba.nvmet_cqset[idx] = qdesc;
8008                 }
8009         }
8010
8011         /*
8012          * Create Slow Path Completion Queues (CQs)
8013          */
8014
8015         /* Create slow-path Mailbox Command Complete Queue */
8016         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
8017                                       phba->sli4_hba.cq_ecount);
8018         if (!qdesc) {
8019                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8020                                 "0500 Failed allocate slow-path mailbox CQ\n");
8021                 goto out_error;
8022         }
8023         phba->sli4_hba.mbx_cq = qdesc;
8024
8025         /* Create slow-path ELS Complete Queue */
8026         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
8027                                       phba->sli4_hba.cq_ecount);
8028         if (!qdesc) {
8029                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8030                                 "0501 Failed allocate slow-path ELS CQ\n");
8031                 goto out_error;
8032         }
8033         phba->sli4_hba.els_cq = qdesc;
8034
8035
8036         /*
8037          * Create Slow Path Work Queues (WQs)
8038          */
8039
8040         /* Create Mailbox Command Queue */
8041
8042         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.mq_esize,
8043                                       phba->sli4_hba.mq_ecount);
8044         if (!qdesc) {
8045                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8046                                 "0505 Failed allocate slow-path MQ\n");
8047                 goto out_error;
8048         }
8049         phba->sli4_hba.mbx_wq = qdesc;
8050
8051         /*
8052          * Create ELS Work Queues
8053          */
8054
8055         /* Create slow-path ELS Work Queue */
8056         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize,
8057                                       phba->sli4_hba.wq_ecount);
8058         if (!qdesc) {
8059                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8060                                 "0504 Failed allocate slow-path ELS WQ\n");
8061                 goto out_error;
8062         }
8063         phba->sli4_hba.els_wq = qdesc;
8064         list_add_tail(&qdesc->wq_list, &phba->sli4_hba.lpfc_wq_list);
8065
8066         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
8067                 /* Create NVME LS Complete Queue */
8068                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
8069                                               phba->sli4_hba.cq_ecount);
8070                 if (!qdesc) {
8071                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8072                                         "6079 Failed allocate NVME LS CQ\n");
8073                         goto out_error;
8074                 }
8075                 phba->sli4_hba.nvmels_cq = qdesc;
8076
8077                 /* Create NVME LS Work Queue */
8078                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize,
8079                                               phba->sli4_hba.wq_ecount);
8080                 if (!qdesc) {
8081                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8082                                         "6080 Failed allocate NVME LS WQ\n");
8083                         goto out_error;
8084                 }
8085                 phba->sli4_hba.nvmels_wq = qdesc;
8086                 list_add_tail(&qdesc->wq_list, &phba->sli4_hba.lpfc_wq_list);
8087         }
8088
8089         /*
8090          * Create Receive Queue (RQ)
8091          */
8092
8093         /* Create Receive Queue for header */
8094         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize,
8095                                       phba->sli4_hba.rq_ecount);
8096         if (!qdesc) {
8097                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8098                                 "0506 Failed allocate receive HRQ\n");
8099                 goto out_error;
8100         }
8101         phba->sli4_hba.hdr_rq = qdesc;
8102
8103         /* Create Receive Queue for data */
8104         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize,
8105                                       phba->sli4_hba.rq_ecount);
8106         if (!qdesc) {
8107                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8108                                 "0507 Failed allocate receive DRQ\n");
8109                 goto out_error;
8110         }
8111         phba->sli4_hba.dat_rq = qdesc;
8112
8113         if (phba->nvmet_support) {
8114                 for (idx = 0; idx < phba->cfg_nvmet_mrq; idx++) {
8115                         /* Create NVMET Receive Queue for header */
8116                         qdesc = lpfc_sli4_queue_alloc(phba,
8117                                                       phba->sli4_hba.rq_esize,
8118                                                       phba->sli4_hba.rq_ecount);
8119                         if (!qdesc) {
8120                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8121                                                 "3146 Failed allocate "
8122                                                 "receive HRQ\n");
8123                                 goto out_error;
8124                         }
8125                         phba->sli4_hba.nvmet_mrq_hdr[idx] = qdesc;
8126
8127                         /* Only needed for header of RQ pair */
8128                         qdesc->rqbp = kzalloc(sizeof(struct lpfc_rqb),
8129                                               GFP_KERNEL);
8130                         if (qdesc->rqbp == NULL) {
8131                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8132                                                 "6131 Failed allocate "
8133                                                 "Header RQBP\n");
8134                                 goto out_error;
8135                         }
8136
8137                         /* Create NVMET Receive Queue for data */
8138                         qdesc = lpfc_sli4_queue_alloc(phba,
8139                                                       phba->sli4_hba.rq_esize,
8140                                                       phba->sli4_hba.rq_ecount);
8141                         if (!qdesc) {
8142                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8143                                                 "3156 Failed allocate "
8144                                                 "receive DRQ\n");
8145                                 goto out_error;
8146                         }
8147                         phba->sli4_hba.nvmet_mrq_data[idx] = qdesc;
8148                 }
8149         }
8150
8151         /* Create the Queues needed for Flash Optimized Fabric operations */
8152         if (phba->cfg_fof)
8153                 lpfc_fof_queue_create(phba);
8154         return 0;
8155
8156 out_error:
8157         lpfc_sli4_queue_destroy(phba);
8158         return -ENOMEM;
8159 }
8160
8161 static inline void
8162 __lpfc_sli4_release_queue(struct lpfc_queue **qp)
8163 {
8164         if (*qp != NULL) {
8165                 lpfc_sli4_queue_free(*qp);
8166                 *qp = NULL;
8167         }
8168 }
8169
8170 static inline void
8171 lpfc_sli4_release_queues(struct lpfc_queue ***qs, int max)
8172 {
8173         int idx;
8174
8175         if (*qs == NULL)
8176                 return;
8177
8178         for (idx = 0; idx < max; idx++)
8179                 __lpfc_sli4_release_queue(&(*qs)[idx]);
8180
8181         kfree(*qs);
8182         *qs = NULL;
8183 }
8184
8185 static inline void
8186 lpfc_sli4_release_queue_map(uint16_t **qmap)
8187 {
8188         if (*qmap != NULL) {
8189                 kfree(*qmap);
8190                 *qmap = NULL;
8191         }
8192 }
8193
8194 /**
8195  * lpfc_sli4_queue_destroy - Destroy all the SLI4 queues
8196  * @phba: pointer to lpfc hba data structure.
8197  *
8198  * This routine is invoked to release all the SLI4 queues with the FCoE HBA
8199  * operation.
8200  *
8201  * Return codes
8202  *      0 - successful
8203  *      -ENOMEM - No available memory
8204  *      -EIO - The mailbox failed to complete successfully.
8205  **/
8206 void
8207 lpfc_sli4_queue_destroy(struct lpfc_hba *phba)
8208 {
8209         if (phba->cfg_fof)
8210                 lpfc_fof_queue_destroy(phba);
8211
8212         /* Release HBA eqs */
8213         lpfc_sli4_release_queues(&phba->sli4_hba.hba_eq, phba->io_channel_irqs);
8214
8215         /* Release FCP cqs */
8216         lpfc_sli4_release_queues(&phba->sli4_hba.fcp_cq,
8217                                         phba->cfg_fcp_io_channel);
8218
8219         /* Release FCP wqs */
8220         lpfc_sli4_release_queues(&phba->sli4_hba.fcp_wq,
8221                                         phba->cfg_fcp_io_channel);
8222
8223         /* Release FCP CQ mapping array */
8224         lpfc_sli4_release_queue_map(&phba->sli4_hba.fcp_cq_map);
8225
8226         /* Release NVME cqs */
8227         lpfc_sli4_release_queues(&phba->sli4_hba.nvme_cq,
8228                                         phba->cfg_nvme_io_channel);
8229
8230         /* Release NVME wqs */
8231         lpfc_sli4_release_queues(&phba->sli4_hba.nvme_wq,
8232                                         phba->cfg_nvme_io_channel);
8233
8234         /* Release NVME CQ mapping array */
8235         lpfc_sli4_release_queue_map(&phba->sli4_hba.nvme_cq_map);
8236
8237         lpfc_sli4_release_queues(&phba->sli4_hba.nvmet_cqset,
8238                                         phba->cfg_nvmet_mrq);
8239
8240         lpfc_sli4_release_queues(&phba->sli4_hba.nvmet_mrq_hdr,
8241                                         phba->cfg_nvmet_mrq);
8242         lpfc_sli4_release_queues(&phba->sli4_hba.nvmet_mrq_data,
8243                                         phba->cfg_nvmet_mrq);
8244
8245         /* Release mailbox command work queue */
8246         __lpfc_sli4_release_queue(&phba->sli4_hba.mbx_wq);
8247
8248         /* Release ELS work queue */
8249         __lpfc_sli4_release_queue(&phba->sli4_hba.els_wq);
8250
8251         /* Release ELS work queue */
8252         __lpfc_sli4_release_queue(&phba->sli4_hba.nvmels_wq);
8253
8254         /* Release unsolicited receive queue */
8255         __lpfc_sli4_release_queue(&phba->sli4_hba.hdr_rq);
8256         __lpfc_sli4_release_queue(&phba->sli4_hba.dat_rq);
8257
8258         /* Release ELS complete queue */
8259         __lpfc_sli4_release_queue(&phba->sli4_hba.els_cq);
8260
8261         /* Release NVME LS complete queue */
8262         __lpfc_sli4_release_queue(&phba->sli4_hba.nvmels_cq);
8263
8264         /* Release mailbox command complete queue */
8265         __lpfc_sli4_release_queue(&phba->sli4_hba.mbx_cq);
8266
8267         /* Everything on this list has been freed */
8268         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_wq_list);
8269 }
8270
8271 int
8272 lpfc_post_rq_buffer(struct lpfc_hba *phba, struct lpfc_queue *hrq,
8273                     struct lpfc_queue *drq, int count)
8274 {
8275         int rc, i;
8276         struct lpfc_rqe hrqe;
8277         struct lpfc_rqe drqe;
8278         struct lpfc_rqb *rqbp;
8279         struct rqb_dmabuf *rqb_buffer;
8280         LIST_HEAD(rqb_buf_list);
8281
8282         rqbp = hrq->rqbp;
8283         for (i = 0; i < count; i++) {
8284                 rqb_buffer = (rqbp->rqb_alloc_buffer)(phba);
8285                 if (!rqb_buffer)
8286                         break;
8287                 rqb_buffer->hrq = hrq;
8288                 rqb_buffer->drq = drq;
8289                 list_add_tail(&rqb_buffer->hbuf.list, &rqb_buf_list);
8290         }
8291         while (!list_empty(&rqb_buf_list)) {
8292                 list_remove_head(&rqb_buf_list, rqb_buffer, struct rqb_dmabuf,
8293                                  hbuf.list);
8294
8295                 hrqe.address_lo = putPaddrLow(rqb_buffer->hbuf.phys);
8296                 hrqe.address_hi = putPaddrHigh(rqb_buffer->hbuf.phys);
8297                 drqe.address_lo = putPaddrLow(rqb_buffer->dbuf.phys);
8298                 drqe.address_hi = putPaddrHigh(rqb_buffer->dbuf.phys);
8299                 rc = lpfc_sli4_rq_put(hrq, drq, &hrqe, &drqe);
8300                 if (rc < 0) {
8301                         (rqbp->rqb_free_buffer)(phba, rqb_buffer);
8302                 } else {
8303                         list_add_tail(&rqb_buffer->hbuf.list,
8304                                       &rqbp->rqb_buffer_list);
8305                         rqbp->buffer_count++;
8306                 }
8307         }
8308         return 1;
8309 }
8310
8311 int
8312 lpfc_free_rq_buffer(struct lpfc_hba *phba, struct lpfc_queue *rq)
8313 {
8314         struct lpfc_rqb *rqbp;
8315         struct lpfc_dmabuf *h_buf;
8316         struct rqb_dmabuf *rqb_buffer;
8317
8318         rqbp = rq->rqbp;
8319         while (!list_empty(&rqbp->rqb_buffer_list)) {
8320                 list_remove_head(&rqbp->rqb_buffer_list, h_buf,
8321                                  struct lpfc_dmabuf, list);
8322
8323                 rqb_buffer = container_of(h_buf, struct rqb_dmabuf, hbuf);
8324                 (rqbp->rqb_free_buffer)(phba, rqb_buffer);
8325                 rqbp->buffer_count--;
8326         }
8327         return 1;
8328 }
8329
8330 static int
8331 lpfc_create_wq_cq(struct lpfc_hba *phba, struct lpfc_queue *eq,
8332         struct lpfc_queue *cq, struct lpfc_queue *wq, uint16_t *cq_map,
8333         int qidx, uint32_t qtype)
8334 {
8335         struct lpfc_sli_ring *pring;
8336         int rc;
8337
8338         if (!eq || !cq || !wq) {
8339                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8340                         "6085 Fast-path %s (%d) not allocated\n",
8341                         ((eq) ? ((cq) ? "WQ" : "CQ") : "EQ"), qidx);
8342                 return -ENOMEM;
8343         }
8344
8345         /* create the Cq first */
8346         rc = lpfc_cq_create(phba, cq, eq,
8347                         (qtype == LPFC_MBOX) ? LPFC_MCQ : LPFC_WCQ, qtype);
8348         if (rc) {
8349                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8350                         "6086 Failed setup of CQ (%d), rc = 0x%x\n",
8351                         qidx, (uint32_t)rc);
8352                 return rc;
8353         }
8354
8355         if (qtype != LPFC_MBOX) {
8356                 /* Setup nvme_cq_map for fast lookup */
8357                 if (cq_map)
8358                         *cq_map = cq->queue_id;
8359
8360                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8361                         "6087 CQ setup: cq[%d]-id=%d, parent eq[%d]-id=%d\n",
8362                         qidx, cq->queue_id, qidx, eq->queue_id);
8363
8364                 /* create the wq */
8365                 rc = lpfc_wq_create(phba, wq, cq, qtype);
8366                 if (rc) {
8367                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8368                                 "6123 Fail setup fastpath WQ (%d), rc = 0x%x\n",
8369                                 qidx, (uint32_t)rc);
8370                         /* no need to tear down cq - caller will do so */
8371                         return rc;
8372                 }
8373
8374                 /* Bind this CQ/WQ to the NVME ring */
8375                 pring = wq->pring;
8376                 pring->sli.sli4.wqp = (void *)wq;
8377                 cq->pring = pring;
8378
8379                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8380                         "2593 WQ setup: wq[%d]-id=%d assoc=%d, cq[%d]-id=%d\n",
8381                         qidx, wq->queue_id, wq->assoc_qid, qidx, cq->queue_id);
8382         } else {
8383                 rc = lpfc_mq_create(phba, wq, cq, LPFC_MBOX);
8384                 if (rc) {
8385                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8386                                 "0539 Failed setup of slow-path MQ: "
8387                                 "rc = 0x%x\n", rc);
8388                         /* no need to tear down cq - caller will do so */
8389                         return rc;
8390                 }
8391
8392                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8393                         "2589 MBX MQ setup: wq-id=%d, parent cq-id=%d\n",
8394                         phba->sli4_hba.mbx_wq->queue_id,
8395                         phba->sli4_hba.mbx_cq->queue_id);
8396         }
8397
8398         return 0;
8399 }
8400
8401 /**
8402  * lpfc_sli4_queue_setup - Set up all the SLI4 queues
8403  * @phba: pointer to lpfc hba data structure.
8404  *
8405  * This routine is invoked to set up all the SLI4 queues for the FCoE HBA
8406  * operation.
8407  *
8408  * Return codes
8409  *      0 - successful
8410  *      -ENOMEM - No available memory
8411  *      -EIO - The mailbox failed to complete successfully.
8412  **/
8413 int
8414 lpfc_sli4_queue_setup(struct lpfc_hba *phba)
8415 {
8416         uint32_t shdr_status, shdr_add_status;
8417         union lpfc_sli4_cfg_shdr *shdr;
8418         LPFC_MBOXQ_t *mboxq;
8419         int qidx;
8420         uint32_t length, io_channel;
8421         int rc = -ENOMEM;
8422
8423         /* Check for dual-ULP support */
8424         mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
8425         if (!mboxq) {
8426                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8427                                 "3249 Unable to allocate memory for "
8428                                 "QUERY_FW_CFG mailbox command\n");
8429                 return -ENOMEM;
8430         }
8431         length = (sizeof(struct lpfc_mbx_query_fw_config) -
8432                   sizeof(struct lpfc_sli4_cfg_mhdr));
8433         lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
8434                          LPFC_MBOX_OPCODE_QUERY_FW_CFG,
8435                          length, LPFC_SLI4_MBX_EMBED);
8436
8437         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
8438
8439         shdr = (union lpfc_sli4_cfg_shdr *)
8440                         &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
8441         shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
8442         shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
8443         if (shdr_status || shdr_add_status || rc) {
8444                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8445                                 "3250 QUERY_FW_CFG mailbox failed with status "
8446                                 "x%x add_status x%x, mbx status x%x\n",
8447                                 shdr_status, shdr_add_status, rc);
8448                 if (rc != MBX_TIMEOUT)
8449                         mempool_free(mboxq, phba->mbox_mem_pool);
8450                 rc = -ENXIO;
8451                 goto out_error;
8452         }
8453
8454         phba->sli4_hba.fw_func_mode =
8455                         mboxq->u.mqe.un.query_fw_cfg.rsp.function_mode;
8456         phba->sli4_hba.ulp0_mode = mboxq->u.mqe.un.query_fw_cfg.rsp.ulp0_mode;
8457         phba->sli4_hba.ulp1_mode = mboxq->u.mqe.un.query_fw_cfg.rsp.ulp1_mode;
8458         phba->sli4_hba.physical_port =
8459                         mboxq->u.mqe.un.query_fw_cfg.rsp.physical_port;
8460         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8461                         "3251 QUERY_FW_CFG: func_mode:x%x, ulp0_mode:x%x, "
8462                         "ulp1_mode:x%x\n", phba->sli4_hba.fw_func_mode,
8463                         phba->sli4_hba.ulp0_mode, phba->sli4_hba.ulp1_mode);
8464
8465         if (rc != MBX_TIMEOUT)
8466                 mempool_free(mboxq, phba->mbox_mem_pool);
8467
8468         /*
8469          * Set up HBA Event Queues (EQs)
8470          */
8471         io_channel = phba->io_channel_irqs;
8472
8473         /* Set up HBA event queue */
8474         if (io_channel && !phba->sli4_hba.hba_eq) {
8475                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8476                                 "3147 Fast-path EQs not allocated\n");
8477                 rc = -ENOMEM;
8478                 goto out_error;
8479         }
8480         for (qidx = 0; qidx < io_channel; qidx++) {
8481                 if (!phba->sli4_hba.hba_eq[qidx]) {
8482                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8483                                         "0522 Fast-path EQ (%d) not "
8484                                         "allocated\n", qidx);
8485                         rc = -ENOMEM;
8486                         goto out_destroy;
8487                 }
8488                 rc = lpfc_eq_create(phba, phba->sli4_hba.hba_eq[qidx],
8489                                                 phba->cfg_fcp_imax);
8490                 if (rc) {
8491                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8492                                         "0523 Failed setup of fast-path EQ "
8493                                         "(%d), rc = 0x%x\n", qidx,
8494                                         (uint32_t)rc);
8495                         goto out_destroy;
8496                 }
8497                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8498                                 "2584 HBA EQ setup: queue[%d]-id=%d\n",
8499                                 qidx, phba->sli4_hba.hba_eq[qidx]->queue_id);
8500         }
8501
8502         if (phba->cfg_nvme_io_channel) {
8503                 if (!phba->sli4_hba.nvme_cq || !phba->sli4_hba.nvme_wq) {
8504                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8505                                 "6084 Fast-path NVME %s array not allocated\n",
8506                                 (phba->sli4_hba.nvme_cq) ? "CQ" : "WQ");
8507                         rc = -ENOMEM;
8508                         goto out_destroy;
8509                 }
8510
8511                 for (qidx = 0; qidx < phba->cfg_nvme_io_channel; qidx++) {
8512                         rc = lpfc_create_wq_cq(phba,
8513                                         phba->sli4_hba.hba_eq[
8514                                                 qidx % io_channel],
8515                                         phba->sli4_hba.nvme_cq[qidx],
8516                                         phba->sli4_hba.nvme_wq[qidx],
8517                                         &phba->sli4_hba.nvme_cq_map[qidx],
8518                                         qidx, LPFC_NVME);
8519                         if (rc) {
8520                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8521                                         "6123 Failed to setup fastpath "
8522                                         "NVME WQ/CQ (%d), rc = 0x%x\n",
8523                                         qidx, (uint32_t)rc);
8524                                 goto out_destroy;
8525                         }
8526                 }
8527         }
8528
8529         if (phba->cfg_fcp_io_channel) {
8530                 /* Set up fast-path FCP Response Complete Queue */
8531                 if (!phba->sli4_hba.fcp_cq || !phba->sli4_hba.fcp_wq) {
8532                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8533                                 "3148 Fast-path FCP %s array not allocated\n",
8534                                 phba->sli4_hba.fcp_cq ? "WQ" : "CQ");
8535                         rc = -ENOMEM;
8536                         goto out_destroy;
8537                 }
8538
8539                 for (qidx = 0; qidx < phba->cfg_fcp_io_channel; qidx++) {
8540                         rc = lpfc_create_wq_cq(phba,
8541                                         phba->sli4_hba.hba_eq[
8542                                                 qidx % io_channel],
8543                                         phba->sli4_hba.fcp_cq[qidx],
8544                                         phba->sli4_hba.fcp_wq[qidx],
8545                                         &phba->sli4_hba.fcp_cq_map[qidx],
8546                                         qidx, LPFC_FCP);
8547                         if (rc) {
8548                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8549                                         "0535 Failed to setup fastpath "
8550                                         "FCP WQ/CQ (%d), rc = 0x%x\n",
8551                                         qidx, (uint32_t)rc);
8552                                 goto out_destroy;
8553                         }
8554                 }
8555         }
8556
8557         /*
8558          * Set up Slow Path Complete Queues (CQs)
8559          */
8560
8561         /* Set up slow-path MBOX CQ/MQ */
8562
8563         if (!phba->sli4_hba.mbx_cq || !phba->sli4_hba.mbx_wq) {
8564                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8565                                 "0528 %s not allocated\n",
8566                                 phba->sli4_hba.mbx_cq ?
8567                                                 "Mailbox WQ" : "Mailbox CQ");
8568                 rc = -ENOMEM;
8569                 goto out_destroy;
8570         }
8571
8572         rc = lpfc_create_wq_cq(phba, phba->sli4_hba.hba_eq[0],
8573                                         phba->sli4_hba.mbx_cq,
8574                                         phba->sli4_hba.mbx_wq,
8575                                         NULL, 0, LPFC_MBOX);
8576         if (rc) {
8577                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8578                         "0529 Failed setup of mailbox WQ/CQ: rc = 0x%x\n",
8579                         (uint32_t)rc);
8580                 goto out_destroy;
8581         }
8582         if (phba->nvmet_support) {
8583                 if (!phba->sli4_hba.nvmet_cqset) {
8584                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8585                                         "3165 Fast-path NVME CQ Set "
8586                                         "array not allocated\n");
8587                         rc = -ENOMEM;
8588                         goto out_destroy;
8589                 }
8590                 if (phba->cfg_nvmet_mrq > 1) {
8591                         rc = lpfc_cq_create_set(phba,
8592                                         phba->sli4_hba.nvmet_cqset,
8593                                         phba->sli4_hba.hba_eq,
8594                                         LPFC_WCQ, LPFC_NVMET);
8595                         if (rc) {
8596                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8597                                                 "3164 Failed setup of NVME CQ "
8598                                                 "Set, rc = 0x%x\n",
8599                                                 (uint32_t)rc);
8600                                 goto out_destroy;
8601                         }
8602                 } else {
8603                         /* Set up NVMET Receive Complete Queue */
8604                         rc = lpfc_cq_create(phba, phba->sli4_hba.nvmet_cqset[0],
8605                                             phba->sli4_hba.hba_eq[0],
8606                                             LPFC_WCQ, LPFC_NVMET);
8607                         if (rc) {
8608                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8609                                                 "6089 Failed setup NVMET CQ: "
8610                                                 "rc = 0x%x\n", (uint32_t)rc);
8611                                 goto out_destroy;
8612                         }
8613                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8614                                         "6090 NVMET CQ setup: cq-id=%d, "
8615                                         "parent eq-id=%d\n",
8616                                         phba->sli4_hba.nvmet_cqset[0]->queue_id,
8617                                         phba->sli4_hba.hba_eq[0]->queue_id);
8618                 }
8619         }
8620
8621         /* Set up slow-path ELS WQ/CQ */
8622         if (!phba->sli4_hba.els_cq || !phba->sli4_hba.els_wq) {
8623                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8624                                 "0530 ELS %s not allocated\n",
8625                                 phba->sli4_hba.els_cq ? "WQ" : "CQ");
8626                 rc = -ENOMEM;
8627                 goto out_destroy;
8628         }
8629         rc = lpfc_create_wq_cq(phba, phba->sli4_hba.hba_eq[0],
8630                                         phba->sli4_hba.els_cq,
8631                                         phba->sli4_hba.els_wq,
8632                                         NULL, 0, LPFC_ELS);
8633         if (rc) {
8634                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8635                         "0529 Failed setup of ELS WQ/CQ: rc = 0x%x\n",
8636                         (uint32_t)rc);
8637                 goto out_destroy;
8638         }
8639         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8640                         "2590 ELS WQ setup: wq-id=%d, parent cq-id=%d\n",
8641                         phba->sli4_hba.els_wq->queue_id,
8642                         phba->sli4_hba.els_cq->queue_id);
8643
8644         if (phba->cfg_nvme_io_channel) {
8645                 /* Set up NVME LS Complete Queue */
8646                 if (!phba->sli4_hba.nvmels_cq || !phba->sli4_hba.nvmels_wq) {
8647                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8648                                         "6091 LS %s not allocated\n",
8649                                         phba->sli4_hba.nvmels_cq ? "WQ" : "CQ");
8650                         rc = -ENOMEM;
8651                         goto out_destroy;
8652                 }
8653                 rc = lpfc_create_wq_cq(phba, phba->sli4_hba.hba_eq[0],
8654                                         phba->sli4_hba.nvmels_cq,
8655                                         phba->sli4_hba.nvmels_wq,
8656                                         NULL, 0, LPFC_NVME_LS);
8657                 if (rc) {
8658                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8659                                 "0529 Failed setup of NVVME LS WQ/CQ: "
8660                                 "rc = 0x%x\n", (uint32_t)rc);
8661                         goto out_destroy;
8662                 }
8663
8664                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8665                                 "6096 ELS WQ setup: wq-id=%d, "
8666                                 "parent cq-id=%d\n",
8667                                 phba->sli4_hba.nvmels_wq->queue_id,
8668                                 phba->sli4_hba.nvmels_cq->queue_id);
8669         }
8670
8671         /*
8672          * Create NVMET Receive Queue (RQ)
8673          */
8674         if (phba->nvmet_support) {
8675                 if ((!phba->sli4_hba.nvmet_cqset) ||
8676                     (!phba->sli4_hba.nvmet_mrq_hdr) ||
8677                     (!phba->sli4_hba.nvmet_mrq_data)) {
8678                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8679                                         "6130 MRQ CQ Queues not "
8680                                         "allocated\n");
8681                         rc = -ENOMEM;
8682                         goto out_destroy;
8683                 }
8684                 if (phba->cfg_nvmet_mrq > 1) {
8685                         rc = lpfc_mrq_create(phba,
8686                                              phba->sli4_hba.nvmet_mrq_hdr,
8687                                              phba->sli4_hba.nvmet_mrq_data,
8688                                              phba->sli4_hba.nvmet_cqset,
8689                                              LPFC_NVMET);
8690                         if (rc) {
8691                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8692                                                 "6098 Failed setup of NVMET "
8693                                                 "MRQ: rc = 0x%x\n",
8694                                                 (uint32_t)rc);
8695                                 goto out_destroy;
8696                         }
8697
8698                 } else {
8699                         rc = lpfc_rq_create(phba,
8700                                             phba->sli4_hba.nvmet_mrq_hdr[0],
8701                                             phba->sli4_hba.nvmet_mrq_data[0],
8702                                             phba->sli4_hba.nvmet_cqset[0],
8703                                             LPFC_NVMET);
8704                         if (rc) {
8705                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8706                                                 "6057 Failed setup of NVMET "
8707                                                 "Receive Queue: rc = 0x%x\n",
8708                                                 (uint32_t)rc);
8709                                 goto out_destroy;
8710                         }
8711
8712                         lpfc_printf_log(
8713                                 phba, KERN_INFO, LOG_INIT,
8714                                 "6099 NVMET RQ setup: hdr-rq-id=%d, "
8715                                 "dat-rq-id=%d parent cq-id=%d\n",
8716                                 phba->sli4_hba.nvmet_mrq_hdr[0]->queue_id,
8717                                 phba->sli4_hba.nvmet_mrq_data[0]->queue_id,
8718                                 phba->sli4_hba.nvmet_cqset[0]->queue_id);
8719
8720                 }
8721         }
8722
8723         if (!phba->sli4_hba.hdr_rq || !phba->sli4_hba.dat_rq) {
8724                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8725                                 "0540 Receive Queue not allocated\n");
8726                 rc = -ENOMEM;
8727                 goto out_destroy;
8728         }
8729
8730         lpfc_rq_adjust_repost(phba, phba->sli4_hba.hdr_rq, LPFC_ELS_HBQ);
8731         lpfc_rq_adjust_repost(phba, phba->sli4_hba.dat_rq, LPFC_ELS_HBQ);
8732
8733         rc = lpfc_rq_create(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq,
8734                             phba->sli4_hba.els_cq, LPFC_USOL);
8735         if (rc) {
8736                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8737                                 "0541 Failed setup of Receive Queue: "
8738                                 "rc = 0x%x\n", (uint32_t)rc);
8739                 goto out_destroy;
8740         }
8741
8742         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8743                         "2592 USL RQ setup: hdr-rq-id=%d, dat-rq-id=%d "
8744                         "parent cq-id=%d\n",
8745                         phba->sli4_hba.hdr_rq->queue_id,
8746                         phba->sli4_hba.dat_rq->queue_id,
8747                         phba->sli4_hba.els_cq->queue_id);
8748
8749         if (phba->cfg_fof) {
8750                 rc = lpfc_fof_queue_setup(phba);
8751                 if (rc) {
8752                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8753                                         "0549 Failed setup of FOF Queues: "
8754                                         "rc = 0x%x\n", rc);
8755                         goto out_destroy;
8756                 }
8757         }
8758
8759         for (qidx = 0; qidx < io_channel; qidx += LPFC_MAX_EQ_DELAY_EQID_CNT)
8760                 lpfc_modify_hba_eq_delay(phba, qidx);
8761
8762         return 0;
8763
8764 out_destroy:
8765         lpfc_sli4_queue_unset(phba);
8766 out_error:
8767         return rc;
8768 }
8769
8770 /**
8771  * lpfc_sli4_queue_unset - Unset all the SLI4 queues
8772  * @phba: pointer to lpfc hba data structure.
8773  *
8774  * This routine is invoked to unset all the SLI4 queues with the FCoE HBA
8775  * operation.
8776  *
8777  * Return codes
8778  *      0 - successful
8779  *      -ENOMEM - No available memory
8780  *      -EIO - The mailbox failed to complete successfully.
8781  **/
8782 void
8783 lpfc_sli4_queue_unset(struct lpfc_hba *phba)
8784 {
8785         int qidx;
8786
8787         /* Unset the queues created for Flash Optimized Fabric operations */
8788         if (phba->cfg_fof)
8789                 lpfc_fof_queue_destroy(phba);
8790
8791         /* Unset mailbox command work queue */
8792         if (phba->sli4_hba.mbx_wq)
8793                 lpfc_mq_destroy(phba, phba->sli4_hba.mbx_wq);
8794
8795         /* Unset NVME LS work queue */
8796         if (phba->sli4_hba.nvmels_wq)
8797                 lpfc_wq_destroy(phba, phba->sli4_hba.nvmels_wq);
8798
8799         /* Unset ELS work queue */
8800         if (phba->sli4_hba.els_cq)
8801                 lpfc_wq_destroy(phba, phba->sli4_hba.els_wq);
8802
8803         /* Unset unsolicited receive queue */
8804         if (phba->sli4_hba.hdr_rq)
8805                 lpfc_rq_destroy(phba, phba->sli4_hba.hdr_rq,
8806                                 phba->sli4_hba.dat_rq);
8807
8808         /* Unset FCP work queue */
8809         if (phba->sli4_hba.fcp_wq)
8810                 for (qidx = 0; qidx < phba->cfg_fcp_io_channel; qidx++)
8811                         lpfc_wq_destroy(phba, phba->sli4_hba.fcp_wq[qidx]);
8812
8813         /* Unset NVME work queue */
8814         if (phba->sli4_hba.nvme_wq) {
8815                 for (qidx = 0; qidx < phba->cfg_nvme_io_channel; qidx++)
8816                         lpfc_wq_destroy(phba, phba->sli4_hba.nvme_wq[qidx]);
8817         }
8818
8819         /* Unset mailbox command complete queue */
8820         if (phba->sli4_hba.mbx_cq)
8821                 lpfc_cq_destroy(phba, phba->sli4_hba.mbx_cq);
8822
8823         /* Unset ELS complete queue */
8824         if (phba->sli4_hba.els_cq)
8825                 lpfc_cq_destroy(phba, phba->sli4_hba.els_cq);
8826
8827         /* Unset NVME LS complete queue */
8828         if (phba->sli4_hba.nvmels_cq)
8829                 lpfc_cq_destroy(phba, phba->sli4_hba.nvmels_cq);
8830
8831         /* Unset NVME response complete queue */
8832         if (phba->sli4_hba.nvme_cq)
8833                 for (qidx = 0; qidx < phba->cfg_nvme_io_channel; qidx++)
8834                         lpfc_cq_destroy(phba, phba->sli4_hba.nvme_cq[qidx]);
8835
8836         /* Unset NVMET MRQ queue */
8837         if (phba->sli4_hba.nvmet_mrq_hdr) {
8838                 for (qidx = 0; qidx < phba->cfg_nvmet_mrq; qidx++)
8839                         lpfc_rq_destroy(phba,
8840                                         phba->sli4_hba.nvmet_mrq_hdr[qidx],
8841                                         phba->sli4_hba.nvmet_mrq_data[qidx]);
8842         }
8843
8844         /* Unset NVMET CQ Set complete queue */
8845         if (phba->sli4_hba.nvmet_cqset) {
8846                 for (qidx = 0; qidx < phba->cfg_nvmet_mrq; qidx++)
8847                         lpfc_cq_destroy(phba,
8848                                         phba->sli4_hba.nvmet_cqset[qidx]);
8849         }
8850
8851         /* Unset FCP response complete queue */
8852         if (phba->sli4_hba.fcp_cq)
8853                 for (qidx = 0; qidx < phba->cfg_fcp_io_channel; qidx++)
8854                         lpfc_cq_destroy(phba, phba->sli4_hba.fcp_cq[qidx]);
8855
8856         /* Unset fast-path event queue */
8857         if (phba->sli4_hba.hba_eq)
8858                 for (qidx = 0; qidx < phba->io_channel_irqs; qidx++)
8859                         lpfc_eq_destroy(phba, phba->sli4_hba.hba_eq[qidx]);
8860 }
8861
8862 /**
8863  * lpfc_sli4_cq_event_pool_create - Create completion-queue event free pool
8864  * @phba: pointer to lpfc hba data structure.
8865  *
8866  * This routine is invoked to allocate and set up a pool of completion queue
8867  * events. The body of the completion queue event is a completion queue entry
8868  * CQE. For now, this pool is used for the interrupt service routine to queue
8869  * the following HBA completion queue events for the worker thread to process:
8870  *   - Mailbox asynchronous events
8871  *   - Receive queue completion unsolicited events
8872  * Later, this can be used for all the slow-path events.
8873  *
8874  * Return codes
8875  *      0 - successful
8876  *      -ENOMEM - No available memory
8877  **/
8878 static int
8879 lpfc_sli4_cq_event_pool_create(struct lpfc_hba *phba)
8880 {
8881         struct lpfc_cq_event *cq_event;
8882         int i;
8883
8884         for (i = 0; i < (4 * phba->sli4_hba.cq_ecount); i++) {
8885                 cq_event = kmalloc(sizeof(struct lpfc_cq_event), GFP_KERNEL);
8886                 if (!cq_event)
8887                         goto out_pool_create_fail;
8888                 list_add_tail(&cq_event->list,
8889                               &phba->sli4_hba.sp_cqe_event_pool);
8890         }
8891         return 0;
8892
8893 out_pool_create_fail:
8894         lpfc_sli4_cq_event_pool_destroy(phba);
8895         return -ENOMEM;
8896 }
8897
8898 /**
8899  * lpfc_sli4_cq_event_pool_destroy - Free completion-queue event free pool
8900  * @phba: pointer to lpfc hba data structure.
8901  *
8902  * This routine is invoked to free the pool of completion queue events at
8903  * driver unload time. Note that, it is the responsibility of the driver
8904  * cleanup routine to free all the outstanding completion-queue events
8905  * allocated from this pool back into the pool before invoking this routine
8906  * to destroy the pool.
8907  **/
8908 static void
8909 lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *phba)
8910 {
8911         struct lpfc_cq_event *cq_event, *next_cq_event;
8912
8913         list_for_each_entry_safe(cq_event, next_cq_event,
8914                                  &phba->sli4_hba.sp_cqe_event_pool, list) {
8915                 list_del(&cq_event->list);
8916                 kfree(cq_event);
8917         }
8918 }
8919
8920 /**
8921  * __lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool
8922  * @phba: pointer to lpfc hba data structure.
8923  *
8924  * This routine is the lock free version of the API invoked to allocate a
8925  * completion-queue event from the free pool.
8926  *
8927  * Return: Pointer to the newly allocated completion-queue event if successful
8928  *         NULL otherwise.
8929  **/
8930 struct lpfc_cq_event *
8931 __lpfc_sli4_cq_event_alloc(struct lpfc_hba *phba)
8932 {
8933         struct lpfc_cq_event *cq_event = NULL;
8934
8935         list_remove_head(&phba->sli4_hba.sp_cqe_event_pool, cq_event,
8936                          struct lpfc_cq_event, list);
8937         return cq_event;
8938 }
8939
8940 /**
8941  * lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool
8942  * @phba: pointer to lpfc hba data structure.
8943  *
8944  * This routine is the lock version of the API invoked to allocate a
8945  * completion-queue event from the free pool.
8946  *
8947  * Return: Pointer to the newly allocated completion-queue event if successful
8948  *         NULL otherwise.
8949  **/
8950 struct lpfc_cq_event *
8951 lpfc_sli4_cq_event_alloc(struct lpfc_hba *phba)
8952 {
8953         struct lpfc_cq_event *cq_event;
8954         unsigned long iflags;
8955
8956         spin_lock_irqsave(&phba->hbalock, iflags);
8957         cq_event = __lpfc_sli4_cq_event_alloc(phba);
8958         spin_unlock_irqrestore(&phba->hbalock, iflags);
8959         return cq_event;
8960 }
8961
8962 /**
8963  * __lpfc_sli4_cq_event_release - Release a completion-queue event to free pool
8964  * @phba: pointer to lpfc hba data structure.
8965  * @cq_event: pointer to the completion queue event to be freed.
8966  *
8967  * This routine is the lock free version of the API invoked to release a
8968  * completion-queue event back into the free pool.
8969  **/
8970 void
8971 __lpfc_sli4_cq_event_release(struct lpfc_hba *phba,
8972                              struct lpfc_cq_event *cq_event)
8973 {
8974         list_add_tail(&cq_event->list, &phba->sli4_hba.sp_cqe_event_pool);
8975 }
8976
8977 /**
8978  * lpfc_sli4_cq_event_release - Release a completion-queue event to free pool
8979  * @phba: pointer to lpfc hba data structure.
8980  * @cq_event: pointer to the completion queue event to be freed.
8981  *
8982  * This routine is the lock version of the API invoked to release a
8983  * completion-queue event back into the free pool.
8984  **/
8985 void
8986 lpfc_sli4_cq_event_release(struct lpfc_hba *phba,
8987                            struct lpfc_cq_event *cq_event)
8988 {
8989         unsigned long iflags;
8990         spin_lock_irqsave(&phba->hbalock, iflags);
8991         __lpfc_sli4_cq_event_release(phba, cq_event);
8992         spin_unlock_irqrestore(&phba->hbalock, iflags);
8993 }
8994
8995 /**
8996  * lpfc_sli4_cq_event_release_all - Release all cq events to the free pool
8997  * @phba: pointer to lpfc hba data structure.
8998  *
8999  * This routine is to free all the pending completion-queue events to the
9000  * back into the free pool for device reset.
9001  **/
9002 static void
9003 lpfc_sli4_cq_event_release_all(struct lpfc_hba *phba)
9004 {
9005         LIST_HEAD(cqelist);
9006         struct lpfc_cq_event *cqe;
9007         unsigned long iflags;
9008
9009         /* Retrieve all the pending WCQEs from pending WCQE lists */
9010         spin_lock_irqsave(&phba->hbalock, iflags);
9011         /* Pending FCP XRI abort events */
9012         list_splice_init(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue,
9013                          &cqelist);
9014         /* Pending ELS XRI abort events */
9015         list_splice_init(&phba->sli4_hba.sp_els_xri_aborted_work_queue,
9016                          &cqelist);
9017         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
9018                 /* Pending NVME XRI abort events */
9019                 list_splice_init(&phba->sli4_hba.sp_nvme_xri_aborted_work_queue,
9020                                  &cqelist);
9021         }
9022         /* Pending asynnc events */
9023         list_splice_init(&phba->sli4_hba.sp_asynce_work_queue,
9024                          &cqelist);
9025         spin_unlock_irqrestore(&phba->hbalock, iflags);
9026
9027         while (!list_empty(&cqelist)) {
9028                 list_remove_head(&cqelist, cqe, struct lpfc_cq_event, list);
9029                 lpfc_sli4_cq_event_release(phba, cqe);
9030         }
9031 }
9032
9033 /**
9034  * lpfc_pci_function_reset - Reset pci function.
9035  * @phba: pointer to lpfc hba data structure.
9036  *
9037  * This routine is invoked to request a PCI function reset. It will destroys
9038  * all resources assigned to the PCI function which originates this request.
9039  *
9040  * Return codes
9041  *      0 - successful
9042  *      -ENOMEM - No available memory
9043  *      -EIO - The mailbox failed to complete successfully.
9044  **/
9045 int
9046 lpfc_pci_function_reset(struct lpfc_hba *phba)
9047 {
9048         LPFC_MBOXQ_t *mboxq;
9049         uint32_t rc = 0, if_type;
9050         uint32_t shdr_status, shdr_add_status;
9051         uint32_t rdy_chk;
9052         uint32_t port_reset = 0;
9053         union lpfc_sli4_cfg_shdr *shdr;
9054         struct lpfc_register reg_data;
9055         uint16_t devid;
9056
9057         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
9058         switch (if_type) {
9059         case LPFC_SLI_INTF_IF_TYPE_0:
9060                 mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
9061                                                        GFP_KERNEL);
9062                 if (!mboxq) {
9063                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9064                                         "0494 Unable to allocate memory for "
9065                                         "issuing SLI_FUNCTION_RESET mailbox "
9066                                         "command\n");
9067                         return -ENOMEM;
9068                 }
9069
9070                 /* Setup PCI function reset mailbox-ioctl command */
9071                 lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
9072                                  LPFC_MBOX_OPCODE_FUNCTION_RESET, 0,
9073                                  LPFC_SLI4_MBX_EMBED);
9074                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
9075                 shdr = (union lpfc_sli4_cfg_shdr *)
9076                         &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
9077                 shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
9078                 shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
9079                                          &shdr->response);
9080                 if (rc != MBX_TIMEOUT)
9081                         mempool_free(mboxq, phba->mbox_mem_pool);
9082                 if (shdr_status || shdr_add_status || rc) {
9083                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9084                                         "0495 SLI_FUNCTION_RESET mailbox "
9085                                         "failed with status x%x add_status x%x,"
9086                                         " mbx status x%x\n",
9087                                         shdr_status, shdr_add_status, rc);
9088                         rc = -ENXIO;
9089                 }
9090                 break;
9091         case LPFC_SLI_INTF_IF_TYPE_2:
9092 wait:
9093                 /*
9094                  * Poll the Port Status Register and wait for RDY for
9095                  * up to 30 seconds. If the port doesn't respond, treat
9096                  * it as an error.
9097                  */
9098                 for (rdy_chk = 0; rdy_chk < 1500; rdy_chk++) {
9099                         if (lpfc_readl(phba->sli4_hba.u.if_type2.
9100                                 STATUSregaddr, &reg_data.word0)) {
9101                                 rc = -ENODEV;
9102                                 goto out;
9103                         }
9104                         if (bf_get(lpfc_sliport_status_rdy, &reg_data))
9105                                 break;
9106                         msleep(20);
9107                 }
9108
9109                 if (!bf_get(lpfc_sliport_status_rdy, &reg_data)) {
9110                         phba->work_status[0] = readl(
9111                                 phba->sli4_hba.u.if_type2.ERR1regaddr);
9112                         phba->work_status[1] = readl(
9113                                 phba->sli4_hba.u.if_type2.ERR2regaddr);
9114                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9115                                         "2890 Port not ready, port status reg "
9116                                         "0x%x error 1=0x%x, error 2=0x%x\n",
9117                                         reg_data.word0,
9118                                         phba->work_status[0],
9119                                         phba->work_status[1]);
9120                         rc = -ENODEV;
9121                         goto out;
9122                 }
9123
9124                 if (!port_reset) {
9125                         /*
9126                          * Reset the port now
9127                          */
9128                         reg_data.word0 = 0;
9129                         bf_set(lpfc_sliport_ctrl_end, &reg_data,
9130                                LPFC_SLIPORT_LITTLE_ENDIAN);
9131                         bf_set(lpfc_sliport_ctrl_ip, &reg_data,
9132                                LPFC_SLIPORT_INIT_PORT);
9133                         writel(reg_data.word0, phba->sli4_hba.u.if_type2.
9134                                CTRLregaddr);
9135                         /* flush */
9136                         pci_read_config_word(phba->pcidev,
9137                                              PCI_DEVICE_ID, &devid);
9138
9139                         port_reset = 1;
9140                         msleep(20);
9141                         goto wait;
9142                 } else if (bf_get(lpfc_sliport_status_rn, &reg_data)) {
9143                         rc = -ENODEV;
9144                         goto out;
9145                 }
9146                 break;
9147
9148         case LPFC_SLI_INTF_IF_TYPE_1:
9149         default:
9150                 break;
9151         }
9152
9153 out:
9154         /* Catch the not-ready port failure after a port reset. */
9155         if (rc) {
9156                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9157                                 "3317 HBA not functional: IP Reset Failed "
9158                                 "try: echo fw_reset > board_mode\n");
9159                 rc = -ENODEV;
9160         }
9161
9162         return rc;
9163 }
9164
9165 /**
9166  * lpfc_sli4_pci_mem_setup - Setup SLI4 HBA PCI memory space.
9167  * @phba: pointer to lpfc hba data structure.
9168  *
9169  * This routine is invoked to set up the PCI device memory space for device
9170  * with SLI-4 interface spec.
9171  *
9172  * Return codes
9173  *      0 - successful
9174  *      other values - error
9175  **/
9176 static int
9177 lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
9178 {
9179         struct pci_dev *pdev;
9180         unsigned long bar0map_len, bar1map_len, bar2map_len;
9181         int error = -ENODEV;
9182         uint32_t if_type;
9183
9184         /* Obtain PCI device reference */
9185         if (!phba->pcidev)
9186                 return error;
9187         else
9188                 pdev = phba->pcidev;
9189
9190         /* Set the device DMA mask size */
9191         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
9192          || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
9193                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
9194                  || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
9195                         return error;
9196                 }
9197         }
9198
9199         /*
9200          * The BARs and register set definitions and offset locations are
9201          * dependent on the if_type.
9202          */
9203         if (pci_read_config_dword(pdev, LPFC_SLI_INTF,
9204                                   &phba->sli4_hba.sli_intf.word0)) {
9205                 return error;
9206         }
9207
9208         /* There is no SLI3 failback for SLI4 devices. */
9209         if (bf_get(lpfc_sli_intf_valid, &phba->sli4_hba.sli_intf) !=
9210             LPFC_SLI_INTF_VALID) {
9211                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9212                                 "2894 SLI_INTF reg contents invalid "
9213                                 "sli_intf reg 0x%x\n",
9214                                 phba->sli4_hba.sli_intf.word0);
9215                 return error;
9216         }
9217
9218         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
9219         /*
9220          * Get the bus address of SLI4 device Bar regions and the
9221          * number of bytes required by each mapping. The mapping of the
9222          * particular PCI BARs regions is dependent on the type of
9223          * SLI4 device.
9224          */
9225         if (pci_resource_start(pdev, PCI_64BIT_BAR0)) {
9226                 phba->pci_bar0_map = pci_resource_start(pdev, PCI_64BIT_BAR0);
9227                 bar0map_len = pci_resource_len(pdev, PCI_64BIT_BAR0);
9228
9229                 /*
9230                  * Map SLI4 PCI Config Space Register base to a kernel virtual
9231                  * addr
9232                  */
9233                 phba->sli4_hba.conf_regs_memmap_p =
9234                         ioremap(phba->pci_bar0_map, bar0map_len);
9235                 if (!phba->sli4_hba.conf_regs_memmap_p) {
9236                         dev_printk(KERN_ERR, &pdev->dev,
9237                                    "ioremap failed for SLI4 PCI config "
9238                                    "registers.\n");
9239                         goto out;
9240                 }
9241                 phba->pci_bar0_memmap_p = phba->sli4_hba.conf_regs_memmap_p;
9242                 /* Set up BAR0 PCI config space register memory map */
9243                 lpfc_sli4_bar0_register_memmap(phba, if_type);
9244         } else {
9245                 phba->pci_bar0_map = pci_resource_start(pdev, 1);
9246                 bar0map_len = pci_resource_len(pdev, 1);
9247                 if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
9248                         dev_printk(KERN_ERR, &pdev->dev,
9249                            "FATAL - No BAR0 mapping for SLI4, if_type 2\n");
9250                         goto out;
9251                 }
9252                 phba->sli4_hba.conf_regs_memmap_p =
9253                                 ioremap(phba->pci_bar0_map, bar0map_len);
9254                 if (!phba->sli4_hba.conf_regs_memmap_p) {
9255                         dev_printk(KERN_ERR, &pdev->dev,
9256                                 "ioremap failed for SLI4 PCI config "
9257                                 "registers.\n");
9258                                 goto out;
9259                 }
9260                 lpfc_sli4_bar0_register_memmap(phba, if_type);
9261         }
9262
9263         if ((if_type == LPFC_SLI_INTF_IF_TYPE_0) &&
9264             (pci_resource_start(pdev, PCI_64BIT_BAR2))) {
9265                 /*
9266                  * Map SLI4 if type 0 HBA Control Register base to a kernel
9267                  * virtual address and setup the registers.
9268                  */
9269                 phba->pci_bar1_map = pci_resource_start(pdev, PCI_64BIT_BAR2);
9270                 bar1map_len = pci_resource_len(pdev, PCI_64BIT_BAR2);
9271                 phba->sli4_hba.ctrl_regs_memmap_p =
9272                                 ioremap(phba->pci_bar1_map, bar1map_len);
9273                 if (!phba->sli4_hba.ctrl_regs_memmap_p) {
9274                         dev_printk(KERN_ERR, &pdev->dev,
9275                            "ioremap failed for SLI4 HBA control registers.\n");
9276                         goto out_iounmap_conf;
9277                 }
9278                 phba->pci_bar2_memmap_p = phba->sli4_hba.ctrl_regs_memmap_p;
9279                 lpfc_sli4_bar1_register_memmap(phba);
9280         }
9281
9282         if ((if_type == LPFC_SLI_INTF_IF_TYPE_0) &&
9283             (pci_resource_start(pdev, PCI_64BIT_BAR4))) {
9284                 /*
9285                  * Map SLI4 if type 0 HBA Doorbell Register base to a kernel
9286                  * virtual address and setup the registers.
9287                  */
9288                 phba->pci_bar2_map = pci_resource_start(pdev, PCI_64BIT_BAR4);
9289                 bar2map_len = pci_resource_len(pdev, PCI_64BIT_BAR4);
9290                 phba->sli4_hba.drbl_regs_memmap_p =
9291                                 ioremap(phba->pci_bar2_map, bar2map_len);
9292                 if (!phba->sli4_hba.drbl_regs_memmap_p) {
9293                         dev_printk(KERN_ERR, &pdev->dev,
9294                            "ioremap failed for SLI4 HBA doorbell registers.\n");
9295                         goto out_iounmap_ctrl;
9296                 }
9297                 phba->pci_bar4_memmap_p = phba->sli4_hba.drbl_regs_memmap_p;
9298                 error = lpfc_sli4_bar2_register_memmap(phba, LPFC_VF0);
9299                 if (error)
9300                         goto out_iounmap_all;
9301         }
9302
9303         return 0;
9304
9305 out_iounmap_all:
9306         iounmap(phba->sli4_hba.drbl_regs_memmap_p);
9307 out_iounmap_ctrl:
9308         iounmap(phba->sli4_hba.ctrl_regs_memmap_p);
9309 out_iounmap_conf:
9310         iounmap(phba->sli4_hba.conf_regs_memmap_p);
9311 out:
9312         return error;
9313 }
9314
9315 /**
9316  * lpfc_sli4_pci_mem_unset - Unset SLI4 HBA PCI memory space.
9317  * @phba: pointer to lpfc hba data structure.
9318  *
9319  * This routine is invoked to unset the PCI device memory space for device
9320  * with SLI-4 interface spec.
9321  **/
9322 static void
9323 lpfc_sli4_pci_mem_unset(struct lpfc_hba *phba)
9324 {
9325         uint32_t if_type;
9326         if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
9327
9328         switch (if_type) {
9329         case LPFC_SLI_INTF_IF_TYPE_0:
9330                 iounmap(phba->sli4_hba.drbl_regs_memmap_p);
9331                 iounmap(phba->sli4_hba.ctrl_regs_memmap_p);
9332                 iounmap(phba->sli4_hba.conf_regs_memmap_p);
9333                 break;
9334         case LPFC_SLI_INTF_IF_TYPE_2:
9335                 iounmap(phba->sli4_hba.conf_regs_memmap_p);
9336                 break;
9337         case LPFC_SLI_INTF_IF_TYPE_1:
9338         default:
9339                 dev_printk(KERN_ERR, &phba->pcidev->dev,
9340                            "FATAL - unsupported SLI4 interface type - %d\n",
9341                            if_type);
9342                 break;
9343         }
9344 }
9345
9346 /**
9347  * lpfc_sli_enable_msix - Enable MSI-X interrupt mode on SLI-3 device
9348  * @phba: pointer to lpfc hba data structure.
9349  *
9350  * This routine is invoked to enable the MSI-X interrupt vectors to device
9351  * with SLI-3 interface specs.
9352  *
9353  * Return codes
9354  *   0 - successful
9355  *   other values - error
9356  **/
9357 static int
9358 lpfc_sli_enable_msix(struct lpfc_hba *phba)
9359 {
9360         int rc;
9361         LPFC_MBOXQ_t *pmb;
9362
9363         /* Set up MSI-X multi-message vectors */
9364         rc = pci_alloc_irq_vectors(phba->pcidev,
9365                         LPFC_MSIX_VECTORS, LPFC_MSIX_VECTORS, PCI_IRQ_MSIX);
9366         if (rc < 0) {
9367                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9368                                 "0420 PCI enable MSI-X failed (%d)\n", rc);
9369                 goto vec_fail_out;
9370         }
9371
9372         /*
9373          * Assign MSI-X vectors to interrupt handlers
9374          */
9375
9376         /* vector-0 is associated to slow-path handler */
9377         rc = request_irq(pci_irq_vector(phba->pcidev, 0),
9378                          &lpfc_sli_sp_intr_handler, 0,
9379                          LPFC_SP_DRIVER_HANDLER_NAME, phba);
9380         if (rc) {
9381                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
9382                                 "0421 MSI-X slow-path request_irq failed "
9383                                 "(%d)\n", rc);
9384                 goto msi_fail_out;
9385         }
9386
9387         /* vector-1 is associated to fast-path handler */
9388         rc = request_irq(pci_irq_vector(phba->pcidev, 1),
9389                          &lpfc_sli_fp_intr_handler, 0,
9390                          LPFC_FP_DRIVER_HANDLER_NAME, phba);
9391
9392         if (rc) {
9393                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
9394                                 "0429 MSI-X fast-path request_irq failed "
9395                                 "(%d)\n", rc);
9396                 goto irq_fail_out;
9397         }
9398
9399         /*
9400          * Configure HBA MSI-X attention conditions to messages
9401          */
9402         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
9403
9404         if (!pmb) {
9405                 rc = -ENOMEM;
9406                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9407                                 "0474 Unable to allocate memory for issuing "
9408                                 "MBOX_CONFIG_MSI command\n");
9409                 goto mem_fail_out;
9410         }
9411         rc = lpfc_config_msi(phba, pmb);
9412         if (rc)
9413                 goto mbx_fail_out;
9414         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
9415         if (rc != MBX_SUCCESS) {
9416                 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
9417                                 "0351 Config MSI mailbox command failed, "
9418                                 "mbxCmd x%x, mbxStatus x%x\n",
9419                                 pmb->u.mb.mbxCommand, pmb->u.mb.mbxStatus);
9420                 goto mbx_fail_out;
9421         }
9422
9423         /* Free memory allocated for mailbox command */
9424         mempool_free(pmb, phba->mbox_mem_pool);
9425         return rc;
9426
9427 mbx_fail_out:
9428         /* Free memory allocated for mailbox command */
9429         mempool_free(pmb, phba->mbox_mem_pool);
9430
9431 mem_fail_out:
9432         /* free the irq already requested */
9433         free_irq(pci_irq_vector(phba->pcidev, 1), phba);
9434
9435 irq_fail_out:
9436         /* free the irq already requested */
9437         free_irq(pci_irq_vector(phba->pcidev, 0), phba);
9438
9439 msi_fail_out:
9440         /* Unconfigure MSI-X capability structure */
9441         pci_free_irq_vectors(phba->pcidev);
9442
9443 vec_fail_out:
9444         return rc;
9445 }
9446
9447 /**
9448  * lpfc_sli_enable_msi - Enable MSI interrupt mode on SLI-3 device.
9449  * @phba: pointer to lpfc hba data structure.
9450  *
9451  * This routine is invoked to enable the MSI interrupt mode to device with
9452  * SLI-3 interface spec. The kernel function pci_enable_msi() is called to
9453  * enable the MSI vector. The device driver is responsible for calling the
9454  * request_irq() to register MSI vector with a interrupt the handler, which
9455  * is done in this function.
9456  *
9457  * Return codes
9458  *      0 - successful
9459  *      other values - error
9460  */
9461 static int
9462 lpfc_sli_enable_msi(struct lpfc_hba *phba)
9463 {
9464         int rc;
9465
9466         rc = pci_enable_msi(phba->pcidev);
9467         if (!rc)
9468                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9469                                 "0462 PCI enable MSI mode success.\n");
9470         else {
9471                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9472                                 "0471 PCI enable MSI mode failed (%d)\n", rc);
9473                 return rc;
9474         }
9475
9476         rc = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler,
9477                          0, LPFC_DRIVER_NAME, phba);
9478         if (rc) {
9479                 pci_disable_msi(phba->pcidev);
9480                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
9481                                 "0478 MSI request_irq failed (%d)\n", rc);
9482         }
9483         return rc;
9484 }
9485
9486 /**
9487  * lpfc_sli_enable_intr - Enable device interrupt to SLI-3 device.
9488  * @phba: pointer to lpfc hba data structure.
9489  *
9490  * This routine is invoked to enable device interrupt and associate driver's
9491  * interrupt handler(s) to interrupt vector(s) to device with SLI-3 interface
9492  * spec. Depends on the interrupt mode configured to the driver, the driver
9493  * will try to fallback from the configured interrupt mode to an interrupt
9494  * mode which is supported by the platform, kernel, and device in the order
9495  * of:
9496  * MSI-X -> MSI -> IRQ.
9497  *
9498  * Return codes
9499  *   0 - successful
9500  *   other values - error
9501  **/
9502 static uint32_t
9503 lpfc_sli_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode)
9504 {
9505         uint32_t intr_mode = LPFC_INTR_ERROR;
9506         int retval;
9507
9508         if (cfg_mode == 2) {
9509                 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
9510                 retval = lpfc_sli_config_port(phba, LPFC_SLI_REV3);
9511                 if (!retval) {
9512                         /* Now, try to enable MSI-X interrupt mode */
9513                         retval = lpfc_sli_enable_msix(phba);
9514                         if (!retval) {
9515                                 /* Indicate initialization to MSI-X mode */
9516                                 phba->intr_type = MSIX;
9517                                 intr_mode = 2;
9518                         }
9519                 }
9520         }
9521
9522         /* Fallback to MSI if MSI-X initialization failed */
9523         if (cfg_mode >= 1 && phba->intr_type == NONE) {
9524                 retval = lpfc_sli_enable_msi(phba);
9525                 if (!retval) {
9526                         /* Indicate initialization to MSI mode */
9527                         phba->intr_type = MSI;
9528                         intr_mode = 1;
9529                 }
9530         }
9531
9532         /* Fallback to INTx if both MSI-X/MSI initalization failed */
9533         if (phba->intr_type == NONE) {
9534                 retval = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler,
9535                                      IRQF_SHARED, LPFC_DRIVER_NAME, phba);
9536                 if (!retval) {
9537                         /* Indicate initialization to INTx mode */
9538                         phba->intr_type = INTx;
9539                         intr_mode = 0;
9540                 }
9541         }
9542         return intr_mode;
9543 }
9544
9545 /**
9546  * lpfc_sli_disable_intr - Disable device interrupt to SLI-3 device.
9547  * @phba: pointer to lpfc hba data structure.
9548  *
9549  * This routine is invoked to disable device interrupt and disassociate the
9550  * driver's interrupt handler(s) from interrupt vector(s) to device with
9551  * SLI-3 interface spec. Depending on the interrupt mode, the driver will
9552  * release the interrupt vector(s) for the message signaled interrupt.
9553  **/
9554 static void
9555 lpfc_sli_disable_intr(struct lpfc_hba *phba)
9556 {
9557         int nr_irqs, i;
9558
9559         if (phba->intr_type == MSIX)
9560                 nr_irqs = LPFC_MSIX_VECTORS;
9561         else
9562                 nr_irqs = 1;
9563
9564         for (i = 0; i < nr_irqs; i++)
9565                 free_irq(pci_irq_vector(phba->pcidev, i), phba);
9566         pci_free_irq_vectors(phba->pcidev);
9567
9568         /* Reset interrupt management states */
9569         phba->intr_type = NONE;
9570         phba->sli.slistat.sli_intr = 0;
9571 }
9572
9573 /**
9574  * lpfc_cpu_affinity_check - Check vector CPU affinity mappings
9575  * @phba: pointer to lpfc hba data structure.
9576  * @vectors: number of msix vectors allocated.
9577  *
9578  * The routine will figure out the CPU affinity assignment for every
9579  * MSI-X vector allocated for the HBA.  The hba_eq_hdl will be updated
9580  * with a pointer to the CPU mask that defines ALL the CPUs this vector
9581  * can be associated with. If the vector can be unquely associated with
9582  * a single CPU, that CPU will be recorded in hba_eq_hdl[index].cpu.
9583  * In addition, the CPU to IO channel mapping will be calculated
9584  * and the phba->sli4_hba.cpu_map array will reflect this.
9585  */
9586 static void
9587 lpfc_cpu_affinity_check(struct lpfc_hba *phba, int vectors)
9588 {
9589         struct lpfc_vector_map_info *cpup;
9590         int index = 0;
9591         int vec = 0;
9592         int cpu;
9593 #ifdef CONFIG_X86
9594         struct cpuinfo_x86 *cpuinfo;
9595 #endif
9596
9597         /* Init cpu_map array */
9598         memset(phba->sli4_hba.cpu_map, 0xff,
9599                (sizeof(struct lpfc_vector_map_info) *
9600                phba->sli4_hba.num_present_cpu));
9601
9602         /* Update CPU map with physical id and core id of each CPU */
9603         cpup = phba->sli4_hba.cpu_map;
9604         for (cpu = 0; cpu < phba->sli4_hba.num_present_cpu; cpu++) {
9605 #ifdef CONFIG_X86
9606                 cpuinfo = &cpu_data(cpu);
9607                 cpup->phys_id = cpuinfo->phys_proc_id;
9608                 cpup->core_id = cpuinfo->cpu_core_id;
9609 #else
9610                 /* No distinction between CPUs for other platforms */
9611                 cpup->phys_id = 0;
9612                 cpup->core_id = 0;
9613 #endif
9614                 cpup->channel_id = index;  /* For now round robin */
9615                 cpup->irq = pci_irq_vector(phba->pcidev, vec);
9616                 vec++;
9617                 if (vec >= vectors)
9618                         vec = 0;
9619                 index++;
9620                 if (index >= phba->cfg_fcp_io_channel)
9621                         index = 0;
9622                 cpup++;
9623         }
9624 }
9625
9626
9627 /**
9628  * lpfc_sli4_enable_msix - Enable MSI-X interrupt mode to SLI-4 device
9629  * @phba: pointer to lpfc hba data structure.
9630  *
9631  * This routine is invoked to enable the MSI-X interrupt vectors to device
9632  * with SLI-4 interface spec.
9633  *
9634  * Return codes
9635  * 0 - successful
9636  * other values - error
9637  **/
9638 static int
9639 lpfc_sli4_enable_msix(struct lpfc_hba *phba)
9640 {
9641         int vectors, rc, index;
9642
9643         /* Set up MSI-X multi-message vectors */
9644         vectors = phba->io_channel_irqs;
9645         if (phba->cfg_fof)
9646                 vectors++;
9647
9648         rc = pci_alloc_irq_vectors(phba->pcidev,
9649                                 (phba->nvmet_support) ? 1 : 2,
9650                                 vectors, PCI_IRQ_MSIX | PCI_IRQ_AFFINITY);
9651         if (rc < 0) {
9652                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9653                                 "0484 PCI enable MSI-X failed (%d)\n", rc);
9654                 goto vec_fail_out;
9655         }
9656         vectors = rc;
9657
9658         /* Assign MSI-X vectors to interrupt handlers */
9659         for (index = 0; index < vectors; index++) {
9660                 memset(&phba->sli4_hba.handler_name[index], 0, 16);
9661                 snprintf((char *)&phba->sli4_hba.handler_name[index],
9662                          LPFC_SLI4_HANDLER_NAME_SZ,
9663                          LPFC_DRIVER_HANDLER_NAME"%d", index);
9664
9665                 phba->sli4_hba.hba_eq_hdl[index].idx = index;
9666                 phba->sli4_hba.hba_eq_hdl[index].phba = phba;
9667                 atomic_set(&phba->sli4_hba.hba_eq_hdl[index].hba_eq_in_use, 1);
9668                 if (phba->cfg_fof && (index == (vectors - 1)))
9669                         rc = request_irq(pci_irq_vector(phba->pcidev, index),
9670                                  &lpfc_sli4_fof_intr_handler, 0,
9671                                  (char *)&phba->sli4_hba.handler_name[index],
9672                                  &phba->sli4_hba.hba_eq_hdl[index]);
9673                 else
9674                         rc = request_irq(pci_irq_vector(phba->pcidev, index),
9675                                  &lpfc_sli4_hba_intr_handler, 0,
9676                                  (char *)&phba->sli4_hba.handler_name[index],
9677                                  &phba->sli4_hba.hba_eq_hdl[index]);
9678                 if (rc) {
9679                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
9680                                         "0486 MSI-X fast-path (%d) "
9681                                         "request_irq failed (%d)\n", index, rc);
9682                         goto cfg_fail_out;
9683                 }
9684         }
9685
9686         if (phba->cfg_fof)
9687                 vectors--;
9688
9689         if (vectors != phba->io_channel_irqs) {
9690                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9691                                 "3238 Reducing IO channels to match number of "
9692                                 "MSI-X vectors, requested %d got %d\n",
9693                                 phba->io_channel_irqs, vectors);
9694                 if (phba->cfg_fcp_io_channel > vectors)
9695                         phba->cfg_fcp_io_channel = vectors;
9696                 if (phba->cfg_nvme_io_channel > vectors)
9697                         phba->cfg_nvme_io_channel = vectors;
9698                 if (phba->cfg_fcp_io_channel > phba->cfg_nvme_io_channel)
9699                         phba->io_channel_irqs = phba->cfg_fcp_io_channel;
9700                 else
9701                         phba->io_channel_irqs = phba->cfg_nvme_io_channel;
9702         }
9703         lpfc_cpu_affinity_check(phba, vectors);
9704
9705         return rc;
9706
9707 cfg_fail_out:
9708         /* free the irq already requested */
9709         for (--index; index >= 0; index--)
9710                 free_irq(pci_irq_vector(phba->pcidev, index),
9711                                 &phba->sli4_hba.hba_eq_hdl[index]);
9712
9713         /* Unconfigure MSI-X capability structure */
9714         pci_free_irq_vectors(phba->pcidev);
9715
9716 vec_fail_out:
9717         return rc;
9718 }
9719
9720 /**
9721  * lpfc_sli4_enable_msi - Enable MSI interrupt mode to SLI-4 device
9722  * @phba: pointer to lpfc hba data structure.
9723  *
9724  * This routine is invoked to enable the MSI interrupt mode to device with
9725  * SLI-4 interface spec. The kernel function pci_enable_msi() is called
9726  * to enable the MSI vector. The device driver is responsible for calling
9727  * the request_irq() to register MSI vector with a interrupt the handler,
9728  * which is done in this function.
9729  *
9730  * Return codes
9731  *      0 - successful
9732  *      other values - error
9733  **/
9734 static int
9735 lpfc_sli4_enable_msi(struct lpfc_hba *phba)
9736 {
9737         int rc, index;
9738
9739         rc = pci_enable_msi(phba->pcidev);
9740         if (!rc)
9741                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9742                                 "0487 PCI enable MSI mode success.\n");
9743         else {
9744                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
9745                                 "0488 PCI enable MSI mode failed (%d)\n", rc);
9746                 return rc;
9747         }
9748
9749         rc = request_irq(phba->pcidev->irq, lpfc_sli4_intr_handler,
9750                          0, LPFC_DRIVER_NAME, phba);
9751         if (rc) {
9752                 pci_disable_msi(phba->pcidev);
9753                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
9754                                 "0490 MSI request_irq failed (%d)\n", rc);
9755                 return rc;
9756         }
9757
9758         for (index = 0; index < phba->io_channel_irqs; index++) {
9759                 phba->sli4_hba.hba_eq_hdl[index].idx = index;
9760                 phba->sli4_hba.hba_eq_hdl[index].phba = phba;
9761         }
9762
9763         if (phba->cfg_fof) {
9764                 phba->sli4_hba.hba_eq_hdl[index].idx = index;
9765                 phba->sli4_hba.hba_eq_hdl[index].phba = phba;
9766         }
9767         return 0;
9768 }
9769
9770 /**
9771  * lpfc_sli4_enable_intr - Enable device interrupt to SLI-4 device
9772  * @phba: pointer to lpfc hba data structure.
9773  *
9774  * This routine is invoked to enable device interrupt and associate driver's
9775  * interrupt handler(s) to interrupt vector(s) to device with SLI-4
9776  * interface spec. Depends on the interrupt mode configured to the driver,
9777  * the driver will try to fallback from the configured interrupt mode to an
9778  * interrupt mode which is supported by the platform, kernel, and device in
9779  * the order of:
9780  * MSI-X -> MSI -> IRQ.
9781  *
9782  * Return codes
9783  *      0 - successful
9784  *      other values - error
9785  **/
9786 static uint32_t
9787 lpfc_sli4_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode)
9788 {
9789         uint32_t intr_mode = LPFC_INTR_ERROR;
9790         int retval, idx;
9791
9792         if (cfg_mode == 2) {
9793                 /* Preparation before conf_msi mbox cmd */
9794                 retval = 0;
9795                 if (!retval) {
9796                         /* Now, try to enable MSI-X interrupt mode */
9797                         retval = lpfc_sli4_enable_msix(phba);
9798                         if (!retval) {
9799                                 /* Indicate initialization to MSI-X mode */
9800                                 phba->intr_type = MSIX;
9801                                 intr_mode = 2;
9802                         }
9803                 }
9804         }
9805
9806         /* Fallback to MSI if MSI-X initialization failed */
9807         if (cfg_mode >= 1 && phba->intr_type == NONE) {
9808                 retval = lpfc_sli4_enable_msi(phba);
9809                 if (!retval) {
9810                         /* Indicate initialization to MSI mode */
9811                         phba->intr_type = MSI;
9812                         intr_mode = 1;
9813                 }
9814         }
9815
9816         /* Fallback to INTx if both MSI-X/MSI initalization failed */
9817         if (phba->intr_type == NONE) {
9818                 retval = request_irq(phba->pcidev->irq, lpfc_sli4_intr_handler,
9819                                      IRQF_SHARED, LPFC_DRIVER_NAME, phba);
9820                 if (!retval) {
9821                         struct lpfc_hba_eq_hdl *eqhdl;
9822
9823                         /* Indicate initialization to INTx mode */
9824                         phba->intr_type = INTx;
9825                         intr_mode = 0;
9826
9827                         for (idx = 0; idx < phba->io_channel_irqs; idx++) {
9828                                 eqhdl = &phba->sli4_hba.hba_eq_hdl[idx];
9829                                 eqhdl->idx = idx;
9830                                 eqhdl->phba = phba;
9831                                 atomic_set(&eqhdl->hba_eq_in_use, 1);
9832                         }
9833                         if (phba->cfg_fof) {
9834                                 eqhdl = &phba->sli4_hba.hba_eq_hdl[idx];
9835                                 eqhdl->idx = idx;
9836                                 eqhdl->phba = phba;
9837                                 atomic_set(&eqhdl->hba_eq_in_use, 1);
9838                         }
9839                 }
9840         }
9841         return intr_mode;
9842 }
9843
9844 /**
9845  * lpfc_sli4_disable_intr - Disable device interrupt to SLI-4 device
9846  * @phba: pointer to lpfc hba data structure.
9847  *
9848  * This routine is invoked to disable device interrupt and disassociate
9849  * the driver's interrupt handler(s) from interrupt vector(s) to device
9850  * with SLI-4 interface spec. Depending on the interrupt mode, the driver
9851  * will release the interrupt vector(s) for the message signaled interrupt.
9852  **/
9853 static void
9854 lpfc_sli4_disable_intr(struct lpfc_hba *phba)
9855 {
9856         /* Disable the currently initialized interrupt mode */
9857         if (phba->intr_type == MSIX) {
9858                 int index;
9859
9860                 /* Free up MSI-X multi-message vectors */
9861                 for (index = 0; index < phba->io_channel_irqs; index++)
9862                         free_irq(pci_irq_vector(phba->pcidev, index),
9863                                         &phba->sli4_hba.hba_eq_hdl[index]);
9864
9865                 if (phba->cfg_fof)
9866                         free_irq(pci_irq_vector(phba->pcidev, index),
9867                                         &phba->sli4_hba.hba_eq_hdl[index]);
9868         } else {
9869                 free_irq(phba->pcidev->irq, phba);
9870         }
9871
9872         pci_free_irq_vectors(phba->pcidev);
9873
9874         /* Reset interrupt management states */
9875         phba->intr_type = NONE;
9876         phba->sli.slistat.sli_intr = 0;
9877 }
9878
9879 /**
9880  * lpfc_unset_hba - Unset SLI3 hba device initialization
9881  * @phba: pointer to lpfc hba data structure.
9882  *
9883  * This routine is invoked to unset the HBA device initialization steps to
9884  * a device with SLI-3 interface spec.
9885  **/
9886 static void
9887 lpfc_unset_hba(struct lpfc_hba *phba)
9888 {
9889         struct lpfc_vport *vport = phba->pport;
9890         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
9891
9892         spin_lock_irq(shost->host_lock);
9893         vport->load_flag |= FC_UNLOADING;
9894         spin_unlock_irq(shost->host_lock);
9895
9896         kfree(phba->vpi_bmask);
9897         kfree(phba->vpi_ids);
9898
9899         lpfc_stop_hba_timers(phba);
9900
9901         phba->pport->work_port_events = 0;
9902
9903         lpfc_sli_hba_down(phba);
9904
9905         lpfc_sli_brdrestart(phba);
9906
9907         lpfc_sli_disable_intr(phba);
9908
9909         return;
9910 }
9911
9912 /**
9913  * lpfc_sli4_xri_exchange_busy_wait - Wait for device XRI exchange busy
9914  * @phba: Pointer to HBA context object.
9915  *
9916  * This function is called in the SLI4 code path to wait for completion
9917  * of device's XRIs exchange busy. It will check the XRI exchange busy
9918  * on outstanding FCP and ELS I/Os every 10ms for up to 10 seconds; after
9919  * that, it will check the XRI exchange busy on outstanding FCP and ELS
9920  * I/Os every 30 seconds, log error message, and wait forever. Only when
9921  * all XRI exchange busy complete, the driver unload shall proceed with
9922  * invoking the function reset ioctl mailbox command to the CNA and the
9923  * the rest of the driver unload resource release.
9924  **/
9925 static void
9926 lpfc_sli4_xri_exchange_busy_wait(struct lpfc_hba *phba)
9927 {
9928         int wait_time = 0;
9929         int nvme_xri_cmpl = 1;
9930         int fcp_xri_cmpl = 1;
9931         int els_xri_cmpl = list_empty(&phba->sli4_hba.lpfc_abts_els_sgl_list);
9932         int nvmet_xri_cmpl =
9933                         list_empty(&phba->sli4_hba.lpfc_abts_nvmet_sgl_list);
9934
9935         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP)
9936                 fcp_xri_cmpl =
9937                         list_empty(&phba->sli4_hba.lpfc_abts_scsi_buf_list);
9938         if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
9939                 nvme_xri_cmpl =
9940                         list_empty(&phba->sli4_hba.lpfc_abts_nvme_buf_list);
9941
9942         while (!fcp_xri_cmpl || !els_xri_cmpl || !nvme_xri_cmpl ||
9943                !nvmet_xri_cmpl) {
9944                 if (wait_time > LPFC_XRI_EXCH_BUSY_WAIT_TMO) {
9945                         if (!nvme_xri_cmpl)
9946                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9947                                                 "6100 NVME XRI exchange busy "
9948                                                 "wait time: %d seconds.\n",
9949                                                 wait_time/1000);
9950                         if (!fcp_xri_cmpl)
9951                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9952                                                 "2877 FCP XRI exchange busy "
9953                                                 "wait time: %d seconds.\n",
9954                                                 wait_time/1000);
9955                         if (!els_xri_cmpl)
9956                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
9957                                                 "2878 ELS XRI exchange busy "
9958                                                 "wait time: %d seconds.\n",
9959                                                 wait_time/1000);
9960                         msleep(LPFC_XRI_EXCH_BUSY_WAIT_T2);
9961                         wait_time += LPFC_XRI_EXCH_BUSY_WAIT_T2;
9962                 } else {
9963                         msleep(LPFC_XRI_EXCH_BUSY_WAIT_T1);
9964                         wait_time += LPFC_XRI_EXCH_BUSY_WAIT_T1;
9965                 }
9966                 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)
9967                         nvme_xri_cmpl = list_empty(
9968                                 &phba->sli4_hba.lpfc_abts_nvme_buf_list);
9969
9970                 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP)
9971                         fcp_xri_cmpl = list_empty(
9972                                 &phba->sli4_hba.lpfc_abts_scsi_buf_list);
9973
9974                 els_xri_cmpl =
9975                         list_empty(&phba->sli4_hba.lpfc_abts_els_sgl_list);
9976
9977                 nvmet_xri_cmpl =
9978                         list_empty(&phba->sli4_hba.lpfc_abts_nvmet_sgl_list);
9979         }
9980 }
9981
9982 /**
9983  * lpfc_sli4_hba_unset - Unset the fcoe hba
9984  * @phba: Pointer to HBA context object.
9985  *
9986  * This function is called in the SLI4 code path to reset the HBA's FCoE
9987  * function. The caller is not required to hold any lock. This routine
9988  * issues PCI function reset mailbox command to reset the FCoE function.
9989  * At the end of the function, it calls lpfc_hba_down_post function to
9990  * free any pending commands.
9991  **/
9992 static void
9993 lpfc_sli4_hba_unset(struct lpfc_hba *phba)
9994 {
9995         int wait_cnt = 0;
9996         LPFC_MBOXQ_t *mboxq;
9997         struct pci_dev *pdev = phba->pcidev;
9998
9999         lpfc_stop_hba_timers(phba);
10000         phba->sli4_hba.intr_enable = 0;
10001
10002         /*
10003          * Gracefully wait out the potential current outstanding asynchronous
10004          * mailbox command.
10005          */
10006
10007         /* First, block any pending async mailbox command from posted */
10008         spin_lock_irq(&phba->hbalock);
10009         phba->sli.sli_flag |= LPFC_SLI_ASYNC_MBX_BLK;
10010         spin_unlock_irq(&phba->hbalock);
10011         /* Now, trying to wait it out if we can */
10012         while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) {
10013                 msleep(10);
10014                 if (++wait_cnt > LPFC_ACTIVE_MBOX_WAIT_CNT)
10015                         break;
10016         }
10017         /* Forcefully release the outstanding mailbox command if timed out */
10018         if (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) {
10019                 spin_lock_irq(&phba->hbalock);
10020                 mboxq = phba->sli.mbox_active;
10021                 mboxq->u.mb.mbxStatus = MBX_NOT_FINISHED;
10022                 __lpfc_mbox_cmpl_put(phba, mboxq);
10023                 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
10024                 phba->sli.mbox_active = NULL;
10025                 spin_unlock_irq(&phba->hbalock);
10026         }
10027
10028         /* Abort all iocbs associated with the hba */
10029         lpfc_sli_hba_iocb_abort(phba);
10030
10031         /* Wait for completion of device XRI exchange busy */
10032         lpfc_sli4_xri_exchange_busy_wait(phba);
10033
10034         /* Disable PCI subsystem interrupt */
10035         lpfc_sli4_disable_intr(phba);
10036
10037         /* Disable SR-IOV if enabled */
10038         if (phba->cfg_sriov_nr_virtfn)
10039                 pci_disable_sriov(pdev);
10040
10041         /* Stop kthread signal shall trigger work_done one more time */
10042         kthread_stop(phba->worker_thread);
10043
10044         /* Reset SLI4 HBA FCoE function */
10045         lpfc_pci_function_reset(phba);
10046         lpfc_sli4_queue_destroy(phba);
10047
10048         /* Stop the SLI4 device port */
10049         phba->pport->work_port_events = 0;
10050 }
10051
10052  /**
10053  * lpfc_pc_sli4_params_get - Get the SLI4_PARAMS port capabilities.
10054  * @phba: Pointer to HBA context object.
10055  * @mboxq: Pointer to the mailboxq memory for the mailbox command response.
10056  *
10057  * This function is called in the SLI4 code path to read the port's
10058  * sli4 capabilities.
10059  *
10060  * This function may be be called from any context that can block-wait
10061  * for the completion.  The expectation is that this routine is called
10062  * typically from probe_one or from the online routine.
10063  **/
10064 int
10065 lpfc_pc_sli4_params_get(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
10066 {
10067         int rc;
10068         struct lpfc_mqe *mqe;
10069         struct lpfc_pc_sli4_params *sli4_params;
10070         uint32_t mbox_tmo;
10071
10072         rc = 0;
10073         mqe = &mboxq->u.mqe;
10074
10075         /* Read the port's SLI4 Parameters port capabilities */
10076         lpfc_pc_sli4_params(mboxq);
10077         if (!phba->sli4_hba.intr_enable)
10078                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
10079         else {
10080                 mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq);
10081                 rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
10082         }
10083
10084         if (unlikely(rc))
10085                 return 1;
10086
10087         sli4_params = &phba->sli4_hba.pc_sli4_params;
10088         sli4_params->if_type = bf_get(if_type, &mqe->un.sli4_params);
10089         sli4_params->sli_rev = bf_get(sli_rev, &mqe->un.sli4_params);
10090         sli4_params->sli_family = bf_get(sli_family, &mqe->un.sli4_params);
10091         sli4_params->featurelevel_1 = bf_get(featurelevel_1,
10092                                              &mqe->un.sli4_params);
10093         sli4_params->featurelevel_2 = bf_get(featurelevel_2,
10094                                              &mqe->un.sli4_params);
10095         sli4_params->proto_types = mqe->un.sli4_params.word3;
10096         sli4_params->sge_supp_len = mqe->un.sli4_params.sge_supp_len;
10097         sli4_params->if_page_sz = bf_get(if_page_sz, &mqe->un.sli4_params);
10098         sli4_params->rq_db_window = bf_get(rq_db_window, &mqe->un.sli4_params);
10099         sli4_params->loopbk_scope = bf_get(loopbk_scope, &mqe->un.sli4_params);
10100         sli4_params->eq_pages_max = bf_get(eq_pages, &mqe->un.sli4_params);
10101         sli4_params->eqe_size = bf_get(eqe_size, &mqe->un.sli4_params);
10102         sli4_params->cq_pages_max = bf_get(cq_pages, &mqe->un.sli4_params);
10103         sli4_params->cqe_size = bf_get(cqe_size, &mqe->un.sli4_params);
10104         sli4_params->mq_pages_max = bf_get(mq_pages, &mqe->un.sli4_params);
10105         sli4_params->mqe_size = bf_get(mqe_size, &mqe->un.sli4_params);
10106         sli4_params->mq_elem_cnt = bf_get(mq_elem_cnt, &mqe->un.sli4_params);
10107         sli4_params->wq_pages_max = bf_get(wq_pages, &mqe->un.sli4_params);
10108         sli4_params->wqe_size = bf_get(wqe_size, &mqe->un.sli4_params);
10109         sli4_params->rq_pages_max = bf_get(rq_pages, &mqe->un.sli4_params);
10110         sli4_params->rqe_size = bf_get(rqe_size, &mqe->un.sli4_params);
10111         sli4_params->hdr_pages_max = bf_get(hdr_pages, &mqe->un.sli4_params);
10112         sli4_params->hdr_size = bf_get(hdr_size, &mqe->un.sli4_params);
10113         sli4_params->hdr_pp_align = bf_get(hdr_pp_align, &mqe->un.sli4_params);
10114         sli4_params->sgl_pages_max = bf_get(sgl_pages, &mqe->un.sli4_params);
10115         sli4_params->sgl_pp_align = bf_get(sgl_pp_align, &mqe->un.sli4_params);
10116
10117         /* Make sure that sge_supp_len can be handled by the driver */
10118         if (sli4_params->sge_supp_len > LPFC_MAX_SGE_SIZE)
10119                 sli4_params->sge_supp_len = LPFC_MAX_SGE_SIZE;
10120
10121         return rc;
10122 }
10123
10124 /**
10125  * lpfc_get_sli4_parameters - Get the SLI4 Config PARAMETERS.
10126  * @phba: Pointer to HBA context object.
10127  * @mboxq: Pointer to the mailboxq memory for the mailbox command response.
10128  *
10129  * This function is called in the SLI4 code path to read the port's
10130  * sli4 capabilities.
10131  *
10132  * This function may be be called from any context that can block-wait
10133  * for the completion.  The expectation is that this routine is called
10134  * typically from probe_one or from the online routine.
10135  **/
10136 int
10137 lpfc_get_sli4_parameters(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
10138 {
10139         int rc;
10140         struct lpfc_mqe *mqe = &mboxq->u.mqe;
10141         struct lpfc_pc_sli4_params *sli4_params;
10142         uint32_t mbox_tmo;
10143         int length;
10144         struct lpfc_sli4_parameters *mbx_sli4_parameters;
10145
10146         /*
10147          * By default, the driver assumes the SLI4 port requires RPI
10148          * header postings.  The SLI4_PARAM response will correct this
10149          * assumption.
10150          */
10151         phba->sli4_hba.rpi_hdrs_in_use = 1;
10152
10153         /* Read the port's SLI4 Config Parameters */
10154         length = (sizeof(struct lpfc_mbx_get_sli4_parameters) -
10155                   sizeof(struct lpfc_sli4_cfg_mhdr));
10156         lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
10157                          LPFC_MBOX_OPCODE_GET_SLI4_PARAMETERS,
10158                          length, LPFC_SLI4_MBX_EMBED);
10159         if (!phba->sli4_hba.intr_enable)
10160                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
10161         else {
10162                 mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq);
10163                 rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
10164         }
10165         if (unlikely(rc))
10166                 return rc;
10167         sli4_params = &phba->sli4_hba.pc_sli4_params;
10168         mbx_sli4_parameters = &mqe->un.get_sli4_parameters.sli4_parameters;
10169         sli4_params->if_type = bf_get(cfg_if_type, mbx_sli4_parameters);
10170         sli4_params->sli_rev = bf_get(cfg_sli_rev, mbx_sli4_parameters);
10171         sli4_params->sli_family = bf_get(cfg_sli_family, mbx_sli4_parameters);
10172         sli4_params->featurelevel_1 = bf_get(cfg_sli_hint_1,
10173                                              mbx_sli4_parameters);
10174         sli4_params->featurelevel_2 = bf_get(cfg_sli_hint_2,
10175                                              mbx_sli4_parameters);
10176         if (bf_get(cfg_phwq, mbx_sli4_parameters))
10177                 phba->sli3_options |= LPFC_SLI4_PHWQ_ENABLED;
10178         else
10179                 phba->sli3_options &= ~LPFC_SLI4_PHWQ_ENABLED;
10180         sli4_params->sge_supp_len = mbx_sli4_parameters->sge_supp_len;
10181         sli4_params->loopbk_scope = bf_get(loopbk_scope, mbx_sli4_parameters);
10182         sli4_params->oas_supported = bf_get(cfg_oas, mbx_sli4_parameters);
10183         sli4_params->cqv = bf_get(cfg_cqv, mbx_sli4_parameters);
10184         sli4_params->mqv = bf_get(cfg_mqv, mbx_sli4_parameters);
10185         sli4_params->wqv = bf_get(cfg_wqv, mbx_sli4_parameters);
10186         sli4_params->rqv = bf_get(cfg_rqv, mbx_sli4_parameters);
10187         sli4_params->wqsize = bf_get(cfg_wqsize, mbx_sli4_parameters);
10188         sli4_params->sgl_pages_max = bf_get(cfg_sgl_page_cnt,
10189                                             mbx_sli4_parameters);
10190         sli4_params->wqpcnt = bf_get(cfg_wqpcnt, mbx_sli4_parameters);
10191         sli4_params->sgl_pp_align = bf_get(cfg_sgl_pp_align,
10192                                            mbx_sli4_parameters);
10193         phba->sli4_hba.extents_in_use = bf_get(cfg_ext, mbx_sli4_parameters);
10194         phba->sli4_hba.rpi_hdrs_in_use = bf_get(cfg_hdrr, mbx_sli4_parameters);
10195         phba->nvme_support = (bf_get(cfg_nvme, mbx_sli4_parameters) &&
10196                               bf_get(cfg_xib, mbx_sli4_parameters));
10197
10198         if ((phba->cfg_enable_fc4_type == LPFC_ENABLE_FCP) ||
10199             !phba->nvme_support) {
10200                 phba->nvme_support = 0;
10201                 phba->nvmet_support = 0;
10202                 phba->cfg_nvmet_mrq = 0;
10203                 phba->cfg_nvme_io_channel = 0;
10204                 phba->io_channel_irqs = phba->cfg_fcp_io_channel;
10205                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_NVME,
10206                                 "6101 Disabling NVME support: "
10207                                 "Not supported by firmware: %d %d\n",
10208                                 bf_get(cfg_nvme, mbx_sli4_parameters),
10209                                 bf_get(cfg_xib, mbx_sli4_parameters));
10210
10211                 /* If firmware doesn't support NVME, just use SCSI support */
10212                 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
10213                         return -ENODEV;
10214                 phba->cfg_enable_fc4_type = LPFC_ENABLE_FCP;
10215         }
10216
10217         if (bf_get(cfg_xib, mbx_sli4_parameters) && phba->cfg_suppress_rsp)
10218                 phba->sli.sli_flag |= LPFC_SLI_SUPPRESS_RSP;
10219
10220         /* Make sure that sge_supp_len can be handled by the driver */
10221         if (sli4_params->sge_supp_len > LPFC_MAX_SGE_SIZE)
10222                 sli4_params->sge_supp_len = LPFC_MAX_SGE_SIZE;
10223
10224         /*
10225          * Issue IOs with CDB embedded in WQE to minimized the number
10226          * of DMAs the firmware has to do. Setting this to 1 also forces
10227          * the driver to use 128 bytes WQEs for FCP IOs.
10228          */
10229         if (bf_get(cfg_ext_embed_cb, mbx_sli4_parameters))
10230                 phba->fcp_embed_io = 1;
10231         else
10232                 phba->fcp_embed_io = 0;
10233
10234         /*
10235          * Check if the SLI port supports MDS Diagnostics
10236          */
10237         if (bf_get(cfg_mds_diags, mbx_sli4_parameters))
10238                 phba->mds_diags_support = 1;
10239         else
10240                 phba->mds_diags_support = 0;
10241         return 0;
10242 }
10243
10244 /**
10245  * lpfc_pci_probe_one_s3 - PCI probe func to reg SLI-3 device to PCI subsystem.
10246  * @pdev: pointer to PCI device
10247  * @pid: pointer to PCI device identifier
10248  *
10249  * This routine is to be called to attach a device with SLI-3 interface spec
10250  * to the PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
10251  * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
10252  * information of the device and driver to see if the driver state that it can
10253  * support this kind of device. If the match is successful, the driver core
10254  * invokes this routine. If this routine determines it can claim the HBA, it
10255  * does all the initialization that it needs to do to handle the HBA properly.
10256  *
10257  * Return code
10258  *      0 - driver can claim the device
10259  *      negative value - driver can not claim the device
10260  **/
10261 static int
10262 lpfc_pci_probe_one_s3(struct pci_dev *pdev, const struct pci_device_id *pid)
10263 {
10264         struct lpfc_hba   *phba;
10265         struct lpfc_vport *vport = NULL;
10266         struct Scsi_Host  *shost = NULL;
10267         int error;
10268         uint32_t cfg_mode, intr_mode;
10269
10270         /* Allocate memory for HBA structure */
10271         phba = lpfc_hba_alloc(pdev);
10272         if (!phba)
10273                 return -ENOMEM;
10274
10275         /* Perform generic PCI device enabling operation */
10276         error = lpfc_enable_pci_dev(phba);
10277         if (error)
10278                 goto out_free_phba;
10279
10280         /* Set up SLI API function jump table for PCI-device group-0 HBAs */
10281         error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_LP);
10282         if (error)
10283                 goto out_disable_pci_dev;
10284
10285         /* Set up SLI-3 specific device PCI memory space */
10286         error = lpfc_sli_pci_mem_setup(phba);
10287         if (error) {
10288                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10289                                 "1402 Failed to set up pci memory space.\n");
10290                 goto out_disable_pci_dev;
10291         }
10292
10293         /* Set up SLI-3 specific device driver resources */
10294         error = lpfc_sli_driver_resource_setup(phba);
10295         if (error) {
10296                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10297                                 "1404 Failed to set up driver resource.\n");
10298                 goto out_unset_pci_mem_s3;
10299         }
10300
10301         /* Initialize and populate the iocb list per host */
10302         error = lpfc_init_iocb_list(phba, LPFC_IOCB_LIST_CNT);
10303         if (error) {
10304                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10305                                 "1405 Failed to initialize iocb list.\n");
10306                 goto out_unset_driver_resource_s3;
10307         }
10308
10309         /* Set up common device driver resources */
10310         error = lpfc_setup_driver_resource_phase2(phba);
10311         if (error) {
10312                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10313                                 "1406 Failed to set up driver resource.\n");
10314                 goto out_free_iocb_list;
10315         }
10316
10317         /* Get the default values for Model Name and Description */
10318         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
10319
10320         /* Create SCSI host to the physical port */
10321         error = lpfc_create_shost(phba);
10322         if (error) {
10323                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10324                                 "1407 Failed to create scsi host.\n");
10325                 goto out_unset_driver_resource;
10326         }
10327
10328         /* Configure sysfs attributes */
10329         vport = phba->pport;
10330         error = lpfc_alloc_sysfs_attr(vport);
10331         if (error) {
10332                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10333                                 "1476 Failed to allocate sysfs attr\n");
10334                 goto out_destroy_shost;
10335         }
10336
10337         shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */
10338         /* Now, trying to enable interrupt and bring up the device */
10339         cfg_mode = phba->cfg_use_msi;
10340         while (true) {
10341                 /* Put device to a known state before enabling interrupt */
10342                 lpfc_stop_port(phba);
10343                 /* Configure and enable interrupt */
10344                 intr_mode = lpfc_sli_enable_intr(phba, cfg_mode);
10345                 if (intr_mode == LPFC_INTR_ERROR) {
10346                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10347                                         "0431 Failed to enable interrupt.\n");
10348                         error = -ENODEV;
10349                         goto out_free_sysfs_attr;
10350                 }
10351                 /* SLI-3 HBA setup */
10352                 if (lpfc_sli_hba_setup(phba)) {
10353                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10354                                         "1477 Failed to set up hba\n");
10355                         error = -ENODEV;
10356                         goto out_remove_device;
10357                 }
10358
10359                 /* Wait 50ms for the interrupts of previous mailbox commands */
10360                 msleep(50);
10361                 /* Check active interrupts on message signaled interrupts */
10362                 if (intr_mode == 0 ||
10363                     phba->sli.slistat.sli_intr > LPFC_MSIX_VECTORS) {
10364                         /* Log the current active interrupt mode */
10365                         phba->intr_mode = intr_mode;
10366                         lpfc_log_intr_mode(phba, intr_mode);
10367                         break;
10368                 } else {
10369                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
10370                                         "0447 Configure interrupt mode (%d) "
10371                                         "failed active interrupt test.\n",
10372                                         intr_mode);
10373                         /* Disable the current interrupt mode */
10374                         lpfc_sli_disable_intr(phba);
10375                         /* Try next level of interrupt mode */
10376                         cfg_mode = --intr_mode;
10377                 }
10378         }
10379
10380         /* Perform post initialization setup */
10381         lpfc_post_init_setup(phba);
10382
10383         /* Check if there are static vports to be created. */
10384         lpfc_create_static_vport(phba);
10385
10386         return 0;
10387
10388 out_remove_device:
10389         lpfc_unset_hba(phba);
10390 out_free_sysfs_attr:
10391         lpfc_free_sysfs_attr(vport);
10392 out_destroy_shost:
10393         lpfc_destroy_shost(phba);
10394 out_unset_driver_resource:
10395         lpfc_unset_driver_resource_phase2(phba);
10396 out_free_iocb_list:
10397         lpfc_free_iocb_list(phba);
10398 out_unset_driver_resource_s3:
10399         lpfc_sli_driver_resource_unset(phba);
10400 out_unset_pci_mem_s3:
10401         lpfc_sli_pci_mem_unset(phba);
10402 out_disable_pci_dev:
10403         lpfc_disable_pci_dev(phba);
10404         if (shost)
10405                 scsi_host_put(shost);
10406 out_free_phba:
10407         lpfc_hba_free(phba);
10408         return error;
10409 }
10410
10411 /**
10412  * lpfc_pci_remove_one_s3 - PCI func to unreg SLI-3 device from PCI subsystem.
10413  * @pdev: pointer to PCI device
10414  *
10415  * This routine is to be called to disattach a device with SLI-3 interface
10416  * spec from PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
10417  * removed from PCI bus, it performs all the necessary cleanup for the HBA
10418  * device to be removed from the PCI subsystem properly.
10419  **/
10420 static void
10421 lpfc_pci_remove_one_s3(struct pci_dev *pdev)
10422 {
10423         struct Scsi_Host  *shost = pci_get_drvdata(pdev);
10424         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
10425         struct lpfc_vport **vports;
10426         struct lpfc_hba   *phba = vport->phba;
10427         int i;
10428
10429         spin_lock_irq(&phba->hbalock);
10430         vport->load_flag |= FC_UNLOADING;
10431         spin_unlock_irq(&phba->hbalock);
10432
10433         lpfc_free_sysfs_attr(vport);
10434
10435         /* Release all the vports against this physical port */
10436         vports = lpfc_create_vport_work_array(phba);
10437         if (vports != NULL)
10438                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
10439                         if (vports[i]->port_type == LPFC_PHYSICAL_PORT)
10440                                 continue;
10441                         fc_vport_terminate(vports[i]->fc_vport);
10442                 }
10443         lpfc_destroy_vport_work_array(phba, vports);
10444
10445         /* Remove FC host and then SCSI host with the physical port */
10446         fc_remove_host(shost);
10447         scsi_remove_host(shost);
10448
10449         lpfc_cleanup(vport);
10450
10451         /*
10452          * Bring down the SLI Layer. This step disable all interrupts,
10453          * clears the rings, discards all mailbox commands, and resets
10454          * the HBA.
10455          */
10456
10457         /* HBA interrupt will be disabled after this call */
10458         lpfc_sli_hba_down(phba);
10459         /* Stop kthread signal shall trigger work_done one more time */
10460         kthread_stop(phba->worker_thread);
10461         /* Final cleanup of txcmplq and reset the HBA */
10462         lpfc_sli_brdrestart(phba);
10463
10464         kfree(phba->vpi_bmask);
10465         kfree(phba->vpi_ids);
10466
10467         lpfc_stop_hba_timers(phba);
10468         spin_lock_irq(&phba->hbalock);
10469         list_del_init(&vport->listentry);
10470         spin_unlock_irq(&phba->hbalock);
10471
10472         lpfc_debugfs_terminate(vport);
10473
10474         /* Disable SR-IOV if enabled */
10475         if (phba->cfg_sriov_nr_virtfn)
10476                 pci_disable_sriov(pdev);
10477
10478         /* Disable interrupt */
10479         lpfc_sli_disable_intr(phba);
10480
10481         scsi_host_put(shost);
10482
10483         /*
10484          * Call scsi_free before mem_free since scsi bufs are released to their
10485          * corresponding pools here.
10486          */
10487         lpfc_scsi_free(phba);
10488         lpfc_mem_free_all(phba);
10489
10490         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
10491                           phba->hbqslimp.virt, phba->hbqslimp.phys);
10492
10493         /* Free resources associated with SLI2 interface */
10494         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
10495                           phba->slim2p.virt, phba->slim2p.phys);
10496
10497         /* unmap adapter SLIM and Control Registers */
10498         iounmap(phba->ctrl_regs_memmap_p);
10499         iounmap(phba->slim_memmap_p);
10500
10501         lpfc_hba_free(phba);
10502
10503         pci_release_mem_regions(pdev);
10504         pci_disable_device(pdev);
10505 }
10506
10507 /**
10508  * lpfc_pci_suspend_one_s3 - PCI func to suspend SLI-3 device for power mgmnt
10509  * @pdev: pointer to PCI device
10510  * @msg: power management message
10511  *
10512  * This routine is to be called from the kernel's PCI subsystem to support
10513  * system Power Management (PM) to device with SLI-3 interface spec. When
10514  * PM invokes this method, it quiesces the device by stopping the driver's
10515  * worker thread for the device, turning off device's interrupt and DMA,
10516  * and bring the device offline. Note that as the driver implements the
10517  * minimum PM requirements to a power-aware driver's PM support for the
10518  * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
10519  * to the suspend() method call will be treated as SUSPEND and the driver will
10520  * fully reinitialize its device during resume() method call, the driver will
10521  * set device to PCI_D3hot state in PCI config space instead of setting it
10522  * according to the @msg provided by the PM.
10523  *
10524  * Return code
10525  *      0 - driver suspended the device
10526  *      Error otherwise
10527  **/
10528 static int
10529 lpfc_pci_suspend_one_s3(struct pci_dev *pdev, pm_message_t msg)
10530 {
10531         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10532         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
10533
10534         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
10535                         "0473 PCI device Power Management suspend.\n");
10536
10537         /* Bring down the device */
10538         lpfc_offline_prep(phba, LPFC_MBX_WAIT);
10539         lpfc_offline(phba);
10540         kthread_stop(phba->worker_thread);
10541
10542         /* Disable interrupt from device */
10543         lpfc_sli_disable_intr(phba);
10544
10545         /* Save device state to PCI config space */
10546         pci_save_state(pdev);
10547         pci_set_power_state(pdev, PCI_D3hot);
10548
10549         return 0;
10550 }
10551
10552 /**
10553  * lpfc_pci_resume_one_s3 - PCI func to resume SLI-3 device for power mgmnt
10554  * @pdev: pointer to PCI device
10555  *
10556  * This routine is to be called from the kernel's PCI subsystem to support
10557  * system Power Management (PM) to device with SLI-3 interface spec. When PM
10558  * invokes this method, it restores the device's PCI config space state and
10559  * fully reinitializes the device and brings it online. Note that as the
10560  * driver implements the minimum PM requirements to a power-aware driver's
10561  * PM for suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE,
10562  * FREEZE) to the suspend() method call will be treated as SUSPEND and the
10563  * driver will fully reinitialize its device during resume() method call,
10564  * the device will be set to PCI_D0 directly in PCI config space before
10565  * restoring the state.
10566  *
10567  * Return code
10568  *      0 - driver suspended the device
10569  *      Error otherwise
10570  **/
10571 static int
10572 lpfc_pci_resume_one_s3(struct pci_dev *pdev)
10573 {
10574         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10575         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
10576         uint32_t intr_mode;
10577         int error;
10578
10579         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
10580                         "0452 PCI device Power Management resume.\n");
10581
10582         /* Restore device state from PCI config space */
10583         pci_set_power_state(pdev, PCI_D0);
10584         pci_restore_state(pdev);
10585
10586         /*
10587          * As the new kernel behavior of pci_restore_state() API call clears
10588          * device saved_state flag, need to save the restored state again.
10589          */
10590         pci_save_state(pdev);
10591
10592         if (pdev->is_busmaster)
10593                 pci_set_master(pdev);
10594
10595         /* Startup the kernel thread for this host adapter. */
10596         phba->worker_thread = kthread_run(lpfc_do_work, phba,
10597                                         "lpfc_worker_%d", phba->brd_no);
10598         if (IS_ERR(phba->worker_thread)) {
10599                 error = PTR_ERR(phba->worker_thread);
10600                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10601                                 "0434 PM resume failed to start worker "
10602                                 "thread: error=x%x.\n", error);
10603                 return error;
10604         }
10605
10606         /* Configure and enable interrupt */
10607         intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
10608         if (intr_mode == LPFC_INTR_ERROR) {
10609                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10610                                 "0430 PM resume Failed to enable interrupt\n");
10611                 return -EIO;
10612         } else
10613                 phba->intr_mode = intr_mode;
10614
10615         /* Restart HBA and bring it online */
10616         lpfc_sli_brdrestart(phba);
10617         lpfc_online(phba);
10618
10619         /* Log the current active interrupt mode */
10620         lpfc_log_intr_mode(phba, phba->intr_mode);
10621
10622         return 0;
10623 }
10624
10625 /**
10626  * lpfc_sli_prep_dev_for_recover - Prepare SLI3 device for pci slot recover
10627  * @phba: pointer to lpfc hba data structure.
10628  *
10629  * This routine is called to prepare the SLI3 device for PCI slot recover. It
10630  * aborts all the outstanding SCSI I/Os to the pci device.
10631  **/
10632 static void
10633 lpfc_sli_prep_dev_for_recover(struct lpfc_hba *phba)
10634 {
10635         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10636                         "2723 PCI channel I/O abort preparing for recovery\n");
10637
10638         /*
10639          * There may be errored I/Os through HBA, abort all I/Os on txcmplq
10640          * and let the SCSI mid-layer to retry them to recover.
10641          */
10642         lpfc_sli_abort_fcp_rings(phba);
10643 }
10644
10645 /**
10646  * lpfc_sli_prep_dev_for_reset - Prepare SLI3 device for pci slot reset
10647  * @phba: pointer to lpfc hba data structure.
10648  *
10649  * This routine is called to prepare the SLI3 device for PCI slot reset. It
10650  * disables the device interrupt and pci device, and aborts the internal FCP
10651  * pending I/Os.
10652  **/
10653 static void
10654 lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba)
10655 {
10656         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10657                         "2710 PCI channel disable preparing for reset\n");
10658
10659         /* Block any management I/Os to the device */
10660         lpfc_block_mgmt_io(phba, LPFC_MBX_WAIT);
10661
10662         /* Block all SCSI devices' I/Os on the host */
10663         lpfc_scsi_dev_block(phba);
10664
10665         /* Flush all driver's outstanding SCSI I/Os as we are to reset */
10666         lpfc_sli_flush_fcp_rings(phba);
10667
10668         /* stop all timers */
10669         lpfc_stop_hba_timers(phba);
10670
10671         /* Disable interrupt and pci device */
10672         lpfc_sli_disable_intr(phba);
10673         pci_disable_device(phba->pcidev);
10674 }
10675
10676 /**
10677  * lpfc_sli_prep_dev_for_perm_failure - Prepare SLI3 dev for pci slot disable
10678  * @phba: pointer to lpfc hba data structure.
10679  *
10680  * This routine is called to prepare the SLI3 device for PCI slot permanently
10681  * disabling. It blocks the SCSI transport layer traffic and flushes the FCP
10682  * pending I/Os.
10683  **/
10684 static void
10685 lpfc_sli_prep_dev_for_perm_failure(struct lpfc_hba *phba)
10686 {
10687         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10688                         "2711 PCI channel permanent disable for failure\n");
10689         /* Block all SCSI devices' I/Os on the host */
10690         lpfc_scsi_dev_block(phba);
10691
10692         /* stop all timers */
10693         lpfc_stop_hba_timers(phba);
10694
10695         /* Clean up all driver's outstanding SCSI I/Os */
10696         lpfc_sli_flush_fcp_rings(phba);
10697 }
10698
10699 /**
10700  * lpfc_io_error_detected_s3 - Method for handling SLI-3 device PCI I/O error
10701  * @pdev: pointer to PCI device.
10702  * @state: the current PCI connection state.
10703  *
10704  * This routine is called from the PCI subsystem for I/O error handling to
10705  * device with SLI-3 interface spec. This function is called by the PCI
10706  * subsystem after a PCI bus error affecting this device has been detected.
10707  * When this function is invoked, it will need to stop all the I/Os and
10708  * interrupt(s) to the device. Once that is done, it will return
10709  * PCI_ERS_RESULT_NEED_RESET for the PCI subsystem to perform proper recovery
10710  * as desired.
10711  *
10712  * Return codes
10713  *      PCI_ERS_RESULT_CAN_RECOVER - can be recovered with reset_link
10714  *      PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
10715  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
10716  **/
10717 static pci_ers_result_t
10718 lpfc_io_error_detected_s3(struct pci_dev *pdev, pci_channel_state_t state)
10719 {
10720         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10721         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
10722
10723         switch (state) {
10724         case pci_channel_io_normal:
10725                 /* Non-fatal error, prepare for recovery */
10726                 lpfc_sli_prep_dev_for_recover(phba);
10727                 return PCI_ERS_RESULT_CAN_RECOVER;
10728         case pci_channel_io_frozen:
10729                 /* Fatal error, prepare for slot reset */
10730                 lpfc_sli_prep_dev_for_reset(phba);
10731                 return PCI_ERS_RESULT_NEED_RESET;
10732         case pci_channel_io_perm_failure:
10733                 /* Permanent failure, prepare for device down */
10734                 lpfc_sli_prep_dev_for_perm_failure(phba);
10735                 return PCI_ERS_RESULT_DISCONNECT;
10736         default:
10737                 /* Unknown state, prepare and request slot reset */
10738                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10739                                 "0472 Unknown PCI error state: x%x\n", state);
10740                 lpfc_sli_prep_dev_for_reset(phba);
10741                 return PCI_ERS_RESULT_NEED_RESET;
10742         }
10743 }
10744
10745 /**
10746  * lpfc_io_slot_reset_s3 - Method for restarting PCI SLI-3 device from scratch.
10747  * @pdev: pointer to PCI device.
10748  *
10749  * This routine is called from the PCI subsystem for error handling to
10750  * device with SLI-3 interface spec. This is called after PCI bus has been
10751  * reset to restart the PCI card from scratch, as if from a cold-boot.
10752  * During the PCI subsystem error recovery, after driver returns
10753  * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
10754  * recovery and then call this routine before calling the .resume method
10755  * to recover the device. This function will initialize the HBA device,
10756  * enable the interrupt, but it will just put the HBA to offline state
10757  * without passing any I/O traffic.
10758  *
10759  * Return codes
10760  *      PCI_ERS_RESULT_RECOVERED - the device has been recovered
10761  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
10762  */
10763 static pci_ers_result_t
10764 lpfc_io_slot_reset_s3(struct pci_dev *pdev)
10765 {
10766         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10767         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
10768         struct lpfc_sli *psli = &phba->sli;
10769         uint32_t intr_mode;
10770
10771         dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
10772         if (pci_enable_device_mem(pdev)) {
10773                 printk(KERN_ERR "lpfc: Cannot re-enable "
10774                         "PCI device after reset.\n");
10775                 return PCI_ERS_RESULT_DISCONNECT;
10776         }
10777
10778         pci_restore_state(pdev);
10779
10780         /*
10781          * As the new kernel behavior of pci_restore_state() API call clears
10782          * device saved_state flag, need to save the restored state again.
10783          */
10784         pci_save_state(pdev);
10785
10786         if (pdev->is_busmaster)
10787                 pci_set_master(pdev);
10788
10789         spin_lock_irq(&phba->hbalock);
10790         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
10791         spin_unlock_irq(&phba->hbalock);
10792
10793         /* Configure and enable interrupt */
10794         intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
10795         if (intr_mode == LPFC_INTR_ERROR) {
10796                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10797                                 "0427 Cannot re-enable interrupt after "
10798                                 "slot reset.\n");
10799                 return PCI_ERS_RESULT_DISCONNECT;
10800         } else
10801                 phba->intr_mode = intr_mode;
10802
10803         /* Take device offline, it will perform cleanup */
10804         lpfc_offline_prep(phba, LPFC_MBX_WAIT);
10805         lpfc_offline(phba);
10806         lpfc_sli_brdrestart(phba);
10807
10808         /* Log the current active interrupt mode */
10809         lpfc_log_intr_mode(phba, phba->intr_mode);
10810
10811         return PCI_ERS_RESULT_RECOVERED;
10812 }
10813
10814 /**
10815  * lpfc_io_resume_s3 - Method for resuming PCI I/O operation on SLI-3 device.
10816  * @pdev: pointer to PCI device
10817  *
10818  * This routine is called from the PCI subsystem for error handling to device
10819  * with SLI-3 interface spec. It is called when kernel error recovery tells
10820  * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
10821  * error recovery. After this call, traffic can start to flow from this device
10822  * again.
10823  */
10824 static void
10825 lpfc_io_resume_s3(struct pci_dev *pdev)
10826 {
10827         struct Scsi_Host *shost = pci_get_drvdata(pdev);
10828         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
10829
10830         /* Bring device online, it will be no-op for non-fatal error resume */
10831         lpfc_online(phba);
10832
10833         /* Clean up Advanced Error Reporting (AER) if needed */
10834         if (phba->hba_flag & HBA_AER_ENABLED)
10835                 pci_cleanup_aer_uncorrect_error_status(pdev);
10836 }
10837
10838 /**
10839  * lpfc_sli4_get_els_iocb_cnt - Calculate the # of ELS IOCBs to reserve
10840  * @phba: pointer to lpfc hba data structure.
10841  *
10842  * returns the number of ELS/CT IOCBs to reserve
10843  **/
10844 int
10845 lpfc_sli4_get_els_iocb_cnt(struct lpfc_hba *phba)
10846 {
10847         int max_xri = phba->sli4_hba.max_cfg_param.max_xri;
10848
10849         if (phba->sli_rev == LPFC_SLI_REV4) {
10850                 if (max_xri <= 100)
10851                         return 10;
10852                 else if (max_xri <= 256)
10853                         return 25;
10854                 else if (max_xri <= 512)
10855                         return 50;
10856                 else if (max_xri <= 1024)
10857                         return 100;
10858                 else if (max_xri <= 1536)
10859                         return 150;
10860                 else if (max_xri <= 2048)
10861                         return 200;
10862                 else
10863                         return 250;
10864         } else
10865                 return 0;
10866 }
10867
10868 /**
10869  * lpfc_sli4_get_iocb_cnt - Calculate the # of total IOCBs to reserve
10870  * @phba: pointer to lpfc hba data structure.
10871  *
10872  * returns the number of ELS/CT + NVMET IOCBs to reserve
10873  **/
10874 int
10875 lpfc_sli4_get_iocb_cnt(struct lpfc_hba *phba)
10876 {
10877         int max_xri = lpfc_sli4_get_els_iocb_cnt(phba);
10878
10879         if (phba->nvmet_support)
10880                 max_xri += LPFC_NVMET_BUF_POST;
10881         return max_xri;
10882 }
10883
10884
10885 /**
10886  * lpfc_write_firmware - attempt to write a firmware image to the port
10887  * @fw: pointer to firmware image returned from request_firmware.
10888  * @phba: pointer to lpfc hba data structure.
10889  *
10890  **/
10891 static void
10892 lpfc_write_firmware(const struct firmware *fw, void *context)
10893 {
10894         struct lpfc_hba *phba = (struct lpfc_hba *)context;
10895         char fwrev[FW_REV_STR_SIZE];
10896         struct lpfc_grp_hdr *image;
10897         struct list_head dma_buffer_list;
10898         int i, rc = 0;
10899         struct lpfc_dmabuf *dmabuf, *next;
10900         uint32_t offset = 0, temp_offset = 0;
10901         uint32_t magic_number, ftype, fid, fsize;
10902
10903         /* It can be null in no-wait mode, sanity check */
10904         if (!fw) {
10905                 rc = -ENXIO;
10906                 goto out;
10907         }
10908         image = (struct lpfc_grp_hdr *)fw->data;
10909
10910         magic_number = be32_to_cpu(image->magic_number);
10911         ftype = bf_get_be32(lpfc_grp_hdr_file_type, image);
10912         fid = bf_get_be32(lpfc_grp_hdr_id, image),
10913         fsize = be32_to_cpu(image->size);
10914
10915         INIT_LIST_HEAD(&dma_buffer_list);
10916         if ((magic_number != LPFC_GROUP_OJECT_MAGIC_G5 &&
10917              magic_number != LPFC_GROUP_OJECT_MAGIC_G6) ||
10918             ftype != LPFC_FILE_TYPE_GROUP || fsize != fw->size) {
10919                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10920                                 "3022 Invalid FW image found. "
10921                                 "Magic:%x Type:%x ID:%x Size %d %zd\n",
10922                                 magic_number, ftype, fid, fsize, fw->size);
10923                 rc = -EINVAL;
10924                 goto release_out;
10925         }
10926         lpfc_decode_firmware_rev(phba, fwrev, 1);
10927         if (strncmp(fwrev, image->revision, strnlen(image->revision, 16))) {
10928                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10929                                 "3023 Updating Firmware, Current Version:%s "
10930                                 "New Version:%s\n",
10931                                 fwrev, image->revision);
10932                 for (i = 0; i < LPFC_MBX_WR_CONFIG_MAX_BDE; i++) {
10933                         dmabuf = kzalloc(sizeof(struct lpfc_dmabuf),
10934                                          GFP_KERNEL);
10935                         if (!dmabuf) {
10936                                 rc = -ENOMEM;
10937                                 goto release_out;
10938                         }
10939                         dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
10940                                                           SLI4_PAGE_SIZE,
10941                                                           &dmabuf->phys,
10942                                                           GFP_KERNEL);
10943                         if (!dmabuf->virt) {
10944                                 kfree(dmabuf);
10945                                 rc = -ENOMEM;
10946                                 goto release_out;
10947                         }
10948                         list_add_tail(&dmabuf->list, &dma_buffer_list);
10949                 }
10950                 while (offset < fw->size) {
10951                         temp_offset = offset;
10952                         list_for_each_entry(dmabuf, &dma_buffer_list, list) {
10953                                 if (temp_offset + SLI4_PAGE_SIZE > fw->size) {
10954                                         memcpy(dmabuf->virt,
10955                                                fw->data + temp_offset,
10956                                                fw->size - temp_offset);
10957                                         temp_offset = fw->size;
10958                                         break;
10959                                 }
10960                                 memcpy(dmabuf->virt, fw->data + temp_offset,
10961                                        SLI4_PAGE_SIZE);
10962                                 temp_offset += SLI4_PAGE_SIZE;
10963                         }
10964                         rc = lpfc_wr_object(phba, &dma_buffer_list,
10965                                     (fw->size - offset), &offset);
10966                         if (rc)
10967                                 goto release_out;
10968                 }
10969                 rc = offset;
10970         }
10971
10972 release_out:
10973         list_for_each_entry_safe(dmabuf, next, &dma_buffer_list, list) {
10974                 list_del(&dmabuf->list);
10975                 dma_free_coherent(&phba->pcidev->dev, SLI4_PAGE_SIZE,
10976                                   dmabuf->virt, dmabuf->phys);
10977                 kfree(dmabuf);
10978         }
10979         release_firmware(fw);
10980 out:
10981         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
10982                         "3024 Firmware update done: %d.\n", rc);
10983         return;
10984 }
10985
10986 /**
10987  * lpfc_sli4_request_firmware_update - Request linux generic firmware upgrade
10988  * @phba: pointer to lpfc hba data structure.
10989  *
10990  * This routine is called to perform Linux generic firmware upgrade on device
10991  * that supports such feature.
10992  **/
10993 int
10994 lpfc_sli4_request_firmware_update(struct lpfc_hba *phba, uint8_t fw_upgrade)
10995 {
10996         uint8_t file_name[ELX_MODEL_NAME_SIZE];
10997         int ret;
10998         const struct firmware *fw;
10999
11000         /* Only supported on SLI4 interface type 2 for now */
11001         if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
11002             LPFC_SLI_INTF_IF_TYPE_2)
11003                 return -EPERM;
11004
11005         snprintf(file_name, ELX_MODEL_NAME_SIZE, "%s.grp", phba->ModelName);
11006
11007         if (fw_upgrade == INT_FW_UPGRADE) {
11008                 ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG,
11009                                         file_name, &phba->pcidev->dev,
11010                                         GFP_KERNEL, (void *)phba,
11011                                         lpfc_write_firmware);
11012         } else if (fw_upgrade == RUN_FW_UPGRADE) {
11013                 ret = request_firmware(&fw, file_name, &phba->pcidev->dev);
11014                 if (!ret)
11015                         lpfc_write_firmware(fw, (void *)phba);
11016         } else {
11017                 ret = -EINVAL;
11018         }
11019
11020         return ret;
11021 }
11022
11023 /**
11024  * lpfc_pci_probe_one_s4 - PCI probe func to reg SLI-4 device to PCI subsys
11025  * @pdev: pointer to PCI device
11026  * @pid: pointer to PCI device identifier
11027  *
11028  * This routine is called from the kernel's PCI subsystem to device with
11029  * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is
11030  * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
11031  * information of the device and driver to see if the driver state that it
11032  * can support this kind of device. If the match is successful, the driver
11033  * core invokes this routine. If this routine determines it can claim the HBA,
11034  * it does all the initialization that it needs to do to handle the HBA
11035  * properly.
11036  *
11037  * Return code
11038  *      0 - driver can claim the device
11039  *      negative value - driver can not claim the device
11040  **/
11041 static int
11042 lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
11043 {
11044         struct lpfc_hba   *phba;
11045         struct lpfc_vport *vport = NULL;
11046         struct Scsi_Host  *shost = NULL;
11047         int error;
11048         uint32_t cfg_mode, intr_mode;
11049
11050         /* Allocate memory for HBA structure */
11051         phba = lpfc_hba_alloc(pdev);
11052         if (!phba)
11053                 return -ENOMEM;
11054
11055         /* Perform generic PCI device enabling operation */
11056         error = lpfc_enable_pci_dev(phba);
11057         if (error)
11058                 goto out_free_phba;
11059
11060         /* Set up SLI API function jump table for PCI-device group-1 HBAs */
11061         error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_OC);
11062         if (error)
11063                 goto out_disable_pci_dev;
11064
11065         /* Set up SLI-4 specific device PCI memory space */
11066         error = lpfc_sli4_pci_mem_setup(phba);
11067         if (error) {
11068                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11069                                 "1410 Failed to set up pci memory space.\n");
11070                 goto out_disable_pci_dev;
11071         }
11072
11073         /* Set up SLI-4 Specific device driver resources */
11074         error = lpfc_sli4_driver_resource_setup(phba);
11075         if (error) {
11076                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11077                                 "1412 Failed to set up driver resource.\n");
11078                 goto out_unset_pci_mem_s4;
11079         }
11080
11081         /* Initialize and populate the iocb list per host */
11082
11083         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
11084                         "2821 initialize iocb list %d.\n",
11085                         phba->cfg_iocb_cnt*1024);
11086         error = lpfc_init_iocb_list(phba, phba->cfg_iocb_cnt*1024);
11087
11088         if (error) {
11089                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11090                                 "1413 Failed to initialize iocb list.\n");
11091                 goto out_unset_driver_resource_s4;
11092         }
11093
11094         INIT_LIST_HEAD(&phba->active_rrq_list);
11095         INIT_LIST_HEAD(&phba->fcf.fcf_pri_list);
11096
11097         /* Set up common device driver resources */
11098         error = lpfc_setup_driver_resource_phase2(phba);
11099         if (error) {
11100                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11101                                 "1414 Failed to set up driver resource.\n");
11102                 goto out_free_iocb_list;
11103         }
11104
11105         /* Get the default values for Model Name and Description */
11106         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
11107
11108         /* Create SCSI host to the physical port */
11109         error = lpfc_create_shost(phba);
11110         if (error) {
11111                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11112                                 "1415 Failed to create scsi host.\n");
11113                 goto out_unset_driver_resource;
11114         }
11115
11116         /* Configure sysfs attributes */
11117         vport = phba->pport;
11118         error = lpfc_alloc_sysfs_attr(vport);
11119         if (error) {
11120                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11121                                 "1416 Failed to allocate sysfs attr\n");
11122                 goto out_destroy_shost;
11123         }
11124
11125         shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */
11126         /* Now, trying to enable interrupt and bring up the device */
11127         cfg_mode = phba->cfg_use_msi;
11128
11129         /* Put device to a known state before enabling interrupt */
11130         lpfc_stop_port(phba);
11131
11132         /* Configure and enable interrupt */
11133         intr_mode = lpfc_sli4_enable_intr(phba, cfg_mode);
11134         if (intr_mode == LPFC_INTR_ERROR) {
11135                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11136                                 "0426 Failed to enable interrupt.\n");
11137                 error = -ENODEV;
11138                 goto out_free_sysfs_attr;
11139         }
11140         /* Default to single EQ for non-MSI-X */
11141         if (phba->intr_type != MSIX) {
11142                 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP)
11143                         phba->cfg_fcp_io_channel = 1;
11144                 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
11145                         phba->cfg_nvme_io_channel = 1;
11146                         if (phba->nvmet_support)
11147                                 phba->cfg_nvmet_mrq = 1;
11148                 }
11149                 phba->io_channel_irqs = 1;
11150         }
11151
11152         /* Set up SLI-4 HBA */
11153         if (lpfc_sli4_hba_setup(phba)) {
11154                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11155                                 "1421 Failed to set up hba\n");
11156                 error = -ENODEV;
11157                 goto out_disable_intr;
11158         }
11159
11160         /* Log the current active interrupt mode */
11161         phba->intr_mode = intr_mode;
11162         lpfc_log_intr_mode(phba, intr_mode);
11163
11164         /* Perform post initialization setup */
11165         lpfc_post_init_setup(phba);
11166
11167         /* NVME support in FW earlier in the driver load corrects the
11168          * FC4 type making a check for nvme_support unnecessary.
11169          */
11170         if ((phba->nvmet_support == 0) &&
11171             (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)) {
11172                 /* Create NVME binding with nvme_fc_transport. This
11173                  * ensures the vport is initialized.
11174                  */
11175                 error = lpfc_nvme_create_localport(vport);
11176                 if (error) {
11177                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11178                                         "6004 NVME registration failed, "
11179                                         "error x%x\n",
11180                                         error);
11181                         goto out_disable_intr;
11182                 }
11183         }
11184
11185         /* check for firmware upgrade or downgrade */
11186         if (phba->cfg_request_firmware_upgrade)
11187                 lpfc_sli4_request_firmware_update(phba, INT_FW_UPGRADE);
11188
11189         /* Check if there are static vports to be created. */
11190         lpfc_create_static_vport(phba);
11191         return 0;
11192
11193 out_disable_intr:
11194         lpfc_sli4_disable_intr(phba);
11195 out_free_sysfs_attr:
11196         lpfc_free_sysfs_attr(vport);
11197 out_destroy_shost:
11198         lpfc_destroy_shost(phba);
11199 out_unset_driver_resource:
11200         lpfc_unset_driver_resource_phase2(phba);
11201 out_free_iocb_list:
11202         lpfc_free_iocb_list(phba);
11203 out_unset_driver_resource_s4:
11204         lpfc_sli4_driver_resource_unset(phba);
11205 out_unset_pci_mem_s4:
11206         lpfc_sli4_pci_mem_unset(phba);
11207 out_disable_pci_dev:
11208         lpfc_disable_pci_dev(phba);
11209         if (shost)
11210                 scsi_host_put(shost);
11211 out_free_phba:
11212         lpfc_hba_free(phba);
11213         return error;
11214 }
11215
11216 /**
11217  * lpfc_pci_remove_one_s4 - PCI func to unreg SLI-4 device from PCI subsystem
11218  * @pdev: pointer to PCI device
11219  *
11220  * This routine is called from the kernel's PCI subsystem to device with
11221  * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is
11222  * removed from PCI bus, it performs all the necessary cleanup for the HBA
11223  * device to be removed from the PCI subsystem properly.
11224  **/
11225 static void
11226 lpfc_pci_remove_one_s4(struct pci_dev *pdev)
11227 {
11228         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11229         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
11230         struct lpfc_vport **vports;
11231         struct lpfc_hba *phba = vport->phba;
11232         int i;
11233
11234         /* Mark the device unloading flag */
11235         spin_lock_irq(&phba->hbalock);
11236         vport->load_flag |= FC_UNLOADING;
11237         spin_unlock_irq(&phba->hbalock);
11238
11239         /* Free the HBA sysfs attributes */
11240         lpfc_free_sysfs_attr(vport);
11241
11242         /* Release all the vports against this physical port */
11243         vports = lpfc_create_vport_work_array(phba);
11244         if (vports != NULL)
11245                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
11246                         if (vports[i]->port_type == LPFC_PHYSICAL_PORT)
11247                                 continue;
11248                         fc_vport_terminate(vports[i]->fc_vport);
11249                 }
11250         lpfc_destroy_vport_work_array(phba, vports);
11251
11252         /* Remove FC host and then SCSI host with the physical port */
11253         fc_remove_host(shost);
11254         scsi_remove_host(shost);
11255
11256         /* Perform ndlp cleanup on the physical port.  The nvme and nvmet
11257          * localports are destroyed after to cleanup all transport memory.
11258          */
11259         lpfc_cleanup(vport);
11260         lpfc_nvmet_destroy_targetport(phba);
11261         lpfc_nvme_destroy_localport(vport);
11262
11263         /*
11264          * Bring down the SLI Layer. This step disables all interrupts,
11265          * clears the rings, discards all mailbox commands, and resets
11266          * the HBA FCoE function.
11267          */
11268         lpfc_debugfs_terminate(vport);
11269         lpfc_sli4_hba_unset(phba);
11270
11271         spin_lock_irq(&phba->hbalock);
11272         list_del_init(&vport->listentry);
11273         spin_unlock_irq(&phba->hbalock);
11274
11275         /* Perform scsi free before driver resource_unset since scsi
11276          * buffers are released to their corresponding pools here.
11277          */
11278         lpfc_scsi_free(phba);
11279         lpfc_nvme_free(phba);
11280         lpfc_free_iocb_list(phba);
11281
11282         lpfc_sli4_driver_resource_unset(phba);
11283
11284         /* Unmap adapter Control and Doorbell registers */
11285         lpfc_sli4_pci_mem_unset(phba);
11286
11287         /* Release PCI resources and disable device's PCI function */
11288         scsi_host_put(shost);
11289         lpfc_disable_pci_dev(phba);
11290
11291         /* Finally, free the driver's device data structure */
11292         lpfc_hba_free(phba);
11293
11294         return;
11295 }
11296
11297 /**
11298  * lpfc_pci_suspend_one_s4 - PCI func to suspend SLI-4 device for power mgmnt
11299  * @pdev: pointer to PCI device
11300  * @msg: power management message
11301  *
11302  * This routine is called from the kernel's PCI subsystem to support system
11303  * Power Management (PM) to device with SLI-4 interface spec. When PM invokes
11304  * this method, it quiesces the device by stopping the driver's worker
11305  * thread for the device, turning off device's interrupt and DMA, and bring
11306  * the device offline. Note that as the driver implements the minimum PM
11307  * requirements to a power-aware driver's PM support for suspend/resume -- all
11308  * the possible PM messages (SUSPEND, HIBERNATE, FREEZE) to the suspend()
11309  * method call will be treated as SUSPEND and the driver will fully
11310  * reinitialize its device during resume() method call, the driver will set
11311  * device to PCI_D3hot state in PCI config space instead of setting it
11312  * according to the @msg provided by the PM.
11313  *
11314  * Return code
11315  *      0 - driver suspended the device
11316  *      Error otherwise
11317  **/
11318 static int
11319 lpfc_pci_suspend_one_s4(struct pci_dev *pdev, pm_message_t msg)
11320 {
11321         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11322         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11323
11324         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
11325                         "2843 PCI device Power Management suspend.\n");
11326
11327         /* Bring down the device */
11328         lpfc_offline_prep(phba, LPFC_MBX_WAIT);
11329         lpfc_offline(phba);
11330         kthread_stop(phba->worker_thread);
11331
11332         /* Disable interrupt from device */
11333         lpfc_sli4_disable_intr(phba);
11334         lpfc_sli4_queue_destroy(phba);
11335
11336         /* Save device state to PCI config space */
11337         pci_save_state(pdev);
11338         pci_set_power_state(pdev, PCI_D3hot);
11339
11340         return 0;
11341 }
11342
11343 /**
11344  * lpfc_pci_resume_one_s4 - PCI func to resume SLI-4 device for power mgmnt
11345  * @pdev: pointer to PCI device
11346  *
11347  * This routine is called from the kernel's PCI subsystem to support system
11348  * Power Management (PM) to device with SLI-4 interface spac. When PM invokes
11349  * this method, it restores the device's PCI config space state and fully
11350  * reinitializes the device and brings it online. Note that as the driver
11351  * implements the minimum PM requirements to a power-aware driver's PM for
11352  * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
11353  * to the suspend() method call will be treated as SUSPEND and the driver
11354  * will fully reinitialize its device during resume() method call, the device
11355  * will be set to PCI_D0 directly in PCI config space before restoring the
11356  * state.
11357  *
11358  * Return code
11359  *      0 - driver suspended the device
11360  *      Error otherwise
11361  **/
11362 static int
11363 lpfc_pci_resume_one_s4(struct pci_dev *pdev)
11364 {
11365         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11366         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11367         uint32_t intr_mode;
11368         int error;
11369
11370         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
11371                         "0292 PCI device Power Management resume.\n");
11372
11373         /* Restore device state from PCI config space */
11374         pci_set_power_state(pdev, PCI_D0);
11375         pci_restore_state(pdev);
11376
11377         /*
11378          * As the new kernel behavior of pci_restore_state() API call clears
11379          * device saved_state flag, need to save the restored state again.
11380          */
11381         pci_save_state(pdev);
11382
11383         if (pdev->is_busmaster)
11384                 pci_set_master(pdev);
11385
11386          /* Startup the kernel thread for this host adapter. */
11387         phba->worker_thread = kthread_run(lpfc_do_work, phba,
11388                                         "lpfc_worker_%d", phba->brd_no);
11389         if (IS_ERR(phba->worker_thread)) {
11390                 error = PTR_ERR(phba->worker_thread);
11391                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11392                                 "0293 PM resume failed to start worker "
11393                                 "thread: error=x%x.\n", error);
11394                 return error;
11395         }
11396
11397         /* Configure and enable interrupt */
11398         intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
11399         if (intr_mode == LPFC_INTR_ERROR) {
11400                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11401                                 "0294 PM resume Failed to enable interrupt\n");
11402                 return -EIO;
11403         } else
11404                 phba->intr_mode = intr_mode;
11405
11406         /* Restart HBA and bring it online */
11407         lpfc_sli_brdrestart(phba);
11408         lpfc_online(phba);
11409
11410         /* Log the current active interrupt mode */
11411         lpfc_log_intr_mode(phba, phba->intr_mode);
11412
11413         return 0;
11414 }
11415
11416 /**
11417  * lpfc_sli4_prep_dev_for_recover - Prepare SLI4 device for pci slot recover
11418  * @phba: pointer to lpfc hba data structure.
11419  *
11420  * This routine is called to prepare the SLI4 device for PCI slot recover. It
11421  * aborts all the outstanding SCSI I/Os to the pci device.
11422  **/
11423 static void
11424 lpfc_sli4_prep_dev_for_recover(struct lpfc_hba *phba)
11425 {
11426         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11427                         "2828 PCI channel I/O abort preparing for recovery\n");
11428         /*
11429          * There may be errored I/Os through HBA, abort all I/Os on txcmplq
11430          * and let the SCSI mid-layer to retry them to recover.
11431          */
11432         lpfc_sli_abort_fcp_rings(phba);
11433 }
11434
11435 /**
11436  * lpfc_sli4_prep_dev_for_reset - Prepare SLI4 device for pci slot reset
11437  * @phba: pointer to lpfc hba data structure.
11438  *
11439  * This routine is called to prepare the SLI4 device for PCI slot reset. It
11440  * disables the device interrupt and pci device, and aborts the internal FCP
11441  * pending I/Os.
11442  **/
11443 static void
11444 lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba)
11445 {
11446         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11447                         "2826 PCI channel disable preparing for reset\n");
11448
11449         /* Block any management I/Os to the device */
11450         lpfc_block_mgmt_io(phba, LPFC_MBX_NO_WAIT);
11451
11452         /* Block all SCSI devices' I/Os on the host */
11453         lpfc_scsi_dev_block(phba);
11454
11455         /* Flush all driver's outstanding SCSI I/Os as we are to reset */
11456         lpfc_sli_flush_fcp_rings(phba);
11457
11458         /* stop all timers */
11459         lpfc_stop_hba_timers(phba);
11460
11461         /* Disable interrupt and pci device */
11462         lpfc_sli4_disable_intr(phba);
11463         lpfc_sli4_queue_destroy(phba);
11464         pci_disable_device(phba->pcidev);
11465 }
11466
11467 /**
11468  * lpfc_sli4_prep_dev_for_perm_failure - Prepare SLI4 dev for pci slot disable
11469  * @phba: pointer to lpfc hba data structure.
11470  *
11471  * This routine is called to prepare the SLI4 device for PCI slot permanently
11472  * disabling. It blocks the SCSI transport layer traffic and flushes the FCP
11473  * pending I/Os.
11474  **/
11475 static void
11476 lpfc_sli4_prep_dev_for_perm_failure(struct lpfc_hba *phba)
11477 {
11478         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11479                         "2827 PCI channel permanent disable for failure\n");
11480
11481         /* Block all SCSI devices' I/Os on the host */
11482         lpfc_scsi_dev_block(phba);
11483
11484         /* stop all timers */
11485         lpfc_stop_hba_timers(phba);
11486
11487         /* Clean up all driver's outstanding SCSI I/Os */
11488         lpfc_sli_flush_fcp_rings(phba);
11489 }
11490
11491 /**
11492  * lpfc_io_error_detected_s4 - Method for handling PCI I/O error to SLI-4 device
11493  * @pdev: pointer to PCI device.
11494  * @state: the current PCI connection state.
11495  *
11496  * This routine is called from the PCI subsystem for error handling to device
11497  * with SLI-4 interface spec. This function is called by the PCI subsystem
11498  * after a PCI bus error affecting this device has been detected. When this
11499  * function is invoked, it will need to stop all the I/Os and interrupt(s)
11500  * to the device. Once that is done, it will return PCI_ERS_RESULT_NEED_RESET
11501  * for the PCI subsystem to perform proper recovery as desired.
11502  *
11503  * Return codes
11504  *      PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
11505  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
11506  **/
11507 static pci_ers_result_t
11508 lpfc_io_error_detected_s4(struct pci_dev *pdev, pci_channel_state_t state)
11509 {
11510         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11511         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11512
11513         switch (state) {
11514         case pci_channel_io_normal:
11515                 /* Non-fatal error, prepare for recovery */
11516                 lpfc_sli4_prep_dev_for_recover(phba);
11517                 return PCI_ERS_RESULT_CAN_RECOVER;
11518         case pci_channel_io_frozen:
11519                 /* Fatal error, prepare for slot reset */
11520                 lpfc_sli4_prep_dev_for_reset(phba);
11521                 return PCI_ERS_RESULT_NEED_RESET;
11522         case pci_channel_io_perm_failure:
11523                 /* Permanent failure, prepare for device down */
11524                 lpfc_sli4_prep_dev_for_perm_failure(phba);
11525                 return PCI_ERS_RESULT_DISCONNECT;
11526         default:
11527                 /* Unknown state, prepare and request slot reset */
11528                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11529                                 "2825 Unknown PCI error state: x%x\n", state);
11530                 lpfc_sli4_prep_dev_for_reset(phba);
11531                 return PCI_ERS_RESULT_NEED_RESET;
11532         }
11533 }
11534
11535 /**
11536  * lpfc_io_slot_reset_s4 - Method for restart PCI SLI-4 device from scratch
11537  * @pdev: pointer to PCI device.
11538  *
11539  * This routine is called from the PCI subsystem for error handling to device
11540  * with SLI-4 interface spec. It is called after PCI bus has been reset to
11541  * restart the PCI card from scratch, as if from a cold-boot. During the
11542  * PCI subsystem error recovery, after the driver returns
11543  * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
11544  * recovery and then call this routine before calling the .resume method to
11545  * recover the device. This function will initialize the HBA device, enable
11546  * the interrupt, but it will just put the HBA to offline state without
11547  * passing any I/O traffic.
11548  *
11549  * Return codes
11550  *      PCI_ERS_RESULT_RECOVERED - the device has been recovered
11551  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
11552  */
11553 static pci_ers_result_t
11554 lpfc_io_slot_reset_s4(struct pci_dev *pdev)
11555 {
11556         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11557         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11558         struct lpfc_sli *psli = &phba->sli;
11559         uint32_t intr_mode;
11560
11561         dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
11562         if (pci_enable_device_mem(pdev)) {
11563                 printk(KERN_ERR "lpfc: Cannot re-enable "
11564                         "PCI device after reset.\n");
11565                 return PCI_ERS_RESULT_DISCONNECT;
11566         }
11567
11568         pci_restore_state(pdev);
11569
11570         /*
11571          * As the new kernel behavior of pci_restore_state() API call clears
11572          * device saved_state flag, need to save the restored state again.
11573          */
11574         pci_save_state(pdev);
11575
11576         if (pdev->is_busmaster)
11577                 pci_set_master(pdev);
11578
11579         spin_lock_irq(&phba->hbalock);
11580         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
11581         spin_unlock_irq(&phba->hbalock);
11582
11583         /* Configure and enable interrupt */
11584         intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
11585         if (intr_mode == LPFC_INTR_ERROR) {
11586                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11587                                 "2824 Cannot re-enable interrupt after "
11588                                 "slot reset.\n");
11589                 return PCI_ERS_RESULT_DISCONNECT;
11590         } else
11591                 phba->intr_mode = intr_mode;
11592
11593         /* Log the current active interrupt mode */
11594         lpfc_log_intr_mode(phba, phba->intr_mode);
11595
11596         return PCI_ERS_RESULT_RECOVERED;
11597 }
11598
11599 /**
11600  * lpfc_io_resume_s4 - Method for resuming PCI I/O operation to SLI-4 device
11601  * @pdev: pointer to PCI device
11602  *
11603  * This routine is called from the PCI subsystem for error handling to device
11604  * with SLI-4 interface spec. It is called when kernel error recovery tells
11605  * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
11606  * error recovery. After this call, traffic can start to flow from this device
11607  * again.
11608  **/
11609 static void
11610 lpfc_io_resume_s4(struct pci_dev *pdev)
11611 {
11612         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11613         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11614
11615         /*
11616          * In case of slot reset, as function reset is performed through
11617          * mailbox command which needs DMA to be enabled, this operation
11618          * has to be moved to the io resume phase. Taking device offline
11619          * will perform the necessary cleanup.
11620          */
11621         if (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)) {
11622                 /* Perform device reset */
11623                 lpfc_offline_prep(phba, LPFC_MBX_WAIT);
11624                 lpfc_offline(phba);
11625                 lpfc_sli_brdrestart(phba);
11626                 /* Bring the device back online */
11627                 lpfc_online(phba);
11628         }
11629
11630         /* Clean up Advanced Error Reporting (AER) if needed */
11631         if (phba->hba_flag & HBA_AER_ENABLED)
11632                 pci_cleanup_aer_uncorrect_error_status(pdev);
11633 }
11634
11635 /**
11636  * lpfc_pci_probe_one - lpfc PCI probe func to reg dev to PCI subsystem
11637  * @pdev: pointer to PCI device
11638  * @pid: pointer to PCI device identifier
11639  *
11640  * This routine is to be registered to the kernel's PCI subsystem. When an
11641  * Emulex HBA device is presented on PCI bus, the kernel PCI subsystem looks
11642  * at PCI device-specific information of the device and driver to see if the
11643  * driver state that it can support this kind of device. If the match is
11644  * successful, the driver core invokes this routine. This routine dispatches
11645  * the action to the proper SLI-3 or SLI-4 device probing routine, which will
11646  * do all the initialization that it needs to do to handle the HBA device
11647  * properly.
11648  *
11649  * Return code
11650  *      0 - driver can claim the device
11651  *      negative value - driver can not claim the device
11652  **/
11653 static int
11654 lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
11655 {
11656         int rc;
11657         struct lpfc_sli_intf intf;
11658
11659         if (pci_read_config_dword(pdev, LPFC_SLI_INTF, &intf.word0))
11660                 return -ENODEV;
11661
11662         if ((bf_get(lpfc_sli_intf_valid, &intf) == LPFC_SLI_INTF_VALID) &&
11663             (bf_get(lpfc_sli_intf_slirev, &intf) == LPFC_SLI_INTF_REV_SLI4))
11664                 rc = lpfc_pci_probe_one_s4(pdev, pid);
11665         else
11666                 rc = lpfc_pci_probe_one_s3(pdev, pid);
11667
11668         return rc;
11669 }
11670
11671 /**
11672  * lpfc_pci_remove_one - lpfc PCI func to unreg dev from PCI subsystem
11673  * @pdev: pointer to PCI device
11674  *
11675  * This routine is to be registered to the kernel's PCI subsystem. When an
11676  * Emulex HBA is removed from PCI bus, the driver core invokes this routine.
11677  * This routine dispatches the action to the proper SLI-3 or SLI-4 device
11678  * remove routine, which will perform all the necessary cleanup for the
11679  * device to be removed from the PCI subsystem properly.
11680  **/
11681 static void
11682 lpfc_pci_remove_one(struct pci_dev *pdev)
11683 {
11684         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11685         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11686
11687         switch (phba->pci_dev_grp) {
11688         case LPFC_PCI_DEV_LP:
11689                 lpfc_pci_remove_one_s3(pdev);
11690                 break;
11691         case LPFC_PCI_DEV_OC:
11692                 lpfc_pci_remove_one_s4(pdev);
11693                 break;
11694         default:
11695                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11696                                 "1424 Invalid PCI device group: 0x%x\n",
11697                                 phba->pci_dev_grp);
11698                 break;
11699         }
11700         return;
11701 }
11702
11703 /**
11704  * lpfc_pci_suspend_one - lpfc PCI func to suspend dev for power management
11705  * @pdev: pointer to PCI device
11706  * @msg: power management message
11707  *
11708  * This routine is to be registered to the kernel's PCI subsystem to support
11709  * system Power Management (PM). When PM invokes this method, it dispatches
11710  * the action to the proper SLI-3 or SLI-4 device suspend routine, which will
11711  * suspend the device.
11712  *
11713  * Return code
11714  *      0 - driver suspended the device
11715  *      Error otherwise
11716  **/
11717 static int
11718 lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg)
11719 {
11720         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11721         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11722         int rc = -ENODEV;
11723
11724         switch (phba->pci_dev_grp) {
11725         case LPFC_PCI_DEV_LP:
11726                 rc = lpfc_pci_suspend_one_s3(pdev, msg);
11727                 break;
11728         case LPFC_PCI_DEV_OC:
11729                 rc = lpfc_pci_suspend_one_s4(pdev, msg);
11730                 break;
11731         default:
11732                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11733                                 "1425 Invalid PCI device group: 0x%x\n",
11734                                 phba->pci_dev_grp);
11735                 break;
11736         }
11737         return rc;
11738 }
11739
11740 /**
11741  * lpfc_pci_resume_one - lpfc PCI func to resume dev for power management
11742  * @pdev: pointer to PCI device
11743  *
11744  * This routine is to be registered to the kernel's PCI subsystem to support
11745  * system Power Management (PM). When PM invokes this method, it dispatches
11746  * the action to the proper SLI-3 or SLI-4 device resume routine, which will
11747  * resume the device.
11748  *
11749  * Return code
11750  *      0 - driver suspended the device
11751  *      Error otherwise
11752  **/
11753 static int
11754 lpfc_pci_resume_one(struct pci_dev *pdev)
11755 {
11756         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11757         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11758         int rc = -ENODEV;
11759
11760         switch (phba->pci_dev_grp) {
11761         case LPFC_PCI_DEV_LP:
11762                 rc = lpfc_pci_resume_one_s3(pdev);
11763                 break;
11764         case LPFC_PCI_DEV_OC:
11765                 rc = lpfc_pci_resume_one_s4(pdev);
11766                 break;
11767         default:
11768                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11769                                 "1426 Invalid PCI device group: 0x%x\n",
11770                                 phba->pci_dev_grp);
11771                 break;
11772         }
11773         return rc;
11774 }
11775
11776 /**
11777  * lpfc_io_error_detected - lpfc method for handling PCI I/O error
11778  * @pdev: pointer to PCI device.
11779  * @state: the current PCI connection state.
11780  *
11781  * This routine is registered to the PCI subsystem for error handling. This
11782  * function is called by the PCI subsystem after a PCI bus error affecting
11783  * this device has been detected. When this routine is invoked, it dispatches
11784  * the action to the proper SLI-3 or SLI-4 device error detected handling
11785  * routine, which will perform the proper error detected operation.
11786  *
11787  * Return codes
11788  *      PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
11789  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
11790  **/
11791 static pci_ers_result_t
11792 lpfc_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
11793 {
11794         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11795         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11796         pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
11797
11798         switch (phba->pci_dev_grp) {
11799         case LPFC_PCI_DEV_LP:
11800                 rc = lpfc_io_error_detected_s3(pdev, state);
11801                 break;
11802         case LPFC_PCI_DEV_OC:
11803                 rc = lpfc_io_error_detected_s4(pdev, state);
11804                 break;
11805         default:
11806                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11807                                 "1427 Invalid PCI device group: 0x%x\n",
11808                                 phba->pci_dev_grp);
11809                 break;
11810         }
11811         return rc;
11812 }
11813
11814 /**
11815  * lpfc_io_slot_reset - lpfc method for restart PCI dev from scratch
11816  * @pdev: pointer to PCI device.
11817  *
11818  * This routine is registered to the PCI subsystem for error handling. This
11819  * function is called after PCI bus has been reset to restart the PCI card
11820  * from scratch, as if from a cold-boot. When this routine is invoked, it
11821  * dispatches the action to the proper SLI-3 or SLI-4 device reset handling
11822  * routine, which will perform the proper device reset.
11823  *
11824  * Return codes
11825  *      PCI_ERS_RESULT_RECOVERED - the device has been recovered
11826  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
11827  **/
11828 static pci_ers_result_t
11829 lpfc_io_slot_reset(struct pci_dev *pdev)
11830 {
11831         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11832         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11833         pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
11834
11835         switch (phba->pci_dev_grp) {
11836         case LPFC_PCI_DEV_LP:
11837                 rc = lpfc_io_slot_reset_s3(pdev);
11838                 break;
11839         case LPFC_PCI_DEV_OC:
11840                 rc = lpfc_io_slot_reset_s4(pdev);
11841                 break;
11842         default:
11843                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11844                                 "1428 Invalid PCI device group: 0x%x\n",
11845                                 phba->pci_dev_grp);
11846                 break;
11847         }
11848         return rc;
11849 }
11850
11851 /**
11852  * lpfc_io_resume - lpfc method for resuming PCI I/O operation
11853  * @pdev: pointer to PCI device
11854  *
11855  * This routine is registered to the PCI subsystem for error handling. It
11856  * is called when kernel error recovery tells the lpfc driver that it is
11857  * OK to resume normal PCI operation after PCI bus error recovery. When
11858  * this routine is invoked, it dispatches the action to the proper SLI-3
11859  * or SLI-4 device io_resume routine, which will resume the device operation.
11860  **/
11861 static void
11862 lpfc_io_resume(struct pci_dev *pdev)
11863 {
11864         struct Scsi_Host *shost = pci_get_drvdata(pdev);
11865         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
11866
11867         switch (phba->pci_dev_grp) {
11868         case LPFC_PCI_DEV_LP:
11869                 lpfc_io_resume_s3(pdev);
11870                 break;
11871         case LPFC_PCI_DEV_OC:
11872                 lpfc_io_resume_s4(pdev);
11873                 break;
11874         default:
11875                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
11876                                 "1429 Invalid PCI device group: 0x%x\n",
11877                                 phba->pci_dev_grp);
11878                 break;
11879         }
11880         return;
11881 }
11882
11883 /**
11884  * lpfc_sli4_oas_verify - Verify OAS is supported by this adapter
11885  * @phba: pointer to lpfc hba data structure.
11886  *
11887  * This routine checks to see if OAS is supported for this adapter. If
11888  * supported, the configure Flash Optimized Fabric flag is set.  Otherwise,
11889  * the enable oas flag is cleared and the pool created for OAS device data
11890  * is destroyed.
11891  *
11892  **/
11893 void
11894 lpfc_sli4_oas_verify(struct lpfc_hba *phba)
11895 {
11896
11897         if (!phba->cfg_EnableXLane)
11898                 return;
11899
11900         if (phba->sli4_hba.pc_sli4_params.oas_supported) {
11901                 phba->cfg_fof = 1;
11902         } else {
11903                 phba->cfg_fof = 0;
11904                 if (phba->device_data_mem_pool)
11905                         mempool_destroy(phba->device_data_mem_pool);
11906                 phba->device_data_mem_pool = NULL;
11907         }
11908
11909         return;
11910 }
11911
11912 /**
11913  * lpfc_fof_queue_setup - Set up all the fof queues
11914  * @phba: pointer to lpfc hba data structure.
11915  *
11916  * This routine is invoked to set up all the fof queues for the FC HBA
11917  * operation.
11918  *
11919  * Return codes
11920  *      0 - successful
11921  *      -ENOMEM - No available memory
11922  **/
11923 int
11924 lpfc_fof_queue_setup(struct lpfc_hba *phba)
11925 {
11926         struct lpfc_sli_ring *pring;
11927         int rc;
11928
11929         rc = lpfc_eq_create(phba, phba->sli4_hba.fof_eq, LPFC_MAX_IMAX);
11930         if (rc)
11931                 return -ENOMEM;
11932
11933         if (phba->cfg_fof) {
11934
11935                 rc = lpfc_cq_create(phba, phba->sli4_hba.oas_cq,
11936                                     phba->sli4_hba.fof_eq, LPFC_WCQ, LPFC_FCP);
11937                 if (rc)
11938                         goto out_oas_cq;
11939
11940                 rc = lpfc_wq_create(phba, phba->sli4_hba.oas_wq,
11941                                     phba->sli4_hba.oas_cq, LPFC_FCP);
11942                 if (rc)
11943                         goto out_oas_wq;
11944
11945                 /* Bind this CQ/WQ to the NVME ring */
11946                 pring = phba->sli4_hba.oas_wq->pring;
11947                 pring->sli.sli4.wqp =
11948                         (void *)phba->sli4_hba.oas_wq;
11949                 phba->sli4_hba.oas_cq->pring = pring;
11950         }
11951
11952         return 0;
11953
11954 out_oas_wq:
11955         lpfc_cq_destroy(phba, phba->sli4_hba.oas_cq);
11956 out_oas_cq:
11957         lpfc_eq_destroy(phba, phba->sli4_hba.fof_eq);
11958         return rc;
11959
11960 }
11961
11962 /**
11963  * lpfc_fof_queue_create - Create all the fof queues
11964  * @phba: pointer to lpfc hba data structure.
11965  *
11966  * This routine is invoked to allocate all the fof queues for the FC HBA
11967  * operation. For each SLI4 queue type, the parameters such as queue entry
11968  * count (queue depth) shall be taken from the module parameter. For now,
11969  * we just use some constant number as place holder.
11970  *
11971  * Return codes
11972  *      0 - successful
11973  *      -ENOMEM - No availble memory
11974  *      -EIO - The mailbox failed to complete successfully.
11975  **/
11976 int
11977 lpfc_fof_queue_create(struct lpfc_hba *phba)
11978 {
11979         struct lpfc_queue *qdesc;
11980
11981         /* Create FOF EQ */
11982         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize,
11983                                       phba->sli4_hba.eq_ecount);
11984         if (!qdesc)
11985                 goto out_error;
11986
11987         phba->sli4_hba.fof_eq = qdesc;
11988
11989         if (phba->cfg_fof) {
11990
11991                 /* Create OAS CQ */
11992                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
11993                                                       phba->sli4_hba.cq_ecount);
11994                 if (!qdesc)
11995                         goto out_error;
11996
11997                 phba->sli4_hba.oas_cq = qdesc;
11998
11999                 /* Create OAS WQ */
12000                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize,
12001                                               phba->sli4_hba.wq_ecount);
12002                 if (!qdesc)
12003                         goto out_error;
12004
12005                 phba->sli4_hba.oas_wq = qdesc;
12006                 list_add_tail(&qdesc->wq_list, &phba->sli4_hba.lpfc_wq_list);
12007
12008         }
12009         return 0;
12010
12011 out_error:
12012         lpfc_fof_queue_destroy(phba);
12013         return -ENOMEM;
12014 }
12015
12016 /**
12017  * lpfc_fof_queue_destroy - Destroy all the fof queues
12018  * @phba: pointer to lpfc hba data structure.
12019  *
12020  * This routine is invoked to release all the SLI4 queues with the FC HBA
12021  * operation.
12022  *
12023  * Return codes
12024  *      0 - successful
12025  **/
12026 int
12027 lpfc_fof_queue_destroy(struct lpfc_hba *phba)
12028 {
12029         /* Release FOF Event queue */
12030         if (phba->sli4_hba.fof_eq != NULL) {
12031                 lpfc_sli4_queue_free(phba->sli4_hba.fof_eq);
12032                 phba->sli4_hba.fof_eq = NULL;
12033         }
12034
12035         /* Release OAS Completion queue */
12036         if (phba->sli4_hba.oas_cq != NULL) {
12037                 lpfc_sli4_queue_free(phba->sli4_hba.oas_cq);
12038                 phba->sli4_hba.oas_cq = NULL;
12039         }
12040
12041         /* Release OAS Work queue */
12042         if (phba->sli4_hba.oas_wq != NULL) {
12043                 lpfc_sli4_queue_free(phba->sli4_hba.oas_wq);
12044                 phba->sli4_hba.oas_wq = NULL;
12045         }
12046         return 0;
12047 }
12048
12049 MODULE_DEVICE_TABLE(pci, lpfc_id_table);
12050
12051 static const struct pci_error_handlers lpfc_err_handler = {
12052         .error_detected = lpfc_io_error_detected,
12053         .slot_reset = lpfc_io_slot_reset,
12054         .resume = lpfc_io_resume,
12055 };
12056
12057 static struct pci_driver lpfc_driver = {
12058         .name           = LPFC_DRIVER_NAME,
12059         .id_table       = lpfc_id_table,
12060         .probe          = lpfc_pci_probe_one,
12061         .remove         = lpfc_pci_remove_one,
12062         .shutdown       = lpfc_pci_remove_one,
12063         .suspend        = lpfc_pci_suspend_one,
12064         .resume         = lpfc_pci_resume_one,
12065         .err_handler    = &lpfc_err_handler,
12066 };
12067
12068 static const struct file_operations lpfc_mgmt_fop = {
12069         .owner = THIS_MODULE,
12070 };
12071
12072 static struct miscdevice lpfc_mgmt_dev = {
12073         .minor = MISC_DYNAMIC_MINOR,
12074         .name = "lpfcmgmt",
12075         .fops = &lpfc_mgmt_fop,
12076 };
12077
12078 /**
12079  * lpfc_init - lpfc module initialization routine
12080  *
12081  * This routine is to be invoked when the lpfc module is loaded into the
12082  * kernel. The special kernel macro module_init() is used to indicate the
12083  * role of this routine to the kernel as lpfc module entry point.
12084  *
12085  * Return codes
12086  *   0 - successful
12087  *   -ENOMEM - FC attach transport failed
12088  *   all others - failed
12089  */
12090 static int __init
12091 lpfc_init(void)
12092 {
12093         int error = 0;
12094
12095         printk(LPFC_MODULE_DESC "\n");
12096         printk(LPFC_COPYRIGHT "\n");
12097
12098         error = misc_register(&lpfc_mgmt_dev);
12099         if (error)
12100                 printk(KERN_ERR "Could not register lpfcmgmt device, "
12101                         "misc_register returned with status %d", error);
12102
12103         lpfc_transport_functions.vport_create = lpfc_vport_create;
12104         lpfc_transport_functions.vport_delete = lpfc_vport_delete;
12105         lpfc_transport_template =
12106                                 fc_attach_transport(&lpfc_transport_functions);
12107         if (lpfc_transport_template == NULL)
12108                 return -ENOMEM;
12109         lpfc_vport_transport_template =
12110                 fc_attach_transport(&lpfc_vport_transport_functions);
12111         if (lpfc_vport_transport_template == NULL) {
12112                 fc_release_transport(lpfc_transport_template);
12113                 return -ENOMEM;
12114         }
12115
12116         /* Initialize in case vector mapping is needed */
12117         lpfc_used_cpu = NULL;
12118         lpfc_present_cpu = num_present_cpus();
12119
12120         error = pci_register_driver(&lpfc_driver);
12121         if (error) {
12122                 fc_release_transport(lpfc_transport_template);
12123                 fc_release_transport(lpfc_vport_transport_template);
12124         }
12125
12126         return error;
12127 }
12128
12129 /**
12130  * lpfc_exit - lpfc module removal routine
12131  *
12132  * This routine is invoked when the lpfc module is removed from the kernel.
12133  * The special kernel macro module_exit() is used to indicate the role of
12134  * this routine to the kernel as lpfc module exit point.
12135  */
12136 static void __exit
12137 lpfc_exit(void)
12138 {
12139         misc_deregister(&lpfc_mgmt_dev);
12140         pci_unregister_driver(&lpfc_driver);
12141         fc_release_transport(lpfc_transport_template);
12142         fc_release_transport(lpfc_vport_transport_template);
12143         if (_dump_buf_data) {
12144                 printk(KERN_ERR "9062 BLKGRD: freeing %lu pages for "
12145                                 "_dump_buf_data at 0x%p\n",
12146                                 (1L << _dump_buf_data_order), _dump_buf_data);
12147                 free_pages((unsigned long)_dump_buf_data, _dump_buf_data_order);
12148         }
12149
12150         if (_dump_buf_dif) {
12151                 printk(KERN_ERR "9049 BLKGRD: freeing %lu pages for "
12152                                 "_dump_buf_dif at 0x%p\n",
12153                                 (1L << _dump_buf_dif_order), _dump_buf_dif);
12154                 free_pages((unsigned long)_dump_buf_dif, _dump_buf_dif_order);
12155         }
12156         kfree(lpfc_used_cpu);
12157         idr_destroy(&lpfc_hba_index);
12158 }
12159
12160 module_init(lpfc_init);
12161 module_exit(lpfc_exit);
12162 MODULE_LICENSE("GPL");
12163 MODULE_DESCRIPTION(LPFC_MODULE_DESC);
12164 MODULE_AUTHOR("Broadcom");
12165 MODULE_VERSION("0:" LPFC_DRIVER_VERSION);