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) 2004-2010 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
   8  *                                                                 *
   9  * This program is free software; you can redistribute it and/or   *
  10  * modify it under the terms of version 2 of the GNU General       *
  11  * Public License as published by the Free Software Foundation.    *
  12  * This program is distributed in the hope that it will be useful. *
  13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  18  * more details, a copy of which can be found in the file COPYING  *
  19  * included with this package.                                     *
  20  *******************************************************************/
  21
  22 #include <linux/blkdev.h>
  23 #include <linux/delay.h>
  24 #include <linux/dma-mapping.h>
  25 #include <linux/idr.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/kthread.h>
  28 #include <linux/pci.h>
  29 #include <linux/spinlock.h>
  30 #include <linux/ctype.h>
  31 #include <linux/aer.h>
  32
  33 #include <scsi/scsi.h>
  34 #include <scsi/scsi_device.h>
  35 #include <scsi/scsi_host.h>
  36 #include <scsi/scsi_transport_fc.h>
  37
  38 #include "lpfc_hw4.h"
  39 #include "lpfc_hw.h"
  40 #include "lpfc_sli.h"
  41 #include "lpfc_sli4.h"
  42 #include "lpfc_nl.h"
  43 #include "lpfc_disc.h"
  44 #include "lpfc_scsi.h"
  45 #include "lpfc.h"
  46 #include "lpfc_logmsg.h"
  47 #include "lpfc_crtn.h"
  48 #include "lpfc_vport.h"
  49 #include "lpfc_version.h"
  50
  51 char *_dump_buf_data;
  52 unsigned long _dump_buf_data_order;
  53 char *_dump_buf_dif;
  54 unsigned long _dump_buf_dif_order;
  55 spinlock_t _dump_buf_lock;
  56
  57 static void lpfc_get_hba_model_desc(struct lpfc_hba *, uint8_t *, uint8_t *);
  58 static int lpfc_post_rcv_buf(struct lpfc_hba *);
  59 static int lpfc_sli4_queue_create(struct lpfc_hba *);
  60 static void lpfc_sli4_queue_destroy(struct lpfc_hba *);
  61 static int lpfc_create_bootstrap_mbox(struct lpfc_hba *);
  62 static int lpfc_setup_endian_order(struct lpfc_hba *);
  63 static int lpfc_sli4_read_config(struct lpfc_hba *);
  64 static void lpfc_destroy_bootstrap_mbox(struct lpfc_hba *);
  65 static void lpfc_free_sgl_list(struct lpfc_hba *);
  66 static int lpfc_init_sgl_list(struct lpfc_hba *);
  67 static int lpfc_init_active_sgl_array(struct lpfc_hba *);
  68 static void lpfc_free_active_sgl(struct lpfc_hba *);
  69 static int lpfc_hba_down_post_s3(struct lpfc_hba *phba);
  70 static int lpfc_hba_down_post_s4(struct lpfc_hba *phba);
  71 static int lpfc_sli4_cq_event_pool_create(struct lpfc_hba *);
  72 static void lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *);
  73 static void lpfc_sli4_cq_event_release_all(struct lpfc_hba *);
  74
  75 static struct scsi_transport_template *lpfc_transport_template = NULL;
  76 static struct scsi_transport_template *lpfc_vport_transport_template = NULL;
  77 static DEFINE_IDR(lpfc_hba_index);
  78
  79 /**
  80  * lpfc_config_port_prep - Perform lpfc initialization prior to config port
  81  * @phba: pointer to lpfc hba data structure.
  82  *
  83  * This routine will do LPFC initialization prior to issuing the CONFIG_PORT
  84  * mailbox command. It retrieves the revision information from the HBA and
  85  * collects the Vital Product Data (VPD) about the HBA for preparing the
  86  * configuration of the HBA.
  87  *
  88  * Return codes:
  89  *   0 - success.
  90  *   -ERESTART - requests the SLI layer to reset the HBA and try again.
  91  *   Any other value - indicates an error.
  92  **/
  93 int
  94 lpfc_config_port_prep(struct lpfc_hba *phba)
  95 {
  96         lpfc_vpd_t *vp = &phba->vpd;
  97         int i = 0, rc;
  98         LPFC_MBOXQ_t *pmb;
  99         MAILBOX_t *mb;
 100         char *lpfc_vpd_data = NULL;
 101         uint16_t offset = 0;
 102         static char licensed[56] =
 103                     "key unlock for use with gnu public licensed code only\0";
 104         static int init_key = 1;
 105
 106         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 107         if (!pmb) {
 108                 phba->link_state = LPFC_HBA_ERROR;
 109                 return -ENOMEM;
 110         }
 111
 112         mb = &pmb->u.mb;
 113         phba->link_state = LPFC_INIT_MBX_CMDS;
 114
 115         if (lpfc_is_LC_HBA(phba->pcidev->device)) {
 116                 if (init_key) {
 117                         uint32_t *ptext = (uint32_t *) licensed;
 118
 119                         for (i = 0; i < 56; i += sizeof (uint32_t), ptext++)
 120                                 *ptext = cpu_to_be32(*ptext);
 121                         init_key = 0;
 122                 }
 123
 124                 lpfc_read_nv(phba, pmb);
 125                 memset((char*)mb->un.varRDnvp.rsvd3, 0,
 126                         sizeof (mb->un.varRDnvp.rsvd3));
 127                 memcpy((char*)mb->un.varRDnvp.rsvd3, licensed,
 128                          sizeof (licensed));
 129
 130                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 131
 132                 if (rc != MBX_SUCCESS) {
 133                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
 134                                         "0324 Config Port initialization "
 135                                         "error, mbxCmd x%x READ_NVPARM, "
 136                                         "mbxStatus x%x\n",
 137                                         mb->mbxCommand, mb->mbxStatus);
 138                         mempool_free(pmb, phba->mbox_mem_pool);
 139                         return -ERESTART;
 140                 }
 141                 memcpy(phba->wwnn, (char *)mb->un.varRDnvp.nodename,
 142                        sizeof(phba->wwnn));
 143                 memcpy(phba->wwpn, (char *)mb->un.varRDnvp.portname,
 144                        sizeof(phba->wwpn));
 145         }
 146
 147         phba->sli3_options = 0x0;
 148
 149         /* Setup and issue mailbox READ REV command */
 150         lpfc_read_rev(phba, pmb);
 151         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 152         if (rc != MBX_SUCCESS) {
 153                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 154                                 "0439 Adapter failed to init, mbxCmd x%x "
 155                                 "READ_REV, mbxStatus x%x\n",
 156                                 mb->mbxCommand, mb->mbxStatus);
 157                 mempool_free( pmb, phba->mbox_mem_pool);
 158                 return -ERESTART;
 159         }
 160
 161
 162         /*
 163          * The value of rr must be 1 since the driver set the cv field to 1.
 164          * This setting requires the FW to set all revision fields.
 165          */
 166         if (mb->un.varRdRev.rr == 0) {
 167                 vp->rev.rBit = 0;
 168                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 169                                 "0440 Adapter failed to init, READ_REV has "
 170                                 "missing revision information.\n");
 171                 mempool_free(pmb, phba->mbox_mem_pool);
 172                 return -ERESTART;
 173         }
 174
 175         if (phba->sli_rev == 3 && !mb->un.varRdRev.v3rsp) {
 176                 mempool_free(pmb, phba->mbox_mem_pool);
 177                 return -EINVAL;
 178         }
 179
 180         /* Save information as VPD data */
 181         vp->rev.rBit = 1;
 182         memcpy(&vp->sli3Feat, &mb->un.varRdRev.sli3Feat, sizeof(uint32_t));
 183         vp->rev.sli1FwRev = mb->un.varRdRev.sli1FwRev;
 184         memcpy(vp->rev.sli1FwName, (char*) mb->un.varRdRev.sli1FwName, 16);
 185         vp->rev.sli2FwRev = mb->un.varRdRev.sli2FwRev;
 186         memcpy(vp->rev.sli2FwName, (char *) mb->un.varRdRev.sli2FwName, 16);
 187         vp->rev.biuRev = mb->un.varRdRev.biuRev;
 188         vp->rev.smRev = mb->un.varRdRev.smRev;
 189         vp->rev.smFwRev = mb->un.varRdRev.un.smFwRev;
 190         vp->rev.endecRev = mb->un.varRdRev.endecRev;
 191         vp->rev.fcphHigh = mb->un.varRdRev.fcphHigh;
 192         vp->rev.fcphLow = mb->un.varRdRev.fcphLow;
 193         vp->rev.feaLevelHigh = mb->un.varRdRev.feaLevelHigh;
 194         vp->rev.feaLevelLow = mb->un.varRdRev.feaLevelLow;
 195         vp->rev.postKernRev = mb->un.varRdRev.postKernRev;
 196         vp->rev.opFwRev = mb->un.varRdRev.opFwRev;
 197
 198         /* If the sli feature level is less then 9, we must
 199          * tear down all RPIs and VPIs on link down if NPIV
 200          * is enabled.
 201          */
 202         if (vp->rev.feaLevelHigh < 9)
 203                 phba->sli3_options |= LPFC_SLI3_VPORT_TEARDOWN;
 204
 205         if (lpfc_is_LC_HBA(phba->pcidev->device))
 206                 memcpy(phba->RandomData, (char *)&mb->un.varWords[24],
 207                                                 sizeof (phba->RandomData));
 208
 209         /* Get adapter VPD information */
 210         lpfc_vpd_data = kmalloc(DMP_VPD_SIZE, GFP_KERNEL);
 211         if (!lpfc_vpd_data)
 212                 goto out_free_mbox;
 213
 214         do {
 215                 lpfc_dump_mem(phba, pmb, offset, DMP_REGION_VPD);
 216                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 217
 218                 if (rc != MBX_SUCCESS) {
 219                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
 220                                         "0441 VPD not present on adapter, "
 221                                         "mbxCmd x%x DUMP VPD, mbxStatus x%x\n",
 222                                         mb->mbxCommand, mb->mbxStatus);
 223                         mb->un.varDmp.word_cnt = 0;
 224                 }
 225                 /* dump mem may return a zero when finished or we got a
 226                  * mailbox error, either way we are done.
 227                  */
 228                 if (mb->un.varDmp.word_cnt == 0)
 229                         break;
 230                 if (mb->un.varDmp.word_cnt > DMP_VPD_SIZE - offset)
 231                         mb->un.varDmp.word_cnt = DMP_VPD_SIZE - offset;
 232                 lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
 233                                       lpfc_vpd_data + offset,
 234                                       mb->un.varDmp.word_cnt);
 235                 offset += mb->un.varDmp.word_cnt;
 236         } while (mb->un.varDmp.word_cnt && offset < DMP_VPD_SIZE);
 237         lpfc_parse_vpd(phba, lpfc_vpd_data, offset);
 238
 239         kfree(lpfc_vpd_data);
 240 out_free_mbox:
 241         mempool_free(pmb, phba->mbox_mem_pool);
 242         return 0;
 243 }
 244
 245 /**
 246  * lpfc_config_async_cmpl - Completion handler for config async event mbox cmd
 247  * @phba: pointer to lpfc hba data structure.
 248  * @pmboxq: pointer to the driver internal queue element for mailbox command.
 249  *
 250  * This is the completion handler for driver's configuring asynchronous event
 251  * mailbox command to the device. If the mailbox command returns successfully,
 252  * it will set internal async event support flag to 1; otherwise, it will
 253  * set internal async event support flag to 0.
 254  **/
 255 static void
 256 lpfc_config_async_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
 257 {
 258         if (pmboxq->u.mb.mbxStatus == MBX_SUCCESS)
 259                 phba->temp_sensor_support = 1;
 260         else
 261                 phba->temp_sensor_support = 0;
 262         mempool_free(pmboxq, phba->mbox_mem_pool);
 263         return;
 264 }
 265
 266 /**
 267  * lpfc_dump_wakeup_param_cmpl - dump memory mailbox command completion handler
 268  * @phba: pointer to lpfc hba data structure.
 269  * @pmboxq: pointer to the driver internal queue element for mailbox command.
 270  *
 271  * This is the completion handler for dump mailbox command for getting
 272  * wake up parameters. When this command complete, the response contain
 273  * Option rom version of the HBA. This function translate the version number
 274  * into a human readable string and store it in OptionROMVersion.
 275  **/
 276 static void
 277 lpfc_dump_wakeup_param_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
 278 {
 279         struct prog_id *prg;
 280         uint32_t prog_id_word;
 281         char dist = ' ';
 282         /* character array used for decoding dist type. */
 283         char dist_char[] = "nabx";
 284
 285         if (pmboxq->u.mb.mbxStatus != MBX_SUCCESS) {
 286                 mempool_free(pmboxq, phba->mbox_mem_pool);
 287                 return;
 288         }
 289
 290         prg = (struct prog_id *) &prog_id_word;
 291
 292         /* word 7 contain option rom version */
 293         prog_id_word = pmboxq->u.mb.un.varWords[7];
 294
 295         /* Decode the Option rom version word to a readable string */
 296         if (prg->dist < 4)
 297                 dist = dist_char[prg->dist];
 298
 299         if ((prg->dist == 3) && (prg->num == 0))
 300                 sprintf(phba->OptionROMVersion, "%d.%d%d",
 301                         prg->ver, prg->rev, prg->lev);
 302         else
 303                 sprintf(phba->OptionROMVersion, "%d.%d%d%c%d",
 304                         prg->ver, prg->rev, prg->lev,
 305                         dist, prg->num);
 306         mempool_free(pmboxq, phba->mbox_mem_pool);
 307         return;
 308 }
 309
 310 /**
 311  * lpfc_config_port_post - Perform lpfc initialization after config port
 312  * @phba: pointer to lpfc hba data structure.
 313  *
 314  * This routine will do LPFC initialization after the CONFIG_PORT mailbox
 315  * command call. It performs all internal resource and state setups on the
 316  * port: post IOCB buffers, enable appropriate host interrupt attentions,
 317  * ELS ring timers, etc.
 318  *
 319  * Return codes
 320  *   0 - success.
 321  *   Any other value - error.
 322  **/
 323 int
 324 lpfc_config_port_post(struct lpfc_hba *phba)
 325 {
 326         struct lpfc_vport *vport = phba->pport;
 327         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 328         LPFC_MBOXQ_t *pmb;
 329         MAILBOX_t *mb;
 330         struct lpfc_dmabuf *mp;
 331         struct lpfc_sli *psli = &phba->sli;
 332         uint32_t status, timeout;
 333         int i, j;
 334         int rc;
 335
 336         spin_lock_irq(&phba->hbalock);
 337         /*
 338          * If the Config port completed correctly the HBA is not
 339          * over heated any more.
 340          */
 341         if (phba->over_temp_state == HBA_OVER_TEMP)
 342                 phba->over_temp_state = HBA_NORMAL_TEMP;
 343         spin_unlock_irq(&phba->hbalock);
 344
 345         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 346         if (!pmb) {
 347                 phba->link_state = LPFC_HBA_ERROR;
 348                 return -ENOMEM;
 349         }
 350         mb = &pmb->u.mb;
 351
 352         /* Get login parameters for NID.  */
 353         lpfc_read_sparam(phba, pmb, 0);
 354         pmb->vport = vport;
 355         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
 356                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 357                                 "0448 Adapter failed init, mbxCmd x%x "
 358                                 "READ_SPARM mbxStatus x%x\n",
 359                                 mb->mbxCommand, mb->mbxStatus);
 360                 phba->link_state = LPFC_HBA_ERROR;
 361                 mp = (struct lpfc_dmabuf *) pmb->context1;
 362                 mempool_free( pmb, phba->mbox_mem_pool);
 363                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
 364                 kfree(mp);
 365                 return -EIO;
 366         }
 367
 368         mp = (struct lpfc_dmabuf *) pmb->context1;
 369
 370         memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
 371         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 372         kfree(mp);
 373         pmb->context1 = NULL;
 374
 375         if (phba->cfg_soft_wwnn)
 376                 u64_to_wwn(phba->cfg_soft_wwnn,
 377                            vport->fc_sparam.nodeName.u.wwn);
 378         if (phba->cfg_soft_wwpn)
 379                 u64_to_wwn(phba->cfg_soft_wwpn,
 380                            vport->fc_sparam.portName.u.wwn);
 381         memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
 382                sizeof (struct lpfc_name));
 383         memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
 384                sizeof (struct lpfc_name));
 385
 386         /* Update the fc_host data structures with new wwn. */
 387         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
 388         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
 389         fc_host_max_npiv_vports(shost) = phba->max_vpi;
 390
 391         /* If no serial number in VPD data, use low 6 bytes of WWNN */
 392         /* This should be consolidated into parse_vpd ? - mr */
 393         if (phba->SerialNumber[0] == 0) {
 394                 uint8_t *outptr;
 395
 396                 outptr = &vport->fc_nodename.u.s.IEEE[0];
 397                 for (i = 0; i < 12; i++) {
 398                         status = *outptr++;
 399                         j = ((status & 0xf0) >> 4);
 400                         if (j <= 9)
 401                                 phba->SerialNumber[i] =
 402                                     (char)((uint8_t) 0x30 + (uint8_t) j);
 403                         else
 404                                 phba->SerialNumber[i] =
 405                                     (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
 406                         i++;
 407                         j = (status & 0xf);
 408                         if (j <= 9)
 409                                 phba->SerialNumber[i] =
 410                                     (char)((uint8_t) 0x30 + (uint8_t) j);
 411                         else
 412                                 phba->SerialNumber[i] =
 413                                     (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
 414                 }
 415         }
 416
 417         lpfc_read_config(phba, pmb);
 418         pmb->vport = vport;
 419         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
 420                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 421                                 "0453 Adapter failed to init, mbxCmd x%x "
 422                                 "READ_CONFIG, mbxStatus x%x\n",
 423                                 mb->mbxCommand, mb->mbxStatus);
 424                 phba->link_state = LPFC_HBA_ERROR;
 425                 mempool_free( pmb, phba->mbox_mem_pool);
 426                 return -EIO;
 427         }
 428
 429         /* Check if the port is disabled */
 430         lpfc_sli_read_link_ste(phba);
 431
 432         /* Reset the DFT_HBA_Q_DEPTH to the max xri  */
 433         if (phba->cfg_hba_queue_depth > (mb->un.varRdConfig.max_xri+1))
 434                 phba->cfg_hba_queue_depth =
 435                         (mb->un.varRdConfig.max_xri + 1) -
 436                                         lpfc_sli4_get_els_iocb_cnt(phba);
 437
 438         phba->lmt = mb->un.varRdConfig.lmt;
 439
 440         /* Get the default values for Model Name and Description */
 441         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
 442
 443         if ((phba->cfg_link_speed > LINK_SPEED_10G)
 444             || ((phba->cfg_link_speed == LINK_SPEED_1G)
 445                 && !(phba->lmt & LMT_1Gb))
 446             || ((phba->cfg_link_speed == LINK_SPEED_2G)
 447                 && !(phba->lmt & LMT_2Gb))
 448             || ((phba->cfg_link_speed == LINK_SPEED_4G)
 449                 && !(phba->lmt & LMT_4Gb))
 450             || ((phba->cfg_link_speed == LINK_SPEED_8G)
 451                 && !(phba->lmt & LMT_8Gb))
 452             || ((phba->cfg_link_speed == LINK_SPEED_10G)
 453                 && !(phba->lmt & LMT_10Gb))) {
 454                 /* Reset link speed to auto */
 455                 lpfc_printf_log(phba, KERN_WARNING, LOG_LINK_EVENT,
 456                         "1302 Invalid speed for this board: "
 457                         "Reset link speed to auto: x%x\n",
 458                         phba->cfg_link_speed);
 459                         phba->cfg_link_speed = LINK_SPEED_AUTO;
 460         }
 461
 462         phba->link_state = LPFC_LINK_DOWN;
 463
 464         /* Only process IOCBs on ELS ring till hba_state is READY */
 465         if (psli->ring[psli->extra_ring].cmdringaddr)
 466                 psli->ring[psli->extra_ring].flag |= LPFC_STOP_IOCB_EVENT;
 467         if (psli->ring[psli->fcp_ring].cmdringaddr)
 468                 psli->ring[psli->fcp_ring].flag |= LPFC_STOP_IOCB_EVENT;
 469         if (psli->ring[psli->next_ring].cmdringaddr)
 470                 psli->ring[psli->next_ring].flag |= LPFC_STOP_IOCB_EVENT;
 471
 472         /* Post receive buffers for desired rings */
 473         if (phba->sli_rev != 3)
 474                 lpfc_post_rcv_buf(phba);
 475
 476         /*
 477          * Configure HBA MSI-X attention conditions to messages if MSI-X mode
 478          */
 479         if (phba->intr_type == MSIX) {
 480                 rc = lpfc_config_msi(phba, pmb);
 481                 if (rc) {
 482                         mempool_free(pmb, phba->mbox_mem_pool);
 483                         return -EIO;
 484                 }
 485                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 486                 if (rc != MBX_SUCCESS) {
 487                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
 488                                         "0352 Config MSI mailbox command "
 489                                         "failed, mbxCmd x%x, mbxStatus x%x\n",
 490                                         pmb->u.mb.mbxCommand,
 491                                         pmb->u.mb.mbxStatus);
 492                         mempool_free(pmb, phba->mbox_mem_pool);
 493                         return -EIO;
 494                 }
 495         }
 496
 497         spin_lock_irq(&phba->hbalock);
 498         /* Initialize ERATT handling flag */
 499         phba->hba_flag &= ~HBA_ERATT_HANDLED;
 500
 501         /* Enable appropriate host interrupts */
 502         status = readl(phba->HCregaddr);
 503         status |= HC_MBINT_ENA | HC_ERINT_ENA | HC_LAINT_ENA;
 504         if (psli->num_rings > 0)
 505                 status |= HC_R0INT_ENA;
 506         if (psli->num_rings > 1)
 507                 status |= HC_R1INT_ENA;
 508         if (psli->num_rings > 2)
 509                 status |= HC_R2INT_ENA;
 510         if (psli->num_rings > 3)
 511                 status |= HC_R3INT_ENA;
 512
 513         if ((phba->cfg_poll & ENABLE_FCP_RING_POLLING) &&
 514             (phba->cfg_poll & DISABLE_FCP_RING_INT))
 515                 status &= ~(HC_R0INT_ENA);
 516
 517         writel(status, phba->HCregaddr);
 518         readl(phba->HCregaddr); /* flush */
 519         spin_unlock_irq(&phba->hbalock);
 520
 521         /* Set up ring-0 (ELS) timer */
 522         timeout = phba->fc_ratov * 2;
 523         mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
 524         /* Set up heart beat (HB) timer */
 525         mod_timer(&phba->hb_tmofunc, jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
 526         phba->hb_outstanding = 0;
 527         phba->last_completion_time = jiffies;
 528         /* Set up error attention (ERATT) polling timer */
 529         mod_timer(&phba->eratt_poll, jiffies + HZ * LPFC_ERATT_POLL_INTERVAL);
 530
 531         if (phba->hba_flag & LINK_DISABLED) {
 532                 lpfc_printf_log(phba,
 533                         KERN_ERR, LOG_INIT,
 534                         "2598 Adapter Link is disabled.\n");
 535                 lpfc_down_link(phba, pmb);
 536                 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 537                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 538                 if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
 539                         lpfc_printf_log(phba,
 540                         KERN_ERR, LOG_INIT,
 541                         "2599 Adapter failed to issue DOWN_LINK"
 542                         " mbox command rc 0x%x\n", rc);
 543
 544                         mempool_free(pmb, phba->mbox_mem_pool);
 545                         return -EIO;
 546                 }
 547         } else if (phba->cfg_suppress_link_up == 0) {
 548                 lpfc_init_link(phba, pmb, phba->cfg_topology,
 549                         phba->cfg_link_speed);
 550                 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 551                 lpfc_set_loopback_flag(phba);
 552                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 553                 if (rc != MBX_SUCCESS) {
 554                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 555                                 "0454 Adapter failed to init, mbxCmd x%x "
 556                                 "INIT_LINK, mbxStatus x%x\n",
 557                                 mb->mbxCommand, mb->mbxStatus);
 558
 559                         /* Clear all interrupt enable conditions */
 560                         writel(0, phba->HCregaddr);
 561                         readl(phba->HCregaddr); /* flush */
 562                         /* Clear all pending interrupts */
 563                         writel(0xffffffff, phba->HAregaddr);
 564                         readl(phba->HAregaddr); /* flush */
 565
 566                         phba->link_state = LPFC_HBA_ERROR;
 567                         if (rc != MBX_BUSY)
 568                                 mempool_free(pmb, phba->mbox_mem_pool);
 569                         return -EIO;
 570                 }
 571         }
 572         /* MBOX buffer will be freed in mbox compl */
 573         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 574         lpfc_config_async(phba, pmb, LPFC_ELS_RING);
 575         pmb->mbox_cmpl = lpfc_config_async_cmpl;
 576         pmb->vport = phba->pport;
 577         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 578
 579         if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
 580                 lpfc_printf_log(phba,
 581                                 KERN_ERR,
 582                                 LOG_INIT,
 583                                 "0456 Adapter failed to issue "
 584                                 "ASYNCEVT_ENABLE mbox status x%x\n",
 585                                 rc);
 586                 mempool_free(pmb, phba->mbox_mem_pool);
 587         }
 588
 589         /* Get Option rom version */
 590         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 591         lpfc_dump_wakeup_param(phba, pmb);
 592         pmb->mbox_cmpl = lpfc_dump_wakeup_param_cmpl;
 593         pmb->vport = phba->pport;
 594         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 595
 596         if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
 597                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, "0435 Adapter failed "
 598                                 "to get Option ROM version status x%x\n", rc);
 599                 mempool_free(pmb, phba->mbox_mem_pool);
 600         }
 601
 602         return 0;
 603 }
 604
 605 /**
 606  * lpfc_hba_init_link - Initialize the FC link
 607  * @phba: pointer to lpfc hba data structure.
 608  *
 609  * This routine will issue the INIT_LINK mailbox command call.
 610  * It is available to other drivers through the lpfc_hba data
 611  * structure for use as a delayed link up mechanism with the
 612  * module parameter lpfc_suppress_link_up.
 613  *
 614  * Return code
 615  *              0 - success
 616  *              Any other value - error
 617  **/
 618 int
 619 lpfc_hba_init_link(struct lpfc_hba *phba)
 620 {
 621         struct lpfc_vport *vport = phba->pport;
 622         LPFC_MBOXQ_t *pmb;
 623         MAILBOX_t *mb;
 624         int rc;
 625
 626         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 627         if (!pmb) {
 628                 phba->link_state = LPFC_HBA_ERROR;
 629                 return -ENOMEM;
 630         }
 631         mb = &pmb->u.mb;
 632         pmb->vport = vport;
 633
 634         lpfc_init_link(phba, pmb, phba->cfg_topology,
 635                 phba->cfg_link_speed);
 636         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 637         lpfc_set_loopback_flag(phba);
 638         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 639         if (rc != MBX_SUCCESS) {
 640                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 641                         "0498 Adapter failed to init, mbxCmd x%x "
 642                         "INIT_LINK, mbxStatus x%x\n",
 643                         mb->mbxCommand, mb->mbxStatus);
 644                 /* Clear all interrupt enable conditions */
 645                 writel(0, phba->HCregaddr);
 646                 readl(phba->HCregaddr); /* flush */
 647                 /* Clear all pending interrupts */
 648                 writel(0xffffffff, phba->HAregaddr);
 649                 readl(phba->HAregaddr); /* flush */
 650                 phba->link_state = LPFC_HBA_ERROR;
 651                 if (rc != MBX_BUSY)
 652                         mempool_free(pmb, phba->mbox_mem_pool);
 653                 return -EIO;
 654         }
 655         phba->cfg_suppress_link_up = 0;
 656
 657         return 0;
 658 }
 659
 660 /**
 661  * lpfc_hba_down_link - this routine downs the FC link
 662  *
 663  * This routine will issue the DOWN_LINK mailbox command call.
 664  * It is available to other drivers through the lpfc_hba data
 665  * structure for use to stop the link.
 666  *
 667  * Return code
 668  *              0 - success
 669  *              Any other value - error
 670  **/
 671 int
 672 lpfc_hba_down_link(struct lpfc_hba *phba)
 673 {
 674         LPFC_MBOXQ_t *pmb;
 675         int rc;
 676
 677         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 678         if (!pmb) {
 679                 phba->link_state = LPFC_HBA_ERROR;
 680                 return -ENOMEM;
 681         }
 682
 683         lpfc_printf_log(phba,
 684                 KERN_ERR, LOG_INIT,
 685                 "0491 Adapter Link is disabled.\n");
 686         lpfc_down_link(phba, pmb);
 687         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 688         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 689         if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
 690                 lpfc_printf_log(phba,
 691                 KERN_ERR, LOG_INIT,
 692                 "2522 Adapter failed to issue DOWN_LINK"
 693                 " mbox command rc 0x%x\n", rc);
 694
 695                 mempool_free(pmb, phba->mbox_mem_pool);
 696                 return -EIO;
 697         }
 698         return 0;
 699 }
 700
 701 /**
 702  * lpfc_hba_down_prep - Perform lpfc uninitialization prior to HBA reset
 703  * @phba: pointer to lpfc HBA data structure.
 704  *
 705  * This routine will do LPFC uninitialization before the HBA is reset when
 706  * bringing down the SLI Layer.
 707  *
 708  * Return codes
 709  *   0 - success.
 710  *   Any other value - error.
 711  **/
 712 int
 713 lpfc_hba_down_prep(struct lpfc_hba *phba)
 714 {
 715         struct lpfc_vport **vports;
 716         int i;
 717
 718         if (phba->sli_rev <= LPFC_SLI_REV3) {
 719                 /* Disable interrupts */
 720                 writel(0, phba->HCregaddr);
 721                 readl(phba->HCregaddr); /* flush */
 722         }
 723
 724         if (phba->pport->load_flag & FC_UNLOADING)
 725                 lpfc_cleanup_discovery_resources(phba->pport);
 726         else {
 727                 vports = lpfc_create_vport_work_array(phba);
 728                 if (vports != NULL)
 729                         for (i = 0; i <= phba->max_vports &&
 730                                 vports[i] != NULL; i++)
 731                                 lpfc_cleanup_discovery_resources(vports[i]);
 732                 lpfc_destroy_vport_work_array(phba, vports);
 733         }
 734         return 0;
 735 }
 736
 737 /**
 738  * lpfc_hba_down_post_s3 - Perform lpfc uninitialization after HBA reset
 739  * @phba: pointer to lpfc HBA data structure.
 740  *
 741  * This routine will do uninitialization after the HBA is reset when bring
 742  * down the SLI Layer.
 743  *
 744  * Return codes
 745  *   0 - success.
 746  *   Any other value - error.
 747  **/
 748 static int
 749 lpfc_hba_down_post_s3(struct lpfc_hba *phba)
 750 {
 751         struct lpfc_sli *psli = &phba->sli;
 752         struct lpfc_sli_ring *pring;
 753         struct lpfc_dmabuf *mp, *next_mp;
 754         LIST_HEAD(completions);
 755         int i;
 756
 757         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
 758                 lpfc_sli_hbqbuf_free_all(phba);
 759         else {
 760                 /* Cleanup preposted buffers on the ELS ring */
 761                 pring = &psli->ring[LPFC_ELS_RING];
 762                 list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
 763                         list_del(&mp->list);
 764                         pring->postbufq_cnt--;
 765                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 766                         kfree(mp);
 767                 }
 768         }
 769
 770         spin_lock_irq(&phba->hbalock);
 771         for (i = 0; i < psli->num_rings; i++) {
 772                 pring = &psli->ring[i];
 773
 774                 /* At this point in time the HBA is either reset or DOA. Either
 775                  * way, nothing should be on txcmplq as it will NEVER complete.
 776                  */
 777                 list_splice_init(&pring->txcmplq, &completions);
 778                 pring->txcmplq_cnt = 0;
 779                 spin_unlock_irq(&phba->hbalock);
 780
 781                 /* Cancel all the IOCBs from the completions list */
 782                 lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT,
 783                                       IOERR_SLI_ABORTED);
 784
 785                 lpfc_sli_abort_iocb_ring(phba, pring);
 786                 spin_lock_irq(&phba->hbalock);
 787         }
 788         spin_unlock_irq(&phba->hbalock);
 789
 790         return 0;
 791 }
 792 /**
 793  * lpfc_hba_down_post_s4 - Perform lpfc uninitialization after HBA reset
 794  * @phba: pointer to lpfc HBA data structure.
 795  *
 796  * This routine will do uninitialization after the HBA is reset when bring
 797  * down the SLI Layer.
 798  *
 799  * Return codes
 800  *   0 - success.
 801  *   Any other value - error.
 802  **/
 803 static int
 804 lpfc_hba_down_post_s4(struct lpfc_hba *phba)
 805 {
 806         struct lpfc_scsi_buf *psb, *psb_next;
 807         LIST_HEAD(aborts);
 808         int ret;
 809         unsigned long iflag = 0;
 810         ret = lpfc_hba_down_post_s3(phba);
 811         if (ret)
 812                 return ret;
 813         /* At this point in time the HBA is either reset or DOA. Either
 814          * way, nothing should be on lpfc_abts_els_sgl_list, it needs to be
 815          * on the lpfc_sgl_list so that it can either be freed if the
 816          * driver is unloading or reposted if the driver is restarting
 817          * the port.
 818          */
 819         spin_lock_irq(&phba->hbalock);  /* required for lpfc_sgl_list and */
 820                                         /* scsl_buf_list */
 821         /* abts_sgl_list_lock required because worker thread uses this
 822          * list.
 823          */
 824         spin_lock(&phba->sli4_hba.abts_sgl_list_lock);
 825         list_splice_init(&phba->sli4_hba.lpfc_abts_els_sgl_list,
 826                         &phba->sli4_hba.lpfc_sgl_list);
 827         spin_unlock(&phba->sli4_hba.abts_sgl_list_lock);
 828         /* abts_scsi_buf_list_lock required because worker thread uses this
 829          * list.
 830          */
 831         spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock);
 832         list_splice_init(&phba->sli4_hba.lpfc_abts_scsi_buf_list,
 833                         &aborts);
 834         spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock);
 835         spin_unlock_irq(&phba->hbalock);
 836
 837         list_for_each_entry_safe(psb, psb_next, &aborts, list) {
 838                 psb->pCmd = NULL;
 839                 psb->status = IOSTAT_SUCCESS;
 840         }
 841         spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
 842         list_splice(&aborts, &phba->lpfc_scsi_buf_list);
 843         spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
 844         return 0;
 845 }
 846
 847 /**
 848  * lpfc_hba_down_post - Wrapper func for hba down post routine
 849  * @phba: pointer to lpfc HBA data structure.
 850  *
 851  * This routine wraps the actual SLI3 or SLI4 routine for performing
 852  * uninitialization after the HBA is reset when bring down the SLI Layer.
 853  *
 854  * Return codes
 855  *   0 - success.
 856  *   Any other value - error.
 857  **/
 858 int
 859 lpfc_hba_down_post(struct lpfc_hba *phba)
 860 {
 861         return (*phba->lpfc_hba_down_post)(phba);
 862 }
 863
 864 /**
 865  * lpfc_hb_timeout - The HBA-timer timeout handler
 866  * @ptr: unsigned long holds the pointer to lpfc hba data structure.
 867  *
 868  * This is the HBA-timer timeout handler registered to the lpfc driver. When
 869  * this timer fires, a HBA timeout event shall be posted to the lpfc driver
 870  * work-port-events bitmap and the worker thread is notified. This timeout
 871  * event will be used by the worker thread to invoke the actual timeout
 872  * handler routine, lpfc_hb_timeout_handler. Any periodical operations will
 873  * be performed in the timeout handler and the HBA timeout event bit shall
 874  * be cleared by the worker thread after it has taken the event bitmap out.
 875  **/
 876 static void
 877 lpfc_hb_timeout(unsigned long ptr)
 878 {
 879         struct lpfc_hba *phba;
 880         uint32_t tmo_posted;
 881         unsigned long iflag;
 882
 883         phba = (struct lpfc_hba *)ptr;
 884
 885         /* Check for heart beat timeout conditions */
 886         spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
 887         tmo_posted = phba->pport->work_port_events & WORKER_HB_TMO;
 888         if (!tmo_posted)
 889                 phba->pport->work_port_events |= WORKER_HB_TMO;
 890         spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
 891
 892         /* Tell the worker thread there is work to do */
 893         if (!tmo_posted)
 894                 lpfc_worker_wake_up(phba);
 895         return;
 896 }
 897
 898 /**
 899  * lpfc_hb_mbox_cmpl - The lpfc heart-beat mailbox command callback function
 900  * @phba: pointer to lpfc hba data structure.
 901  * @pmboxq: pointer to the driver internal queue element for mailbox command.
 902  *
 903  * This is the callback function to the lpfc heart-beat mailbox command.
 904  * If configured, the lpfc driver issues the heart-beat mailbox command to
 905  * the HBA every LPFC_HB_MBOX_INTERVAL (current 5) seconds. At the time the
 906  * heart-beat mailbox command is issued, the driver shall set up heart-beat
 907  * timeout timer to LPFC_HB_MBOX_TIMEOUT (current 30) seconds and marks
 908  * heart-beat outstanding state. Once the mailbox command comes back and
 909  * no error conditions detected, the heart-beat mailbox command timer is
 910  * reset to LPFC_HB_MBOX_INTERVAL seconds and the heart-beat outstanding
 911  * state is cleared for the next heart-beat. If the timer expired with the
 912  * heart-beat outstanding state set, the driver will put the HBA offline.
 913  **/
 914 static void
 915 lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
 916 {
 917         unsigned long drvr_flag;
 918
 919         spin_lock_irqsave(&phba->hbalock, drvr_flag);
 920         phba->hb_outstanding = 0;
 921         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
 922
 923         /* Check and reset heart-beat timer is necessary */
 924         mempool_free(pmboxq, phba->mbox_mem_pool);
 925         if (!(phba->pport->fc_flag & FC_OFFLINE_MODE) &&
 926                 !(phba->link_state == LPFC_HBA_ERROR) &&
 927                 !(phba->pport->load_flag & FC_UNLOADING))
 928                 mod_timer(&phba->hb_tmofunc,
 929                         jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
 930         return;
 931 }
 932
 933 /**
 934  * lpfc_hb_timeout_handler - The HBA-timer timeout handler
 935  * @phba: pointer to lpfc hba data structure.
 936  *
 937  * This is the actual HBA-timer timeout handler to be invoked by the worker
 938  * thread whenever the HBA timer fired and HBA-timeout event posted. This
 939  * handler performs any periodic operations needed for the device. If such
 940  * periodic event has already been attended to either in the interrupt handler
 941  * or by processing slow-ring or fast-ring events within the HBA-timer
 942  * timeout window (LPFC_HB_MBOX_INTERVAL), this handler just simply resets
 943  * the timer for the next timeout period. If lpfc heart-beat mailbox command
 944  * is configured and there is no heart-beat mailbox command outstanding, a
 945  * heart-beat mailbox is issued and timer set properly. Otherwise, if there
 946  * has been a heart-beat mailbox command outstanding, the HBA shall be put
 947  * to offline.
 948  **/
 949 void
 950 lpfc_hb_timeout_handler(struct lpfc_hba *phba)
 951 {
 952         struct lpfc_vport **vports;
 953         LPFC_MBOXQ_t *pmboxq;
 954         struct lpfc_dmabuf *buf_ptr;
 955         int retval, i;
 956         struct lpfc_sli *psli = &phba->sli;
 957         LIST_HEAD(completions);
 958
 959         vports = lpfc_create_vport_work_array(phba);
 960         if (vports != NULL)
 961                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
 962                         lpfc_rcv_seq_check_edtov(vports[i]);
 963         lpfc_destroy_vport_work_array(phba, vports);
 964
 965         if ((phba->link_state == LPFC_HBA_ERROR) ||
 966                 (phba->pport->load_flag & FC_UNLOADING) ||
 967                 (phba->pport->fc_flag & FC_OFFLINE_MODE))
 968                 return;
 969
 970         spin_lock_irq(&phba->pport->work_port_lock);
 971
 972         if (time_after(phba->last_completion_time + LPFC_HB_MBOX_INTERVAL * HZ,
 973                 jiffies)) {
 974                 spin_unlock_irq(&phba->pport->work_port_lock);
 975                 if (!phba->hb_outstanding)
 976                         mod_timer(&phba->hb_tmofunc,
 977                                 jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
 978                 else
 979                         mod_timer(&phba->hb_tmofunc,
 980                                 jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
 981                 return;
 982         }
 983         spin_unlock_irq(&phba->pport->work_port_lock);
 984
 985         if (phba->elsbuf_cnt &&
 986                 (phba->elsbuf_cnt == phba->elsbuf_prev_cnt)) {
 987                 spin_lock_irq(&phba->hbalock);
 988                 list_splice_init(&phba->elsbuf, &completions);
 989                 phba->elsbuf_cnt = 0;
 990                 phba->elsbuf_prev_cnt = 0;
 991                 spin_unlock_irq(&phba->hbalock);
 992
 993                 while (!list_empty(&completions)) {
 994                         list_remove_head(&completions, buf_ptr,
 995                                 struct lpfc_dmabuf, list);
 996                         lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
 997                         kfree(buf_ptr);
 998                 }
 999         }
1000         phba->elsbuf_prev_cnt = phba->elsbuf_cnt;
1001
1002         /* If there is no heart beat outstanding, issue a heartbeat command */
1003         if (phba->cfg_enable_hba_heartbeat) {
1004                 if (!phba->hb_outstanding) {
1005                         pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
1006                         if (!pmboxq) {
1007                                 mod_timer(&phba->hb_tmofunc,
1008                                           jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
1009                                 return;
1010                         }
1011
1012                         lpfc_heart_beat(phba, pmboxq);
1013                         pmboxq->mbox_cmpl = lpfc_hb_mbox_cmpl;
1014                         pmboxq->vport = phba->pport;
1015                         retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
1016
1017                         if (retval != MBX_BUSY && retval != MBX_SUCCESS) {
1018                                 mempool_free(pmboxq, phba->mbox_mem_pool);
1019                                 mod_timer(&phba->hb_tmofunc,
1020                                           jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
1021                                 return;
1022                         }
1023                         mod_timer(&phba->hb_tmofunc,
1024                                   jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
1025                         phba->hb_outstanding = 1;
1026                         return;
1027                 } else {
1028                         /*
1029                         * If heart beat timeout called with hb_outstanding set
1030                         * we need to take the HBA offline.
1031                         */
1032                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1033                                         "0459 Adapter heartbeat failure, "
1034                                         "taking this port offline.\n");
1035
1036                         spin_lock_irq(&phba->hbalock);
1037                         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1038                         spin_unlock_irq(&phba->hbalock);
1039
1040                         lpfc_offline_prep(phba);
1041                         lpfc_offline(phba);
1042                         lpfc_unblock_mgmt_io(phba);
1043                         phba->link_state = LPFC_HBA_ERROR;
1044                         lpfc_hba_down_post(phba);
1045                 }
1046         }
1047 }
1048
1049 /**
1050  * lpfc_offline_eratt - Bring lpfc offline on hardware error attention
1051  * @phba: pointer to lpfc hba data structure.
1052  *
1053  * This routine is called to bring the HBA offline when HBA hardware error
1054  * other than Port Error 6 has been detected.
1055  **/
1056 static void
1057 lpfc_offline_eratt(struct lpfc_hba *phba)
1058 {
1059         struct lpfc_sli   *psli = &phba->sli;
1060
1061         spin_lock_irq(&phba->hbalock);
1062         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1063         spin_unlock_irq(&phba->hbalock);
1064         lpfc_offline_prep(phba);
1065
1066         lpfc_offline(phba);
1067         lpfc_reset_barrier(phba);
1068         spin_lock_irq(&phba->hbalock);
1069         lpfc_sli_brdreset(phba);
1070         spin_unlock_irq(&phba->hbalock);
1071         lpfc_hba_down_post(phba);
1072         lpfc_sli_brdready(phba, HS_MBRDY);
1073         lpfc_unblock_mgmt_io(phba);
1074         phba->link_state = LPFC_HBA_ERROR;
1075         return;
1076 }
1077
1078 /**
1079  * lpfc_sli4_offline_eratt - Bring lpfc offline on SLI4 hardware error attention
1080  * @phba: pointer to lpfc hba data structure.
1081  *
1082  * This routine is called to bring a SLI4 HBA offline when HBA hardware error
1083  * other than Port Error 6 has been detected.
1084  **/
1085 static void
1086 lpfc_sli4_offline_eratt(struct lpfc_hba *phba)
1087 {
1088         lpfc_offline_prep(phba);
1089         lpfc_offline(phba);
1090         lpfc_sli4_brdreset(phba);
1091         lpfc_hba_down_post(phba);
1092         lpfc_sli4_post_status_check(phba);
1093         lpfc_unblock_mgmt_io(phba);
1094         phba->link_state = LPFC_HBA_ERROR;
1095 }
1096
1097 /**
1098  * lpfc_handle_deferred_eratt - The HBA hardware deferred error handler
1099  * @phba: pointer to lpfc hba data structure.
1100  *
1101  * This routine is invoked to handle the deferred HBA hardware error
1102  * conditions. This type of error is indicated by HBA by setting ER1
1103  * and another ER bit in the host status register. The driver will
1104  * wait until the ER1 bit clears before handling the error condition.
1105  **/
1106 static void
1107 lpfc_handle_deferred_eratt(struct lpfc_hba *phba)
1108 {
1109         uint32_t old_host_status = phba->work_hs;
1110         struct lpfc_sli_ring  *pring;
1111         struct lpfc_sli *psli = &phba->sli;
1112
1113         /* If the pci channel is offline, ignore possible errors,
1114          * since we cannot communicate with the pci card anyway.
1115          */
1116         if (pci_channel_offline(phba->pcidev)) {
1117                 spin_lock_irq(&phba->hbalock);
1118                 phba->hba_flag &= ~DEFER_ERATT;
1119                 spin_unlock_irq(&phba->hbalock);
1120                 return;
1121         }
1122
1123         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1124                 "0479 Deferred Adapter Hardware Error "
1125                 "Data: x%x x%x x%x\n",
1126                 phba->work_hs,
1127                 phba->work_status[0], phba->work_status[1]);
1128
1129         spin_lock_irq(&phba->hbalock);
1130         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1131         spin_unlock_irq(&phba->hbalock);
1132
1133
1134         /*
1135          * Firmware stops when it triggred erratt. That could cause the I/Os
1136          * dropped by the firmware. Error iocb (I/O) on txcmplq and let the
1137          * SCSI layer retry it after re-establishing link.
1138          */
1139         pring = &psli->ring[psli->fcp_ring];
1140         lpfc_sli_abort_iocb_ring(phba, pring);
1141
1142         /*
1143          * There was a firmware error. Take the hba offline and then
1144          * attempt to restart it.
1145          */
1146         lpfc_offline_prep(phba);
1147         lpfc_offline(phba);
1148
1149         /* Wait for the ER1 bit to clear.*/
1150         while (phba->work_hs & HS_FFER1) {
1151                 msleep(100);
1152                 phba->work_hs = readl(phba->HSregaddr);
1153                 /* If driver is unloading let the worker thread continue */
1154                 if (phba->pport->load_flag & FC_UNLOADING) {
1155                         phba->work_hs = 0;
1156                         break;
1157                 }
1158         }
1159
1160         /*
1161          * This is to ptrotect against a race condition in which
1162          * first write to the host attention register clear the
1163          * host status register.
1164          */
1165         if ((!phba->work_hs) && (!(phba->pport->load_flag & FC_UNLOADING)))
1166                 phba->work_hs = old_host_status & ~HS_FFER1;
1167
1168         spin_lock_irq(&phba->hbalock);
1169         phba->hba_flag &= ~DEFER_ERATT;
1170         spin_unlock_irq(&phba->hbalock);
1171         phba->work_status[0] = readl(phba->MBslimaddr + 0xa8);
1172         phba->work_status[1] = readl(phba->MBslimaddr + 0xac);
1173 }
1174
1175 static void
1176 lpfc_board_errevt_to_mgmt(struct lpfc_hba *phba)
1177 {
1178         struct lpfc_board_event_header board_event;
1179         struct Scsi_Host *shost;
1180
1181         board_event.event_type = FC_REG_BOARD_EVENT;
1182         board_event.subcategory = LPFC_EVENT_PORTINTERR;
1183         shost = lpfc_shost_from_vport(phba->pport);
1184         fc_host_post_vendor_event(shost, fc_get_event_number(),
1185                                   sizeof(board_event),
1186                                   (char *) &board_event,
1187                                   LPFC_NL_VENDOR_ID);
1188 }
1189
1190 /**
1191  * lpfc_handle_eratt_s3 - The SLI3 HBA hardware error handler
1192  * @phba: pointer to lpfc hba data structure.
1193  *
1194  * This routine is invoked to handle the following HBA hardware error
1195  * conditions:
1196  * 1 - HBA error attention interrupt
1197  * 2 - DMA ring index out of range
1198  * 3 - Mailbox command came back as unknown
1199  **/
1200 static void
1201 lpfc_handle_eratt_s3(struct lpfc_hba *phba)
1202 {
1203         struct lpfc_vport *vport = phba->pport;
1204         struct lpfc_sli   *psli = &phba->sli;
1205         struct lpfc_sli_ring  *pring;
1206         uint32_t event_data;
1207         unsigned long temperature;
1208         struct temp_event temp_event_data;
1209         struct Scsi_Host  *shost;
1210
1211         /* If the pci channel is offline, ignore possible errors,
1212          * since we cannot communicate with the pci card anyway.
1213          */
1214         if (pci_channel_offline(phba->pcidev)) {
1215                 spin_lock_irq(&phba->hbalock);
1216                 phba->hba_flag &= ~DEFER_ERATT;
1217                 spin_unlock_irq(&phba->hbalock);
1218                 return;
1219         }
1220
1221         /* If resets are disabled then leave the HBA alone and return */
1222         if (!phba->cfg_enable_hba_reset)
1223                 return;
1224
1225         /* Send an internal error event to mgmt application */
1226         lpfc_board_errevt_to_mgmt(phba);
1227
1228         if (phba->hba_flag & DEFER_ERATT)
1229                 lpfc_handle_deferred_eratt(phba);
1230
1231         if (phba->work_hs & HS_FFER6) {
1232                 /* Re-establishing Link */
1233                 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
1234                                 "1301 Re-establishing Link "
1235                                 "Data: x%x x%x x%x\n",
1236                                 phba->work_hs,
1237                                 phba->work_status[0], phba->work_status[1]);
1238
1239                 spin_lock_irq(&phba->hbalock);
1240                 psli->sli_flag &= ~LPFC_SLI_ACTIVE;
1241                 spin_unlock_irq(&phba->hbalock);
1242
1243                 /*
1244                 * Firmware stops when it triggled erratt with HS_FFER6.
1245                 * That could cause the I/Os dropped by the firmware.
1246                 * Error iocb (I/O) on txcmplq and let the SCSI layer
1247                 * retry it after re-establishing link.
1248                 */
1249                 pring = &psli->ring[psli->fcp_ring];
1250                 lpfc_sli_abort_iocb_ring(phba, pring);
1251
1252                 /*
1253                  * There was a firmware error.  Take the hba offline and then
1254                  * attempt to restart it.
1255                  */
1256                 lpfc_offline_prep(phba);
1257                 lpfc_offline(phba);
1258                 lpfc_sli_brdrestart(phba);
1259                 if (lpfc_online(phba) == 0) {   /* Initialize the HBA */
1260                         lpfc_unblock_mgmt_io(phba);
1261                         return;
1262                 }
1263                 lpfc_unblock_mgmt_io(phba);
1264         } else if (phba->work_hs & HS_CRIT_TEMP) {
1265                 temperature = readl(phba->MBslimaddr + TEMPERATURE_OFFSET);
1266                 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
1267                 temp_event_data.event_code = LPFC_CRIT_TEMP;
1268                 temp_event_data.data = (uint32_t)temperature;
1269
1270                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1271                                 "0406 Adapter maximum temperature exceeded "
1272                                 "(%ld), taking this port offline "
1273                                 "Data: x%x x%x x%x\n",
1274                                 temperature, phba->work_hs,
1275                                 phba->work_status[0], phba->work_status[1]);
1276
1277                 shost = lpfc_shost_from_vport(phba->pport);
1278                 fc_host_post_vendor_event(shost, fc_get_event_number(),
1279                                           sizeof(temp_event_data),
1280                                           (char *) &temp_event_data,
1281                                           SCSI_NL_VID_TYPE_PCI
1282                                           | PCI_VENDOR_ID_EMULEX);
1283
1284                 spin_lock_irq(&phba->hbalock);
1285                 phba->over_temp_state = HBA_OVER_TEMP;
1286                 spin_unlock_irq(&phba->hbalock);
1287                 lpfc_offline_eratt(phba);
1288
1289         } else {
1290                 /* The if clause above forces this code path when the status
1291                  * failure is a value other than FFER6. Do not call the offline
1292                  * twice. This is the adapter hardware error path.
1293                  */
1294                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1295                                 "0457 Adapter Hardware Error "
1296                                 "Data: x%x x%x x%x\n",
1297                                 phba->work_hs,
1298                                 phba->work_status[0], phba->work_status[1]);
1299
1300                 event_data = FC_REG_DUMP_EVENT;
1301                 shost = lpfc_shost_from_vport(vport);
1302                 fc_host_post_vendor_event(shost, fc_get_event_number(),
1303                                 sizeof(event_data), (char *) &event_data,
1304                                 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1305
1306                 lpfc_offline_eratt(phba);
1307         }
1308         return;
1309 }
1310
1311 /**
1312  * lpfc_handle_eratt_s4 - The SLI4 HBA hardware error handler
1313  * @phba: pointer to lpfc hba data structure.
1314  *
1315  * This routine is invoked to handle the SLI4 HBA hardware error attention
1316  * conditions.
1317  **/
1318 static void
1319 lpfc_handle_eratt_s4(struct lpfc_hba *phba)
1320 {
1321         struct lpfc_vport *vport = phba->pport;
1322         uint32_t event_data;
1323         struct Scsi_Host *shost;
1324
1325         /* If the pci channel is offline, ignore possible errors, since
1326          * we cannot communicate with the pci card anyway.
1327          */
1328         if (pci_channel_offline(phba->pcidev))
1329                 return;
1330         /* If resets are disabled then leave the HBA alone and return */
1331         if (!phba->cfg_enable_hba_reset)
1332                 return;
1333
1334         /* Send an internal error event to mgmt application */
1335         lpfc_board_errevt_to_mgmt(phba);
1336
1337         /* For now, the actual action for SLI4 device handling is not
1338          * specified yet, just treated it as adaptor hardware failure
1339          */
1340         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1341                         "0143 SLI4 Adapter Hardware Error Data: x%x x%x\n",
1342                         phba->work_status[0], phba->work_status[1]);
1343
1344         event_data = FC_REG_DUMP_EVENT;
1345         shost = lpfc_shost_from_vport(vport);
1346         fc_host_post_vendor_event(shost, fc_get_event_number(),
1347                                   sizeof(event_data), (char *) &event_data,
1348                                   SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1349
1350         lpfc_sli4_offline_eratt(phba);
1351 }
1352
1353 /**
1354  * lpfc_handle_eratt - Wrapper func for handling hba error attention
1355  * @phba: pointer to lpfc HBA data structure.
1356  *
1357  * This routine wraps the actual SLI3 or SLI4 hba error attention handling
1358  * routine from the API jump table function pointer from the lpfc_hba struct.
1359  *
1360  * Return codes
1361  *   0 - success.
1362  *   Any other value - error.
1363  **/
1364 void
1365 lpfc_handle_eratt(struct lpfc_hba *phba)
1366 {
1367         (*phba->lpfc_handle_eratt)(phba);
1368 }
1369
1370 /**
1371  * lpfc_handle_latt - The HBA link event handler
1372  * @phba: pointer to lpfc hba data structure.
1373  *
1374  * This routine is invoked from the worker thread to handle a HBA host
1375  * attention link event.
1376  **/
1377 void
1378 lpfc_handle_latt(struct lpfc_hba *phba)
1379 {
1380         struct lpfc_vport *vport = phba->pport;
1381         struct lpfc_sli   *psli = &phba->sli;
1382         LPFC_MBOXQ_t *pmb;
1383         volatile uint32_t control;
1384         struct lpfc_dmabuf *mp;
1385         int rc = 0;
1386
1387         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1388         if (!pmb) {
1389                 rc = 1;
1390                 goto lpfc_handle_latt_err_exit;
1391         }
1392
1393         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
1394         if (!mp) {
1395                 rc = 2;
1396                 goto lpfc_handle_latt_free_pmb;
1397         }
1398
1399         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
1400         if (!mp->virt) {
1401                 rc = 3;
1402                 goto lpfc_handle_latt_free_mp;
1403         }
1404
1405         /* Cleanup any outstanding ELS commands */
1406         lpfc_els_flush_all_cmd(phba);
1407
1408         psli->slistat.link_event++;
1409         lpfc_read_la(phba, pmb, mp);
1410         pmb->mbox_cmpl = lpfc_mbx_cmpl_read_la;
1411         pmb->vport = vport;
1412         /* Block ELS IOCBs until we have processed this mbox command */
1413         phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
1414         rc = lpfc_sli_issue_mbox (phba, pmb, MBX_NOWAIT);
1415         if (rc == MBX_NOT_FINISHED) {
1416                 rc = 4;
1417                 goto lpfc_handle_latt_free_mbuf;
1418         }
1419
1420         /* Clear Link Attention in HA REG */
1421         spin_lock_irq(&phba->hbalock);
1422         writel(HA_LATT, phba->HAregaddr);
1423         readl(phba->HAregaddr); /* flush */
1424         spin_unlock_irq(&phba->hbalock);
1425
1426         return;
1427
1428 lpfc_handle_latt_free_mbuf:
1429         phba->sli.ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT;
1430         lpfc_mbuf_free(phba, mp->virt, mp->phys);
1431 lpfc_handle_latt_free_mp:
1432         kfree(mp);
1433 lpfc_handle_latt_free_pmb:
1434         mempool_free(pmb, phba->mbox_mem_pool);
1435 lpfc_handle_latt_err_exit:
1436         /* Enable Link attention interrupts */
1437         spin_lock_irq(&phba->hbalock);
1438         psli->sli_flag |= LPFC_PROCESS_LA;
1439         control = readl(phba->HCregaddr);
1440         control |= HC_LAINT_ENA;
1441         writel(control, phba->HCregaddr);
1442         readl(phba->HCregaddr); /* flush */
1443
1444         /* Clear Link Attention in HA REG */
1445         writel(HA_LATT, phba->HAregaddr);
1446         readl(phba->HAregaddr); /* flush */
1447         spin_unlock_irq(&phba->hbalock);
1448         lpfc_linkdown(phba);
1449         phba->link_state = LPFC_HBA_ERROR;
1450
1451         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1452                      "0300 LATT: Cannot issue READ_LA: Data:%d\n", rc);
1453
1454         return;
1455 }
1456
1457 /**
1458  * lpfc_parse_vpd - Parse VPD (Vital Product Data)
1459  * @phba: pointer to lpfc hba data structure.
1460  * @vpd: pointer to the vital product data.
1461  * @len: length of the vital product data in bytes.
1462  *
1463  * This routine parses the Vital Product Data (VPD). The VPD is treated as
1464  * an array of characters. In this routine, the ModelName, ProgramType, and
1465  * ModelDesc, etc. fields of the phba data structure will be populated.
1466  *
1467  * Return codes
1468  *   0 - pointer to the VPD passed in is NULL
1469  *   1 - success
1470  **/
1471 int
1472 lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len)
1473 {
1474         uint8_t lenlo, lenhi;
1475         int Length;
1476         int i, j;
1477         int finished = 0;
1478         int index = 0;
1479
1480         if (!vpd)
1481                 return 0;
1482
1483         /* Vital Product */
1484         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1485                         "0455 Vital Product Data: x%x x%x x%x x%x\n",
1486                         (uint32_t) vpd[0], (uint32_t) vpd[1], (uint32_t) vpd[2],
1487                         (uint32_t) vpd[3]);
1488         while (!finished && (index < (len - 4))) {
1489                 switch (vpd[index]) {
1490                 case 0x82:
1491                 case 0x91:
1492                         index += 1;
1493                         lenlo = vpd[index];
1494                         index += 1;
1495                         lenhi = vpd[index];
1496                         index += 1;
1497                         i = ((((unsigned short)lenhi) << 8) + lenlo);
1498                         index += i;
1499                         break;
1500                 case 0x90:
1501                         index += 1;
1502                         lenlo = vpd[index];
1503                         index += 1;
1504                         lenhi = vpd[index];
1505                         index += 1;
1506                         Length = ((((unsigned short)lenhi) << 8) + lenlo);
1507                         if (Length > len - index)
1508                                 Length = len - index;
1509                         while (Length > 0) {
1510                         /* Look for Serial Number */
1511                         if ((vpd[index] == 'S') && (vpd[index+1] == 'N')) {
1512                                 index += 2;
1513                                 i = vpd[index];
1514                                 index += 1;
1515                                 j = 0;
1516                                 Length -= (3+i);
1517                                 while(i--) {
1518                                         phba->SerialNumber[j++] = vpd[index++];
1519                                         if (j == 31)
1520                                                 break;
1521                                 }
1522                                 phba->SerialNumber[j] = 0;
1523                                 continue;
1524                         }
1525                         else if ((vpd[index] == 'V') && (vpd[index+1] == '1')) {
1526                                 phba->vpd_flag |= VPD_MODEL_DESC;
1527                                 index += 2;
1528                                 i = vpd[index];
1529                                 index += 1;
1530                                 j = 0;
1531                                 Length -= (3+i);
1532                                 while(i--) {
1533                                         phba->ModelDesc[j++] = vpd[index++];
1534                                         if (j == 255)
1535                                                 break;
1536                                 }
1537                                 phba->ModelDesc[j] = 0;
1538                                 continue;
1539                         }
1540                         else if ((vpd[index] == 'V') && (vpd[index+1] == '2')) {
1541                                 phba->vpd_flag |= VPD_MODEL_NAME;
1542                                 index += 2;
1543                                 i = vpd[index];
1544                                 index += 1;
1545                                 j = 0;
1546                                 Length -= (3+i);
1547                                 while(i--) {
1548                                         phba->ModelName[j++] = vpd[index++];
1549                                         if (j == 79)
1550                                                 break;
1551                                 }
1552                                 phba->ModelName[j] = 0;
1553                                 continue;
1554                         }
1555                         else if ((vpd[index] == 'V') && (vpd[index+1] == '3')) {
1556                                 phba->vpd_flag |= VPD_PROGRAM_TYPE;
1557                                 index += 2;
1558                                 i = vpd[index];
1559                                 index += 1;
1560                                 j = 0;
1561                                 Length -= (3+i);
1562                                 while(i--) {
1563                                         phba->ProgramType[j++] = vpd[index++];
1564                                         if (j == 255)
1565                                                 break;
1566                                 }
1567                                 phba->ProgramType[j] = 0;
1568                                 continue;
1569                         }
1570                         else if ((vpd[index] == 'V') && (vpd[index+1] == '4')) {
1571                                 phba->vpd_flag |= VPD_PORT;
1572                                 index += 2;
1573                                 i = vpd[index];
1574                                 index += 1;
1575                                 j = 0;
1576                                 Length -= (3+i);
1577                                 while(i--) {
1578                                 phba->Port[j++] = vpd[index++];
1579                                 if (j == 19)
1580                                         break;
1581                                 }
1582                                 phba->Port[j] = 0;
1583                                 continue;
1584                         }
1585                         else {
1586                                 index += 2;
1587                                 i = vpd[index];
1588                                 index += 1;
1589                                 index += i;
1590                                 Length -= (3 + i);
1591                         }
1592                 }
1593                 finished = 0;
1594                 break;
1595                 case 0x78:
1596                         finished = 1;
1597                         break;
1598                 default:
1599                         index ++;
1600                         break;
1601                 }
1602         }
1603
1604         return(1);
1605 }
1606
1607 /**
1608  * lpfc_get_hba_model_desc - Retrieve HBA device model name and description
1609  * @phba: pointer to lpfc hba data structure.
1610  * @mdp: pointer to the data structure to hold the derived model name.
1611  * @descp: pointer to the data structure to hold the derived description.
1612  *
1613  * This routine retrieves HBA's description based on its registered PCI device
1614  * ID. The @descp passed into this function points to an array of 256 chars. It
1615  * shall be returned with the model name, maximum speed, and the host bus type.
1616  * The @mdp passed into this function points to an array of 80 chars. When the
1617  * function returns, the @mdp will be filled with the model name.
1618  **/
1619 static void
1620 lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
1621 {
1622         lpfc_vpd_t *vp;
1623         uint16_t dev_id = phba->pcidev->device;
1624         int max_speed;
1625         int GE = 0;
1626         int oneConnect = 0; /* default is not a oneConnect */
1627         struct {
1628                 char *name;
1629                 char *bus;
1630                 char *function;
1631         } m = {"<Unknown>", "", ""};
1632
1633         if (mdp && mdp[0] != '\0'
1634                 && descp && descp[0] != '\0')
1635                 return;
1636
1637         if (phba->lmt & LMT_10Gb)
1638                 max_speed = 10;
1639         else if (phba->lmt & LMT_8Gb)
1640                 max_speed = 8;
1641         else if (phba->lmt & LMT_4Gb)
1642                 max_speed = 4;
1643         else if (phba->lmt & LMT_2Gb)
1644                 max_speed = 2;
1645         else
1646                 max_speed = 1;
1647
1648         vp = &phba->vpd;
1649
1650         switch (dev_id) {
1651         case PCI_DEVICE_ID_FIREFLY:
1652                 m = (typeof(m)){"LP6000", "PCI", "Fibre Channel Adapter"};
1653                 break;
1654         case PCI_DEVICE_ID_SUPERFLY:
1655                 if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3)
1656                         m = (typeof(m)){"LP7000", "PCI",
1657                                         "Fibre Channel Adapter"};
1658                 else
1659                         m = (typeof(m)){"LP7000E", "PCI",
1660                                         "Fibre Channel Adapter"};
1661                 break;
1662         case PCI_DEVICE_ID_DRAGONFLY:
1663                 m = (typeof(m)){"LP8000", "PCI",
1664                                 "Fibre Channel Adapter"};
1665                 break;
1666         case PCI_DEVICE_ID_CENTAUR:
1667                 if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID)
1668                         m = (typeof(m)){"LP9002", "PCI",
1669                                         "Fibre Channel Adapter"};
1670                 else
1671                         m = (typeof(m)){"LP9000", "PCI",
1672                                         "Fibre Channel Adapter"};
1673                 break;
1674         case PCI_DEVICE_ID_RFLY:
1675                 m = (typeof(m)){"LP952", "PCI",
1676                                 "Fibre Channel Adapter"};
1677                 break;
1678         case PCI_DEVICE_ID_PEGASUS:
1679                 m = (typeof(m)){"LP9802", "PCI-X",
1680                                 "Fibre Channel Adapter"};
1681                 break;
1682         case PCI_DEVICE_ID_THOR:
1683                 m = (typeof(m)){"LP10000", "PCI-X",
1684                                 "Fibre Channel Adapter"};
1685                 break;
1686         case PCI_DEVICE_ID_VIPER:
1687                 m = (typeof(m)){"LPX1000",  "PCI-X",
1688                                 "Fibre Channel Adapter"};
1689                 break;
1690         case PCI_DEVICE_ID_PFLY:
1691                 m = (typeof(m)){"LP982", "PCI-X",
1692                                 "Fibre Channel Adapter"};
1693                 break;
1694         case PCI_DEVICE_ID_TFLY:
1695                 m = (typeof(m)){"LP1050", "PCI-X",
1696                                 "Fibre Channel Adapter"};
1697                 break;
1698         case PCI_DEVICE_ID_HELIOS:
1699                 m = (typeof(m)){"LP11000", "PCI-X2",
1700                                 "Fibre Channel Adapter"};
1701                 break;
1702         case PCI_DEVICE_ID_HELIOS_SCSP:
1703                 m = (typeof(m)){"LP11000-SP", "PCI-X2",
1704                                 "Fibre Channel Adapter"};
1705                 break;
1706         case PCI_DEVICE_ID_HELIOS_DCSP:
1707                 m = (typeof(m)){"LP11002-SP",  "PCI-X2",
1708                                 "Fibre Channel Adapter"};
1709                 break;
1710         case PCI_DEVICE_ID_NEPTUNE:
1711                 m = (typeof(m)){"LPe1000", "PCIe", "Fibre Channel Adapter"};
1712                 break;
1713         case PCI_DEVICE_ID_NEPTUNE_SCSP:
1714                 m = (typeof(m)){"LPe1000-SP", "PCIe", "Fibre Channel Adapter"};
1715                 break;
1716         case PCI_DEVICE_ID_NEPTUNE_DCSP:
1717                 m = (typeof(m)){"LPe1002-SP", "PCIe", "Fibre Channel Adapter"};
1718                 break;
1719         case PCI_DEVICE_ID_BMID:
1720                 m = (typeof(m)){"LP1150", "PCI-X2", "Fibre Channel Adapter"};
1721                 break;
1722         case PCI_DEVICE_ID_BSMB:
1723                 m = (typeof(m)){"LP111", "PCI-X2", "Fibre Channel Adapter"};
1724                 break;
1725         case PCI_DEVICE_ID_ZEPHYR:
1726                 m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
1727                 break;
1728         case PCI_DEVICE_ID_ZEPHYR_SCSP:
1729                 m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
1730                 break;
1731         case PCI_DEVICE_ID_ZEPHYR_DCSP:
1732                 m = (typeof(m)){"LP2105", "PCIe", "FCoE Adapter"};
1733                 GE = 1;
1734                 break;
1735         case PCI_DEVICE_ID_ZMID:
1736                 m = (typeof(m)){"LPe1150", "PCIe", "Fibre Channel Adapter"};
1737                 break;
1738         case PCI_DEVICE_ID_ZSMB:
1739                 m = (typeof(m)){"LPe111", "PCIe", "Fibre Channel Adapter"};
1740                 break;
1741         case PCI_DEVICE_ID_LP101:
1742                 m = (typeof(m)){"LP101", "PCI-X", "Fibre Channel Adapter"};
1743                 break;
1744         case PCI_DEVICE_ID_LP10000S:
1745                 m = (typeof(m)){"LP10000-S", "PCI", "Fibre Channel Adapter"};
1746                 break;
1747         case PCI_DEVICE_ID_LP11000S:
1748                 m = (typeof(m)){"LP11000-S", "PCI-X2", "Fibre Channel Adapter"};
1749                 break;
1750         case PCI_DEVICE_ID_LPE11000S:
1751                 m = (typeof(m)){"LPe11000-S", "PCIe", "Fibre Channel Adapter"};
1752                 break;
1753         case PCI_DEVICE_ID_SAT:
1754                 m = (typeof(m)){"LPe12000", "PCIe", "Fibre Channel Adapter"};
1755                 break;
1756         case PCI_DEVICE_ID_SAT_MID:
1757                 m = (typeof(m)){"LPe1250", "PCIe", "Fibre Channel Adapter"};
1758                 break;
1759         case PCI_DEVICE_ID_SAT_SMB:
1760                 m = (typeof(m)){"LPe121", "PCIe", "Fibre Channel Adapter"};
1761                 break;
1762         case PCI_DEVICE_ID_SAT_DCSP:
1763                 m = (typeof(m)){"LPe12002-SP", "PCIe", "Fibre Channel Adapter"};
1764                 break;
1765         case PCI_DEVICE_ID_SAT_SCSP:
1766                 m = (typeof(m)){"LPe12000-SP", "PCIe", "Fibre Channel Adapter"};
1767                 break;
1768         case PCI_DEVICE_ID_SAT_S:
1769                 m = (typeof(m)){"LPe12000-S", "PCIe", "Fibre Channel Adapter"};
1770                 break;
1771         case PCI_DEVICE_ID_HORNET:
1772                 m = (typeof(m)){"LP21000", "PCIe", "FCoE Adapter"};
1773                 GE = 1;
1774                 break;
1775         case PCI_DEVICE_ID_PROTEUS_VF:
1776                 m = (typeof(m)){"LPev12000", "PCIe IOV",
1777                                 "Fibre Channel Adapter"};
1778                 break;
1779         case PCI_DEVICE_ID_PROTEUS_PF:
1780                 m = (typeof(m)){"LPev12000", "PCIe IOV",
1781                                 "Fibre Channel Adapter"};
1782                 break;
1783         case PCI_DEVICE_ID_PROTEUS_S:
1784                 m = (typeof(m)){"LPemv12002-S", "PCIe IOV",
1785                                 "Fibre Channel Adapter"};
1786                 break;
1787         case PCI_DEVICE_ID_TIGERSHARK:
1788                 oneConnect = 1;
1789                 m = (typeof(m)){"OCe10100", "PCIe", "FCoE"};
1790                 break;
1791         case PCI_DEVICE_ID_TOMCAT:
1792                 oneConnect = 1;
1793                 m = (typeof(m)){"OCe11100", "PCIe", "FCoE"};
1794                 break;
1795         case PCI_DEVICE_ID_FALCON:
1796                 m = (typeof(m)){"LPSe12002-ML1-E", "PCIe",
1797                                 "EmulexSecure Fibre"};
1798                 break;
1799         default:
1800                 m = (typeof(m)){"Unknown", "", ""};
1801                 break;
1802         }
1803
1804         if (mdp && mdp[0] == '\0')
1805                 snprintf(mdp, 79,"%s", m.name);
1806         /* oneConnect hba requires special processing, they are all initiators
1807          * and we put the port number on the end
1808          */
1809         if (descp && descp[0] == '\0') {
1810                 if (oneConnect)
1811                         snprintf(descp, 255,
1812                                 "Emulex OneConnect %s, %s Initiator, Port %s",
1813                                 m.name, m.function,
1814                                 phba->Port);
1815                 else
1816                         snprintf(descp, 255,
1817                                 "Emulex %s %d%s %s %s",
1818                                 m.name, max_speed, (GE) ? "GE" : "Gb",
1819                                 m.bus, m.function);
1820         }
1821 }
1822
1823 /**
1824  * lpfc_post_buffer - Post IOCB(s) with DMA buffer descriptor(s) to a IOCB ring
1825  * @phba: pointer to lpfc hba data structure.
1826  * @pring: pointer to a IOCB ring.
1827  * @cnt: the number of IOCBs to be posted to the IOCB ring.
1828  *
1829  * This routine posts a given number of IOCBs with the associated DMA buffer
1830  * descriptors specified by the cnt argument to the given IOCB ring.
1831  *
1832  * Return codes
1833  *   The number of IOCBs NOT able to be posted to the IOCB ring.
1834  **/
1835 int
1836 lpfc_post_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, int cnt)
1837 {
1838         IOCB_t *icmd;
1839         struct lpfc_iocbq *iocb;
1840         struct lpfc_dmabuf *mp1, *mp2;
1841
1842         cnt += pring->missbufcnt;
1843
1844         /* While there are buffers to post */
1845         while (cnt > 0) {
1846                 /* Allocate buffer for  command iocb */
1847                 iocb = lpfc_sli_get_iocbq(phba);
1848                 if (iocb == NULL) {
1849                         pring->missbufcnt = cnt;
1850                         return cnt;
1851                 }
1852                 icmd = &iocb->iocb;
1853
1854                 /* 2 buffers can be posted per command */
1855                 /* Allocate buffer to post */
1856                 mp1 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1857                 if (mp1)
1858                     mp1->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp1->phys);
1859                 if (!mp1 || !mp1->virt) {
1860                         kfree(mp1);
1861                         lpfc_sli_release_iocbq(phba, iocb);
1862                         pring->missbufcnt = cnt;
1863                         return cnt;
1864                 }
1865
1866                 INIT_LIST_HEAD(&mp1->list);
1867                 /* Allocate buffer to post */
1868                 if (cnt > 1) {
1869                         mp2 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1870                         if (mp2)
1871                                 mp2->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
1872                                                             &mp2->phys);
1873                         if (!mp2 || !mp2->virt) {
1874                                 kfree(mp2);
1875                                 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1876                                 kfree(mp1);
1877                                 lpfc_sli_release_iocbq(phba, iocb);
1878                                 pring->missbufcnt = cnt;
1879                                 return cnt;
1880                         }
1881
1882                         INIT_LIST_HEAD(&mp2->list);
1883                 } else {
1884                         mp2 = NULL;
1885                 }
1886
1887                 icmd->un.cont64[0].addrHigh = putPaddrHigh(mp1->phys);
1888                 icmd->un.cont64[0].addrLow = putPaddrLow(mp1->phys);
1889                 icmd->un.cont64[0].tus.f.bdeSize = FCELSSIZE;
1890                 icmd->ulpBdeCount = 1;
1891                 cnt--;
1892                 if (mp2) {
1893                         icmd->un.cont64[1].addrHigh = putPaddrHigh(mp2->phys);
1894                         icmd->un.cont64[1].addrLow = putPaddrLow(mp2->phys);
1895                         icmd->un.cont64[1].tus.f.bdeSize = FCELSSIZE;
1896                         cnt--;
1897                         icmd->ulpBdeCount = 2;
1898                 }
1899
1900                 icmd->ulpCommand = CMD_QUE_RING_BUF64_CN;
1901                 icmd->ulpLe = 1;
1902
1903                 if (lpfc_sli_issue_iocb(phba, pring->ringno, iocb, 0) ==
1904                     IOCB_ERROR) {
1905                         lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1906                         kfree(mp1);
1907                         cnt++;
1908                         if (mp2) {
1909                                 lpfc_mbuf_free(phba, mp2->virt, mp2->phys);
1910                                 kfree(mp2);
1911                                 cnt++;
1912                         }
1913                         lpfc_sli_release_iocbq(phba, iocb);
1914                         pring->missbufcnt = cnt;
1915                         return cnt;
1916                 }
1917                 lpfc_sli_ringpostbuf_put(phba, pring, mp1);
1918                 if (mp2)
1919                         lpfc_sli_ringpostbuf_put(phba, pring, mp2);
1920         }
1921         pring->missbufcnt = 0;
1922         return 0;
1923 }
1924
1925 /**
1926  * lpfc_post_rcv_buf - Post the initial receive IOCB buffers to ELS ring
1927  * @phba: pointer to lpfc hba data structure.
1928  *
1929  * This routine posts initial receive IOCB buffers to the ELS ring. The
1930  * current number of initial IOCB buffers specified by LPFC_BUF_RING0 is
1931  * set to 64 IOCBs.
1932  *
1933  * Return codes
1934  *   0 - success (currently always success)
1935  **/
1936 static int
1937 lpfc_post_rcv_buf(struct lpfc_hba *phba)
1938 {
1939         struct lpfc_sli *psli = &phba->sli;
1940
1941         /* Ring 0, ELS / CT buffers */
1942         lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], LPFC_BUF_RING0);
1943         /* Ring 2 - FCP no buffers needed */
1944
1945         return 0;
1946 }
1947
1948 #define S(N,V) (((V)<<(N))|((V)>>(32-(N))))
1949
1950 /**
1951  * lpfc_sha_init - Set up initial array of hash table entries
1952  * @HashResultPointer: pointer to an array as hash table.
1953  *
1954  * This routine sets up the initial values to the array of hash table entries
1955  * for the LC HBAs.
1956  **/
1957 static void
1958 lpfc_sha_init(uint32_t * HashResultPointer)
1959 {
1960         HashResultPointer[0] = 0x67452301;
1961         HashResultPointer[1] = 0xEFCDAB89;
1962         HashResultPointer[2] = 0x98BADCFE;
1963         HashResultPointer[3] = 0x10325476;
1964         HashResultPointer[4] = 0xC3D2E1F0;
1965 }
1966
1967 /**
1968  * lpfc_sha_iterate - Iterate initial hash table with the working hash table
1969  * @HashResultPointer: pointer to an initial/result hash table.
1970  * @HashWorkingPointer: pointer to an working hash table.
1971  *
1972  * This routine iterates an initial hash table pointed by @HashResultPointer
1973  * with the values from the working hash table pointeed by @HashWorkingPointer.
1974  * The results are putting back to the initial hash table, returned through
1975  * the @HashResultPointer as the result hash table.
1976  **/
1977 static void
1978 lpfc_sha_iterate(uint32_t * HashResultPointer, uint32_t * HashWorkingPointer)
1979 {
1980         int t;
1981         uint32_t TEMP;
1982         uint32_t A, B, C, D, E;
1983         t = 16;
1984         do {
1985                 HashWorkingPointer[t] =
1986                     S(1,
1987                       HashWorkingPointer[t - 3] ^ HashWorkingPointer[t -
1988                                                                      8] ^
1989                       HashWorkingPointer[t - 14] ^ HashWorkingPointer[t - 16]);
1990         } while (++t <= 79);
1991         t = 0;
1992         A = HashResultPointer[0];
1993         B = HashResultPointer[1];
1994         C = HashResultPointer[2];
1995         D = HashResultPointer[3];
1996         E = HashResultPointer[4];
1997
1998         do {
1999                 if (t < 20) {
2000                         TEMP = ((B & C) | ((~B) & D)) + 0x5A827999;
2001                 } else if (t < 40) {
2002                         TEMP = (B ^ C ^ D) + 0x6ED9EBA1;
2003                 } else if (t < 60) {
2004                         TEMP = ((B & C) | (B & D) | (C & D)) + 0x8F1BBCDC;
2005                 } else {
2006                         TEMP = (B ^ C ^ D) + 0xCA62C1D6;
2007                 }
2008                 TEMP += S(5, A) + E + HashWorkingPointer[t];
2009                 E = D;
2010                 D = C;
2011                 C = S(30, B);
2012                 B = A;
2013                 A = TEMP;
2014         } while (++t <= 79);
2015
2016         HashResultPointer[0] += A;
2017         HashResultPointer[1] += B;
2018         HashResultPointer[2] += C;
2019         HashResultPointer[3] += D;
2020         HashResultPointer[4] += E;
2021
2022 }
2023
2024 /**
2025  * lpfc_challenge_key - Create challenge key based on WWPN of the HBA
2026  * @RandomChallenge: pointer to the entry of host challenge random number array.
2027  * @HashWorking: pointer to the entry of the working hash array.
2028  *
2029  * This routine calculates the working hash array referred by @HashWorking
2030  * from the challenge random numbers associated with the host, referred by
2031  * @RandomChallenge. The result is put into the entry of the working hash
2032  * array and returned by reference through @HashWorking.
2033  **/
2034 static void
2035 lpfc_challenge_key(uint32_t * RandomChallenge, uint32_t * HashWorking)
2036 {
2037         *HashWorking = (*RandomChallenge ^ *HashWorking);
2038 }
2039
2040 /**
2041  * lpfc_hba_init - Perform special handling for LC HBA initialization
2042  * @phba: pointer to lpfc hba data structure.
2043  * @hbainit: pointer to an array of unsigned 32-bit integers.
2044  *
2045  * This routine performs the special handling for LC HBA initialization.
2046  **/
2047 void
2048 lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit)
2049 {
2050         int t;
2051         uint32_t *HashWorking;
2052         uint32_t *pwwnn = (uint32_t *) phba->wwnn;
2053
2054         HashWorking = kcalloc(80, sizeof(uint32_t), GFP_KERNEL);
2055         if (!HashWorking)
2056                 return;
2057
2058         HashWorking[0] = HashWorking[78] = *pwwnn++;
2059         HashWorking[1] = HashWorking[79] = *pwwnn;
2060
2061         for (t = 0; t < 7; t++)
2062                 lpfc_challenge_key(phba->RandomData + t, HashWorking + t);
2063
2064         lpfc_sha_init(hbainit);
2065         lpfc_sha_iterate(hbainit, HashWorking);
2066         kfree(HashWorking);
2067 }
2068
2069 /**
2070  * lpfc_cleanup - Performs vport cleanups before deleting a vport
2071  * @vport: pointer to a virtual N_Port data structure.
2072  *
2073  * This routine performs the necessary cleanups before deleting the @vport.
2074  * It invokes the discovery state machine to perform necessary state
2075  * transitions and to release the ndlps associated with the @vport. Note,
2076  * the physical port is treated as @vport 0.
2077  **/
2078 void
2079 lpfc_cleanup(struct lpfc_vport *vport)
2080 {
2081         struct lpfc_hba   *phba = vport->phba;
2082         struct lpfc_nodelist *ndlp, *next_ndlp;
2083         int i = 0;
2084
2085         if (phba->link_state > LPFC_LINK_DOWN)
2086                 lpfc_port_link_failure(vport);
2087
2088         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
2089                 if (!NLP_CHK_NODE_ACT(ndlp)) {
2090                         ndlp = lpfc_enable_node(vport, ndlp,
2091                                                 NLP_STE_UNUSED_NODE);
2092                         if (!ndlp)
2093                                 continue;
2094                         spin_lock_irq(&phba->ndlp_lock);
2095                         NLP_SET_FREE_REQ(ndlp);
2096                         spin_unlock_irq(&phba->ndlp_lock);
2097                         /* Trigger the release of the ndlp memory */
2098                         lpfc_nlp_put(ndlp);
2099                         continue;
2100                 }
2101                 spin_lock_irq(&phba->ndlp_lock);
2102                 if (NLP_CHK_FREE_REQ(ndlp)) {
2103                         /* The ndlp should not be in memory free mode already */
2104                         spin_unlock_irq(&phba->ndlp_lock);
2105                         continue;
2106                 } else
2107                         /* Indicate request for freeing ndlp memory */
2108                         NLP_SET_FREE_REQ(ndlp);
2109                 spin_unlock_irq(&phba->ndlp_lock);
2110
2111                 if (vport->port_type != LPFC_PHYSICAL_PORT &&
2112                     ndlp->nlp_DID == Fabric_DID) {
2113                         /* Just free up ndlp with Fabric_DID for vports */
2114                         lpfc_nlp_put(ndlp);
2115                         continue;
2116                 }
2117
2118                 if (ndlp->nlp_type & NLP_FABRIC)
2119                         lpfc_disc_state_machine(vport, ndlp, NULL,
2120                                         NLP_EVT_DEVICE_RECOVERY);
2121
2122                 lpfc_disc_state_machine(vport, ndlp, NULL,
2123                                              NLP_EVT_DEVICE_RM);
2124
2125         }
2126
2127         /* At this point, ALL ndlp's should be gone
2128          * because of the previous NLP_EVT_DEVICE_RM.
2129          * Lets wait for this to happen, if needed.
2130          */
2131         while (!list_empty(&vport->fc_nodes)) {
2132                 if (i++ > 3000) {
2133                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2134                                 "0233 Nodelist not empty\n");
2135                         list_for_each_entry_safe(ndlp, next_ndlp,
2136                                                 &vport->fc_nodes, nlp_listp) {
2137                                 lpfc_printf_vlog(ndlp->vport, KERN_ERR,
2138                                                 LOG_NODE,
2139                                                 "0282 did:x%x ndlp:x%p "
2140                                                 "usgmap:x%x refcnt:%d\n",
2141                                                 ndlp->nlp_DID, (void *)ndlp,
2142                                                 ndlp->nlp_usg_map,
2143                                                 atomic_read(
2144                                                         &ndlp->kref.refcount));
2145                         }
2146                         break;
2147                 }
2148
2149                 /* Wait for any activity on ndlps to settle */
2150                 msleep(10);
2151         }
2152 }
2153
2154 /**
2155  * lpfc_stop_vport_timers - Stop all the timers associated with a vport
2156  * @vport: pointer to a virtual N_Port data structure.
2157  *
2158  * This routine stops all the timers associated with a @vport. This function
2159  * is invoked before disabling or deleting a @vport. Note that the physical
2160  * port is treated as @vport 0.
2161  **/
2162 void
2163 lpfc_stop_vport_timers(struct lpfc_vport *vport)
2164 {
2165         del_timer_sync(&vport->els_tmofunc);
2166         del_timer_sync(&vport->fc_fdmitmo);
2167         lpfc_can_disctmo(vport);
2168         return;
2169 }
2170
2171 /**
2172  * __lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2173  * @phba: pointer to lpfc hba data structure.
2174  *
2175  * This routine stops the SLI4 FCF rediscover wait timer if it's on. The
2176  * caller of this routine should already hold the host lock.
2177  **/
2178 void
2179 __lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
2180 {
2181         /* Clear pending FCF rediscovery wait timer */
2182         phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
2183         /* Now, try to stop the timer */
2184         del_timer(&phba->fcf.redisc_wait);
2185 }
2186
2187 /**
2188  * lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
2189  * @phba: pointer to lpfc hba data structure.
2190  *
2191  * This routine stops the SLI4 FCF rediscover wait timer if it's on. It
2192  * checks whether the FCF rediscovery wait timer is pending with the host
2193  * lock held before proceeding with disabling the timer and clearing the
2194  * wait timer pendig flag.
2195  **/
2196 void
2197 lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
2198 {
2199         spin_lock_irq(&phba->hbalock);
2200         if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
2201                 /* FCF rediscovery timer already fired or stopped */
2202                 spin_unlock_irq(&phba->hbalock);
2203                 return;
2204         }
2205         __lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2206         spin_unlock_irq(&phba->hbalock);
2207 }
2208
2209 /**
2210  * lpfc_stop_hba_timers - Stop all the timers associated with an HBA
2211  * @phba: pointer to lpfc hba data structure.
2212  *
2213  * This routine stops all the timers associated with a HBA. This function is
2214  * invoked before either putting a HBA offline or unloading the driver.
2215  **/
2216 void
2217 lpfc_stop_hba_timers(struct lpfc_hba *phba)
2218 {
2219         lpfc_stop_vport_timers(phba->pport);
2220         del_timer_sync(&phba->sli.mbox_tmo);
2221         del_timer_sync(&phba->fabric_block_timer);
2222         del_timer_sync(&phba->eratt_poll);
2223         del_timer_sync(&phba->hb_tmofunc);
2224         phba->hb_outstanding = 0;
2225
2226         switch (phba->pci_dev_grp) {
2227         case LPFC_PCI_DEV_LP:
2228                 /* Stop any LightPulse device specific driver timers */
2229                 del_timer_sync(&phba->fcp_poll_timer);
2230                 break;
2231         case LPFC_PCI_DEV_OC:
2232                 /* Stop any OneConnect device sepcific driver timers */
2233                 lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
2234                 break;
2235         default:
2236                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2237                                 "0297 Invalid device group (x%x)\n",
2238                                 phba->pci_dev_grp);
2239                 break;
2240         }
2241         return;
2242 }
2243
2244 /**
2245  * lpfc_block_mgmt_io - Mark a HBA's management interface as blocked
2246  * @phba: pointer to lpfc hba data structure.
2247  *
2248  * This routine marks a HBA's management interface as blocked. Once the HBA's
2249  * management interface is marked as blocked, all the user space access to
2250  * the HBA, whether they are from sysfs interface or libdfc interface will
2251  * all be blocked. The HBA is set to block the management interface when the
2252  * driver prepares the HBA interface for online or offline.
2253  **/
2254 static void
2255 lpfc_block_mgmt_io(struct lpfc_hba * phba)
2256 {
2257         unsigned long iflag;
2258
2259         spin_lock_irqsave(&phba->hbalock, iflag);
2260         phba->sli.sli_flag |= LPFC_BLOCK_MGMT_IO;
2261         spin_unlock_irqrestore(&phba->hbalock, iflag);
2262 }
2263
2264 /**
2265  * lpfc_online - Initialize and bring a HBA online
2266  * @phba: pointer to lpfc hba data structure.
2267  *
2268  * This routine initializes the HBA and brings a HBA online. During this
2269  * process, the management interface is blocked to prevent user space access
2270  * to the HBA interfering with the driver initialization.
2271  *
2272  * Return codes
2273  *   0 - successful
2274  *   1 - failed
2275  **/
2276 int
2277 lpfc_online(struct lpfc_hba *phba)
2278 {
2279         struct lpfc_vport *vport;
2280         struct lpfc_vport **vports;
2281         int i;
2282
2283         if (!phba)
2284                 return 0;
2285         vport = phba->pport;
2286
2287         if (!(vport->fc_flag & FC_OFFLINE_MODE))
2288                 return 0;
2289
2290         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
2291                         "0458 Bring Adapter online\n");
2292
2293         lpfc_block_mgmt_io(phba);
2294
2295         if (!lpfc_sli_queue_setup(phba)) {
2296                 lpfc_unblock_mgmt_io(phba);
2297                 return 1;
2298         }
2299
2300         if (phba->sli_rev == LPFC_SLI_REV4) {
2301                 if (lpfc_sli4_hba_setup(phba)) { /* Initialize SLI4 HBA */
2302                         lpfc_unblock_mgmt_io(phba);
2303                         return 1;
2304                 }
2305         } else {
2306                 if (lpfc_sli_hba_setup(phba)) { /* Initialize SLI2/SLI3 HBA */
2307                         lpfc_unblock_mgmt_io(phba);
2308                         return 1;
2309                 }
2310         }
2311
2312         vports = lpfc_create_vport_work_array(phba);
2313         if (vports != NULL)
2314                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2315                         struct Scsi_Host *shost;
2316                         shost = lpfc_shost_from_vport(vports[i]);
2317                         spin_lock_irq(shost->host_lock);
2318                         vports[i]->fc_flag &= ~FC_OFFLINE_MODE;
2319                         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
2320                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
2321                         if (phba->sli_rev == LPFC_SLI_REV4)
2322                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
2323                         spin_unlock_irq(shost->host_lock);
2324                 }
2325                 lpfc_destroy_vport_work_array(phba, vports);
2326
2327         lpfc_unblock_mgmt_io(phba);
2328         return 0;
2329 }
2330
2331 /**
2332  * lpfc_unblock_mgmt_io - Mark a HBA's management interface to be not blocked
2333  * @phba: pointer to lpfc hba data structure.
2334  *
2335  * This routine marks a HBA's management interface as not blocked. Once the
2336  * HBA's management interface is marked as not blocked, all the user space
2337  * access to the HBA, whether they are from sysfs interface or libdfc
2338  * interface will be allowed. The HBA is set to block the management interface
2339  * when the driver prepares the HBA interface for online or offline and then
2340  * set to unblock the management interface afterwards.
2341  **/
2342 void
2343 lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
2344 {
2345         unsigned long iflag;
2346
2347         spin_lock_irqsave(&phba->hbalock, iflag);
2348         phba->sli.sli_flag &= ~LPFC_BLOCK_MGMT_IO;
2349         spin_unlock_irqrestore(&phba->hbalock, iflag);
2350 }
2351
2352 /**
2353  * lpfc_offline_prep - Prepare a HBA to be brought offline
2354  * @phba: pointer to lpfc hba data structure.
2355  *
2356  * This routine is invoked to prepare a HBA to be brought offline. It performs
2357  * unregistration login to all the nodes on all vports and flushes the mailbox
2358  * queue to make it ready to be brought offline.
2359  **/
2360 void
2361 lpfc_offline_prep(struct lpfc_hba * phba)
2362 {
2363         struct lpfc_vport *vport = phba->pport;
2364         struct lpfc_nodelist  *ndlp, *next_ndlp;
2365         struct lpfc_vport **vports;
2366         struct Scsi_Host *shost;
2367         int i;
2368
2369         if (vport->fc_flag & FC_OFFLINE_MODE)
2370                 return;
2371
2372         lpfc_block_mgmt_io(phba);
2373
2374         lpfc_linkdown(phba);
2375
2376         /* Issue an unreg_login to all nodes on all vports */
2377         vports = lpfc_create_vport_work_array(phba);
2378         if (vports != NULL) {
2379                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2380                         if (vports[i]->load_flag & FC_UNLOADING)
2381                                 continue;
2382                         shost = lpfc_shost_from_vport(vports[i]);
2383                         spin_lock_irq(shost->host_lock);
2384                         vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
2385                         vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
2386                         vports[i]->fc_flag &= ~FC_VFI_REGISTERED;
2387                         spin_unlock_irq(shost->host_lock);
2388
2389                         shost = lpfc_shost_from_vport(vports[i]);
2390                         list_for_each_entry_safe(ndlp, next_ndlp,
2391                                                  &vports[i]->fc_nodes,
2392                                                  nlp_listp) {
2393                                 if (!NLP_CHK_NODE_ACT(ndlp))
2394                                         continue;
2395                                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
2396                                         continue;
2397                                 if (ndlp->nlp_type & NLP_FABRIC) {
2398                                         lpfc_disc_state_machine(vports[i], ndlp,
2399                                                 NULL, NLP_EVT_DEVICE_RECOVERY);
2400                                         lpfc_disc_state_machine(vports[i], ndlp,
2401                                                 NULL, NLP_EVT_DEVICE_RM);
2402                                 }
2403                                 spin_lock_irq(shost->host_lock);
2404                                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
2405                                 spin_unlock_irq(shost->host_lock);
2406                                 lpfc_unreg_rpi(vports[i], ndlp);
2407                         }
2408                 }
2409         }
2410         lpfc_destroy_vport_work_array(phba, vports);
2411
2412         lpfc_sli_mbox_sys_shutdown(phba);
2413 }
2414
2415 /**
2416  * lpfc_offline - Bring a HBA offline
2417  * @phba: pointer to lpfc hba data structure.
2418  *
2419  * This routine actually brings a HBA offline. It stops all the timers
2420  * associated with the HBA, brings down the SLI layer, and eventually
2421  * marks the HBA as in offline state for the upper layer protocol.
2422  **/
2423 void
2424 lpfc_offline(struct lpfc_hba *phba)
2425 {
2426         struct Scsi_Host  *shost;
2427         struct lpfc_vport **vports;
2428         int i;
2429
2430         if (phba->pport->fc_flag & FC_OFFLINE_MODE)
2431                 return;
2432
2433         /* stop port and all timers associated with this hba */
2434         lpfc_stop_port(phba);
2435         vports = lpfc_create_vport_work_array(phba);
2436         if (vports != NULL)
2437                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
2438                         lpfc_stop_vport_timers(vports[i]);
2439         lpfc_destroy_vport_work_array(phba, vports);
2440         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
2441                         "0460 Bring Adapter offline\n");
2442         /* Bring down the SLI Layer and cleanup.  The HBA is offline
2443            now.  */
2444         lpfc_sli_hba_down(phba);
2445         spin_lock_irq(&phba->hbalock);
2446         phba->work_ha = 0;
2447         spin_unlock_irq(&phba->hbalock);
2448         vports = lpfc_create_vport_work_array(phba);
2449         if (vports != NULL)
2450                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2451                         shost = lpfc_shost_from_vport(vports[i]);
2452                         spin_lock_irq(shost->host_lock);
2453                         vports[i]->work_port_events = 0;
2454                         vports[i]->fc_flag |= FC_OFFLINE_MODE;
2455                         spin_unlock_irq(shost->host_lock);
2456                 }
2457         lpfc_destroy_vport_work_array(phba, vports);
2458 }
2459
2460 /**
2461  * lpfc_scsi_free - Free all the SCSI buffers and IOCBs from driver lists
2462  * @phba: pointer to lpfc hba data structure.
2463  *
2464  * This routine is to free all the SCSI buffers and IOCBs from the driver
2465  * list back to kernel. It is called from lpfc_pci_remove_one to free
2466  * the internal resources before the device is removed from the system.
2467  *
2468  * Return codes
2469  *   0 - successful (for now, it always returns 0)
2470  **/
2471 static int
2472 lpfc_scsi_free(struct lpfc_hba *phba)
2473 {
2474         struct lpfc_scsi_buf *sb, *sb_next;
2475         struct lpfc_iocbq *io, *io_next;
2476
2477         spin_lock_irq(&phba->hbalock);
2478         /* Release all the lpfc_scsi_bufs maintained by this host. */
2479         spin_lock(&phba->scsi_buf_list_lock);
2480         list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) {
2481                 list_del(&sb->list);
2482                 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
2483                               sb->dma_handle);
2484                 kfree(sb);
2485                 phba->total_scsi_bufs--;
2486         }
2487         spin_unlock(&phba->scsi_buf_list_lock);
2488
2489         /* Release all the lpfc_iocbq entries maintained by this host. */
2490         list_for_each_entry_safe(io, io_next, &phba->lpfc_iocb_list, list) {
2491                 list_del(&io->list);
2492                 kfree(io);
2493                 phba->total_iocbq_bufs--;
2494         }
2495         spin_unlock_irq(&phba->hbalock);
2496         return 0;
2497 }
2498
2499 /**
2500  * lpfc_create_port - Create an FC port
2501  * @phba: pointer to lpfc hba data structure.
2502  * @instance: a unique integer ID to this FC port.
2503  * @dev: pointer to the device data structure.
2504  *
2505  * This routine creates a FC port for the upper layer protocol. The FC port
2506  * can be created on top of either a physical port or a virtual port provided
2507  * by the HBA. This routine also allocates a SCSI host data structure (shost)
2508  * and associates the FC port created before adding the shost into the SCSI
2509  * layer.
2510  *
2511  * Return codes
2512  *   @vport - pointer to the virtual N_Port data structure.
2513  *   NULL - port create failed.
2514  **/
2515 struct lpfc_vport *
2516 lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
2517 {
2518         struct lpfc_vport *vport;
2519         struct Scsi_Host  *shost;
2520         int error = 0;
2521
2522         if (dev != &phba->pcidev->dev)
2523                 shost = scsi_host_alloc(&lpfc_vport_template,
2524                                         sizeof(struct lpfc_vport));
2525         else
2526                 shost = scsi_host_alloc(&lpfc_template,
2527                                         sizeof(struct lpfc_vport));
2528         if (!shost)
2529                 goto out;
2530
2531         vport = (struct lpfc_vport *) shost->hostdata;
2532         vport->phba = phba;
2533         vport->load_flag |= FC_LOADING;
2534         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
2535         vport->fc_rscn_flush = 0;
2536
2537         lpfc_get_vport_cfgparam(vport);
2538         shost->unique_id = instance;
2539         shost->max_id = LPFC_MAX_TARGET;
2540         shost->max_lun = vport->cfg_max_luns;
2541         shost->this_id = -1;
2542         shost->max_cmd_len = 16;
2543         if (phba->sli_rev == LPFC_SLI_REV4) {
2544                 shost->dma_boundary =
2545                         phba->sli4_hba.pc_sli4_params.sge_supp_len;
2546                 shost->sg_tablesize = phba->cfg_sg_seg_cnt;
2547         }
2548
2549         /*
2550          * Set initial can_queue value since 0 is no longer supported and
2551          * scsi_add_host will fail. This will be adjusted later based on the
2552          * max xri value determined in hba setup.
2553          */
2554         shost->can_queue = phba->cfg_hba_queue_depth - 10;
2555         if (dev != &phba->pcidev->dev) {
2556                 shost->transportt = lpfc_vport_transport_template;
2557                 vport->port_type = LPFC_NPIV_PORT;
2558         } else {
2559                 shost->transportt = lpfc_transport_template;
2560                 vport->port_type = LPFC_PHYSICAL_PORT;
2561         }
2562
2563         /* Initialize all internally managed lists. */
2564         INIT_LIST_HEAD(&vport->fc_nodes);
2565         INIT_LIST_HEAD(&vport->rcv_buffer_list);
2566         spin_lock_init(&vport->work_port_lock);
2567
2568         init_timer(&vport->fc_disctmo);
2569         vport->fc_disctmo.function = lpfc_disc_timeout;
2570         vport->fc_disctmo.data = (unsigned long)vport;
2571
2572         init_timer(&vport->fc_fdmitmo);
2573         vport->fc_fdmitmo.function = lpfc_fdmi_tmo;
2574         vport->fc_fdmitmo.data = (unsigned long)vport;
2575
2576         init_timer(&vport->els_tmofunc);
2577         vport->els_tmofunc.function = lpfc_els_timeout;
2578         vport->els_tmofunc.data = (unsigned long)vport;
2579
2580         error = scsi_add_host_with_dma(shost, dev, &phba->pcidev->dev);
2581         if (error)
2582                 goto out_put_shost;
2583
2584         spin_lock_irq(&phba->hbalock);
2585         list_add_tail(&vport->listentry, &phba->port_list);
2586         spin_unlock_irq(&phba->hbalock);
2587         return vport;
2588
2589 out_put_shost:
2590         scsi_host_put(shost);
2591 out:
2592         return NULL;
2593 }
2594
2595 /**
2596  * destroy_port -  destroy an FC port
2597  * @vport: pointer to an lpfc virtual N_Port data structure.
2598  *
2599  * This routine destroys a FC port from the upper layer protocol. All the
2600  * resources associated with the port are released.
2601  **/
2602 void
2603 destroy_port(struct lpfc_vport *vport)
2604 {
2605         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2606         struct lpfc_hba  *phba = vport->phba;
2607
2608         lpfc_debugfs_terminate(vport);
2609         fc_remove_host(shost);
2610         scsi_remove_host(shost);
2611
2612         spin_lock_irq(&phba->hbalock);
2613         list_del_init(&vport->listentry);
2614         spin_unlock_irq(&phba->hbalock);
2615
2616         lpfc_cleanup(vport);
2617         return;
2618 }
2619
2620 /**
2621  * lpfc_get_instance - Get a unique integer ID
2622  *
2623  * This routine allocates a unique integer ID from lpfc_hba_index pool. It
2624  * uses the kernel idr facility to perform the task.
2625  *
2626  * Return codes:
2627  *   instance - a unique integer ID allocated as the new instance.
2628  *   -1 - lpfc get instance failed.
2629  **/
2630 int
2631 lpfc_get_instance(void)
2632 {
2633         int instance = 0;
2634
2635         /* Assign an unused number */
2636         if (!idr_pre_get(&lpfc_hba_index, GFP_KERNEL))
2637                 return -1;
2638         if (idr_get_new(&lpfc_hba_index, NULL, &instance))
2639                 return -1;
2640         return instance;
2641 }
2642
2643 /**
2644  * lpfc_scan_finished - method for SCSI layer to detect whether scan is done
2645  * @shost: pointer to SCSI host data structure.
2646  * @time: elapsed time of the scan in jiffies.
2647  *
2648  * This routine is called by the SCSI layer with a SCSI host to determine
2649  * whether the scan host is finished.
2650  *
2651  * Note: there is no scan_start function as adapter initialization will have
2652  * asynchronously kicked off the link initialization.
2653  *
2654  * Return codes
2655  *   0 - SCSI host scan is not over yet.
2656  *   1 - SCSI host scan is over.
2657  **/
2658 int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
2659 {
2660         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2661         struct lpfc_hba   *phba = vport->phba;
2662         int stat = 0;
2663
2664         spin_lock_irq(shost->host_lock);
2665
2666         if (vport->load_flag & FC_UNLOADING) {
2667                 stat = 1;
2668                 goto finished;
2669         }
2670         if (time >= 30 * HZ) {
2671                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2672                                 "0461 Scanning longer than 30 "
2673                                 "seconds.  Continuing initialization\n");
2674                 stat = 1;
2675                 goto finished;
2676         }
2677         if (time >= 15 * HZ && phba->link_state <= LPFC_LINK_DOWN) {
2678                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2679                                 "0465 Link down longer than 15 "
2680                                 "seconds.  Continuing initialization\n");
2681                 stat = 1;
2682                 goto finished;
2683         }
2684
2685         if (vport->port_state != LPFC_VPORT_READY)
2686                 goto finished;
2687         if (vport->num_disc_nodes || vport->fc_prli_sent)
2688                 goto finished;
2689         if (vport->fc_map_cnt == 0 && time < 2 * HZ)
2690                 goto finished;
2691         if ((phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) != 0)
2692                 goto finished;
2693
2694         stat = 1;
2695
2696 finished:
2697         spin_unlock_irq(shost->host_lock);
2698         return stat;
2699 }
2700
2701 /**
2702  * lpfc_host_attrib_init - Initialize SCSI host attributes on a FC port
2703  * @shost: pointer to SCSI host data structure.
2704  *
2705  * This routine initializes a given SCSI host attributes on a FC port. The
2706  * SCSI host can be either on top of a physical port or a virtual port.
2707  **/
2708 void lpfc_host_attrib_init(struct Scsi_Host *shost)
2709 {
2710         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2711         struct lpfc_hba   *phba = vport->phba;
2712         /*
2713          * Set fixed host attributes.  Must done after lpfc_sli_hba_setup().
2714          */
2715
2716         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
2717         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
2718         fc_host_supported_classes(shost) = FC_COS_CLASS3;
2719
2720         memset(fc_host_supported_fc4s(shost), 0,
2721                sizeof(fc_host_supported_fc4s(shost)));
2722         fc_host_supported_fc4s(shost)[2] = 1;
2723         fc_host_supported_fc4s(shost)[7] = 1;
2724
2725         lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
2726                                  sizeof fc_host_symbolic_name(shost));
2727
2728         fc_host_supported_speeds(shost) = 0;
2729         if (phba->lmt & LMT_10Gb)
2730                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT;
2731         if (phba->lmt & LMT_8Gb)
2732                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_8GBIT;
2733         if (phba->lmt & LMT_4Gb)
2734                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_4GBIT;
2735         if (phba->lmt & LMT_2Gb)
2736                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_2GBIT;
2737         if (phba->lmt & LMT_1Gb)
2738                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_1GBIT;
2739
2740         fc_host_maxframe_size(shost) =
2741                 (((uint32_t) vport->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
2742                 (uint32_t) vport->fc_sparam.cmn.bbRcvSizeLsb;
2743
2744         /* This value is also unchanging */
2745         memset(fc_host_active_fc4s(shost), 0,
2746                sizeof(fc_host_active_fc4s(shost)));
2747         fc_host_active_fc4s(shost)[2] = 1;
2748         fc_host_active_fc4s(shost)[7] = 1;
2749
2750         fc_host_max_npiv_vports(shost) = phba->max_vpi;
2751         spin_lock_irq(shost->host_lock);
2752         vport->load_flag &= ~FC_LOADING;
2753         spin_unlock_irq(shost->host_lock);
2754 }
2755
2756 /**
2757  * lpfc_stop_port_s3 - Stop SLI3 device port
2758  * @phba: pointer to lpfc hba data structure.
2759  *
2760  * This routine is invoked to stop an SLI3 device port, it stops the device
2761  * from generating interrupts and stops the device driver's timers for the
2762  * device.
2763  **/
2764 static void
2765 lpfc_stop_port_s3(struct lpfc_hba *phba)
2766 {
2767         /* Clear all interrupt enable conditions */
2768         writel(0, phba->HCregaddr);
2769         readl(phba->HCregaddr); /* flush */
2770         /* Clear all pending interrupts */
2771         writel(0xffffffff, phba->HAregaddr);
2772         readl(phba->HAregaddr); /* flush */
2773
2774         /* Reset some HBA SLI setup states */
2775         lpfc_stop_hba_timers(phba);
2776         phba->pport->work_port_events = 0;
2777 }
2778
2779 /**
2780  * lpfc_stop_port_s4 - Stop SLI4 device port
2781  * @phba: pointer to lpfc hba data structure.
2782  *
2783  * This routine is invoked to stop an SLI4 device port, it stops the device
2784  * from generating interrupts and stops the device driver's timers for the
2785  * device.
2786  **/
2787 static void
2788 lpfc_stop_port_s4(struct lpfc_hba *phba)
2789 {
2790         /* Reset some HBA SLI4 setup states */
2791         lpfc_stop_hba_timers(phba);
2792         phba->pport->work_port_events = 0;
2793         phba->sli4_hba.intr_enable = 0;
2794 }
2795
2796 /**
2797  * lpfc_stop_port - Wrapper function for stopping hba port
2798  * @phba: Pointer to HBA context object.
2799  *
2800  * This routine wraps the actual SLI3 or SLI4 hba stop port routine from
2801  * the API jump table function pointer from the lpfc_hba struct.
2802  **/
2803 void
2804 lpfc_stop_port(struct lpfc_hba *phba)
2805 {
2806         phba->lpfc_stop_port(phba);
2807 }
2808
2809 /**
2810  * lpfc_sli4_remove_dflt_fcf - Remove the driver default fcf record from the port.
2811  * @phba: pointer to lpfc hba data structure.
2812  *
2813  * This routine is invoked to remove the driver default fcf record from
2814  * the port.  This routine currently acts on FCF Index 0.
2815  *
2816  **/
2817 void
2818 lpfc_sli_remove_dflt_fcf(struct lpfc_hba *phba)
2819 {
2820         int rc = 0;
2821         LPFC_MBOXQ_t *mboxq;
2822         struct lpfc_mbx_del_fcf_tbl_entry *del_fcf_record;
2823         uint32_t mbox_tmo, req_len;
2824         uint32_t shdr_status, shdr_add_status;
2825
2826         mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2827         if (!mboxq) {
2828                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2829                         "2020 Failed to allocate mbox for ADD_FCF cmd\n");
2830                 return;
2831         }
2832
2833         req_len = sizeof(struct lpfc_mbx_del_fcf_tbl_entry) -
2834                   sizeof(struct lpfc_sli4_cfg_mhdr);
2835         rc = lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
2836                               LPFC_MBOX_OPCODE_FCOE_DELETE_FCF,
2837                               req_len, LPFC_SLI4_MBX_EMBED);
2838         /*
2839          * In phase 1, there is a single FCF index, 0.  In phase2, the driver
2840          * supports multiple FCF indices.
2841          */
2842         del_fcf_record = &mboxq->u.mqe.un.del_fcf_entry;
2843         bf_set(lpfc_mbx_del_fcf_tbl_count, del_fcf_record, 1);
2844         bf_set(lpfc_mbx_del_fcf_tbl_index, del_fcf_record,
2845                phba->fcf.current_rec.fcf_indx);
2846
2847         if (!phba->sli4_hba.intr_enable)
2848                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
2849         else {
2850                 mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
2851                 rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
2852         }
2853         /* The IOCTL status is embedded in the mailbox subheader. */
2854         shdr_status = bf_get(lpfc_mbox_hdr_status,
2855                              &del_fcf_record->header.cfg_shdr.response);
2856         shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
2857                                  &del_fcf_record->header.cfg_shdr.response);
2858         if (shdr_status || shdr_add_status || rc != MBX_SUCCESS) {
2859                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2860                                 "2516 DEL FCF of default FCF Index failed "
2861                                 "mbx status x%x, status x%x add_status x%x\n",
2862                                 rc, shdr_status, shdr_add_status);
2863         }
2864         if (rc != MBX_TIMEOUT)
2865                 mempool_free(mboxq, phba->mbox_mem_pool);
2866 }
2867
2868 /**
2869  * lpfc_fcf_redisc_wait_start_timer - Start fcf rediscover wait timer
2870  * @phba: Pointer to hba for which this call is being executed.
2871  *
2872  * This routine starts the timer waiting for the FCF rediscovery to complete.
2873  **/
2874 void
2875 lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *phba)
2876 {
2877         unsigned long fcf_redisc_wait_tmo =
2878                 (jiffies + msecs_to_jiffies(LPFC_FCF_REDISCOVER_WAIT_TMO));
2879         /* Start fcf rediscovery wait period timer */
2880         mod_timer(&phba->fcf.redisc_wait, fcf_redisc_wait_tmo);
2881         spin_lock_irq(&phba->hbalock);
2882         /* Allow action to new fcf asynchronous event */
2883         phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
2884         /* Mark the FCF rediscovery pending state */
2885         phba->fcf.fcf_flag |= FCF_REDISC_PEND;
2886         spin_unlock_irq(&phba->hbalock);
2887 }
2888
2889 /**
2890  * lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout
2891  * @ptr: Map to lpfc_hba data structure pointer.
2892  *
2893  * This routine is invoked when waiting for FCF table rediscover has been
2894  * timed out. If new FCF record(s) has (have) been discovered during the
2895  * wait period, a new FCF event shall be added to the FCOE async event
2896  * list, and then worker thread shall be waked up for processing from the
2897  * worker thread context.
2898  **/
2899 void
2900 lpfc_sli4_fcf_redisc_wait_tmo(unsigned long ptr)
2901 {
2902         struct lpfc_hba *phba = (struct lpfc_hba *)ptr;
2903
2904         /* Don't send FCF rediscovery event if timer cancelled */
2905         spin_lock_irq(&phba->hbalock);
2906         if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
2907                 spin_unlock_irq(&phba->hbalock);
2908                 return;
2909         }
2910         /* Clear FCF rediscovery timer pending flag */
2911         phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
2912         /* FCF rediscovery event to worker thread */
2913         phba->fcf.fcf_flag |= FCF_REDISC_EVT;
2914         spin_unlock_irq(&phba->hbalock);
2915         /* wake up worker thread */
2916         lpfc_worker_wake_up(phba);
2917 }
2918
2919 /**
2920  * lpfc_sli4_fw_cfg_check - Read the firmware config and verify FCoE support
2921  * @phba: pointer to lpfc hba data structure.
2922  *
2923  * This function uses the QUERY_FW_CFG mailbox command to determine if the
2924  * firmware loaded supports FCoE. A return of zero indicates that the mailbox
2925  * was successful and the firmware supports FCoE. Any other return indicates
2926  * a error. It is assumed that this function will be called before interrupts
2927  * are enabled.
2928  **/
2929 static int
2930 lpfc_sli4_fw_cfg_check(struct lpfc_hba *phba)
2931 {
2932         int rc = 0;
2933         LPFC_MBOXQ_t *mboxq;
2934         struct lpfc_mbx_query_fw_cfg *query_fw_cfg;
2935         uint32_t length;
2936         uint32_t shdr_status, shdr_add_status;
2937
2938         mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2939         if (!mboxq) {
2940                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2941                                 "2621 Failed to allocate mbox for "
2942                                 "query firmware config cmd\n");
2943                 return -ENOMEM;
2944         }
2945         query_fw_cfg = &mboxq->u.mqe.un.query_fw_cfg;
2946         length = (sizeof(struct lpfc_mbx_query_fw_cfg) -
2947                   sizeof(struct lpfc_sli4_cfg_mhdr));
2948         lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
2949                          LPFC_MBOX_OPCODE_QUERY_FW_CFG,
2950                          length, LPFC_SLI4_MBX_EMBED);
2951         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
2952         /* The IOCTL status is embedded in the mailbox subheader. */
2953         shdr_status = bf_get(lpfc_mbox_hdr_status,
2954                              &query_fw_cfg->header.cfg_shdr.response);
2955         shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
2956                                  &query_fw_cfg->header.cfg_shdr.response);
2957         if (shdr_status || shdr_add_status || rc != MBX_SUCCESS) {
2958                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2959                                 "2622 Query Firmware Config failed "
2960                                 "mbx status x%x, status x%x add_status x%x\n",
2961                                 rc, shdr_status, shdr_add_status);
2962                 return -EINVAL;
2963         }
2964         if (!bf_get(lpfc_function_mode_fcoe_i, query_fw_cfg)) {
2965                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
2966                                 "2623 FCoE Function not supported by firmware. "
2967                                 "Function mode = %08x\n",
2968                                 query_fw_cfg->function_mode);
2969                 return -EINVAL;
2970         }
2971         if (rc != MBX_TIMEOUT)
2972                 mempool_free(mboxq, phba->mbox_mem_pool);
2973         return 0;
2974 }
2975
2976 /**
2977  * lpfc_sli4_parse_latt_fault - Parse sli4 link-attention link fault code
2978  * @phba: pointer to lpfc hba data structure.
2979  * @acqe_link: pointer to the async link completion queue entry.
2980  *
2981  * This routine is to parse the SLI4 link-attention link fault code and
2982  * translate it into the base driver's read link attention mailbox command
2983  * status.
2984  *
2985  * Return: Link-attention status in terms of base driver's coding.
2986  **/
2987 static uint16_t
2988 lpfc_sli4_parse_latt_fault(struct lpfc_hba *phba,
2989                            struct lpfc_acqe_link *acqe_link)
2990 {
2991         uint16_t latt_fault;
2992
2993         switch (bf_get(lpfc_acqe_link_fault, acqe_link)) {
2994         case LPFC_ASYNC_LINK_FAULT_NONE:
2995         case LPFC_ASYNC_LINK_FAULT_LOCAL:
2996         case LPFC_ASYNC_LINK_FAULT_REMOTE:
2997                 latt_fault = 0;
2998                 break;
2999         default:
3000                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3001                                 "0398 Invalid link fault code: x%x\n",
3002                                 bf_get(lpfc_acqe_link_fault, acqe_link));
3003                 latt_fault = MBXERR_ERROR;
3004                 break;
3005         }
3006         return latt_fault;
3007 }
3008
3009 /**
3010  * lpfc_sli4_parse_latt_type - Parse sli4 link attention type
3011  * @phba: pointer to lpfc hba data structure.
3012  * @acqe_link: pointer to the async link completion queue entry.
3013  *
3014  * This routine is to parse the SLI4 link attention type and translate it
3015  * into the base driver's link attention type coding.
3016  *
3017  * Return: Link attention type in terms of base driver's coding.
3018  **/
3019 static uint8_t
3020 lpfc_sli4_parse_latt_type(struct lpfc_hba *phba,
3021                           struct lpfc_acqe_link *acqe_link)
3022 {
3023         uint8_t att_type;
3024
3025         switch (bf_get(lpfc_acqe_link_status, acqe_link)) {
3026         case LPFC_ASYNC_LINK_STATUS_DOWN:
3027         case LPFC_ASYNC_LINK_STATUS_LOGICAL_DOWN:
3028                 att_type = AT_LINK_DOWN;
3029                 break;
3030         case LPFC_ASYNC_LINK_STATUS_UP:
3031                 /* Ignore physical link up events - wait for logical link up */
3032                 att_type = AT_RESERVED;
3033                 break;
3034         case LPFC_ASYNC_LINK_STATUS_LOGICAL_UP:
3035                 att_type = AT_LINK_UP;
3036                 break;
3037         default:
3038                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3039                                 "0399 Invalid link attention type: x%x\n",
3040                                 bf_get(lpfc_acqe_link_status, acqe_link));
3041                 att_type = AT_RESERVED;
3042                 break;
3043         }
3044         return att_type;
3045 }
3046
3047 /**
3048  * lpfc_sli4_parse_latt_link_speed - Parse sli4 link-attention link speed
3049  * @phba: pointer to lpfc hba data structure.
3050  * @acqe_link: pointer to the async link completion queue entry.
3051  *
3052  * This routine is to parse the SLI4 link-attention link speed and translate
3053  * it into the base driver's link-attention link speed coding.
3054  *
3055  * Return: Link-attention link speed in terms of base driver's coding.
3056  **/
3057 static uint8_t
3058 lpfc_sli4_parse_latt_link_speed(struct lpfc_hba *phba,
3059                                 struct lpfc_acqe_link *acqe_link)
3060 {
3061         uint8_t link_speed;
3062
3063         switch (bf_get(lpfc_acqe_link_speed, acqe_link)) {
3064         case LPFC_ASYNC_LINK_SPEED_ZERO:
3065                 link_speed = LA_UNKNW_LINK;
3066                 break;
3067         case LPFC_ASYNC_LINK_SPEED_10MBPS:
3068                 link_speed = LA_UNKNW_LINK;
3069                 break;
3070         case LPFC_ASYNC_LINK_SPEED_100MBPS:
3071                 link_speed = LA_UNKNW_LINK;
3072                 break;
3073         case LPFC_ASYNC_LINK_SPEED_1GBPS:
3074                 link_speed = LA_1GHZ_LINK;
3075                 break;
3076         case LPFC_ASYNC_LINK_SPEED_10GBPS:
3077                 link_speed = LA_10GHZ_LINK;
3078                 break;
3079         default:
3080                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3081                                 "0483 Invalid link-attention link speed: x%x\n",
3082                                 bf_get(lpfc_acqe_link_speed, acqe_link));
3083                 link_speed = LA_UNKNW_LINK;
3084                 break;
3085         }
3086         return link_speed;
3087 }
3088
3089 /**
3090  * lpfc_sli4_async_link_evt - Process the asynchronous link event
3091  * @phba: pointer to lpfc hba data structure.
3092  * @acqe_link: pointer to the async link completion queue entry.
3093  *
3094  * This routine is to handle the SLI4 asynchronous link event.
3095  **/
3096 static void
3097 lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
3098                          struct lpfc_acqe_link *acqe_link)
3099 {
3100         struct lpfc_dmabuf *mp;
3101         LPFC_MBOXQ_t *pmb;
3102         MAILBOX_t *mb;
3103         READ_LA_VAR *la;
3104         uint8_t att_type;
3105
3106         att_type = lpfc_sli4_parse_latt_type(phba, acqe_link);
3107         if (att_type != AT_LINK_DOWN && att_type != AT_LINK_UP)
3108                 return;
3109         phba->fcoe_eventtag = acqe_link->event_tag;
3110         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
3111         if (!pmb) {
3112                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3113                                 "0395 The mboxq allocation failed\n");
3114                 return;
3115         }
3116         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
3117         if (!mp) {
3118                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3119                                 "0396 The lpfc_dmabuf allocation failed\n");
3120                 goto out_free_pmb;
3121         }
3122         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
3123         if (!mp->virt) {
3124                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3125                                 "0397 The mbuf allocation failed\n");
3126                 goto out_free_dmabuf;
3127         }
3128
3129         /* Cleanup any outstanding ELS commands */
3130         lpfc_els_flush_all_cmd(phba);
3131
3132         /* Block ELS IOCBs until we have done process link event */
3133         phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
3134
3135         /* Update link event statistics */
3136         phba->sli.slistat.link_event++;
3137
3138         /* Create pseudo lpfc_handle_latt mailbox command from link ACQE */
3139         lpfc_read_la(phba, pmb, mp);
3140         pmb->vport = phba->pport;
3141
3142         /* Parse and translate status field */
3143         mb = &pmb->u.mb;
3144         mb->mbxStatus = lpfc_sli4_parse_latt_fault(phba, acqe_link);
3145
3146         /* Parse and translate link attention fields */
3147         la = (READ_LA_VAR *) &pmb->u.mb.un.varReadLA;
3148         la->eventTag = acqe_link->event_tag;
3149         la->attType = att_type;
3150         la->UlnkSpeed = lpfc_sli4_parse_latt_link_speed(phba, acqe_link);
3151
3152         /* Fake the the following irrelvant fields */
3153         la->topology = TOPOLOGY_PT_PT;
3154         la->granted_AL_PA = 0;
3155         la->il = 0;
3156         la->pb = 0;
3157         la->fa = 0;
3158         la->mm = 0;
3159
3160         /* Keep the link status for extra SLI4 state machine reference */
3161         phba->sli4_hba.link_state.speed =
3162                                 bf_get(lpfc_acqe_link_speed, acqe_link);
3163         phba->sli4_hba.link_state.duplex =
3164                                 bf_get(lpfc_acqe_link_duplex, acqe_link);
3165         phba->sli4_hba.link_state.status =
3166                                 bf_get(lpfc_acqe_link_status, acqe_link);
3167         phba->sli4_hba.link_state.physical =
3168                                 bf_get(lpfc_acqe_link_physical, acqe_link);
3169         phba->sli4_hba.link_state.fault =
3170                                 bf_get(lpfc_acqe_link_fault, acqe_link);
3171         phba->sli4_hba.link_state.logical_speed =
3172                                 bf_get(lpfc_acqe_qos_link_speed, acqe_link);
3173
3174         /* Invoke the lpfc_handle_latt mailbox command callback function */
3175         lpfc_mbx_cmpl_read_la(phba, pmb);
3176
3177         return;
3178
3179 out_free_dmabuf:
3180         kfree(mp);
3181 out_free_pmb:
3182         mempool_free(pmb, phba->mbox_mem_pool);
3183 }
3184
3185 /**
3186  * lpfc_sli4_async_fcoe_evt - Process the asynchronous fcoe event
3187  * @phba: pointer to lpfc hba data structure.
3188  * @acqe_link: pointer to the async fcoe completion queue entry.
3189  *
3190  * This routine is to handle the SLI4 asynchronous fcoe event.
3191  **/
3192 static void
3193 lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
3194                          struct lpfc_acqe_fcoe *acqe_fcoe)
3195 {
3196         uint8_t event_type = bf_get(lpfc_acqe_fcoe_event_type, acqe_fcoe);
3197         int rc;
3198         struct lpfc_vport *vport;
3199         struct lpfc_nodelist *ndlp;
3200         struct Scsi_Host  *shost;
3201         uint32_t link_state;
3202         int active_vlink_present;
3203         struct lpfc_vport **vports;
3204         int i;
3205
3206         phba->fc_eventTag = acqe_fcoe->event_tag;
3207         phba->fcoe_eventtag = acqe_fcoe->event_tag;
3208         switch (event_type) {
3209         case LPFC_FCOE_EVENT_TYPE_NEW_FCF:
3210         case LPFC_FCOE_EVENT_TYPE_FCF_PARAM_MOD:
3211                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
3212                         "2546 New FCF found index 0x%x tag 0x%x\n",
3213                         acqe_fcoe->index,
3214                         acqe_fcoe->event_tag);
3215                 spin_lock_irq(&phba->hbalock);
3216                 if ((phba->fcf.fcf_flag & FCF_SCAN_DONE) ||
3217                     (phba->hba_flag & FCF_DISC_INPROGRESS)) {
3218                         /*
3219                          * If the current FCF is in discovered state or
3220                          * FCF discovery is in progress, do nothing.
3221                          */
3222                         spin_unlock_irq(&phba->hbalock);
3223                         break;
3224                 }
3225                 if (phba->fcf.fcf_flag & FCF_REDISC_EVT) {
3226                         /*
3227                          * If fast FCF failover rescan event is pending,
3228                          * do nothing.
3229                          */
3230                         spin_unlock_irq(&phba->hbalock);
3231                         break;
3232                 }
3233                 spin_unlock_irq(&phba->hbalock);
3234
3235                 /* Read the FCF table and re-discover SAN. */
3236                 rc = lpfc_sli4_read_fcf_record(phba, LPFC_FCOE_FCF_GET_FIRST);
3237                 if (rc)
3238                         lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
3239                                         "2547 Read FCF record failed 0x%x\n",
3240                                         rc);
3241                 break;
3242
3243         case LPFC_FCOE_EVENT_TYPE_FCF_TABLE_FULL:
3244                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3245                         "2548 FCF Table full count 0x%x tag 0x%x\n",
3246                         bf_get(lpfc_acqe_fcoe_fcf_count, acqe_fcoe),
3247                         acqe_fcoe->event_tag);
3248                 break;
3249
3250         case LPFC_FCOE_EVENT_TYPE_FCF_DEAD:
3251                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
3252                         "2549 FCF disconnected from network index 0x%x"
3253                         " tag 0x%x\n", acqe_fcoe->index,
3254                         acqe_fcoe->event_tag);
3255                 /* If the event is not for currently used fcf do nothing */
3256                 if (phba->fcf.current_rec.fcf_indx != acqe_fcoe->index)
3257                         break;
3258                 /*
3259                  * Currently, driver support only one FCF - so treat this as
3260                  * a link down, but save the link state because we don't want
3261                  * it to be changed to Link Down unless it is already down.
3262                  */
3263                 link_state = phba->link_state;
3264                 lpfc_linkdown(phba);
3265                 phba->link_state = link_state;
3266                 /* Unregister FCF if no devices connected to it */
3267                 lpfc_unregister_unused_fcf(phba);
3268                 break;
3269         case LPFC_FCOE_EVENT_TYPE_CVL:
3270                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
3271                         "2718 Clear Virtual Link Received for VPI 0x%x"
3272                         " tag 0x%x\n", acqe_fcoe->index, acqe_fcoe->event_tag);
3273                 vport = lpfc_find_vport_by_vpid(phba,
3274                                 acqe_fcoe->index - phba->vpi_base);
3275                 if (!vport)
3276                         break;
3277                 ndlp = lpfc_findnode_did(vport, Fabric_DID);
3278                 if (!ndlp)
3279                         break;
3280                 shost = lpfc_shost_from_vport(vport);
3281                 if (phba->pport->port_state <= LPFC_FLOGI)
3282                         break;
3283                 /* If virtual link is not yet instantiated ignore CVL */
3284                 if (vport->port_state <= LPFC_FDISC)
3285                         break;
3286
3287                 lpfc_linkdown_port(vport);
3288                 lpfc_cleanup_pending_mbox(vport);
3289                 spin_lock_irq(shost->host_lock);
3290                 vport->fc_flag |= FC_VPORT_CVL_RCVD;
3291                 spin_unlock_irq(shost->host_lock);
3292                 active_vlink_present = 0;
3293
3294                 vports = lpfc_create_vport_work_array(phba);
3295                 if (vports) {
3296                         for (i = 0; i <= phba->max_vports && vports[i] != NULL;
3297                                         i++) {
3298                                 if ((!(vports[i]->fc_flag &
3299                                         FC_VPORT_CVL_RCVD)) &&
3300                                         (vports[i]->port_state > LPFC_FDISC)) {
3301                                         active_vlink_present = 1;
3302                                         break;
3303                                 }
3304                         }
3305                         lpfc_destroy_vport_work_array(phba, vports);
3306                 }
3307
3308                 if (active_vlink_present) {
3309                         /*
3310                          * If there are other active VLinks present,
3311                          * re-instantiate the Vlink using FDISC.
3312                          */
3313                         mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
3314                         spin_lock_irq(shost->host_lock);
3315                         ndlp->nlp_flag |= NLP_DELAY_TMO;
3316                         spin_unlock_irq(shost->host_lock);
3317                         ndlp->nlp_last_elscmd = ELS_CMD_FDISC;
3318                         vport->port_state = LPFC_FDISC;
3319                 } else {
3320                         /*
3321                          * Otherwise, we request port to rediscover
3322                          * the entire FCF table for a fast recovery
3323                          * from possible case that the current FCF
3324                          * is no longer valid.
3325                          */
3326                         rc = lpfc_sli4_redisc_fcf_table(phba);
3327                         if (rc)
3328                                 /*
3329                                  * Last resort will be re-try on the
3330                                  * the current registered FCF entry.
3331                                  */
3332                                 lpfc_retry_pport_discovery(phba);
3333                 }
3334                 break;
3335         default:
3336                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3337                         "0288 Unknown FCoE event type 0x%x event tag "
3338                         "0x%x\n", event_type, acqe_fcoe->event_tag);
3339                 break;
3340         }
3341 }
3342
3343 /**
3344  * lpfc_sli4_async_dcbx_evt - Process the asynchronous dcbx event
3345  * @phba: pointer to lpfc hba data structure.
3346  * @acqe_link: pointer to the async dcbx completion queue entry.
3347  *
3348  * This routine is to handle the SLI4 asynchronous dcbx event.
3349  **/
3350 static void
3351 lpfc_sli4_async_dcbx_evt(struct lpfc_hba *phba,
3352                          struct lpfc_acqe_dcbx *acqe_dcbx)
3353 {
3354         phba->fc_eventTag = acqe_dcbx->event_tag;
3355         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3356                         "0290 The SLI4 DCBX asynchronous event is not "
3357                         "handled yet\n");
3358 }
3359
3360 /**
3361  * lpfc_sli4_async_event_proc - Process all the pending asynchronous event
3362  * @phba: pointer to lpfc hba data structure.
3363  *
3364  * This routine is invoked by the worker thread to process all the pending
3365  * SLI4 asynchronous events.
3366  **/
3367 void lpfc_sli4_async_event_proc(struct lpfc_hba *phba)
3368 {
3369         struct lpfc_cq_event *cq_event;
3370
3371         /* First, declare the async event has been handled */
3372         spin_lock_irq(&phba->hbalock);
3373         phba->hba_flag &= ~ASYNC_EVENT;
3374         spin_unlock_irq(&phba->hbalock);
3375         /* Now, handle all the async events */
3376         while (!list_empty(&phba->sli4_hba.sp_asynce_work_queue)) {
3377                 /* Get the first event from the head of the event queue */
3378                 spin_lock_irq(&phba->hbalock);
3379                 list_remove_head(&phba->sli4_hba.sp_asynce_work_queue,
3380                                  cq_event, struct lpfc_cq_event, list);
3381                 spin_unlock_irq(&phba->hbalock);
3382                 /* Process the asynchronous event */
3383                 switch (bf_get(lpfc_trailer_code, &cq_event->cqe.mcqe_cmpl)) {
3384                 case LPFC_TRAILER_CODE_LINK:
3385                         lpfc_sli4_async_link_evt(phba,
3386                                                  &cq_event->cqe.acqe_link);
3387                         break;
3388                 case LPFC_TRAILER_CODE_FCOE:
3389                         lpfc_sli4_async_fcoe_evt(phba,
3390                                                  &cq_event->cqe.acqe_fcoe);
3391                         break;
3392                 case LPFC_TRAILER_CODE_DCBX:
3393                         lpfc_sli4_async_dcbx_evt(phba,
3394                                                  &cq_event->cqe.acqe_dcbx);
3395                         break;
3396                 default:
3397                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
3398                                         "1804 Invalid asynchrous event code: "
3399                                         "x%x\n", bf_get(lpfc_trailer_code,
3400                                         &cq_event->cqe.mcqe_cmpl));
3401                         break;
3402                 }
3403                 /* Free the completion event processed to the free pool */
3404                 lpfc_sli4_cq_event_release(phba, cq_event);
3405         }
3406 }
3407
3408 /**
3409  * lpfc_sli4_fcf_redisc_event_proc - Process fcf table rediscovery event
3410  * @phba: pointer to lpfc hba data structure.
3411  *
3412  * This routine is invoked by the worker thread to process FCF table
3413  * rediscovery pending completion event.
3414  **/
3415 void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *phba)
3416 {
3417         int rc;
3418
3419         spin_lock_irq(&phba->hbalock);
3420         /* Clear FCF rediscovery timeout event */
3421         phba->fcf.fcf_flag &= ~FCF_REDISC_EVT;
3422         /* Clear driver fast failover FCF record flag */
3423         phba->fcf.failover_rec.flag = 0;
3424         /* Set state for FCF fast failover */
3425         phba->fcf.fcf_flag |= FCF_REDISC_FOV;
3426         spin_unlock_irq(&phba->hbalock);
3427
3428         /* Scan FCF table from the first entry to re-discover SAN */
3429         rc = lpfc_sli4_read_fcf_record(phba, LPFC_FCOE_FCF_GET_FIRST);
3430         if (rc)
3431                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
3432                                 "2747 Post FCF rediscovery read FCF record "
3433                                 "failed 0x%x\n", rc);
3434 }
3435
3436 /**
3437  * lpfc_api_table_setup - Set up per hba pci-device group func api jump table
3438  * @phba: pointer to lpfc hba data structure.
3439  * @dev_grp: The HBA PCI-Device group number.
3440  *
3441  * This routine is invoked to set up the per HBA PCI-Device group function
3442  * API jump table entries.
3443  *
3444  * Return: 0 if success, otherwise -ENODEV
3445  **/
3446 int
3447 lpfc_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
3448 {
3449         int rc;
3450
3451         /* Set up lpfc PCI-device group */
3452         phba->pci_dev_grp = dev_grp;
3453
3454         /* The LPFC_PCI_DEV_OC uses SLI4 */
3455         if (dev_grp == LPFC_PCI_DEV_OC)
3456                 phba->sli_rev = LPFC_SLI_REV4;
3457
3458         /* Set up device INIT API function jump table */
3459         rc = lpfc_init_api_table_setup(phba, dev_grp);
3460         if (rc)
3461                 return -ENODEV;
3462         /* Set up SCSI API function jump table */
3463         rc = lpfc_scsi_api_table_setup(phba, dev_grp);
3464         if (rc)
3465                 return -ENODEV;
3466         /* Set up SLI API function jump table */
3467         rc = lpfc_sli_api_table_setup(phba, dev_grp);
3468         if (rc)
3469                 return -ENODEV;
3470         /* Set up MBOX API function jump table */
3471         rc = lpfc_mbox_api_table_setup(phba, dev_grp);
3472         if (rc)
3473                 return -ENODEV;
3474
3475         return 0;
3476 }
3477
3478 /**
3479  * lpfc_log_intr_mode - Log the active interrupt mode
3480  * @phba: pointer to lpfc hba data structure.
3481  * @intr_mode: active interrupt mode adopted.
3482  *
3483  * This routine it invoked to log the currently used active interrupt mode
3484  * to the device.
3485  **/
3486 static void lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode)
3487 {
3488         switch (intr_mode) {
3489         case 0:
3490                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3491                                 "0470 Enable INTx interrupt mode.\n");
3492                 break;
3493         case 1:
3494                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3495                                 "0481 Enabled MSI interrupt mode.\n");
3496                 break;
3497         case 2:
3498                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3499                                 "0480 Enabled MSI-X interrupt mode.\n");
3500                 break;
3501         default:
3502                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3503                                 "0482 Illegal interrupt mode.\n");
3504                 break;
3505         }
3506         return;
3507 }
3508
3509 /**
3510  * lpfc_enable_pci_dev - Enable a generic PCI device.
3511  * @phba: pointer to lpfc hba data structure.
3512  *
3513  * This routine is invoked to enable the PCI device that is common to all
3514  * PCI devices.
3515  *
3516  * Return codes
3517  *      0 - successful
3518  *      other values - error
3519  **/
3520 static int
3521 lpfc_enable_pci_dev(struct lpfc_hba *phba)
3522 {
3523         struct pci_dev *pdev;
3524         int bars;
3525
3526         /* Obtain PCI device reference */
3527         if (!phba->pcidev)
3528                 goto out_error;
3529         else
3530                 pdev = phba->pcidev;
3531         /* Select PCI BARs */
3532         bars = pci_select_bars(pdev, IORESOURCE_MEM);
3533         /* Enable PCI device */
3534         if (pci_enable_device_mem(pdev))
3535                 goto out_error;
3536         /* Request PCI resource for the device */
3537         if (pci_request_selected_regions(pdev, bars, LPFC_DRIVER_NAME))
3538                 goto out_disable_device;
3539         /* Set up device as PCI master and save state for EEH */
3540         pci_set_master(pdev);
3541         pci_try_set_mwi(pdev);
3542         pci_save_state(pdev);
3543
3544         return 0;
3545
3546 out_disable_device:
3547         pci_disable_device(pdev);
3548 out_error:
3549         return -ENODEV;
3550 }
3551
3552 /**
3553  * lpfc_disable_pci_dev - Disable a generic PCI device.
3554  * @phba: pointer to lpfc hba data structure.
3555  *
3556  * This routine is invoked to disable the PCI device that is common to all
3557  * PCI devices.
3558  **/
3559 static void
3560 lpfc_disable_pci_dev(struct lpfc_hba *phba)
3561 {
3562         struct pci_dev *pdev;
3563         int bars;
3564
3565         /* Obtain PCI device reference */
3566         if (!phba->pcidev)
3567                 return;
3568         else
3569                 pdev = phba->pcidev;
3570         /* Select PCI BARs */
3571         bars = pci_select_bars(pdev, IORESOURCE_MEM);
3572         /* Release PCI resource and disable PCI device */
3573         pci_release_selected_regions(pdev, bars);
3574         pci_disable_device(pdev);
3575         /* Null out PCI private reference to driver */
3576         pci_set_drvdata(pdev, NULL);
3577
3578         return;
3579 }
3580
3581 /**
3582  * lpfc_reset_hba - Reset a hba
3583  * @phba: pointer to lpfc hba data structure.
3584  *
3585  * This routine is invoked to reset a hba device. It brings the HBA
3586  * offline, performs a board restart, and then brings the board back
3587  * online. The lpfc_offline calls lpfc_sli_hba_down which will clean up
3588  * on outstanding mailbox commands.
3589  **/
3590 void
3591 lpfc_reset_hba(struct lpfc_hba *phba)
3592 {
3593         /* If resets are disabled then set error state and return. */
3594         if (!phba->cfg_enable_hba_reset) {
3595                 phba->link_state = LPFC_HBA_ERROR;
3596                 return;
3597         }
3598         lpfc_offline_prep(phba);
3599         lpfc_offline(phba);
3600         lpfc_sli_brdrestart(phba);
3601         lpfc_online(phba);
3602         lpfc_unblock_mgmt_io(phba);
3603 }
3604
3605 /**
3606  * lpfc_sli_driver_resource_setup - Setup driver internal resources for SLI3 dev.
3607  * @phba: pointer to lpfc hba data structure.
3608  *
3609  * This routine is invoked to set up the driver internal resources specific to
3610  * support the SLI-3 HBA device it attached to.
3611  *
3612  * Return codes
3613  *      0 - successful
3614  *      other values - error
3615  **/
3616 static int
3617 lpfc_sli_driver_resource_setup(struct lpfc_hba *phba)
3618 {
3619         struct lpfc_sli *psli;
3620
3621         /*
3622          * Initialize timers used by driver
3623          */
3624
3625         /* Heartbeat timer */
3626         init_timer(&phba->hb_tmofunc);
3627         phba->hb_tmofunc.function = lpfc_hb_timeout;
3628         phba->hb_tmofunc.data = (unsigned long)phba;
3629
3630         psli = &phba->sli;
3631         /* MBOX heartbeat timer */
3632         init_timer(&psli->mbox_tmo);
3633         psli->mbox_tmo.function = lpfc_mbox_timeout;
3634         psli->mbox_tmo.data = (unsigned long) phba;
3635         /* FCP polling mode timer */
3636         init_timer(&phba->fcp_poll_timer);
3637         phba->fcp_poll_timer.function = lpfc_poll_timeout;
3638         phba->fcp_poll_timer.data = (unsigned long) phba;
3639         /* Fabric block timer */
3640         init_timer(&phba->fabric_block_timer);
3641         phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
3642         phba->fabric_block_timer.data = (unsigned long) phba;
3643         /* EA polling mode timer */
3644         init_timer(&phba->eratt_poll);
3645         phba->eratt_poll.function = lpfc_poll_eratt;
3646         phba->eratt_poll.data = (unsigned long) phba;
3647
3648         /* Host attention work mask setup */
3649         phba->work_ha_mask = (HA_ERATT | HA_MBATT | HA_LATT);
3650         phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4));
3651
3652         /* Get all the module params for configuring this host */
3653         lpfc_get_cfgparam(phba);
3654         /*
3655          * Since the sg_tablesize is module parameter, the sg_dma_buf_size
3656          * used to create the sg_dma_buf_pool must be dynamically calculated.
3657          * 2 segments are added since the IOCB needs a command and response bde.
3658          */
3659         phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
3660                 sizeof(struct fcp_rsp) +
3661                         ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
3662
3663         if (phba->cfg_enable_bg) {
3664                 phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SEG_CNT;
3665                 phba->cfg_sg_dma_buf_size +=
3666                         phba->cfg_prot_sg_seg_cnt * sizeof(struct ulp_bde64);
3667         }
3668
3669         /* Also reinitialize the host templates with new values. */
3670         lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
3671         lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
3672
3673         phba->max_vpi = LPFC_MAX_VPI;
3674         /* This will be set to correct value after config_port mbox */
3675         phba->max_vports = 0;
3676
3677         /*
3678          * Initialize the SLI Layer to run with lpfc HBAs.
3679          */
3680         lpfc_sli_setup(phba);
3681         lpfc_sli_queue_setup(phba);
3682
3683         /* Allocate device driver memory */
3684         if (lpfc_mem_alloc(phba, BPL_ALIGN_SZ))
3685                 return -ENOMEM;
3686
3687         return 0;
3688 }
3689
3690 /**
3691  * lpfc_sli_driver_resource_unset - Unset drvr internal resources for SLI3 dev
3692  * @phba: pointer to lpfc hba data structure.
3693  *
3694  * This routine is invoked to unset the driver internal resources set up
3695  * specific for supporting the SLI-3 HBA device it attached to.
3696  **/
3697 static void
3698 lpfc_sli_driver_resource_unset(struct lpfc_hba *phba)
3699 {
3700         /* Free device driver memory allocated */
3701         lpfc_mem_free_all(phba);
3702
3703         return;
3704 }
3705
3706 /**
3707  * lpfc_sli4_driver_resource_setup - Setup drvr internal resources for SLI4 dev
3708  * @phba: pointer to lpfc hba data structure.
3709  *
3710  * This routine is invoked to set up the driver internal resources specific to
3711  * support the SLI-4 HBA device it attached to.
3712  *
3713  * Return codes
3714  *      0 - successful
3715  *      other values - error
3716  **/
3717 static int
3718 lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
3719 {
3720         struct lpfc_sli *psli;
3721         LPFC_MBOXQ_t *mboxq;
3722         int rc, i, hbq_count, buf_size, dma_buf_size, max_buf_size;
3723         uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0};
3724         struct lpfc_mqe *mqe;
3725
3726         /* Before proceed, wait for POST done and device ready */
3727         rc = lpfc_sli4_post_status_check(phba);
3728         if (rc)
3729                 return -ENODEV;
3730
3731         /*
3732          * Initialize timers used by driver
3733          */
3734
3735         /* Heartbeat timer */
3736         init_timer(&phba->hb_tmofunc);
3737         phba->hb_tmofunc.function = lpfc_hb_timeout;
3738         phba->hb_tmofunc.data = (unsigned long)phba;
3739
3740         psli = &phba->sli;
3741         /* MBOX heartbeat timer */
3742         init_timer(&psli->mbox_tmo);
3743         psli->mbox_tmo.function = lpfc_mbox_timeout;
3744         psli->mbox_tmo.data = (unsigned long) phba;
3745         /* Fabric block timer */
3746         init_timer(&phba->fabric_block_timer);
3747         phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
3748         phba->fabric_block_timer.data = (unsigned long) phba;
3749         /* EA polling mode timer */
3750         init_timer(&phba->eratt_poll);
3751         phba->eratt_poll.function = lpfc_poll_eratt;
3752         phba->eratt_poll.data = (unsigned long) phba;
3753         /* FCF rediscover timer */
3754         init_timer(&phba->fcf.redisc_wait);
3755         phba->fcf.redisc_wait.function = lpfc_sli4_fcf_redisc_wait_tmo;
3756         phba->fcf.redisc_wait.data = (unsigned long)phba;
3757
3758         /*
3759          * We need to do a READ_CONFIG mailbox command here before
3760          * calling lpfc_get_cfgparam. For VFs this will report the
3761          * MAX_XRI, MAX_VPI, MAX_RPI, MAX_IOCB, and MAX_VFI settings.
3762          * All of the resources allocated
3763          * for this Port are tied to these values.
3764          */
3765         /* Get all the module params for configuring this host */
3766         lpfc_get_cfgparam(phba);
3767         phba->max_vpi = LPFC_MAX_VPI;
3768         /* This will be set to correct value after the read_config mbox */
3769         phba->max_vports = 0;
3770
3771         /* Program the default value of vlan_id and fc_map */
3772         phba->valid_vlan = 0;
3773         phba->fc_map[0] = LPFC_FCOE_FCF_MAP0;
3774         phba->fc_map[1] = LPFC_FCOE_FCF_MAP1;
3775         phba->fc_map[2] = LPFC_FCOE_FCF_MAP2;
3776
3777         /*
3778          * Since the sg_tablesize is module parameter, the sg_dma_buf_size
3779          * used to create the sg_dma_buf_pool must be dynamically calculated.
3780          * 2 segments are added since the IOCB needs a command and response bde.
3781          * To insure that the scsi sgl does not cross a 4k page boundary only
3782          * sgl sizes of must be a power of 2.
3783          */
3784         buf_size = (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp) +
3785                     ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct sli4_sge)));
3786         /* Feature Level 1 hardware is limited to 2 pages */
3787         if ((bf_get(lpfc_sli_intf_featurelevel1, &phba->sli4_hba.sli_intf) ==
3788              LPFC_SLI_INTF_FEATURELEVEL1_1))
3789                 max_buf_size = LPFC_SLI4_FL1_MAX_BUF_SIZE;
3790         else
3791                 max_buf_size = LPFC_SLI4_MAX_BUF_SIZE;
3792         for (dma_buf_size = LPFC_SLI4_MIN_BUF_SIZE;
3793              dma_buf_size < max_buf_size && buf_size > dma_buf_size;
3794              dma_buf_size = dma_buf_size << 1)
3795                 ;
3796         if (dma_buf_size == max_buf_size)
3797                 phba->cfg_sg_seg_cnt = (dma_buf_size -
3798                         sizeof(struct fcp_cmnd) - sizeof(struct fcp_rsp) -
3799                         (2 * sizeof(struct sli4_sge))) /
3800                                 sizeof(struct sli4_sge);
3801         phba->cfg_sg_dma_buf_size = dma_buf_size;
3802
3803         /* Initialize buffer queue management fields */
3804         hbq_count = lpfc_sli_hbq_count();
3805         for (i = 0; i < hbq_count; ++i)
3806                 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
3807         INIT_LIST_HEAD(&phba->rb_pend_list);
3808         phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_sli4_rb_alloc;
3809         phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_sli4_rb_free;
3810
3811         /*
3812          * Initialize the SLI Layer to run with lpfc SLI4 HBAs.
3813          */
3814         /* Initialize the Abort scsi buffer list used by driver */
3815         spin_lock_init(&phba->sli4_hba.abts_scsi_buf_list_lock);
3816         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_scsi_buf_list);
3817         /* This abort list used by worker thread */
3818         spin_lock_init(&phba->sli4_hba.abts_sgl_list_lock);
3819
3820         /*
3821          * Initialize dirver internal slow-path work queues
3822          */
3823
3824         /* Driver internel slow-path CQ Event pool */
3825         INIT_LIST_HEAD(&phba->sli4_hba.sp_cqe_event_pool);
3826         /* Response IOCB work queue list */
3827         INIT_LIST_HEAD(&phba->sli4_hba.sp_queue_event);
3828         /* Asynchronous event CQ Event work queue list */
3829         INIT_LIST_HEAD(&phba->sli4_hba.sp_asynce_work_queue);
3830         /* Fast-path XRI aborted CQ Event work queue list */
3831         INIT_LIST_HEAD(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue);
3832         /* Slow-path XRI aborted CQ Event work queue list */
3833         INIT_LIST_HEAD(&phba->sli4_hba.sp_els_xri_aborted_work_queue);
3834         /* Receive queue CQ Event work queue list */
3835         INIT_LIST_HEAD(&phba->sli4_hba.sp_unsol_work_queue);
3836
3837         /* Initialize the driver internal SLI layer lists. */
3838         lpfc_sli_setup(phba);
3839         lpfc_sli_queue_setup(phba);
3840
3841         /* Allocate device driver memory */
3842         rc = lpfc_mem_alloc(phba, SGL_ALIGN_SZ);
3843         if (rc)
3844                 return -ENOMEM;
3845
3846         /* Create the bootstrap mailbox command */
3847         rc = lpfc_create_bootstrap_mbox(phba);
3848         if (unlikely(rc))
3849                 goto out_free_mem;
3850
3851         /* Set up the host's endian order with the device. */
3852         rc = lpfc_setup_endian_order(phba);
3853         if (unlikely(rc))
3854                 goto out_free_bsmbx;
3855
3856         rc = lpfc_sli4_fw_cfg_check(phba);
3857         if (unlikely(rc))
3858                 goto out_free_bsmbx;
3859
3860         /* Set up the hba's configuration parameters. */
3861         rc = lpfc_sli4_read_config(phba);
3862         if (unlikely(rc))
3863                 goto out_free_bsmbx;
3864
3865         /* Perform a function reset */
3866         rc = lpfc_pci_function_reset(phba);
3867         if (unlikely(rc))
3868                 goto out_free_bsmbx;
3869
3870         /* Create all the SLI4 queues */
3871         rc = lpfc_sli4_queue_create(phba);
3872         if (rc)
3873                 goto out_free_bsmbx;
3874
3875         /* Create driver internal CQE event pool */
3876         rc = lpfc_sli4_cq_event_pool_create(phba);
3877         if (rc)
3878                 goto out_destroy_queue;
3879
3880         /* Initialize and populate the iocb list per host */
3881         rc = lpfc_init_sgl_list(phba);
3882         if (rc) {
3883                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3884                                 "1400 Failed to initialize sgl list.\n");
3885                 goto out_destroy_cq_event_pool;
3886         }
3887         rc = lpfc_init_active_sgl_array(phba);
3888         if (rc) {
3889                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3890                                 "1430 Failed to initialize sgl list.\n");
3891                 goto out_free_sgl_list;
3892         }
3893
3894         rc = lpfc_sli4_init_rpi_hdrs(phba);
3895         if (rc) {
3896                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3897                                 "1432 Failed to initialize rpi headers.\n");
3898                 goto out_free_active_sgl;
3899         }
3900
3901         phba->sli4_hba.fcp_eq_hdl = kzalloc((sizeof(struct lpfc_fcp_eq_hdl) *
3902                                     phba->cfg_fcp_eq_count), GFP_KERNEL);
3903         if (!phba->sli4_hba.fcp_eq_hdl) {
3904                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3905                                 "2572 Failed allocate memory for fast-path "
3906                                 "per-EQ handle array\n");
3907                 goto out_remove_rpi_hdrs;
3908         }
3909
3910         phba->sli4_hba.msix_entries = kzalloc((sizeof(struct msix_entry) *
3911                                       phba->sli4_hba.cfg_eqn), GFP_KERNEL);
3912         if (!phba->sli4_hba.msix_entries) {
3913                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3914                                 "2573 Failed allocate memory for msi-x "
3915                                 "interrupt vector entries\n");
3916                 goto out_free_fcp_eq_hdl;
3917         }
3918
3919         mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
3920                                                        GFP_KERNEL);
3921         if (!mboxq) {
3922                 rc = -ENOMEM;
3923                 goto out_free_fcp_eq_hdl;
3924         }
3925
3926         /* Get the Supported Pages. It is always available. */
3927         lpfc_supported_pages(mboxq);
3928         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
3929         if (unlikely(rc)) {
3930                 rc = -EIO;
3931                 mempool_free(mboxq, phba->mbox_mem_pool);
3932                 goto out_free_fcp_eq_hdl;
3933         }
3934
3935         mqe = &mboxq->u.mqe;
3936         memcpy(&pn_page[0], ((uint8_t *)&mqe->un.supp_pages.word3),
3937                LPFC_MAX_SUPPORTED_PAGES);
3938         for (i = 0; i < LPFC_MAX_SUPPORTED_PAGES; i++) {
3939                 switch (pn_page[i]) {
3940                 case LPFC_SLI4_PARAMETERS:
3941                         phba->sli4_hba.pc_sli4_params.supported = 1;
3942                         break;
3943                 default:
3944                         break;
3945                 }
3946         }
3947
3948         /* Read the port's SLI4 Parameters capabilities if supported. */
3949         if (phba->sli4_hba.pc_sli4_params.supported)
3950                 rc = lpfc_pc_sli4_params_get(phba, mboxq);
3951         mempool_free(mboxq, phba->mbox_mem_pool);
3952         if (rc) {
3953                 rc = -EIO;
3954                 goto out_free_fcp_eq_hdl;
3955         }
3956         return rc;
3957
3958 out_free_fcp_eq_hdl:
3959         kfree(phba->sli4_hba.fcp_eq_hdl);
3960 out_remove_rpi_hdrs:
3961         lpfc_sli4_remove_rpi_hdrs(phba);
3962 out_free_active_sgl:
3963         lpfc_free_active_sgl(phba);
3964 out_free_sgl_list:
3965         lpfc_free_sgl_list(phba);
3966 out_destroy_cq_event_pool:
3967         lpfc_sli4_cq_event_pool_destroy(phba);
3968 out_destroy_queue:
3969         lpfc_sli4_queue_destroy(phba);
3970 out_free_bsmbx:
3971         lpfc_destroy_bootstrap_mbox(phba);
3972 out_free_mem:
3973         lpfc_mem_free(phba);
3974         return rc;
3975 }
3976
3977 /**
3978  * lpfc_sli4_driver_resource_unset - Unset drvr internal resources for SLI4 dev
3979  * @phba: pointer to lpfc hba data structure.
3980  *
3981  * This routine is invoked to unset the driver internal resources set up
3982  * specific for supporting the SLI-4 HBA device it attached to.
3983  **/
3984 static void
3985 lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
3986 {
3987         struct lpfc_fcf_conn_entry *conn_entry, *next_conn_entry;
3988
3989         /* unregister default FCFI from the HBA */
3990         lpfc_sli4_fcfi_unreg(phba, phba->fcf.fcfi);
3991
3992         /* Free the default FCR table */
3993         lpfc_sli_remove_dflt_fcf(phba);
3994
3995         /* Free memory allocated for msi-x interrupt vector entries */
3996         kfree(phba->sli4_hba.msix_entries);
3997
3998         /* Free memory allocated for fast-path work queue handles */
3999         kfree(phba->sli4_hba.fcp_eq_hdl);
4000
4001         /* Free the allocated rpi headers. */
4002         lpfc_sli4_remove_rpi_hdrs(phba);
4003         lpfc_sli4_remove_rpis(phba);
4004
4005         /* Free the ELS sgl list */
4006         lpfc_free_active_sgl(phba);
4007         lpfc_free_sgl_list(phba);
4008
4009         /* Free the SCSI sgl management array */
4010         kfree(phba->sli4_hba.lpfc_scsi_psb_array);
4011
4012         /* Free the SLI4 queues */
4013         lpfc_sli4_queue_destroy(phba);
4014
4015         /* Free the completion queue EQ event pool */
4016         lpfc_sli4_cq_event_release_all(phba);
4017         lpfc_sli4_cq_event_pool_destroy(phba);
4018
4019         /* Reset SLI4 HBA FCoE function */
4020         lpfc_pci_function_reset(phba);
4021
4022         /* Free the bsmbx region. */
4023         lpfc_destroy_bootstrap_mbox(phba);
4024
4025         /* Free the SLI Layer memory with SLI4 HBAs */
4026         lpfc_mem_free_all(phba);
4027
4028         /* Free the current connect table */
4029         list_for_each_entry_safe(conn_entry, next_conn_entry,
4030                 &phba->fcf_conn_rec_list, list) {
4031                 list_del_init(&conn_entry->list);
4032                 kfree(conn_entry);
4033         }
4034
4035         return;
4036 }
4037
4038 /**
4039  * lpfc_init_api_table_setup - Set up init api fucntion jump table
4040  * @phba: The hba struct for which this call is being executed.
4041  * @dev_grp: The HBA PCI-Device group number.
4042  *
4043  * This routine sets up the device INIT interface API function jump table
4044  * in @phba struct.
4045  *
4046  * Returns: 0 - success, -ENODEV - failure.
4047  **/
4048 int
4049 lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
4050 {
4051         phba->lpfc_hba_init_link = lpfc_hba_init_link;
4052         phba->lpfc_hba_down_link = lpfc_hba_down_link;
4053         switch (dev_grp) {
4054         case LPFC_PCI_DEV_LP:
4055                 phba->lpfc_hba_down_post = lpfc_hba_down_post_s3;
4056                 phba->lpfc_handle_eratt = lpfc_handle_eratt_s3;
4057                 phba->lpfc_stop_port = lpfc_stop_port_s3;
4058                 break;
4059         case LPFC_PCI_DEV_OC:
4060                 phba->lpfc_hba_down_post = lpfc_hba_down_post_s4;
4061                 phba->lpfc_handle_eratt = lpfc_handle_eratt_s4;
4062                 phba->lpfc_stop_port = lpfc_stop_port_s4;
4063                 break;
4064         default:
4065                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4066                                 "1431 Invalid HBA PCI-device group: 0x%x\n",
4067                                 dev_grp);
4068                 return -ENODEV;
4069                 break;
4070         }
4071         return 0;
4072 }
4073
4074 /**
4075  * lpfc_setup_driver_resource_phase1 - Phase1 etup driver internal resources.
4076  * @phba: pointer to lpfc hba data structure.
4077  *
4078  * This routine is invoked to set up the driver internal resources before the
4079  * device specific resource setup to support the HBA device it attached to.
4080  *
4081  * Return codes
4082  *      0 - successful
4083  *      other values - error
4084  **/
4085 static int
4086 lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba)
4087 {
4088         /*
4089          * Driver resources common to all SLI revisions
4090          */
4091         atomic_set(&phba->fast_event_count, 0);
4092         spin_lock_init(&phba->hbalock);
4093
4094         /* Initialize ndlp management spinlock */
4095         spin_lock_init(&phba->ndlp_lock);
4096
4097         INIT_LIST_HEAD(&phba->port_list);
4098         INIT_LIST_HEAD(&phba->work_list);
4099         init_waitqueue_head(&phba->wait_4_mlo_m_q);
4100
4101         /* Initialize the wait queue head for the kernel thread */
4102         init_waitqueue_head(&phba->work_waitq);
4103
4104         /* Initialize the scsi buffer list used by driver for scsi IO */
4105         spin_lock_init(&phba->scsi_buf_list_lock);
4106         INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list);
4107
4108         /* Initialize the fabric iocb list */
4109         INIT_LIST_HEAD(&phba->fabric_iocb_list);
4110
4111         /* Initialize list to save ELS buffers */
4112         INIT_LIST_HEAD(&phba->elsbuf);
4113
4114         /* Initialize FCF connection rec list */
4115         INIT_LIST_HEAD(&phba->fcf_conn_rec_list);
4116
4117         return 0;
4118 }
4119
4120 /**
4121  * lpfc_setup_driver_resource_phase2 - Phase2 setup driver internal resources.
4122  * @phba: pointer to lpfc hba data structure.
4123  *
4124  * This routine is invoked to set up the driver internal resources after the
4125  * device specific resource setup to support the HBA device it attached to.
4126  *
4127  * Return codes
4128  *      0 - successful
4129  *      other values - error
4130  **/
4131 static int
4132 lpfc_setup_driver_resource_phase2(struct lpfc_hba *phba)
4133 {
4134         int error;
4135
4136         /* Startup the kernel thread for this host adapter. */
4137         phba->worker_thread = kthread_run(lpfc_do_work, phba,
4138                                           "lpfc_worker_%d", phba->brd_no);
4139         if (IS_ERR(phba->worker_thread)) {
4140                 error = PTR_ERR(phba->worker_thread);
4141                 return error;
4142         }
4143
4144         return 0;
4145 }
4146
4147 /**
4148  * lpfc_unset_driver_resource_phase2 - Phase2 unset driver internal resources.
4149  * @phba: pointer to lpfc hba data structure.
4150  *
4151  * This routine is invoked to unset the driver internal resources set up after
4152  * the device specific resource setup for supporting the HBA device it
4153  * attached to.
4154  **/
4155 static void
4156 lpfc_unset_driver_resource_phase2(struct lpfc_hba *phba)
4157 {
4158         /* Stop kernel worker thread */
4159         kthread_stop(phba->worker_thread);
4160 }
4161
4162 /**
4163  * lpfc_free_iocb_list - Free iocb list.
4164  * @phba: pointer to lpfc hba data structure.
4165  *
4166  * This routine is invoked to free the driver's IOCB list and memory.
4167  **/
4168 static void
4169 lpfc_free_iocb_list(struct lpfc_hba *phba)
4170 {
4171         struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL;
4172
4173         spin_lock_irq(&phba->hbalock);
4174         list_for_each_entry_safe(iocbq_entry, iocbq_next,
4175                                  &phba->lpfc_iocb_list, list) {
4176                 list_del(&iocbq_entry->list);
4177                 kfree(iocbq_entry);
4178                 phba->total_iocbq_bufs--;
4179         }
4180         spin_unlock_irq(&phba->hbalock);
4181
4182         return;
4183 }
4184
4185 /**
4186  * lpfc_init_iocb_list - Allocate and initialize iocb list.
4187  * @phba: pointer to lpfc hba data structure.
4188  *
4189  * This routine is invoked to allocate and initizlize the driver's IOCB
4190  * list and set up the IOCB tag array accordingly.
4191  *
4192  * Return codes
4193  *      0 - successful
4194  *      other values - error
4195  **/
4196 static int
4197 lpfc_init_iocb_list(struct lpfc_hba *phba, int iocb_count)
4198 {
4199         struct lpfc_iocbq *iocbq_entry = NULL;
4200         uint16_t iotag;
4201         int i;
4202
4203         /* Initialize and populate the iocb list per host.  */
4204         INIT_LIST_HEAD(&phba->lpfc_iocb_list);
4205         for (i = 0; i < iocb_count; i++) {
4206                 iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL);
4207                 if (iocbq_entry == NULL) {
4208                         printk(KERN_ERR "%s: only allocated %d iocbs of "
4209                                 "expected %d count. Unloading driver.\n",
4210                                 __func__, i, LPFC_IOCB_LIST_CNT);
4211                         goto out_free_iocbq;
4212                 }
4213
4214                 iotag = lpfc_sli_next_iotag(phba, iocbq_entry);
4215                 if (iotag == 0) {
4216                         kfree(iocbq_entry);
4217                         printk(KERN_ERR "%s: failed to allocate IOTAG. "
4218                                 "Unloading driver.\n", __func__);
4219                         goto out_free_iocbq;
4220                 }
4221                 iocbq_entry->sli4_xritag = NO_XRI;
4222
4223                 spin_lock_irq(&phba->hbalock);
4224                 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list);
4225                 phba->total_iocbq_bufs++;
4226                 spin_unlock_irq(&phba->hbalock);
4227         }
4228
4229         return 0;
4230
4231 out_free_iocbq:
4232         lpfc_free_iocb_list(phba);
4233
4234         return -ENOMEM;
4235 }
4236
4237 /**
4238  * lpfc_free_sgl_list - Free sgl list.
4239  * @phba: pointer to lpfc hba data structure.
4240  *
4241  * This routine is invoked to free the driver's sgl list and memory.
4242  **/
4243 static void
4244 lpfc_free_sgl_list(struct lpfc_hba *phba)
4245 {
4246         struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
4247         LIST_HEAD(sglq_list);
4248         int rc = 0;
4249
4250         spin_lock_irq(&phba->hbalock);
4251         list_splice_init(&phba->sli4_hba.lpfc_sgl_list, &sglq_list);
4252         spin_unlock_irq(&phba->hbalock);
4253
4254         list_for_each_entry_safe(sglq_entry, sglq_next,
4255                                  &sglq_list, list) {
4256                 list_del(&sglq_entry->list);
4257                 lpfc_mbuf_free(phba, sglq_entry->virt, sglq_entry->phys);
4258                 kfree(sglq_entry);
4259                 phba->sli4_hba.total_sglq_bufs--;
4260         }
4261         rc = lpfc_sli4_remove_all_sgl_pages(phba);
4262         if (rc) {
4263                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4264                         "2005 Unable to deregister pages from HBA: %x\n", rc);
4265         }
4266         kfree(phba->sli4_hba.lpfc_els_sgl_array);
4267 }
4268
4269 /**
4270  * lpfc_init_active_sgl_array - Allocate the buf to track active ELS XRIs.
4271  * @phba: pointer to lpfc hba data structure.
4272  *
4273  * This routine is invoked to allocate the driver's active sgl memory.
4274  * This array will hold the sglq_entry's for active IOs.
4275  **/
4276 static int
4277 lpfc_init_active_sgl_array(struct lpfc_hba *phba)
4278 {
4279         int size;
4280         size = sizeof(struct lpfc_sglq *);
4281         size *= phba->sli4_hba.max_cfg_param.max_xri;
4282
4283         phba->sli4_hba.lpfc_sglq_active_list =
4284                 kzalloc(size, GFP_KERNEL);
4285         if (!phba->sli4_hba.lpfc_sglq_active_list)
4286                 return -ENOMEM;
4287         return 0;
4288 }
4289
4290 /**
4291  * lpfc_free_active_sgl - Free the buf that tracks active ELS XRIs.
4292  * @phba: pointer to lpfc hba data structure.
4293  *
4294  * This routine is invoked to walk through the array of active sglq entries
4295  * and free all of the resources.
4296  * This is just a place holder for now.
4297  **/
4298 static void
4299 lpfc_free_active_sgl(struct lpfc_hba *phba)
4300 {
4301         kfree(phba->sli4_hba.lpfc_sglq_active_list);
4302 }
4303
4304 /**
4305  * lpfc_init_sgl_list - Allocate and initialize sgl list.
4306  * @phba: pointer to lpfc hba data structure.
4307  *
4308  * This routine is invoked to allocate and initizlize the driver's sgl
4309  * list and set up the sgl xritag tag array accordingly.
4310  *
4311  * Return codes
4312  *      0 - successful
4313  *      other values - error
4314  **/
4315 static int
4316 lpfc_init_sgl_list(struct lpfc_hba *phba)
4317 {
4318         struct lpfc_sglq *sglq_entry = NULL;
4319         int i;
4320         int els_xri_cnt;
4321
4322         els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
4323         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
4324                                 "2400 lpfc_init_sgl_list els %d.\n",
4325                                 els_xri_cnt);
4326         /* Initialize and populate the sglq list per host/VF. */
4327         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_sgl_list);
4328         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_els_sgl_list);
4329
4330         /* Sanity check on XRI management */
4331         if (phba->sli4_hba.max_cfg_param.max_xri <= els_xri_cnt) {
4332                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4333                                 "2562 No room left for SCSI XRI allocation: "
4334                                 "max_xri=%d, els_xri=%d\n",
4335                                 phba->sli4_hba.max_cfg_param.max_xri,
4336                                 els_xri_cnt);
4337                 return -ENOMEM;
4338         }
4339
4340         /* Allocate memory for the ELS XRI management array */
4341         phba->sli4_hba.lpfc_els_sgl_array =
4342                         kzalloc((sizeof(struct lpfc_sglq *) * els_xri_cnt),
4343                         GFP_KERNEL);
4344
4345         if (!phba->sli4_hba.lpfc_els_sgl_array) {
4346                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4347                                 "2401 Failed to allocate memory for ELS "
4348                                 "XRI management array of size %d.\n",
4349                                 els_xri_cnt);
4350                 return -ENOMEM;
4351         }
4352
4353         /* Keep the SCSI XRI into the XRI management array */
4354         phba->sli4_hba.scsi_xri_max =
4355                         phba->sli4_hba.max_cfg_param.max_xri - els_xri_cnt;
4356         phba->sli4_hba.scsi_xri_cnt = 0;
4357
4358         phba->sli4_hba.lpfc_scsi_psb_array =
4359                         kzalloc((sizeof(struct lpfc_scsi_buf *) *
4360                         phba->sli4_hba.scsi_xri_max), GFP_KERNEL);
4361
4362         if (!phba->sli4_hba.lpfc_scsi_psb_array) {
4363                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
4364                                 "2563 Failed to allocate memory for SCSI "
4365                                 "XRI management array of size %d.\n",
4366                                 phba->sli4_hba.scsi_xri_max);
4367                 kfree(phba->sli4_hba.lpfc_els_sgl_array);
4368                 return -ENOMEM;
4369         }
4370
4371         for (i = 0; i < els_xri_cnt; i++) {
4372                 sglq_entry = kzalloc(sizeof(struct lpfc_sglq), GFP_KERNEL);
4373                 if (sglq_entry == NULL) {
4374                         printk(KERN_ERR "%s: only allocated %d sgls of "
4375                                 "expected %d count. Unloading driver.\n",
4376                                 __func__, i, els_xri_cnt);
4377                         goto out_free_mem;
4378                 }
4379
4380                 sglq_entry->sli4_xritag = lpfc_sli4_next_xritag(phba);
4381                 if (sglq_entry->sli4_xritag == NO_XRI) {
4382                         kfree(sglq_entry);
4383                         printk(KERN_ERR "%s: failed to allocate XRI.\n"
4384                                 "Unloading driver.\n", __func__);
4385                         goto out_free_mem;
4386                 }
4387                 sglq_entry->buff_type = GEN_BUFF_TYPE;
4388                 sglq_entry->virt = lpfc_mbuf_alloc(phba, 0, &sglq_entry->phys);
4389                 if (sglq_entry->virt == NULL) {
4390                         kfree(sglq_entry);
4391                         printk(KERN_ERR "%s: failed to allocate mbuf.\n"
4392                                 "Unloading driver.\n", __func__);
4393                         goto out_free_mem;
4394                 }
4395                 sglq_entry->sgl = sglq_entry->virt;
4396                 memset(sglq_entry->sgl, 0, LPFC_BPL_SIZE);
4397
4398                 /* The list order is used by later block SGL registraton */
4399                 spin_lock_irq(&phba->hbalock);
4400                 list_add_tail(&sglq_entry->list, &phba->sli4_hba.lpfc_sgl_list);
4401                 phba->sli4_hba.lpfc_els_sgl_array[i] = sglq_entry;
4402                 phba->sli4_hba.total_sglq_bufs++;
4403                 spin_unlock_irq(&phba->hbalock);
4404         }
4405         return 0;
4406
4407 out_free_mem:
4408         kfree(phba->sli4_hba.lpfc_scsi_psb_array);
4409         lpfc_free_sgl_list(phba);
4410         return -ENOMEM;
4411 }
4412
4413 /**
4414  * lpfc_sli4_init_rpi_hdrs - Post the rpi header memory region to the port
4415  * @phba: pointer to lpfc hba data structure.
4416  *
4417  * This routine is invoked to post rpi header templates to the
4418  * HBA consistent with the SLI-4 interface spec.  This routine
4419  * posts a PAGE_SIZE memory region to the port to hold up to
4420  * PAGE_SIZE modulo 64 rpi context headers.
4421  * No locks are held here because this is an initialization routine
4422  * called only from probe or lpfc_online when interrupts are not
4423  * enabled and the driver is reinitializing the device.
4424  *
4425  * Return codes
4426  *      0 - successful
4427  *      ENOMEM - No availble memory
4428  *      EIO - The mailbox failed to complete successfully.
4429  **/
4430 int
4431 lpfc_sli4_init_rpi_hdrs(struct lpfc_hba *phba)
4432 {
4433         int rc = 0;
4434         int longs;
4435         uint16_t rpi_count;
4436         struct lpfc_rpi_hdr *rpi_hdr;
4437
4438         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_hdr_list);
4439
4440         /*
4441          * Provision an rpi bitmask range for discovery. The total count
4442          * is the difference between max and base + 1.
4443          */
4444         rpi_count = phba->sli4_hba.max_cfg_param.rpi_base +
4445                     phba->sli4_hba.max_cfg_param.max_rpi - 1;
4446
4447         longs = ((rpi_count) + BITS_PER_LONG - 1) / BITS_PER_LONG;
4448         phba->sli4_hba.rpi_bmask = kzalloc(longs * sizeof(unsigned long),
4449                                            GFP_KERNEL);
4450         if (!phba->sli4_hba.rpi_bmask)
4451                 return -ENOMEM;
4452
4453         rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
4454         if (!rpi_hdr) {
4455                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
4456                                 "0391 Error during rpi post operation\n");
4457                 lpfc_sli4_remove_rpis(phba);
4458                 rc = -ENODEV;
4459         }
4460
4461         return rc;
4462 }
4463
4464 /**
4465  * lpfc_sli4_create_rpi_hdr - Allocate an rpi header memory region
4466  * @phba: pointer to lpfc hba data structure.
4467  *
4468  * This routine is invoked to allocate a single 4KB memory region to
4469  * support rpis and stores them in the phba.  This single region
4470  * provides support for up to 64 rpis.  The region is used globally
4471  * by the device.
4472  *
4473  * Returns:
4474  *   A valid rpi hdr on success.
4475  *   A NULL pointer on any failure.
4476  **/
4477 struct lpfc_rpi_hdr *
4478 lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
4479 {
4480         uint16_t rpi_limit, curr_rpi_range;
4481         struct lpfc_dmabuf *dmabuf;
4482         struct lpfc_rpi_hdr *rpi_hdr;
4483
4484         rpi_limit = phba->sli4_hba.max_cfg_param.rpi_base +
4485                     phba->sli4_hba.max_cfg_param.max_rpi - 1;
4486
4487         spin_lock_irq(&phba->hbalock);
4488         curr_rpi_range = phba->sli4_hba.next_rpi;
4489         spin_unlock_irq(&phba->hbalock);
4490
4491         /*
4492          * The port has a limited number of rpis. The increment here
4493          * is LPFC_RPI_HDR_COUNT - 1 to account for the starting value
4494          * and to allow the full max_rpi range per port.
4495          */
4496         if ((curr_rpi_range + (LPFC_RPI_HDR_COUNT - 1)) > rpi_limit)
4497                 return NULL;
4498
4499         /*
4500          * First allocate the protocol header region for the port.  The
4501          * port expects a 4KB DMA-mapped memory region that is 4K aligned.
4502          */
4503         dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
4504         if (!dmabuf)
4505                 return NULL;
4506
4507         dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
4508                                           LPFC_HDR_TEMPLATE_SIZE,
4509                                           &dmabuf->phys,
4510                                           GFP_KERNEL);
4511         if (!dmabuf->virt) {
4512                 rpi_hdr = NULL;
4513                 goto err_free_dmabuf;
4514         }
4515
4516         memset(dmabuf->virt, 0, LPFC_HDR_TEMPLATE_SIZE);
4517         if (!IS_ALIGNED(dmabuf->phys, LPFC_HDR_TEMPLATE_SIZE)) {
4518                 rpi_hdr = NULL;
4519                 goto err_free_coherent;
4520         }
4521
4522         /* Save the rpi header data for cleanup later. */
4523         rpi_hdr = kzalloc(sizeof(struct lpfc_rpi_hdr), GFP_KERNEL);
4524         if (!rpi_hdr)
4525                 goto err_free_coherent;
4526
4527         rpi_hdr->dmabuf = dmabuf;
4528         rpi_hdr->len = LPFC_HDR_TEMPLATE_SIZE;
4529         rpi_hdr->page_count = 1;
4530         spin_lock_irq(&phba->hbalock);
4531         rpi_hdr->start_rpi = phba->sli4_hba.next_rpi;
4532         list_add_tail(&rpi_hdr->list, &phba->sli4_hba.lpfc_rpi_hdr_list);
4533
4534         /*
4535          * The next_rpi stores the next module-64 rpi value to post
4536          * in any subsequent rpi memory region postings.
4537          */
4538         phba->sli4_hba.next_rpi += LPFC_RPI_HDR_COUNT;
4539         spin_unlock_irq(&phba->hbalock);
4540         return rpi_hdr;
4541
4542  err_free_coherent:
4543         dma_free_coherent(&phba->pcidev->dev, LPFC_HDR_TEMPLATE_SIZE,
4544                           dmabuf->virt, dmabuf->phys);
4545  err_free_dmabuf:
4546         kfree(dmabuf);
4547         return NULL;
4548 }
4549
4550 /**
4551  * lpfc_sli4_remove_rpi_hdrs - Remove all rpi header memory regions
4552  * @phba: pointer to lpfc hba data structure.
4553  *
4554  * This routine is invoked to remove all memory resources allocated
4555  * to support rpis. This routine presumes the caller has released all
4556  * rpis consumed by fabric or port logins and is prepared to have
4557  * the header pages removed.
4558  **/
4559 void
4560 lpfc_sli4_remove_rpi_hdrs(struct lpfc_hba *phba)
4561 {
4562         struct lpfc_rpi_hdr *rpi_hdr, *next_rpi_hdr;
4563
4564         list_for_each_entry_safe(rpi_hdr, next_rpi_hdr,
4565                                  &phba->sli4_hba.lpfc_rpi_hdr_list, list) {
4566                 list_del(&rpi_hdr->list);
4567                 dma_free_coherent(&phba->pcidev->dev, rpi_hdr->len,
4568                                   rpi_hdr->dmabuf->virt, rpi_hdr->dmabuf->phys);
4569                 kfree(rpi_hdr->dmabuf);
4570                 kfree(rpi_hdr);
4571         }
4572
4573         phba->sli4_hba.next_rpi = phba->sli4_hba.max_cfg_param.rpi_base;
4574         memset(phba->sli4_hba.rpi_bmask, 0, sizeof(*phba->sli4_hba.rpi_bmask));
4575 }
4576
4577 /**
4578  * lpfc_hba_alloc - Allocate driver hba data structure for a device.
4579  * @pdev: pointer to pci device data structure.
4580  *
4581  * This routine is invoked to allocate the driver hba data structure for an
4582  * HBA device. If the allocation is successful, the phba reference to the
4583  * PCI device data structure is set.
4584  *
4585  * Return codes
4586  *      pointer to @phba - successful
4587  *      NULL - error
4588  **/
4589 static struct lpfc_hba *
4590 lpfc_hba_alloc(struct pci_dev *pdev)
4591 {
4592         struct lpfc_hba *phba;
4593
4594         /* Allocate memory for HBA structure */
4595         phba = kzalloc(sizeof(struct lpfc_hba), GFP_KERNEL);
4596         if (!phba) {
4597                 dev_err(&pdev->dev, "failed to allocate hba struct\n");
4598                 return NULL;
4599         }
4600
4601         /* Set reference to PCI device in HBA structure */
4602         phba->pcidev = pdev;
4603
4604         /* Assign an unused board number */
4605         phba->brd_no = lpfc_get_instance();
4606         if (phba->brd_no < 0) {
4607                 kfree(phba);
4608                 return NULL;
4609         }
4610
4611         spin_lock_init(&phba->ct_ev_lock);
4612         INIT_LIST_HEAD(&phba->ct_ev_waiters);
4613
4614         return phba;
4615 }
4616
4617 /**
4618  * lpfc_hba_free - Free driver hba data structure with a device.
4619  * @phba: pointer to lpfc hba data structure.
4620  *
4621  * This routine is invoked to free the driver hba data structure with an
4622  * HBA device.
4623  **/
4624 static void
4625 lpfc_hba_free(struct lpfc_hba *phba)
4626 {
4627         /* Release the driver assigned board number */
4628         idr_remove(&lpfc_hba_index, phba->brd_no);
4629
4630         kfree(phba);
4631         return;
4632 }
4633
4634 /**
4635  * lpfc_create_shost - Create hba physical port with associated scsi host.
4636  * @phba: pointer to lpfc hba data structure.
4637  *
4638  * This routine is invoked to create HBA physical port and associate a SCSI
4639  * host with it.
4640  *
4641  * Return codes
4642  *      0 - successful
4643  *      other values - error
4644  **/
4645 static int
4646 lpfc_create_shost(struct lpfc_hba *phba)
4647 {
4648         struct lpfc_vport *vport;
4649         struct Scsi_Host  *shost;
4650
4651         /* Initialize HBA FC structure */
4652         phba->fc_edtov = FF_DEF_EDTOV;
4653         phba->fc_ratov = FF_DEF_RATOV;
4654         phba->fc_altov = FF_DEF_ALTOV;
4655         phba->fc_arbtov = FF_DEF_ARBTOV;
4656
4657         vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev);
4658         if (!vport)
4659                 return -ENODEV;
4660
4661         shost = lpfc_shost_from_vport(vport);
4662         phba->pport = vport;
4663         lpfc_debugfs_initialize(vport);
4664         /* Put reference to SCSI host to driver's device private data */
4665         pci_set_drvdata(phba->pcidev, shost);
4666
4667         return 0;
4668 }
4669
4670 /**
4671  * lpfc_destroy_shost - Destroy hba physical port with associated scsi host.
4672  * @phba: pointer to lpfc hba data structure.
4673  *
4674  * This routine is invoked to destroy HBA physical port and the associated
4675  * SCSI host.
4676  **/
4677 static void
4678 lpfc_destroy_shost(struct lpfc_hba *phba)
4679 {
4680         struct lpfc_vport *vport = phba->pport;
4681
4682         /* Destroy physical port that associated with the SCSI host */
4683         destroy_port(vport);
4684
4685         return;
4686 }
4687
4688 /**
4689  * lpfc_setup_bg - Setup Block guard structures and debug areas.
4690  * @phba: pointer to lpfc hba data structure.
4691  * @shost: the shost to be used to detect Block guard settings.
4692  *
4693  * This routine sets up the local Block guard protocol settings for @shost.
4694  * This routine also allocates memory for debugging bg buffers.
4695  **/
4696 static void
4697 lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost)
4698 {
4699         int pagecnt = 10;
4700         if (lpfc_prot_mask && lpfc_prot_guard) {
4701                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4702                                 "1478 Registering BlockGuard with the "
4703                                 "SCSI layer\n");
4704                 scsi_host_set_prot(shost, lpfc_prot_mask);
4705                 scsi_host_set_guard(shost, lpfc_prot_guard);
4706         }
4707         if (!_dump_buf_data) {
4708                 while (pagecnt) {
4709                         spin_lock_init(&_dump_buf_lock);
4710                         _dump_buf_data =
4711                                 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
4712                         if (_dump_buf_data) {
4713                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4714                                         "9043 BLKGRD: allocated %d pages for "
4715                                        "_dump_buf_data at 0x%p\n",
4716                                        (1 << pagecnt), _dump_buf_data);
4717                                 _dump_buf_data_order = pagecnt;
4718                                 memset(_dump_buf_data, 0,
4719                                        ((1 << PAGE_SHIFT) << pagecnt));
4720                                 break;
4721                         } else
4722                                 --pagecnt;
4723                 }
4724                 if (!_dump_buf_data_order)
4725                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4726                                 "9044 BLKGRD: ERROR unable to allocate "
4727                                "memory for hexdump\n");
4728         } else
4729                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4730                         "9045 BLKGRD: already allocated _dump_buf_data=0x%p"
4731                        "\n", _dump_buf_data);
4732         if (!_dump_buf_dif) {
4733                 while (pagecnt) {
4734                         _dump_buf_dif =
4735                                 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
4736                         if (_dump_buf_dif) {
4737                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4738                                         "9046 BLKGRD: allocated %d pages for "
4739                                        "_dump_buf_dif at 0x%p\n",
4740                                        (1 << pagecnt), _dump_buf_dif);
4741                                 _dump_buf_dif_order = pagecnt;
4742                                 memset(_dump_buf_dif, 0,
4743                                        ((1 << PAGE_SHIFT) << pagecnt));
4744                                 break;
4745                         } else
4746                                 --pagecnt;
4747                 }
4748                 if (!_dump_buf_dif_order)
4749                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4750                         "9047 BLKGRD: ERROR unable to allocate "
4751                                "memory for hexdump\n");
4752         } else
4753                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
4754                         "9048 BLKGRD: already allocated _dump_buf_dif=0x%p\n",
4755                        _dump_buf_dif);
4756 }
4757
4758 /**
4759  * lpfc_post_init_setup - Perform necessary device post initialization setup.
4760  * @phba: pointer to lpfc hba data structure.
4761  *
4762  * This routine is invoked to perform all the necessary post initialization
4763  * setup for the device.
4764  **/
4765 static void
4766 lpfc_post_init_setup(struct lpfc_hba *phba)
4767 {
4768         struct Scsi_Host  *shost;
4769         struct lpfc_adapter_event_header adapter_event;
4770
4771         /* Get the default values for Model Name and Description */
4772         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
4773
4774         /*
4775          * hba setup may have changed the hba_queue_depth so we need to
4776          * adjust the value of can_queue.
4777          */
4778         shost = pci_get_drvdata(phba->pcidev);
4779         shost->can_queue = phba->cfg_hba_queue_depth - 10;
4780         if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
4781                 lpfc_setup_bg(phba, shost);
4782
4783         lpfc_host_attrib_init(shost);
4784
4785         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
4786                 spin_lock_irq(shost->host_lock);
4787                 lpfc_poll_start_timer(phba);
4788                 spin_unlock_irq(shost->host_lock);
4789         }
4790
4791         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
4792                         "0428 Perform SCSI scan\n");
4793         /* Send board arrival event to upper layer */
4794         adapter_event.event_type = FC_REG_ADAPTER_EVENT;
4795         adapter_event.subcategory = LPFC_EVENT_ARRIVAL;
4796         fc_host_post_vendor_event(shost, fc_get_event_number(),
4797                                   sizeof(adapter_event),
4798                                   (char *) &adapter_event,
4799                                   LPFC_NL_VENDOR_ID);
4800         return;
4801 }
4802
4803 /**
4804  * lpfc_sli_pci_mem_setup - Setup SLI3 HBA PCI memory space.
4805  * @phba: pointer to lpfc hba data structure.
4806  *
4807  * This routine is invoked to set up the PCI device memory space for device
4808  * with SLI-3 interface spec.
4809  *
4810  * Return codes
4811  *      0 - successful
4812  *      other values - error
4813  **/
4814 static int
4815 lpfc_sli_pci_mem_setup(struct lpfc_hba *phba)
4816 {
4817         struct pci_dev *pdev;
4818         unsigned long bar0map_len, bar2map_len;
4819         int i, hbq_count;
4820         void *ptr;
4821         int error = -ENODEV;
4822
4823         /* Obtain PCI device reference */
4824         if (!phba->pcidev)
4825                 return error;
4826         else
4827                 pdev = phba->pcidev;
4828
4829         /* Set the device DMA mask size */
4830         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
4831          || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
4832                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
4833                  || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
4834                         return error;
4835                 }
4836         }
4837
4838         /* Get the bus address of Bar0 and Bar2 and the number of bytes
4839          * required by each mapping.
4840          */
4841         phba->pci_bar0_map = pci_resource_start(pdev, 0);
4842         bar0map_len = pci_resource_len(pdev, 0);
4843
4844         phba->pci_bar2_map = pci_resource_start(pdev, 2);
4845         bar2map_len = pci_resource_len(pdev, 2);
4846
4847         /* Map HBA SLIM to a kernel virtual address. */
4848         phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len);
4849         if (!phba->slim_memmap_p) {
4850                 dev_printk(KERN_ERR, &pdev->dev,
4851                            "ioremap failed for SLIM memory.\n");
4852                 goto out;
4853         }
4854
4855         /* Map HBA Control Registers to a kernel virtual address. */
4856         phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len);
4857         if (!phba->ctrl_regs_memmap_p) {
4858                 dev_printk(KERN_ERR, &pdev->dev,
4859                            "ioremap failed for HBA control registers.\n");
4860                 goto out_iounmap_slim;
4861         }
4862
4863         /* Allocate memory for SLI-2 structures */
4864         phba->slim2p.virt = dma_alloc_coherent(&pdev->dev,
4865                                                SLI2_SLIM_SIZE,
4866                                                &phba->slim2p.phys,
4867                                                GFP_KERNEL);
4868         if (!phba->slim2p.virt)
4869                 goto out_iounmap;
4870
4871         memset(phba->slim2p.virt, 0, SLI2_SLIM_SIZE);
4872         phba->mbox = phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, mbx);
4873         phba->pcb = (phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, pcb));
4874         phba->IOCBs = (phba->slim2p.virt +
4875                        offsetof(struct lpfc_sli2_slim, IOCBs));
4876
4877         phba->hbqslimp.virt = dma_alloc_coherent(&pdev->dev,
4878                                                  lpfc_sli_hbq_size(),
4879                                                  &phba->hbqslimp.phys,
4880                                                  GFP_KERNEL);
4881         if (!phba->hbqslimp.virt)
4882                 goto out_free_slim;
4883
4884         hbq_count = lpfc_sli_hbq_count();
4885         ptr = phba->hbqslimp.virt;
4886         for (i = 0; i < hbq_count; ++i) {
4887                 phba->hbqs[i].hbq_virt = ptr;
4888                 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
4889                 ptr += (lpfc_hbq_defs[i]->entry_count *
4890                         sizeof(struct lpfc_hbq_entry));
4891         }
4892         phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc;
4893         phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_els_hbq_free;
4894
4895         memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size());
4896
4897         INIT_LIST_HEAD(&phba->rb_pend_list);
4898
4899         phba->MBslimaddr = phba->slim_memmap_p;
4900         phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
4901         phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
4902         phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
4903         phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
4904
4905         return 0;
4906
4907 out_free_slim:
4908         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
4909                           phba->slim2p.virt, phba->slim2p.phys);
4910 out_iounmap:
4911         iounmap(phba->ctrl_regs_memmap_p);
4912 out_iounmap_slim:
4913         iounmap(phba->slim_memmap_p);
4914 out:
4915         return error;
4916 }
4917
4918 /**
4919  * lpfc_sli_pci_mem_unset - Unset SLI3 HBA PCI memory space.
4920  * @phba: pointer to lpfc hba data structure.
4921  *
4922  * This routine is invoked to unset the PCI device memory space for device
4923  * with SLI-3 interface spec.
4924  **/
4925 static void
4926 lpfc_sli_pci_mem_unset(struct lpfc_hba *phba)
4927 {
4928         struct pci_dev *pdev;
4929
4930         /* Obtain PCI device reference */
4931         if (!phba->pcidev)
4932                 return;
4933         else
4934                 pdev = phba->pcidev;
4935
4936         /* Free coherent DMA memory allocated */
4937         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
4938                           phba->hbqslimp.virt, phba->hbqslimp.phys);
4939         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
4940                           phba->slim2p.virt, phba->slim2p.phys);
4941
4942         /* I/O memory unmap */
4943         iounmap(phba->ctrl_regs_memmap_p);
4944         iounmap(phba->slim_memmap_p);
4945
4946         return;
4947 }
4948
4949 /**
4950  * lpfc_sli4_post_status_check - Wait for SLI4 POST done and check status
4951  * @phba: pointer to lpfc hba data structure.
4952  *
4953  * This routine is invoked to wait for SLI4 device Power On Self Test (POST)
4954  * done and check status.
4955  *
4956  * Return 0 if successful, otherwise -ENODEV.
4957  **/
4958 int
4959 lpfc_sli4_post_status_check(struct lpfc_hba *phba)
4960 {
4961         struct lpfc_register sta_reg, uerrlo_reg, uerrhi_reg;
4962         int i, port_error = -ENODEV;
4963
4964         if (!phba->sli4_hba.STAregaddr)
4965                 return -ENODEV;
4966
4967         /* Wait up to 30 seconds for the SLI Port POST done and ready */
4968         for (i = 0; i < 3000; i++) {
4969                 sta_reg.word0 = readl(phba->sli4_hba.STAregaddr);
4970                 /* Encounter fatal POST error, break out */
4971                 if (bf_get(lpfc_hst_state_perr, &sta_reg)) {
4972                         port_error = -ENODEV;
4973                         break;
4974                 }
4975                 if (LPFC_POST_STAGE_ARMFW_READY ==
4976                     bf_get(lpfc_hst_state_port_status, &sta_reg)) {
4977                         port_error = 0;
4978                         break;
4979                 }
4980                 msleep(10);
4981         }
4982
4983         if (port_error)
4984                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4985                         "1408 Failure HBA POST Status: sta_reg=0x%x, "
4986                         "perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, xrom=x%x, "
4987                         "dl=x%x, pstatus=x%x\n", sta_reg.word0,
4988                         bf_get(lpfc_hst_state_perr, &sta_reg),
4989                         bf_get(lpfc_hst_state_sfi, &sta_reg),
4990                         bf_get(lpfc_hst_state_nip, &sta_reg),
4991                         bf_get(lpfc_hst_state_ipc, &sta_reg),
4992                         bf_get(lpfc_hst_state_xrom, &sta_reg),
4993                         bf_get(lpfc_hst_state_dl, &sta_reg),
4994                         bf_get(lpfc_hst_state_port_status, &sta_reg));
4995
4996         /* Log device information */
4997         phba->sli4_hba.sli_intf.word0 = readl(phba->sli4_hba.SLIINTFregaddr);
4998         if (bf_get(lpfc_sli_intf_valid,
4999                    &phba->sli4_hba.sli_intf) == LPFC_SLI_INTF_VALID) {
5000                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5001                                 "2534 Device Info: ChipType=0x%x, SliRev=0x%x, "
5002                                 "FeatureL1=0x%x, FeatureL2=0x%x\n",
5003                                 bf_get(lpfc_sli_intf_sli_family,
5004                                        &phba->sli4_hba.sli_intf),
5005                                 bf_get(lpfc_sli_intf_slirev,
5006                                        &phba->sli4_hba.sli_intf),
5007                                 bf_get(lpfc_sli_intf_featurelevel1,
5008                                        &phba->sli4_hba.sli_intf),
5009                                 bf_get(lpfc_sli_intf_featurelevel2,
5010                                        &phba->sli4_hba.sli_intf));
5011         }
5012         phba->sli4_hba.ue_mask_lo = readl(phba->sli4_hba.UEMASKLOregaddr);
5013         phba->sli4_hba.ue_mask_hi = readl(phba->sli4_hba.UEMASKHIregaddr);
5014         /* With uncoverable error, log the error message and return error */
5015         uerrlo_reg.word0 = readl(phba->sli4_hba.UERRLOregaddr);
5016         uerrhi_reg.word0 = readl(phba->sli4_hba.UERRHIregaddr);
5017         if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) ||
5018             (~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) {
5019                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5020                                 "1422 HBA Unrecoverable error: "
5021                                 "uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
5022                                 "ue_mask_lo_reg=0x%x, ue_mask_hi_reg=0x%x\n",
5023                                 uerrlo_reg.word0, uerrhi_reg.word0,
5024                                 phba->sli4_hba.ue_mask_lo,
5025                                 phba->sli4_hba.ue_mask_hi);
5026                 return -ENODEV;
5027         }
5028
5029         return port_error;
5030 }
5031
5032 /**
5033  * lpfc_sli4_bar0_register_memmap - Set up SLI4 BAR0 register memory map.
5034  * @phba: pointer to lpfc hba data structure.
5035  *
5036  * This routine is invoked to set up SLI4 BAR0 PCI config space register
5037  * memory map.
5038  **/
5039 static void
5040 lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba)
5041 {
5042         phba->sli4_hba.UERRLOregaddr = phba->sli4_hba.conf_regs_memmap_p +
5043                                         LPFC_UERR_STATUS_LO;
5044         phba->sli4_hba.UERRHIregaddr = phba->sli4_hba.conf_regs_memmap_p +
5045                                         LPFC_UERR_STATUS_HI;
5046         phba->sli4_hba.UEMASKLOregaddr = phba->sli4_hba.conf_regs_memmap_p +
5047                                         LPFC_UE_MASK_LO;
5048         phba->sli4_hba.UEMASKHIregaddr = phba->sli4_hba.conf_regs_memmap_p +
5049                                         LPFC_UE_MASK_HI;
5050         phba->sli4_hba.SLIINTFregaddr = phba->sli4_hba.conf_regs_memmap_p +
5051                                         LPFC_SLI_INTF;
5052 }
5053
5054 /**
5055  * lpfc_sli4_bar1_register_memmap - Set up SLI4 BAR1 register memory map.
5056  * @phba: pointer to lpfc hba data structure.
5057  *
5058  * This routine is invoked to set up SLI4 BAR1 control status register (CSR)
5059  * memory map.
5060  **/
5061 static void
5062 lpfc_sli4_bar1_register_memmap(struct lpfc_hba *phba)
5063 {
5064
5065         phba->sli4_hba.STAregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
5066                                     LPFC_HST_STATE;
5067         phba->sli4_hba.ISRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
5068                                     LPFC_HST_ISR0;
5069         phba->sli4_hba.IMRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
5070                                     LPFC_HST_IMR0;
5071         phba->sli4_hba.ISCRregaddr = phba->sli4_hba.ctrl_regs_memmap_p +
5072                                      LPFC_HST_ISCR0;
5073         return;
5074 }
5075
5076 /**
5077  * lpfc_sli4_bar2_register_memmap - Set up SLI4 BAR2 register memory map.
5078  * @phba: pointer to lpfc hba data structure.
5079  * @vf: virtual function number
5080  *
5081  * This routine is invoked to set up SLI4 BAR2 doorbell register memory map
5082  * based on the given viftual function number, @vf.
5083  *
5084  * Return 0 if successful, otherwise -ENODEV.
5085  **/
5086 static int
5087 lpfc_sli4_bar2_register_memmap(struct lpfc_hba *phba, uint32_t vf)
5088 {
5089         if (vf > LPFC_VIR_FUNC_MAX)
5090                 return -ENODEV;
5091
5092         phba->sli4_hba.RQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
5093                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_RQ_DOORBELL);
5094         phba->sli4_hba.WQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
5095                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_WQ_DOORBELL);
5096         phba->sli4_hba.EQCQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
5097                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_EQCQ_DOORBELL);
5098         phba->sli4_hba.MQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
5099                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_MQ_DOORBELL);
5100         phba->sli4_hba.BMBXregaddr = (phba->sli4_hba.drbl_regs_memmap_p +
5101                                 vf * LPFC_VFR_PAGE_SIZE + LPFC_BMBX);
5102         return 0;
5103 }
5104
5105 /**
5106  * lpfc_create_bootstrap_mbox - Create the bootstrap mailbox
5107  * @phba: pointer to lpfc hba data structure.
5108  *
5109  * This routine is invoked to create the bootstrap mailbox
5110  * region consistent with the SLI-4 interface spec.  This
5111  * routine allocates all memory necessary to communicate
5112  * mailbox commands to the port and sets up all alignment
5113  * needs.  No locks are expected to be held when calling
5114  * this routine.
5115  *
5116  * Return codes
5117  *      0 - successful
5118  *      ENOMEM - could not allocated memory.
5119  **/
5120 static int
5121 lpfc_create_bootstrap_mbox(struct lpfc_hba *phba)
5122 {
5123         uint32_t bmbx_size;
5124         struct lpfc_dmabuf *dmabuf;
5125         struct dma_address *dma_address;
5126         uint32_t pa_addr;
5127         uint64_t phys_addr;
5128
5129         dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
5130         if (!dmabuf)
5131                 return -ENOMEM;
5132
5133         /*
5134          * The bootstrap mailbox region is comprised of 2 parts
5135          * plus an alignment restriction of 16 bytes.
5136          */
5137         bmbx_size = sizeof(struct lpfc_bmbx_create) + (LPFC_ALIGN_16_BYTE - 1);
5138         dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
5139                                           bmbx_size,
5140                                           &dmabuf->phys,
5141                                           GFP_KERNEL);
5142         if (!dmabuf->virt) {
5143                 kfree(dmabuf);
5144                 return -ENOMEM;
5145         }
5146         memset(dmabuf->virt, 0, bmbx_size);
5147
5148         /*
5149          * Initialize the bootstrap mailbox pointers now so that the register
5150          * operations are simple later.  The mailbox dma address is required
5151          * to be 16-byte aligned.  Also align the virtual memory as each
5152          * maibox is copied into the bmbx mailbox region before issuing the
5153          * command to the port.
5154          */
5155         phba->sli4_hba.bmbx.dmabuf = dmabuf;
5156         phba->sli4_hba.bmbx.bmbx_size = bmbx_size;
5157
5158         phba->sli4_hba.bmbx.avirt = PTR_ALIGN(dmabuf->virt,
5159                                               LPFC_ALIGN_16_BYTE);
5160         phba->sli4_hba.bmbx.aphys = ALIGN(dmabuf->phys,
5161                                               LPFC_ALIGN_16_BYTE);
5162
5163         /*
5164          * Set the high and low physical addresses now.  The SLI4 alignment
5165          * requirement is 16 bytes and the mailbox is posted to the port
5166          * as two 30-bit addresses.  The other data is a bit marking whether
5167          * the 30-bit address is the high or low address.
5168          * Upcast bmbx aphys to 64bits so shift instruction compiles
5169          * clean on 32 bit machines.
5170          */
5171         dma_address = &phba->sli4_hba.bmbx.dma_address;
5172         phys_addr = (uint64_t)phba->sli4_hba.bmbx.aphys;
5173         pa_addr = (uint32_t) ((phys_addr >> 34) & 0x3fffffff);
5174         dma_address->addr_hi = (uint32_t) ((pa_addr << 2) |
5175                                            LPFC_BMBX_BIT1_ADDR_HI);
5176
5177         pa_addr = (uint32_t) ((phba->sli4_hba.bmbx.aphys >> 4) & 0x3fffffff);
5178         dma_address->addr_lo = (uint32_t) ((pa_addr << 2) |
5179                                            LPFC_BMBX_BIT1_ADDR_LO);
5180         return 0;
5181 }
5182
5183 /**
5184  * lpfc_destroy_bootstrap_mbox - Destroy all bootstrap mailbox resources
5185  * @phba: pointer to lpfc hba data structure.
5186  *
5187  * This routine is invoked to teardown the bootstrap mailbox
5188  * region and release all host resources. This routine requires
5189  * the caller to ensure all mailbox commands recovered, no
5190  * additional mailbox comands are sent, and interrupts are disabled
5191  * before calling this routine.
5192  *
5193  **/
5194 static void
5195 lpfc_destroy_bootstrap_mbox(struct lpfc_hba *phba)
5196 {
5197         dma_free_coherent(&phba->pcidev->dev,
5198                           phba->sli4_hba.bmbx.bmbx_size,
5199                           phba->sli4_hba.bmbx.dmabuf->virt,
5200                           phba->sli4_hba.bmbx.dmabuf->phys);
5201
5202         kfree(phba->sli4_hba.bmbx.dmabuf);
5203         memset(&phba->sli4_hba.bmbx, 0, sizeof(struct lpfc_bmbx));
5204 }
5205
5206 /**
5207  * lpfc_sli4_read_config - Get the config parameters.
5208  * @phba: pointer to lpfc hba data structure.
5209  *
5210  * This routine is invoked to read the configuration parameters from the HBA.
5211  * The configuration parameters are used to set the base and maximum values
5212  * for RPI's XRI's VPI's VFI's and FCFIs. These values also affect the resource
5213  * allocation for the port.
5214  *
5215  * Return codes
5216  *      0 - successful
5217  *      ENOMEM - No availble memory
5218  *      EIO - The mailbox failed to complete successfully.
5219  **/
5220 static int
5221 lpfc_sli4_read_config(struct lpfc_hba *phba)
5222 {
5223         LPFC_MBOXQ_t *pmb;
5224         struct lpfc_mbx_read_config *rd_config;
5225         uint32_t rc = 0;
5226
5227         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5228         if (!pmb) {
5229                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5230                                 "2011 Unable to allocate memory for issuing "
5231                                 "SLI_CONFIG_SPECIAL mailbox command\n");
5232                 return -ENOMEM;
5233         }
5234
5235         lpfc_read_config(phba, pmb);
5236
5237         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
5238         if (rc != MBX_SUCCESS) {
5239                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
5240                         "2012 Mailbox failed , mbxCmd x%x "
5241                         "READ_CONFIG, mbxStatus x%x\n",
5242                         bf_get(lpfc_mqe_command, &pmb->u.mqe),
5243                         bf_get(lpfc_mqe_status, &pmb->u.mqe));
5244                 rc = -EIO;
5245         } else {
5246                 rd_config = &pmb->u.mqe.un.rd_config;
5247                 phba->sli4_hba.max_cfg_param.max_xri =
5248                         bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
5249                 phba->sli4_hba.max_cfg_param.xri_base =
5250                         bf_get(lpfc_mbx_rd_conf_xri_base, rd_config);
5251                 phba->sli4_hba.max_cfg_param.max_vpi =
5252                         bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config);
5253                 phba->sli4_hba.max_cfg_param.vpi_base =
5254                         bf_get(lpfc_mbx_rd_conf_vpi_base, rd_config);
5255                 phba->sli4_hba.max_cfg_param.max_rpi =
5256                         bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
5257                 phba->sli4_hba.max_cfg_param.rpi_base =
5258                         bf_get(lpfc_mbx_rd_conf_rpi_base, rd_config);
5259                 phba->sli4_hba.max_cfg_param.max_vfi =
5260                         bf_get(lpfc_mbx_rd_conf_vfi_count, rd_config);
5261                 phba->sli4_hba.max_cfg_param.vfi_base =
5262                         bf_get(lpfc_mbx_rd_conf_vfi_base, rd_config);
5263                 phba->sli4_hba.max_cfg_param.max_fcfi =
5264                         bf_get(lpfc_mbx_rd_conf_fcfi_count, rd_config);
5265                 phba->sli4_hba.max_cfg_param.fcfi_base =
5266                         bf_get(lpfc_mbx_rd_conf_fcfi_base, rd_config);
5267                 phba->sli4_hba.max_cfg_param.max_eq =
5268                         bf_get(lpfc_mbx_rd_conf_eq_count, rd_config);
5269                 phba->sli4_hba.max_cfg_param.max_rq =
5270                         bf_get(lpfc_mbx_rd_conf_rq_count, rd_config);
5271                 phba->sli4_hba.max_cfg_param.max_wq =
5272                         bf_get(lpfc_mbx_rd_conf_wq_count, rd_config);
5273                 phba->sli4_hba.max_cfg_param.max_cq =
5274                         bf_get(lpfc_mbx_rd_conf_cq_count, rd_config);
5275                 phba->lmt = bf_get(lpfc_mbx_rd_conf_lmt, rd_config);
5276                 phba->sli4_hba.next_xri = phba->sli4_hba.max_cfg_param.xri_base;
5277                 phba->vpi_base = phba->sli4_hba.max_cfg_param.vpi_base;
5278                 phba->vfi_base = phba->sli4_hba.max_cfg_param.vfi_base;
5279                 phba->sli4_hba.next_rpi = phba->sli4_hba.max_cfg_param.rpi_base;
5280                 phba->max_vpi = (phba->sli4_hba.max_cfg_param.max_vpi > 0) ?
5281                                 (phba->sli4_hba.max_cfg_param.max_vpi - 1) : 0;
5282                 phba->max_vports = phba->max_vpi;
5283                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
5284                                 "2003 cfg params XRI(B:%d M:%d), "
5285                                 "VPI(B:%d M:%d) "
5286                                 "VFI(B:%d M:%d) "
5287                                 "RPI(B:%d M:%d) "
5288                                 "FCFI(B:%d M:%d)\n",
5289                                 phba->sli4_hba.max_cfg_param.xri_base,
5290                                 phba->sli4_hba.max_cfg_param.max_xri,
5291                                 phba->sli4_hba.max_cfg_param.vpi_base,
5292                                 phba->sli4_hba.max_cfg_param.max_vpi,
5293                                 phba->sli4_hba.max_cfg_param.vfi_base,
5294                                 phba->sli4_hba.max_cfg_param.max_vfi,
5295                                 phba->sli4_hba.max_cfg_param.rpi_base,
5296                                 phba->sli4_hba.max_cfg_param.max_rpi,
5297                                 phba->sli4_hba.max_cfg_param.fcfi_base,
5298                                 phba->sli4_hba.max_cfg_param.max_fcfi);
5299         }
5300         mempool_free(pmb, phba->mbox_mem_pool);
5301
5302         /* Reset the DFT_HBA_Q_DEPTH to the max xri  */
5303         if (phba->cfg_hba_queue_depth > (phba->sli4_hba.max_cfg_param.max_xri))
5304                 phba->cfg_hba_queue_depth =
5305                                 phba->sli4_hba.max_cfg_param.max_xri;
5306         return rc;
5307 }
5308
5309 /**
5310  * lpfc_dev_endian_order_setup - Notify the port of the host's endian order.
5311  * @phba: pointer to lpfc hba data structure.
5312  *
5313  * This routine is invoked to setup the host-side endian order to the
5314  * HBA consistent with the SLI-4 interface spec.
5315  *
5316  * Return codes
5317  *      0 - successful
5318  *      ENOMEM - No availble memory
5319  *      EIO - The mailbox failed to complete successfully.
5320  **/
5321 static int
5322 lpfc_setup_endian_order(struct lpfc_hba *phba)
5323 {
5324         LPFC_MBOXQ_t *mboxq;
5325         uint32_t rc = 0;
5326         uint32_t endian_mb_data[2] = {HOST_ENDIAN_LOW_WORD0,
5327                                       HOST_ENDIAN_HIGH_WORD1};
5328
5329         mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5330         if (!mboxq) {
5331                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5332                                 "0492 Unable to allocate memory for issuing "
5333                                 "SLI_CONFIG_SPECIAL mailbox command\n");
5334                 return -ENOMEM;
5335         }
5336
5337         /*
5338          * The SLI4_CONFIG_SPECIAL mailbox command requires the first two
5339          * words to contain special data values and no other data.
5340          */
5341         memset(mboxq, 0, sizeof(LPFC_MBOXQ_t));
5342         memcpy(&mboxq->u.mqe, &endian_mb_data, sizeof(endian_mb_data));
5343         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
5344         if (rc != MBX_SUCCESS) {
5345                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5346                                 "0493 SLI_CONFIG_SPECIAL mailbox failed with "
5347                                 "status x%x\n",
5348                                 rc);
5349                 rc = -EIO;
5350         }
5351
5352         mempool_free(mboxq, phba->mbox_mem_pool);
5353         return rc;
5354 }
5355
5356 /**
5357  * lpfc_sli4_queue_create - Create all the SLI4 queues
5358  * @phba: pointer to lpfc hba data structure.
5359  *
5360  * This routine is invoked to allocate all the SLI4 queues for the FCoE HBA
5361  * operation. For each SLI4 queue type, the parameters such as queue entry
5362  * count (queue depth) shall be taken from the module parameter. For now,
5363  * we just use some constant number as place holder.
5364  *
5365  * Return codes
5366  *      0 - successful
5367  *      ENOMEM - No availble memory
5368  *      EIO - The mailbox failed to complete successfully.
5369  **/
5370 static int
5371 lpfc_sli4_queue_create(struct lpfc_hba *phba)
5372 {
5373         struct lpfc_queue *qdesc;
5374         int fcp_eqidx, fcp_cqidx, fcp_wqidx;
5375         int cfg_fcp_wq_count;
5376         int cfg_fcp_eq_count;
5377
5378         /*
5379          * Sanity check for confiugred queue parameters against the run-time
5380          * device parameters
5381          */
5382
5383         /* Sanity check on FCP fast-path WQ parameters */
5384         cfg_fcp_wq_count = phba->cfg_fcp_wq_count;
5385         if (cfg_fcp_wq_count >
5386             (phba->sli4_hba.max_cfg_param.max_wq - LPFC_SP_WQN_DEF)) {
5387                 cfg_fcp_wq_count = phba->sli4_hba.max_cfg_param.max_wq -
5388                                    LPFC_SP_WQN_DEF;
5389                 if (cfg_fcp_wq_count < LPFC_FP_WQN_MIN) {
5390                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5391                                         "2581 Not enough WQs (%d) from "
5392                                         "the pci function for supporting "
5393                                         "FCP WQs (%d)\n",
5394                                         phba->sli4_hba.max_cfg_param.max_wq,
5395                                         phba->cfg_fcp_wq_count);
5396                         goto out_error;
5397                 }
5398                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5399                                 "2582 Not enough WQs (%d) from the pci "
5400                                 "function for supporting the requested "
5401                                 "FCP WQs (%d), the actual FCP WQs can "
5402                                 "be supported: %d\n",
5403                                 phba->sli4_hba.max_cfg_param.max_wq,
5404                                 phba->cfg_fcp_wq_count, cfg_fcp_wq_count);
5405         }
5406         /* The actual number of FCP work queues adopted */
5407         phba->cfg_fcp_wq_count = cfg_fcp_wq_count;
5408
5409         /* Sanity check on FCP fast-path EQ parameters */
5410         cfg_fcp_eq_count = phba->cfg_fcp_eq_count;
5411         if (cfg_fcp_eq_count >
5412             (phba->sli4_hba.max_cfg_param.max_eq - LPFC_SP_EQN_DEF)) {
5413                 cfg_fcp_eq_count = phba->sli4_hba.max_cfg_param.max_eq -
5414                                    LPFC_SP_EQN_DEF;
5415                 if (cfg_fcp_eq_count < LPFC_FP_EQN_MIN) {
5416                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5417                                         "2574 Not enough EQs (%d) from the "
5418                                         "pci function for supporting FCP "
5419                                         "EQs (%d)\n",
5420                                         phba->sli4_hba.max_cfg_param.max_eq,
5421                                         phba->cfg_fcp_eq_count);
5422                         goto out_error;
5423                 }
5424                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5425                                 "2575 Not enough EQs (%d) from the pci "
5426                                 "function for supporting the requested "
5427                                 "FCP EQs (%d), the actual FCP EQs can "
5428                                 "be supported: %d\n",
5429                                 phba->sli4_hba.max_cfg_param.max_eq,
5430                                 phba->cfg_fcp_eq_count, cfg_fcp_eq_count);
5431         }
5432         /* It does not make sense to have more EQs than WQs */
5433         if (cfg_fcp_eq_count > phba->cfg_fcp_wq_count) {
5434                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
5435                                 "2593 The FCP EQ count(%d) cannot be greater "
5436                                 "than the FCP WQ count(%d), limiting the "
5437                                 "FCP EQ count to %d\n", cfg_fcp_eq_count,
5438                                 phba->cfg_fcp_wq_count,
5439                                 phba->cfg_fcp_wq_count);
5440                 cfg_fcp_eq_count = phba->cfg_fcp_wq_count;
5441         }
5442         /* The actual number of FCP event queues adopted */
5443         phba->cfg_fcp_eq_count = cfg_fcp_eq_count;
5444         /* The overall number of event queues used */
5445         phba->sli4_hba.cfg_eqn = phba->cfg_fcp_eq_count + LPFC_SP_EQN_DEF;
5446
5447         /*
5448          * Create Event Queues (EQs)
5449          */
5450
5451         /* Get EQ depth from module parameter, fake the default for now */
5452         phba->sli4_hba.eq_esize = LPFC_EQE_SIZE_4B;
5453         phba->sli4_hba.eq_ecount = LPFC_EQE_DEF_COUNT;
5454
5455         /* Create slow path event queue */
5456         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize,
5457                                       phba->sli4_hba.eq_ecount);
5458         if (!qdesc) {
5459                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5460                                 "0496 Failed allocate slow-path EQ\n");
5461                 goto out_error;
5462         }
5463         phba->sli4_hba.sp_eq = qdesc;
5464
5465         /* Create fast-path FCP Event Queue(s) */
5466         phba->sli4_hba.fp_eq = kzalloc((sizeof(struct lpfc_queue *) *
5467                                phba->cfg_fcp_eq_count), GFP_KERNEL);
5468         if (!phba->sli4_hba.fp_eq) {
5469                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5470                                 "2576 Failed allocate memory for fast-path "
5471                                 "EQ record array\n");
5472                 goto out_free_sp_eq;
5473         }
5474         for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_eq_count; fcp_eqidx++) {
5475                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize,
5476                                               phba->sli4_hba.eq_ecount);
5477                 if (!qdesc) {
5478                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5479                                         "0497 Failed allocate fast-path EQ\n");
5480                         goto out_free_fp_eq;
5481                 }
5482                 phba->sli4_hba.fp_eq[fcp_eqidx] = qdesc;
5483         }
5484
5485         /*
5486          * Create Complete Queues (CQs)
5487          */
5488
5489         /* Get CQ depth from module parameter, fake the default for now */
5490         phba->sli4_hba.cq_esize = LPFC_CQE_SIZE;
5491         phba->sli4_hba.cq_ecount = LPFC_CQE_DEF_COUNT;
5492
5493         /* Create slow-path Mailbox Command Complete Queue */
5494         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
5495                                       phba->sli4_hba.cq_ecount);
5496         if (!qdesc) {
5497                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5498                                 "0500 Failed allocate slow-path mailbox CQ\n");
5499                 goto out_free_fp_eq;
5500         }
5501         phba->sli4_hba.mbx_cq = qdesc;
5502
5503         /* Create slow-path ELS Complete Queue */
5504         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
5505                                       phba->sli4_hba.cq_ecount);
5506         if (!qdesc) {
5507                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5508                                 "0501 Failed allocate slow-path ELS CQ\n");
5509                 goto out_free_mbx_cq;
5510         }
5511         phba->sli4_hba.els_cq = qdesc;
5512
5513
5514         /* Create fast-path FCP Completion Queue(s), one-to-one with EQs */
5515         phba->sli4_hba.fcp_cq = kzalloc((sizeof(struct lpfc_queue *) *
5516                                 phba->cfg_fcp_eq_count), GFP_KERNEL);
5517         if (!phba->sli4_hba.fcp_cq) {
5518                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5519                                 "2577 Failed allocate memory for fast-path "
5520                                 "CQ record array\n");
5521                 goto out_free_els_cq;
5522         }
5523         for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++) {
5524                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
5525                                               phba->sli4_hba.cq_ecount);
5526                 if (!qdesc) {
5527                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5528                                         "0499 Failed allocate fast-path FCP "
5529                                         "CQ (%d)\n", fcp_cqidx);
5530                         goto out_free_fcp_cq;
5531                 }
5532                 phba->sli4_hba.fcp_cq[fcp_cqidx] = qdesc;
5533         }
5534
5535         /* Create Mailbox Command Queue */
5536         phba->sli4_hba.mq_esize = LPFC_MQE_SIZE;
5537         phba->sli4_hba.mq_ecount = LPFC_MQE_DEF_COUNT;
5538
5539         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.mq_esize,
5540                                       phba->sli4_hba.mq_ecount);
5541         if (!qdesc) {
5542                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5543                                 "0505 Failed allocate slow-path MQ\n");
5544                 goto out_free_fcp_cq;
5545         }
5546         phba->sli4_hba.mbx_wq = qdesc;
5547
5548         /*
5549          * Create all the Work Queues (WQs)
5550          */
5551         phba->sli4_hba.wq_esize = LPFC_WQE_SIZE;
5552         phba->sli4_hba.wq_ecount = LPFC_WQE_DEF_COUNT;
5553
5554         /* Create slow-path ELS Work Queue */
5555         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize,
5556                                       phba->sli4_hba.wq_ecount);
5557         if (!qdesc) {
5558                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5559                                 "0504 Failed allocate slow-path ELS WQ\n");
5560                 goto out_free_mbx_wq;
5561         }
5562         phba->sli4_hba.els_wq = qdesc;
5563
5564         /* Create fast-path FCP Work Queue(s) */
5565         phba->sli4_hba.fcp_wq = kzalloc((sizeof(struct lpfc_queue *) *
5566                                 phba->cfg_fcp_wq_count), GFP_KERNEL);
5567         if (!phba->sli4_hba.fcp_wq) {
5568                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5569                                 "2578 Failed allocate memory for fast-path "
5570                                 "WQ record array\n");
5571                 goto out_free_els_wq;
5572         }
5573         for (fcp_wqidx = 0; fcp_wqidx < phba->cfg_fcp_wq_count; fcp_wqidx++) {
5574                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize,
5575                                               phba->sli4_hba.wq_ecount);
5576                 if (!qdesc) {
5577                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5578                                         "0503 Failed allocate fast-path FCP "
5579                                         "WQ (%d)\n", fcp_wqidx);
5580                         goto out_free_fcp_wq;
5581                 }
5582                 phba->sli4_hba.fcp_wq[fcp_wqidx] = qdesc;
5583         }
5584
5585         /*
5586          * Create Receive Queue (RQ)
5587          */
5588         phba->sli4_hba.rq_esize = LPFC_RQE_SIZE;
5589         phba->sli4_hba.rq_ecount = LPFC_RQE_DEF_COUNT;
5590
5591         /* Create Receive Queue for header */
5592         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize,
5593                                       phba->sli4_hba.rq_ecount);
5594         if (!qdesc) {
5595                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5596                                 "0506 Failed allocate receive HRQ\n");
5597                 goto out_free_fcp_wq;
5598         }
5599         phba->sli4_hba.hdr_rq = qdesc;
5600
5601         /* Create Receive Queue for data */
5602         qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize,
5603                                       phba->sli4_hba.rq_ecount);
5604         if (!qdesc) {
5605                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5606                                 "0507 Failed allocate receive DRQ\n");
5607                 goto out_free_hdr_rq;
5608         }
5609         phba->sli4_hba.dat_rq = qdesc;
5610
5611         return 0;
5612
5613 out_free_hdr_rq:
5614         lpfc_sli4_queue_free(phba->sli4_hba.hdr_rq);
5615         phba->sli4_hba.hdr_rq = NULL;
5616 out_free_fcp_wq:
5617         for (--fcp_wqidx; fcp_wqidx >= 0; fcp_wqidx--) {
5618                 lpfc_sli4_queue_free(phba->sli4_hba.fcp_wq[fcp_wqidx]);
5619                 phba->sli4_hba.fcp_wq[fcp_wqidx] = NULL;
5620         }
5621         kfree(phba->sli4_hba.fcp_wq);
5622 out_free_els_wq:
5623         lpfc_sli4_queue_free(phba->sli4_hba.els_wq);
5624         phba->sli4_hba.els_wq = NULL;
5625 out_free_mbx_wq:
5626         lpfc_sli4_queue_free(phba->sli4_hba.mbx_wq);
5627         phba->sli4_hba.mbx_wq = NULL;
5628 out_free_fcp_cq:
5629         for (--fcp_cqidx; fcp_cqidx >= 0; fcp_cqidx--) {
5630                 lpfc_sli4_queue_free(phba->sli4_hba.fcp_cq[fcp_cqidx]);
5631                 phba->sli4_hba.fcp_cq[fcp_cqidx] = NULL;
5632         }
5633         kfree(phba->sli4_hba.fcp_cq);
5634 out_free_els_cq:
5635         lpfc_sli4_queue_free(phba->sli4_hba.els_cq);
5636         phba->sli4_hba.els_cq = NULL;
5637 out_free_mbx_cq:
5638         lpfc_sli4_queue_free(phba->sli4_hba.mbx_cq);
5639         phba->sli4_hba.mbx_cq = NULL;
5640 out_free_fp_eq:
5641         for (--fcp_eqidx; fcp_eqidx >= 0; fcp_eqidx--) {
5642                 lpfc_sli4_queue_free(phba->sli4_hba.fp_eq[fcp_eqidx]);
5643                 phba->sli4_hba.fp_eq[fcp_eqidx] = NULL;
5644         }
5645         kfree(phba->sli4_hba.fp_eq);
5646 out_free_sp_eq:
5647         lpfc_sli4_queue_free(phba->sli4_hba.sp_eq);
5648         phba->sli4_hba.sp_eq = NULL;
5649 out_error:
5650         return -ENOMEM;
5651 }
5652
5653 /**
5654  * lpfc_sli4_queue_destroy - Destroy all the SLI4 queues
5655  * @phba: pointer to lpfc hba data structure.
5656  *
5657  * This routine is invoked to release all the SLI4 queues with the FCoE HBA
5658  * operation.
5659  *
5660  * Return codes
5661  *      0 - successful
5662  *      ENOMEM - No availble memory
5663  *      EIO - The mailbox failed to complete successfully.
5664  **/
5665 static void
5666 lpfc_sli4_queue_destroy(struct lpfc_hba *phba)
5667 {
5668         int fcp_qidx;
5669
5670         /* Release mailbox command work queue */
5671         lpfc_sli4_queue_free(phba->sli4_hba.mbx_wq);
5672         phba->sli4_hba.mbx_wq = NULL;
5673
5674         /* Release ELS work queue */
5675         lpfc_sli4_queue_free(phba->sli4_hba.els_wq);
5676         phba->sli4_hba.els_wq = NULL;
5677
5678         /* Release FCP work queue */
5679         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_wq_count; fcp_qidx++)
5680                 lpfc_sli4_queue_free(phba->sli4_hba.fcp_wq[fcp_qidx]);
5681         kfree(phba->sli4_hba.fcp_wq);
5682         phba->sli4_hba.fcp_wq = NULL;
5683
5684         /* Release unsolicited receive queue */
5685         lpfc_sli4_queue_free(phba->sli4_hba.hdr_rq);
5686         phba->sli4_hba.hdr_rq = NULL;
5687         lpfc_sli4_queue_free(phba->sli4_hba.dat_rq);
5688         phba->sli4_hba.dat_rq = NULL;
5689
5690         /* Release ELS complete queue */
5691         lpfc_sli4_queue_free(phba->sli4_hba.els_cq);
5692         phba->sli4_hba.els_cq = NULL;
5693
5694         /* Release mailbox command complete queue */
5695         lpfc_sli4_queue_free(phba->sli4_hba.mbx_cq);
5696         phba->sli4_hba.mbx_cq = NULL;
5697
5698         /* Release FCP response complete queue */
5699         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++)
5700                 lpfc_sli4_queue_free(phba->sli4_hba.fcp_cq[fcp_qidx]);
5701         kfree(phba->sli4_hba.fcp_cq);
5702         phba->sli4_hba.fcp_cq = NULL;
5703
5704         /* Release fast-path event queue */
5705         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++)
5706                 lpfc_sli4_queue_free(phba->sli4_hba.fp_eq[fcp_qidx]);
5707         kfree(phba->sli4_hba.fp_eq);
5708         phba->sli4_hba.fp_eq = NULL;
5709
5710         /* Release slow-path event queue */
5711         lpfc_sli4_queue_free(phba->sli4_hba.sp_eq);
5712         phba->sli4_hba.sp_eq = NULL;
5713
5714         return;
5715 }
5716
5717 /**
5718  * lpfc_sli4_queue_setup - Set up all the SLI4 queues
5719  * @phba: pointer to lpfc hba data structure.
5720  *
5721  * This routine is invoked to set up all the SLI4 queues for the FCoE HBA
5722  * operation.
5723  *
5724  * Return codes
5725  *      0 - successful
5726  *      ENOMEM - No availble memory
5727  *      EIO - The mailbox failed to complete successfully.
5728  **/
5729 int
5730 lpfc_sli4_queue_setup(struct lpfc_hba *phba)
5731 {
5732         int rc = -ENOMEM;
5733         int fcp_eqidx, fcp_cqidx, fcp_wqidx;
5734         int fcp_cq_index = 0;
5735
5736         /*
5737          * Set up Event Queues (EQs)
5738          */
5739
5740         /* Set up slow-path event queue */
5741         if (!phba->sli4_hba.sp_eq) {
5742                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5743                                 "0520 Slow-path EQ not allocated\n");
5744                 goto out_error;
5745         }
5746         rc = lpfc_eq_create(phba, phba->sli4_hba.sp_eq,
5747                             LPFC_SP_DEF_IMAX);
5748         if (rc) {
5749                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5750                                 "0521 Failed setup of slow-path EQ: "
5751                                 "rc = 0x%x\n", rc);
5752                 goto out_error;
5753         }
5754         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5755                         "2583 Slow-path EQ setup: queue-id=%d\n",
5756                         phba->sli4_hba.sp_eq->queue_id);
5757
5758         /* Set up fast-path event queue */
5759         for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_eq_count; fcp_eqidx++) {
5760                 if (!phba->sli4_hba.fp_eq[fcp_eqidx]) {
5761                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5762                                         "0522 Fast-path EQ (%d) not "
5763                                         "allocated\n", fcp_eqidx);
5764                         goto out_destroy_fp_eq;
5765                 }
5766                 rc = lpfc_eq_create(phba, phba->sli4_hba.fp_eq[fcp_eqidx],
5767                                     phba->cfg_fcp_imax);
5768                 if (rc) {
5769                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5770                                         "0523 Failed setup of fast-path EQ "
5771                                         "(%d), rc = 0x%x\n", fcp_eqidx, rc);
5772                         goto out_destroy_fp_eq;
5773                 }
5774                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5775                                 "2584 Fast-path EQ setup: "
5776                                 "queue[%d]-id=%d\n", fcp_eqidx,
5777                                 phba->sli4_hba.fp_eq[fcp_eqidx]->queue_id);
5778         }
5779
5780         /*
5781          * Set up Complete Queues (CQs)
5782          */
5783
5784         /* Set up slow-path MBOX Complete Queue as the first CQ */
5785         if (!phba->sli4_hba.mbx_cq) {
5786                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5787                                 "0528 Mailbox CQ not allocated\n");
5788                 goto out_destroy_fp_eq;
5789         }
5790         rc = lpfc_cq_create(phba, phba->sli4_hba.mbx_cq, phba->sli4_hba.sp_eq,
5791                             LPFC_MCQ, LPFC_MBOX);
5792         if (rc) {
5793                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5794                                 "0529 Failed setup of slow-path mailbox CQ: "
5795                                 "rc = 0x%x\n", rc);
5796                 goto out_destroy_fp_eq;
5797         }
5798         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5799                         "2585 MBX CQ setup: cq-id=%d, parent eq-id=%d\n",
5800                         phba->sli4_hba.mbx_cq->queue_id,
5801                         phba->sli4_hba.sp_eq->queue_id);
5802
5803         /* Set up slow-path ELS Complete Queue */
5804         if (!phba->sli4_hba.els_cq) {
5805                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5806                                 "0530 ELS CQ not allocated\n");
5807                 goto out_destroy_mbx_cq;
5808         }
5809         rc = lpfc_cq_create(phba, phba->sli4_hba.els_cq, phba->sli4_hba.sp_eq,
5810                             LPFC_WCQ, LPFC_ELS);
5811         if (rc) {
5812                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5813                                 "0531 Failed setup of slow-path ELS CQ: "
5814                                 "rc = 0x%x\n", rc);
5815                 goto out_destroy_mbx_cq;
5816         }
5817         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5818                         "2586 ELS CQ setup: cq-id=%d, parent eq-id=%d\n",
5819                         phba->sli4_hba.els_cq->queue_id,
5820                         phba->sli4_hba.sp_eq->queue_id);
5821
5822         /* Set up fast-path FCP Response Complete Queue */
5823         for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++) {
5824                 if (!phba->sli4_hba.fcp_cq[fcp_cqidx]) {
5825                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5826                                         "0526 Fast-path FCP CQ (%d) not "
5827                                         "allocated\n", fcp_cqidx);
5828                         goto out_destroy_fcp_cq;
5829                 }
5830                 rc = lpfc_cq_create(phba, phba->sli4_hba.fcp_cq[fcp_cqidx],
5831                                     phba->sli4_hba.fp_eq[fcp_cqidx],
5832                                     LPFC_WCQ, LPFC_FCP);
5833                 if (rc) {
5834                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5835                                         "0527 Failed setup of fast-path FCP "
5836                                         "CQ (%d), rc = 0x%x\n", fcp_cqidx, rc);
5837                         goto out_destroy_fcp_cq;
5838                 }
5839                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5840                                 "2588 FCP CQ setup: cq[%d]-id=%d, "
5841                                 "parent eq[%d]-id=%d\n",
5842                                 fcp_cqidx,
5843                                 phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id,
5844                                 fcp_cqidx,
5845                                 phba->sli4_hba.fp_eq[fcp_cqidx]->queue_id);
5846         }
5847
5848         /*
5849          * Set up all the Work Queues (WQs)
5850          */
5851
5852         /* Set up Mailbox Command Queue */
5853         if (!phba->sli4_hba.mbx_wq) {
5854                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5855                                 "0538 Slow-path MQ not allocated\n");
5856                 goto out_destroy_fcp_cq;
5857         }
5858         rc = lpfc_mq_create(phba, phba->sli4_hba.mbx_wq,
5859                             phba->sli4_hba.mbx_cq, LPFC_MBOX);
5860         if (rc) {
5861                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5862                                 "0539 Failed setup of slow-path MQ: "
5863                                 "rc = 0x%x\n", rc);
5864                 goto out_destroy_fcp_cq;
5865         }
5866         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5867                         "2589 MBX MQ setup: wq-id=%d, parent cq-id=%d\n",
5868                         phba->sli4_hba.mbx_wq->queue_id,
5869                         phba->sli4_hba.mbx_cq->queue_id);
5870
5871         /* Set up slow-path ELS Work Queue */
5872         if (!phba->sli4_hba.els_wq) {
5873                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5874                                 "0536 Slow-path ELS WQ not allocated\n");
5875                 goto out_destroy_mbx_wq;
5876         }
5877         rc = lpfc_wq_create(phba, phba->sli4_hba.els_wq,
5878                             phba->sli4_hba.els_cq, LPFC_ELS);
5879         if (rc) {
5880                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5881                                 "0537 Failed setup of slow-path ELS WQ: "
5882                                 "rc = 0x%x\n", rc);
5883                 goto out_destroy_mbx_wq;
5884         }
5885         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5886                         "2590 ELS WQ setup: wq-id=%d, parent cq-id=%d\n",
5887                         phba->sli4_hba.els_wq->queue_id,
5888                         phba->sli4_hba.els_cq->queue_id);
5889
5890         /* Set up fast-path FCP Work Queue */
5891         for (fcp_wqidx = 0; fcp_wqidx < phba->cfg_fcp_wq_count; fcp_wqidx++) {
5892                 if (!phba->sli4_hba.fcp_wq[fcp_wqidx]) {
5893                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5894                                         "0534 Fast-path FCP WQ (%d) not "
5895                                         "allocated\n", fcp_wqidx);
5896                         goto out_destroy_fcp_wq;
5897                 }
5898                 rc = lpfc_wq_create(phba, phba->sli4_hba.fcp_wq[fcp_wqidx],
5899                                     phba->sli4_hba.fcp_cq[fcp_cq_index],
5900                                     LPFC_FCP);
5901                 if (rc) {
5902                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5903                                         "0535 Failed setup of fast-path FCP "
5904                                         "WQ (%d), rc = 0x%x\n", fcp_wqidx, rc);
5905                         goto out_destroy_fcp_wq;
5906                 }
5907                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5908                                 "2591 FCP WQ setup: wq[%d]-id=%d, "
5909                                 "parent cq[%d]-id=%d\n",
5910                                 fcp_wqidx,
5911                                 phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id,
5912                                 fcp_cq_index,
5913                                 phba->sli4_hba.fcp_cq[fcp_cq_index]->queue_id);
5914                 /* Round robin FCP Work Queue's Completion Queue assignment */
5915                 fcp_cq_index = ((fcp_cq_index + 1) % phba->cfg_fcp_eq_count);
5916         }
5917
5918         /*
5919          * Create Receive Queue (RQ)
5920          */
5921         if (!phba->sli4_hba.hdr_rq || !phba->sli4_hba.dat_rq) {
5922                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5923                                 "0540 Receive Queue not allocated\n");
5924                 goto out_destroy_fcp_wq;
5925         }
5926         rc = lpfc_rq_create(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq,
5927                             phba->sli4_hba.els_cq, LPFC_USOL);
5928         if (rc) {
5929                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5930                                 "0541 Failed setup of Receive Queue: "
5931                                 "rc = 0x%x\n", rc);
5932                 goto out_destroy_fcp_wq;
5933         }
5934         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5935                         "2592 USL RQ setup: hdr-rq-id=%d, dat-rq-id=%d "
5936                         "parent cq-id=%d\n",
5937                         phba->sli4_hba.hdr_rq->queue_id,
5938                         phba->sli4_hba.dat_rq->queue_id,
5939                         phba->sli4_hba.els_cq->queue_id);
5940         return 0;
5941
5942 out_destroy_fcp_wq:
5943         for (--fcp_wqidx; fcp_wqidx >= 0; fcp_wqidx--)
5944                 lpfc_wq_destroy(phba, phba->sli4_hba.fcp_wq[fcp_wqidx]);
5945         lpfc_wq_destroy(phba, phba->sli4_hba.els_wq);
5946 out_destroy_mbx_wq:
5947         lpfc_mq_destroy(phba, phba->sli4_hba.mbx_wq);
5948 out_destroy_fcp_cq:
5949         for (--fcp_cqidx; fcp_cqidx >= 0; fcp_cqidx--)
5950                 lpfc_cq_destroy(phba, phba->sli4_hba.fcp_cq[fcp_cqidx]);
5951         lpfc_cq_destroy(phba, phba->sli4_hba.els_cq);
5952 out_destroy_mbx_cq:
5953         lpfc_cq_destroy(phba, phba->sli4_hba.mbx_cq);
5954 out_destroy_fp_eq:
5955         for (--fcp_eqidx; fcp_eqidx >= 0; fcp_eqidx--)
5956                 lpfc_eq_destroy(phba, phba->sli4_hba.fp_eq[fcp_eqidx]);
5957         lpfc_eq_destroy(phba, phba->sli4_hba.sp_eq);
5958 out_error:
5959         return rc;
5960 }
5961
5962 /**
5963  * lpfc_sli4_queue_unset - Unset all the SLI4 queues
5964  * @phba: pointer to lpfc hba data structure.
5965  *
5966  * This routine is invoked to unset all the SLI4 queues with the FCoE HBA
5967  * operation.
5968  *
5969  * Return codes
5970  *      0 - successful
5971  *      ENOMEM - No availble memory
5972  *      EIO - The mailbox failed to complete successfully.
5973  **/
5974 void
5975 lpfc_sli4_queue_unset(struct lpfc_hba *phba)
5976 {
5977         int fcp_qidx;
5978
5979         /* Unset mailbox command work queue */
5980         lpfc_mq_destroy(phba, phba->sli4_hba.mbx_wq);
5981         /* Unset ELS work queue */
5982         lpfc_wq_destroy(phba, phba->sli4_hba.els_wq);
5983         /* Unset unsolicited receive queue */
5984         lpfc_rq_destroy(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq);
5985         /* Unset FCP work queue */
5986         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_wq_count; fcp_qidx++)
5987                 lpfc_wq_destroy(phba, phba->sli4_hba.fcp_wq[fcp_qidx]);
5988         /* Unset mailbox command complete queue */
5989         lpfc_cq_destroy(phba, phba->sli4_hba.mbx_cq);
5990         /* Unset ELS complete queue */
5991         lpfc_cq_destroy(phba, phba->sli4_hba.els_cq);
5992         /* Unset FCP response complete queue */
5993         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++)
5994                 lpfc_cq_destroy(phba, phba->sli4_hba.fcp_cq[fcp_qidx]);
5995         /* Unset fast-path event queue */
5996         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++)
5997                 lpfc_eq_destroy(phba, phba->sli4_hba.fp_eq[fcp_qidx]);
5998         /* Unset slow-path event queue */
5999         lpfc_eq_destroy(phba, phba->sli4_hba.sp_eq);
6000 }
6001
6002 /**
6003  * lpfc_sli4_cq_event_pool_create - Create completion-queue event free pool
6004  * @phba: pointer to lpfc hba data structure.
6005  *
6006  * This routine is invoked to allocate and set up a pool of completion queue
6007  * events. The body of the completion queue event is a completion queue entry
6008  * CQE. For now, this pool is used for the interrupt service routine to queue
6009  * the following HBA completion queue events for the worker thread to process:
6010  *   - Mailbox asynchronous events
6011  *   - Receive queue completion unsolicited events
6012  * Later, this can be used for all the slow-path events.
6013  *
6014  * Return codes
6015  *      0 - successful
6016  *      -ENOMEM - No availble memory
6017  **/
6018 static int
6019 lpfc_sli4_cq_event_pool_create(struct lpfc_hba *phba)
6020 {
6021         struct lpfc_cq_event *cq_event;
6022         int i;
6023
6024         for (i = 0; i < (4 * phba->sli4_hba.cq_ecount); i++) {
6025                 cq_event = kmalloc(sizeof(struct lpfc_cq_event), GFP_KERNEL);
6026                 if (!cq_event)
6027                         goto out_pool_create_fail;
6028                 list_add_tail(&cq_event->list,
6029                               &phba->sli4_hba.sp_cqe_event_pool);
6030         }
6031         return 0;
6032
6033 out_pool_create_fail:
6034         lpfc_sli4_cq_event_pool_destroy(phba);
6035         return -ENOMEM;
6036 }
6037
6038 /**
6039  * lpfc_sli4_cq_event_pool_destroy - Free completion-queue event free pool
6040  * @phba: pointer to lpfc hba data structure.
6041  *
6042  * This routine is invoked to free the pool of completion queue events at
6043  * driver unload time. Note that, it is the responsibility of the driver
6044  * cleanup routine to free all the outstanding completion-queue events
6045  * allocated from this pool back into the pool before invoking this routine
6046  * to destroy the pool.
6047  **/
6048 static void
6049 lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *phba)
6050 {
6051         struct lpfc_cq_event *cq_event, *next_cq_event;
6052
6053         list_for_each_entry_safe(cq_event, next_cq_event,
6054                                  &phba->sli4_hba.sp_cqe_event_pool, list) {
6055                 list_del(&cq_event->list);
6056                 kfree(cq_event);
6057         }
6058 }
6059
6060 /**
6061  * __lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool
6062  * @phba: pointer to lpfc hba data structure.
6063  *
6064  * This routine is the lock free version of the API invoked to allocate a
6065  * completion-queue event from the free pool.
6066  *
6067  * Return: Pointer to the newly allocated completion-queue event if successful
6068  *         NULL otherwise.
6069  **/
6070 struct lpfc_cq_event *
6071 __lpfc_sli4_cq_event_alloc(struct lpfc_hba *phba)
6072 {
6073         struct lpfc_cq_event *cq_event = NULL;
6074
6075         list_remove_head(&phba->sli4_hba.sp_cqe_event_pool, cq_event,
6076                          struct lpfc_cq_event, list);
6077         return cq_event;
6078 }
6079
6080 /**
6081  * lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool
6082  * @phba: pointer to lpfc hba data structure.
6083  *
6084  * This routine is the lock version of the API invoked to allocate a
6085  * completion-queue event from the free pool.
6086  *
6087  * Return: Pointer to the newly allocated completion-queue event if successful
6088  *         NULL otherwise.
6089  **/
6090 struct lpfc_cq_event *
6091 lpfc_sli4_cq_event_alloc(struct lpfc_hba *phba)
6092 {
6093         struct lpfc_cq_event *cq_event;
6094         unsigned long iflags;
6095
6096         spin_lock_irqsave(&phba->hbalock, iflags);
6097         cq_event = __lpfc_sli4_cq_event_alloc(phba);
6098         spin_unlock_irqrestore(&phba->hbalock, iflags);
6099         return cq_event;
6100 }
6101
6102 /**
6103  * __lpfc_sli4_cq_event_release - Release a completion-queue event to free pool
6104  * @phba: pointer to lpfc hba data structure.
6105  * @cq_event: pointer to the completion queue event to be freed.
6106  *
6107  * This routine is the lock free version of the API invoked to release a
6108  * completion-queue event back into the free pool.
6109  **/
6110 void
6111 __lpfc_sli4_cq_event_release(struct lpfc_hba *phba,
6112                              struct lpfc_cq_event *cq_event)
6113 {
6114         list_add_tail(&cq_event->list, &phba->sli4_hba.sp_cqe_event_pool);
6115 }
6116
6117 /**
6118  * lpfc_sli4_cq_event_release - Release a completion-queue event to free pool
6119  * @phba: pointer to lpfc hba data structure.
6120  * @cq_event: pointer to the completion queue event to be freed.
6121  *
6122  * This routine is the lock version of the API invoked to release a
6123  * completion-queue event back into the free pool.
6124  **/
6125 void
6126 lpfc_sli4_cq_event_release(struct lpfc_hba *phba,
6127                            struct lpfc_cq_event *cq_event)
6128 {
6129         unsigned long iflags;
6130         spin_lock_irqsave(&phba->hbalock, iflags);
6131         __lpfc_sli4_cq_event_release(phba, cq_event);
6132         spin_unlock_irqrestore(&phba->hbalock, iflags);
6133 }
6134
6135 /**
6136  * lpfc_sli4_cq_event_release_all - Release all cq events to the free pool
6137  * @phba: pointer to lpfc hba data structure.
6138  *
6139  * This routine is to free all the pending completion-queue events to the
6140  * back into the free pool for device reset.
6141  **/
6142 static void
6143 lpfc_sli4_cq_event_release_all(struct lpfc_hba *phba)
6144 {
6145         LIST_HEAD(cqelist);
6146         struct lpfc_cq_event *cqe;
6147         unsigned long iflags;
6148
6149         /* Retrieve all the pending WCQEs from pending WCQE lists */
6150         spin_lock_irqsave(&phba->hbalock, iflags);
6151         /* Pending FCP XRI abort events */
6152         list_splice_init(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue,
6153                          &cqelist);
6154         /* Pending ELS XRI abort events */
6155         list_splice_init(&phba->sli4_hba.sp_els_xri_aborted_work_queue,
6156                          &cqelist);
6157         /* Pending asynnc events */
6158         list_splice_init(&phba->sli4_hba.sp_asynce_work_queue,
6159                          &cqelist);
6160         spin_unlock_irqrestore(&phba->hbalock, iflags);
6161
6162         while (!list_empty(&cqelist)) {
6163                 list_remove_head(&cqelist, cqe, struct lpfc_cq_event, list);
6164                 lpfc_sli4_cq_event_release(phba, cqe);
6165         }
6166 }
6167
6168 /**
6169  * lpfc_pci_function_reset - Reset pci function.
6170  * @phba: pointer to lpfc hba data structure.
6171  *
6172  * This routine is invoked to request a PCI function reset. It will destroys
6173  * all resources assigned to the PCI function which originates this request.
6174  *
6175  * Return codes
6176  *      0 - successful
6177  *      ENOMEM - No availble memory
6178  *      EIO - The mailbox failed to complete successfully.
6179  **/
6180 int
6181 lpfc_pci_function_reset(struct lpfc_hba *phba)
6182 {
6183         LPFC_MBOXQ_t *mboxq;
6184         uint32_t rc = 0;
6185         uint32_t shdr_status, shdr_add_status;
6186         union lpfc_sli4_cfg_shdr *shdr;
6187
6188         mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6189         if (!mboxq) {
6190                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6191                                 "0494 Unable to allocate memory for issuing "
6192                                 "SLI_FUNCTION_RESET mailbox command\n");
6193                 return -ENOMEM;
6194         }
6195
6196         /* Set up PCI function reset SLI4_CONFIG mailbox-ioctl command */
6197         lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
6198                          LPFC_MBOX_OPCODE_FUNCTION_RESET, 0,
6199                          LPFC_SLI4_MBX_EMBED);
6200         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6201         shdr = (union lpfc_sli4_cfg_shdr *)
6202                 &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
6203         shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
6204         shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
6205         if (rc != MBX_TIMEOUT)
6206                 mempool_free(mboxq, phba->mbox_mem_pool);
6207         if (shdr_status || shdr_add_status || rc) {
6208                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6209                                 "0495 SLI_FUNCTION_RESET mailbox failed with "
6210                                 "status x%x add_status x%x, mbx status x%x\n",
6211                                 shdr_status, shdr_add_status, rc);
6212                 rc = -ENXIO;
6213         }
6214         return rc;
6215 }
6216
6217 /**
6218  * lpfc_sli4_send_nop_mbox_cmds - Send sli-4 nop mailbox commands
6219  * @phba: pointer to lpfc hba data structure.
6220  * @cnt: number of nop mailbox commands to send.
6221  *
6222  * This routine is invoked to send a number @cnt of NOP mailbox command and
6223  * wait for each command to complete.
6224  *
6225  * Return: the number of NOP mailbox command completed.
6226  **/
6227 static int
6228 lpfc_sli4_send_nop_mbox_cmds(struct lpfc_hba *phba, uint32_t cnt)
6229 {
6230         LPFC_MBOXQ_t *mboxq;
6231         int length, cmdsent;
6232         uint32_t mbox_tmo;
6233         uint32_t rc = 0;
6234         uint32_t shdr_status, shdr_add_status;
6235         union lpfc_sli4_cfg_shdr *shdr;
6236
6237         if (cnt == 0) {
6238                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6239                                 "2518 Requested to send 0 NOP mailbox cmd\n");
6240                 return cnt;
6241         }
6242
6243         mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6244         if (!mboxq) {
6245                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6246                                 "2519 Unable to allocate memory for issuing "
6247                                 "NOP mailbox command\n");
6248                 return 0;
6249         }
6250
6251         /* Set up NOP SLI4_CONFIG mailbox-ioctl command */
6252         length = (sizeof(struct lpfc_mbx_nop) -
6253                   sizeof(struct lpfc_sli4_cfg_mhdr));
6254         lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
6255                          LPFC_MBOX_OPCODE_NOP, length, LPFC_SLI4_MBX_EMBED);
6256
6257         mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
6258         for (cmdsent = 0; cmdsent < cnt; cmdsent++) {
6259                 if (!phba->sli4_hba.intr_enable)
6260                         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
6261                 else
6262                         rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
6263                 if (rc == MBX_TIMEOUT)
6264                         break;
6265                 /* Check return status */
6266                 shdr = (union lpfc_sli4_cfg_shdr *)
6267                         &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
6268                 shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
6269                 shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
6270                                          &shdr->response);
6271                 if (shdr_status || shdr_add_status || rc) {
6272                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6273                                         "2520 NOP mailbox command failed "
6274                                         "status x%x add_status x%x mbx "
6275                                         "status x%x\n", shdr_status,
6276                                         shdr_add_status, rc);
6277                         break;
6278                 }
6279         }
6280
6281         if (rc != MBX_TIMEOUT)
6282                 mempool_free(mboxq, phba->mbox_mem_pool);
6283
6284         return cmdsent;
6285 }
6286
6287 /**
6288  * lpfc_sli4_fcfi_unreg - Unregister fcfi to device
6289  * @phba: pointer to lpfc hba data structure.
6290  * @fcfi: fcf index.
6291  *
6292  * This routine is invoked to unregister a FCFI from device.
6293  **/
6294 void
6295 lpfc_sli4_fcfi_unreg(struct lpfc_hba *phba, uint16_t fcfi)
6296 {
6297         LPFC_MBOXQ_t *mbox;
6298         uint32_t mbox_tmo;
6299         int rc;
6300         unsigned long flags;
6301
6302         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6303
6304         if (!mbox)
6305                 return;
6306
6307         lpfc_unreg_fcfi(mbox, fcfi);
6308
6309         if (!phba->sli4_hba.intr_enable)
6310                 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
6311         else {
6312                 mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
6313                 rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
6314         }
6315         if (rc != MBX_TIMEOUT)
6316                 mempool_free(mbox, phba->mbox_mem_pool);
6317         if (rc != MBX_SUCCESS)
6318                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
6319                                 "2517 Unregister FCFI command failed "
6320                                 "status %d, mbxStatus x%x\n", rc,
6321                                 bf_get(lpfc_mqe_status, &mbox->u.mqe));
6322         else {
6323                 spin_lock_irqsave(&phba->hbalock, flags);
6324                 /* Mark the FCFI is no longer registered */
6325                 phba->fcf.fcf_flag &=
6326                         ~(FCF_AVAILABLE | FCF_REGISTERED | FCF_SCAN_DONE);
6327                 spin_unlock_irqrestore(&phba->hbalock, flags);
6328         }
6329 }
6330
6331 /**
6332  * lpfc_sli4_pci_mem_setup - Setup SLI4 HBA PCI memory space.
6333  * @phba: pointer to lpfc hba data structure.
6334  *
6335  * This routine is invoked to set up the PCI device memory space for device
6336  * with SLI-4 interface spec.
6337  *
6338  * Return codes
6339  *      0 - successful
6340  *      other values - error
6341  **/
6342 static int
6343 lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
6344 {
6345         struct pci_dev *pdev;
6346         unsigned long bar0map_len, bar1map_len, bar2map_len;
6347         int error = -ENODEV;
6348
6349         /* Obtain PCI device reference */
6350         if (!phba->pcidev)
6351                 return error;
6352         else
6353                 pdev = phba->pcidev;
6354
6355         /* Set the device DMA mask size */
6356         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
6357          || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
6358                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
6359                  || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
6360                         return error;
6361                 }
6362         }
6363
6364         /* Get the bus address of SLI4 device Bar0, Bar1, and Bar2 and the
6365          * number of bytes required by each mapping. They are actually
6366          * mapping to the PCI BAR regions 0 or 1, 2, and 4 by the SLI4 device.
6367          */
6368         if (pci_resource_start(pdev, 0)) {
6369                 phba->pci_bar0_map = pci_resource_start(pdev, 0);
6370                 bar0map_len = pci_resource_len(pdev, 0);
6371         } else {
6372                 phba->pci_bar0_map = pci_resource_start(pdev, 1);
6373                 bar0map_len = pci_resource_len(pdev, 1);
6374         }
6375         phba->pci_bar1_map = pci_resource_start(pdev, 2);
6376         bar1map_len = pci_resource_len(pdev, 2);
6377
6378         phba->pci_bar2_map = pci_resource_start(pdev, 4);
6379         bar2map_len = pci_resource_len(pdev, 4);
6380
6381         /* Map SLI4 PCI Config Space Register base to a kernel virtual addr */
6382         phba->sli4_hba.conf_regs_memmap_p =
6383                                 ioremap(phba->pci_bar0_map, bar0map_len);
6384         if (!phba->sli4_hba.conf_regs_memmap_p) {
6385                 dev_printk(KERN_ERR, &pdev->dev,
6386                            "ioremap failed for SLI4 PCI config registers.\n");
6387                 goto out;
6388         }
6389
6390         /* Map SLI4 HBA Control Register base to a kernel virtual address. */
6391         phba->sli4_hba.ctrl_regs_memmap_p =
6392                                 ioremap(phba->pci_bar1_map, bar1map_len);
6393         if (!phba->sli4_hba.ctrl_regs_memmap_p) {
6394                 dev_printk(KERN_ERR, &pdev->dev,
6395                            "ioremap failed for SLI4 HBA control registers.\n");
6396                 goto out_iounmap_conf;
6397         }
6398
6399         /* Map SLI4 HBA Doorbell Register base to a kernel virtual address. */
6400         phba->sli4_hba.drbl_regs_memmap_p =
6401                                 ioremap(phba->pci_bar2_map, bar2map_len);
6402         if (!phba->sli4_hba.drbl_regs_memmap_p) {
6403                 dev_printk(KERN_ERR, &pdev->dev,
6404                            "ioremap failed for SLI4 HBA doorbell registers.\n");
6405                 goto out_iounmap_ctrl;
6406         }
6407
6408         /* Set up BAR0 PCI config space register memory map */
6409         lpfc_sli4_bar0_register_memmap(phba);
6410
6411         /* Set up BAR1 register memory map */
6412         lpfc_sli4_bar1_register_memmap(phba);
6413
6414         /* Set up BAR2 register memory map */
6415         error = lpfc_sli4_bar2_register_memmap(phba, LPFC_VF0);
6416         if (error)
6417                 goto out_iounmap_all;
6418
6419         return 0;
6420
6421 out_iounmap_all:
6422         iounmap(phba->sli4_hba.drbl_regs_memmap_p);
6423 out_iounmap_ctrl:
6424         iounmap(phba->sli4_hba.ctrl_regs_memmap_p);
6425 out_iounmap_conf:
6426         iounmap(phba->sli4_hba.conf_regs_memmap_p);
6427 out:
6428         return error;
6429 }
6430
6431 /**
6432  * lpfc_sli4_pci_mem_unset - Unset SLI4 HBA PCI memory space.
6433  * @phba: pointer to lpfc hba data structure.
6434  *
6435  * This routine is invoked to unset the PCI device memory space for device
6436  * with SLI-4 interface spec.
6437  **/
6438 static void
6439 lpfc_sli4_pci_mem_unset(struct lpfc_hba *phba)
6440 {
6441         struct pci_dev *pdev;
6442
6443         /* Obtain PCI device reference */
6444         if (!phba->pcidev)
6445                 return;
6446         else
6447                 pdev = phba->pcidev;
6448
6449         /* Free coherent DMA memory allocated */
6450
6451         /* Unmap I/O memory space */
6452         iounmap(phba->sli4_hba.drbl_regs_memmap_p);
6453         iounmap(phba->sli4_hba.ctrl_regs_memmap_p);
6454         iounmap(phba->sli4_hba.conf_regs_memmap_p);
6455
6456         return;
6457 }
6458
6459 /**
6460  * lpfc_sli_enable_msix - Enable MSI-X interrupt mode on SLI-3 device
6461  * @phba: pointer to lpfc hba data structure.
6462  *
6463  * This routine is invoked to enable the MSI-X interrupt vectors to device
6464  * with SLI-3 interface specs. The kernel function pci_enable_msix() is
6465  * called to enable the MSI-X vectors. Note that pci_enable_msix(), once
6466  * invoked, enables either all or nothing, depending on the current
6467  * availability of PCI vector resources. The device driver is responsible
6468  * for calling the individual request_irq() to register each MSI-X vector
6469  * with a interrupt handler, which is done in this function. Note that
6470  * later when device is unloading, the driver should always call free_irq()
6471  * on all MSI-X vectors it has done request_irq() on before calling
6472  * pci_disable_msix(). Failure to do so results in a BUG_ON() and a device
6473  * will be left with MSI-X enabled and leaks its vectors.
6474  *
6475  * Return codes
6476  *   0 - successful
6477  *   other values - error
6478  **/
6479 static int
6480 lpfc_sli_enable_msix(struct lpfc_hba *phba)
6481 {
6482         int rc, i;
6483         LPFC_MBOXQ_t *pmb;
6484
6485         /* Set up MSI-X multi-message vectors */
6486         for (i = 0; i < LPFC_MSIX_VECTORS; i++)
6487                 phba->msix_entries[i].entry = i;
6488
6489         /* Configure MSI-X capability structure */
6490         rc = pci_enable_msix(phba->pcidev, phba->msix_entries,
6491                                 ARRAY_SIZE(phba->msix_entries));
6492         if (rc) {
6493                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6494                                 "0420 PCI enable MSI-X failed (%d)\n", rc);
6495                 goto msi_fail_out;
6496         }
6497         for (i = 0; i < LPFC_MSIX_VECTORS; i++)
6498                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6499                                 "0477 MSI-X entry[%d]: vector=x%x "
6500                                 "message=%d\n", i,
6501                                 phba->msix_entries[i].vector,
6502                                 phba->msix_entries[i].entry);
6503         /*
6504          * Assign MSI-X vectors to interrupt handlers
6505          */
6506
6507         /* vector-0 is associated to slow-path handler */
6508         rc = request_irq(phba->msix_entries[0].vector,
6509                          &lpfc_sli_sp_intr_handler, IRQF_SHARED,
6510                          LPFC_SP_DRIVER_HANDLER_NAME, phba);
6511         if (rc) {
6512                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6513                                 "0421 MSI-X slow-path request_irq failed "
6514                                 "(%d)\n", rc);
6515                 goto msi_fail_out;
6516         }
6517
6518         /* vector-1 is associated to fast-path handler */
6519         rc = request_irq(phba->msix_entries[1].vector,
6520                          &lpfc_sli_fp_intr_handler, IRQF_SHARED,
6521                          LPFC_FP_DRIVER_HANDLER_NAME, phba);
6522
6523         if (rc) {
6524                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6525                                 "0429 MSI-X fast-path request_irq failed "
6526                                 "(%d)\n", rc);
6527                 goto irq_fail_out;
6528         }
6529
6530         /*
6531          * Configure HBA MSI-X attention conditions to messages
6532          */
6533         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6534
6535         if (!pmb) {
6536                 rc = -ENOMEM;
6537                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6538                                 "0474 Unable to allocate memory for issuing "
6539                                 "MBOX_CONFIG_MSI command\n");
6540                 goto mem_fail_out;
6541         }
6542         rc = lpfc_config_msi(phba, pmb);
6543         if (rc)
6544                 goto mbx_fail_out;
6545         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
6546         if (rc != MBX_SUCCESS) {
6547                 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
6548                                 "0351 Config MSI mailbox command failed, "
6549                                 "mbxCmd x%x, mbxStatus x%x\n",
6550                                 pmb->u.mb.mbxCommand, pmb->u.mb.mbxStatus);
6551                 goto mbx_fail_out;
6552         }
6553
6554         /* Free memory allocated for mailbox command */
6555         mempool_free(pmb, phba->mbox_mem_pool);
6556         return rc;
6557
6558 mbx_fail_out:
6559         /* Free memory allocated for mailbox command */
6560         mempool_free(pmb, phba->mbox_mem_pool);
6561
6562 mem_fail_out:
6563         /* free the irq already requested */
6564         free_irq(phba->msix_entries[1].vector, phba);
6565
6566 irq_fail_out:
6567         /* free the irq already requested */
6568         free_irq(phba->msix_entries[0].vector, phba);
6569
6570 msi_fail_out:
6571         /* Unconfigure MSI-X capability structure */
6572         pci_disable_msix(phba->pcidev);
6573         return rc;
6574 }
6575
6576 /**
6577  * lpfc_sli_disable_msix - Disable MSI-X interrupt mode on SLI-3 device.
6578  * @phba: pointer to lpfc hba data structure.
6579  *
6580  * This routine is invoked to release the MSI-X vectors and then disable the
6581  * MSI-X interrupt mode to device with SLI-3 interface spec.
6582  **/
6583 static void
6584 lpfc_sli_disable_msix(struct lpfc_hba *phba)
6585 {
6586         int i;
6587
6588         /* Free up MSI-X multi-message vectors */
6589         for (i = 0; i < LPFC_MSIX_VECTORS; i++)
6590                 free_irq(phba->msix_entries[i].vector, phba);
6591         /* Disable MSI-X */
6592         pci_disable_msix(phba->pcidev);
6593
6594         return;
6595 }
6596
6597 /**
6598  * lpfc_sli_enable_msi - Enable MSI interrupt mode on SLI-3 device.
6599  * @phba: pointer to lpfc hba data structure.
6600  *
6601  * This routine is invoked to enable the MSI interrupt mode to device with
6602  * SLI-3 interface spec. The kernel function pci_enable_msi() is called to
6603  * enable the MSI vector. The device driver is responsible for calling the
6604  * request_irq() to register MSI vector with a interrupt the handler, which
6605  * is done in this function.
6606  *
6607  * Return codes
6608  *      0 - successful
6609  *      other values - error
6610  */
6611 static int
6612 lpfc_sli_enable_msi(struct lpfc_hba *phba)
6613 {
6614         int rc;
6615
6616         rc = pci_enable_msi(phba->pcidev);
6617         if (!rc)
6618                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6619                                 "0462 PCI enable MSI mode success.\n");
6620         else {
6621                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6622                                 "0471 PCI enable MSI mode failed (%d)\n", rc);
6623                 return rc;
6624         }
6625
6626         rc = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler,
6627                          IRQF_SHARED, LPFC_DRIVER_NAME, phba);
6628         if (rc) {
6629                 pci_disable_msi(phba->pcidev);
6630                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6631                                 "0478 MSI request_irq failed (%d)\n", rc);
6632         }
6633         return rc;
6634 }
6635
6636 /**
6637  * lpfc_sli_disable_msi - Disable MSI interrupt mode to SLI-3 device.
6638  * @phba: pointer to lpfc hba data structure.
6639  *
6640  * This routine is invoked to disable the MSI interrupt mode to device with
6641  * SLI-3 interface spec. The driver calls free_irq() on MSI vector it has
6642  * done request_irq() on before calling pci_disable_msi(). Failure to do so
6643  * results in a BUG_ON() and a device will be left with MSI enabled and leaks
6644  * its vector.
6645  */
6646 static void
6647 lpfc_sli_disable_msi(struct lpfc_hba *phba)
6648 {
6649         free_irq(phba->pcidev->irq, phba);
6650         pci_disable_msi(phba->pcidev);
6651         return;
6652 }
6653
6654 /**
6655  * lpfc_sli_enable_intr - Enable device interrupt to SLI-3 device.
6656  * @phba: pointer to lpfc hba data structure.
6657  *
6658  * This routine is invoked to enable device interrupt and associate driver's
6659  * interrupt handler(s) to interrupt vector(s) to device with SLI-3 interface
6660  * spec. Depends on the interrupt mode configured to the driver, the driver
6661  * will try to fallback from the configured interrupt mode to an interrupt
6662  * mode which is supported by the platform, kernel, and device in the order
6663  * of:
6664  * MSI-X -> MSI -> IRQ.
6665  *
6666  * Return codes
6667  *   0 - successful
6668  *   other values - error
6669  **/
6670 static uint32_t
6671 lpfc_sli_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode)
6672 {
6673         uint32_t intr_mode = LPFC_INTR_ERROR;
6674         int retval;
6675
6676         if (cfg_mode == 2) {
6677                 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
6678                 retval = lpfc_sli_config_port(phba, LPFC_SLI_REV3);
6679                 if (!retval) {
6680                         /* Now, try to enable MSI-X interrupt mode */
6681                         retval = lpfc_sli_enable_msix(phba);
6682                         if (!retval) {
6683                                 /* Indicate initialization to MSI-X mode */
6684                                 phba->intr_type = MSIX;
6685                                 intr_mode = 2;
6686                         }
6687                 }
6688         }
6689
6690         /* Fallback to MSI if MSI-X initialization failed */
6691         if (cfg_mode >= 1 && phba->intr_type == NONE) {
6692                 retval = lpfc_sli_enable_msi(phba);
6693                 if (!retval) {
6694                         /* Indicate initialization to MSI mode */
6695                         phba->intr_type = MSI;
6696                         intr_mode = 1;
6697                 }
6698         }
6699
6700         /* Fallback to INTx if both MSI-X/MSI initalization failed */
6701         if (phba->intr_type == NONE) {
6702                 retval = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler,
6703                                      IRQF_SHARED, LPFC_DRIVER_NAME, phba);
6704                 if (!retval) {
6705                         /* Indicate initialization to INTx mode */
6706                         phba->intr_type = INTx;
6707                         intr_mode = 0;
6708                 }
6709         }
6710         return intr_mode;
6711 }
6712
6713 /**
6714  * lpfc_sli_disable_intr - Disable device interrupt to SLI-3 device.
6715  * @phba: pointer to lpfc hba data structure.
6716  *
6717  * This routine is invoked to disable device interrupt and disassociate the
6718  * driver's interrupt handler(s) from interrupt vector(s) to device with
6719  * SLI-3 interface spec. Depending on the interrupt mode, the driver will
6720  * release the interrupt vector(s) for the message signaled interrupt.
6721  **/
6722 static void
6723 lpfc_sli_disable_intr(struct lpfc_hba *phba)
6724 {
6725         /* Disable the currently initialized interrupt mode */
6726         if (phba->intr_type == MSIX)
6727                 lpfc_sli_disable_msix(phba);
6728         else if (phba->intr_type == MSI)
6729                 lpfc_sli_disable_msi(phba);
6730         else if (phba->intr_type == INTx)
6731                 free_irq(phba->pcidev->irq, phba);
6732
6733         /* Reset interrupt management states */
6734         phba->intr_type = NONE;
6735         phba->sli.slistat.sli_intr = 0;
6736
6737         return;
6738 }
6739
6740 /**
6741  * lpfc_sli4_enable_msix - Enable MSI-X interrupt mode to SLI-4 device
6742  * @phba: pointer to lpfc hba data structure.
6743  *
6744  * This routine is invoked to enable the MSI-X interrupt vectors to device
6745  * with SLI-4 interface spec. The kernel function pci_enable_msix() is called
6746  * to enable the MSI-X vectors. Note that pci_enable_msix(), once invoked,
6747  * enables either all or nothing, depending on the current availability of
6748  * PCI vector resources. The device driver is responsible for calling the
6749  * individual request_irq() to register each MSI-X vector with a interrupt
6750  * handler, which is done in this function. Note that later when device is
6751  * unloading, the driver should always call free_irq() on all MSI-X vectors
6752  * it has done request_irq() on before calling pci_disable_msix(). Failure
6753  * to do so results in a BUG_ON() and a device will be left with MSI-X
6754  * enabled and leaks its vectors.
6755  *
6756  * Return codes
6757  * 0 - successful
6758  * other values - error
6759  **/
6760 static int
6761 lpfc_sli4_enable_msix(struct lpfc_hba *phba)
6762 {
6763         int rc, index;
6764
6765         /* Set up MSI-X multi-message vectors */
6766         for (index = 0; index < phba->sli4_hba.cfg_eqn; index++)
6767                 phba->sli4_hba.msix_entries[index].entry = index;
6768
6769         /* Configure MSI-X capability structure */
6770         rc = pci_enable_msix(phba->pcidev, phba->sli4_hba.msix_entries,
6771                              phba->sli4_hba.cfg_eqn);
6772         if (rc) {
6773                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6774                                 "0484 PCI enable MSI-X failed (%d)\n", rc);
6775                 goto msi_fail_out;
6776         }
6777         /* Log MSI-X vector assignment */
6778         for (index = 0; index < phba->sli4_hba.cfg_eqn; index++)
6779                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6780                                 "0489 MSI-X entry[%d]: vector=x%x "
6781                                 "message=%d\n", index,
6782                                 phba->sli4_hba.msix_entries[index].vector,
6783                                 phba->sli4_hba.msix_entries[index].entry);
6784         /*
6785          * Assign MSI-X vectors to interrupt handlers
6786          */
6787
6788         /* The first vector must associated to slow-path handler for MQ */
6789         rc = request_irq(phba->sli4_hba.msix_entries[0].vector,
6790                          &lpfc_sli4_sp_intr_handler, IRQF_SHARED,
6791                          LPFC_SP_DRIVER_HANDLER_NAME, phba);
6792         if (rc) {
6793                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6794                                 "0485 MSI-X slow-path request_irq failed "
6795                                 "(%d)\n", rc);
6796                 goto msi_fail_out;
6797         }
6798
6799         /* The rest of the vector(s) are associated to fast-path handler(s) */
6800         for (index = 1; index < phba->sli4_hba.cfg_eqn; index++) {
6801                 phba->sli4_hba.fcp_eq_hdl[index - 1].idx = index - 1;
6802                 phba->sli4_hba.fcp_eq_hdl[index - 1].phba = phba;
6803                 rc = request_irq(phba->sli4_hba.msix_entries[index].vector,
6804                                  &lpfc_sli4_fp_intr_handler, IRQF_SHARED,
6805                                  LPFC_FP_DRIVER_HANDLER_NAME,
6806                                  &phba->sli4_hba.fcp_eq_hdl[index - 1]);
6807                 if (rc) {
6808                         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6809                                         "0486 MSI-X fast-path (%d) "
6810                                         "request_irq failed (%d)\n", index, rc);
6811                         goto cfg_fail_out;
6812                 }
6813         }
6814
6815         return rc;
6816
6817 cfg_fail_out:
6818         /* free the irq already requested */
6819         for (--index; index >= 1; index--)
6820                 free_irq(phba->sli4_hba.msix_entries[index - 1].vector,
6821                          &phba->sli4_hba.fcp_eq_hdl[index - 1]);
6822
6823         /* free the irq already requested */
6824         free_irq(phba->sli4_hba.msix_entries[0].vector, phba);
6825
6826 msi_fail_out:
6827         /* Unconfigure MSI-X capability structure */
6828         pci_disable_msix(phba->pcidev);
6829         return rc;
6830 }
6831
6832 /**
6833  * lpfc_sli4_disable_msix - Disable MSI-X interrupt mode to SLI-4 device
6834  * @phba: pointer to lpfc hba data structure.
6835  *
6836  * This routine is invoked to release the MSI-X vectors and then disable the
6837  * MSI-X interrupt mode to device with SLI-4 interface spec.
6838  **/
6839 static void
6840 lpfc_sli4_disable_msix(struct lpfc_hba *phba)
6841 {
6842         int index;
6843
6844         /* Free up MSI-X multi-message vectors */
6845         free_irq(phba->sli4_hba.msix_entries[0].vector, phba);
6846
6847         for (index = 1; index < phba->sli4_hba.cfg_eqn; index++)
6848                 free_irq(phba->sli4_hba.msix_entries[index].vector,
6849                          &phba->sli4_hba.fcp_eq_hdl[index - 1]);
6850         /* Disable MSI-X */
6851         pci_disable_msix(phba->pcidev);
6852
6853         return;
6854 }
6855
6856 /**
6857  * lpfc_sli4_enable_msi - Enable MSI interrupt mode to SLI-4 device
6858  * @phba: pointer to lpfc hba data structure.
6859  *
6860  * This routine is invoked to enable the MSI interrupt mode to device with
6861  * SLI-4 interface spec. The kernel function pci_enable_msi() is called
6862  * to enable the MSI vector. The device driver is responsible for calling
6863  * the request_irq() to register MSI vector with a interrupt the handler,
6864  * which is done in this function.
6865  *
6866  * Return codes
6867  *      0 - successful
6868  *      other values - error
6869  **/
6870 static int
6871 lpfc_sli4_enable_msi(struct lpfc_hba *phba)
6872 {
6873         int rc, index;
6874
6875         rc = pci_enable_msi(phba->pcidev);
6876         if (!rc)
6877                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6878                                 "0487 PCI enable MSI mode success.\n");
6879         else {
6880                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
6881                                 "0488 PCI enable MSI mode failed (%d)\n", rc);
6882                 return rc;
6883         }
6884
6885         rc = request_irq(phba->pcidev->irq, lpfc_sli4_intr_handler,
6886                          IRQF_SHARED, LPFC_DRIVER_NAME, phba);
6887         if (rc) {
6888                 pci_disable_msi(phba->pcidev);
6889                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
6890                                 "0490 MSI request_irq failed (%d)\n", rc);
6891         }
6892
6893         for (index = 0; index < phba->cfg_fcp_eq_count; index++) {
6894                 phba->sli4_hba.fcp_eq_hdl[index].idx = index;
6895                 phba->sli4_hba.fcp_eq_hdl[index].phba = phba;
6896         }
6897
6898         return rc;
6899 }
6900
6901 /**
6902  * lpfc_sli4_disable_msi - Disable MSI interrupt mode to SLI-4 device
6903  * @phba: pointer to lpfc hba data structure.
6904  *
6905  * This routine is invoked to disable the MSI interrupt mode to device with
6906  * SLI-4 interface spec. The driver calls free_irq() on MSI vector it has
6907  * done request_irq() on before calling pci_disable_msi(). Failure to do so
6908  * results in a BUG_ON() and a device will be left with MSI enabled and leaks
6909  * its vector.
6910  **/
6911 static void
6912 lpfc_sli4_disable_msi(struct lpfc_hba *phba)
6913 {
6914         free_irq(phba->pcidev->irq, phba);
6915         pci_disable_msi(phba->pcidev);
6916         return;
6917 }
6918
6919 /**
6920  * lpfc_sli4_enable_intr - Enable device interrupt to SLI-4 device
6921  * @phba: pointer to lpfc hba data structure.
6922  *
6923  * This routine is invoked to enable device interrupt and associate driver's
6924  * interrupt handler(s) to interrupt vector(s) to device with SLI-4
6925  * interface spec. Depends on the interrupt mode configured to the driver,
6926  * the driver will try to fallback from the configured interrupt mode to an
6927  * interrupt mode which is supported by the platform, kernel, and device in
6928  * the order of:
6929  * MSI-X -> MSI -> IRQ.
6930  *
6931  * Return codes
6932  *      0 - successful
6933  *      other values - error
6934  **/
6935 static uint32_t
6936 lpfc_sli4_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode)
6937 {
6938         uint32_t intr_mode = LPFC_INTR_ERROR;
6939         int retval, index;
6940
6941         if (cfg_mode == 2) {
6942                 /* Preparation before conf_msi mbox cmd */
6943                 retval = 0;
6944                 if (!retval) {
6945                         /* Now, try to enable MSI-X interrupt mode */
6946                         retval = lpfc_sli4_enable_msix(phba);
6947                         if (!retval) {
6948                                 /* Indicate initialization to MSI-X mode */
6949                                 phba->intr_type = MSIX;
6950                                 intr_mode = 2;
6951                         }
6952                 }
6953         }
6954
6955         /* Fallback to MSI if MSI-X initialization failed */
6956         if (cfg_mode >= 1 && phba->intr_type == NONE) {
6957                 retval = lpfc_sli4_enable_msi(phba);
6958                 if (!retval) {
6959                         /* Indicate initialization to MSI mode */
6960                         phba->intr_type = MSI;
6961                         intr_mode = 1;
6962                 }
6963         }
6964
6965         /* Fallback to INTx if both MSI-X/MSI initalization failed */
6966         if (phba->intr_type == NONE) {
6967                 retval = request_irq(phba->pcidev->irq, lpfc_sli4_intr_handler,
6968                                      IRQF_SHARED, LPFC_DRIVER_NAME, phba);
6969                 if (!retval) {
6970                         /* Indicate initialization to INTx mode */
6971                         phba->intr_type = INTx;
6972                         intr_mode = 0;
6973                         for (index = 0; index < phba->cfg_fcp_eq_count;
6974                              index++) {
6975                                 phba->sli4_hba.fcp_eq_hdl[index].idx = index;
6976                                 phba->sli4_hba.fcp_eq_hdl[index].phba = phba;
6977                         }
6978                 }
6979         }
6980         return intr_mode;
6981 }
6982
6983 /**
6984  * lpfc_sli4_disable_intr - Disable device interrupt to SLI-4 device
6985  * @phba: pointer to lpfc hba data structure.
6986  *
6987  * This routine is invoked to disable device interrupt and disassociate
6988  * the driver's interrupt handler(s) from interrupt vector(s) to device
6989  * with SLI-4 interface spec. Depending on the interrupt mode, the driver
6990  * will release the interrupt vector(s) for the message signaled interrupt.
6991  **/
6992 static void
6993 lpfc_sli4_disable_intr(struct lpfc_hba *phba)
6994 {
6995         /* Disable the currently initialized interrupt mode */
6996         if (phba->intr_type == MSIX)
6997                 lpfc_sli4_disable_msix(phba);
6998         else if (phba->intr_type == MSI)
6999                 lpfc_sli4_disable_msi(phba);
7000         else if (phba->intr_type == INTx)
7001                 free_irq(phba->pcidev->irq, phba);
7002
7003         /* Reset interrupt management states */
7004         phba->intr_type = NONE;
7005         phba->sli.slistat.sli_intr = 0;
7006
7007         return;
7008 }
7009
7010 /**
7011  * lpfc_unset_hba - Unset SLI3 hba device initialization
7012  * @phba: pointer to lpfc hba data structure.
7013  *
7014  * This routine is invoked to unset the HBA device initialization steps to
7015  * a device with SLI-3 interface spec.
7016  **/
7017 static void
7018 lpfc_unset_hba(struct lpfc_hba *phba)
7019 {
7020         struct lpfc_vport *vport = phba->pport;
7021         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
7022
7023         spin_lock_irq(shost->host_lock);
7024         vport->load_flag |= FC_UNLOADING;
7025         spin_unlock_irq(shost->host_lock);
7026
7027         lpfc_stop_hba_timers(phba);
7028
7029         phba->pport->work_port_events = 0;
7030
7031         lpfc_sli_hba_down(phba);
7032
7033         lpfc_sli_brdrestart(phba);
7034
7035         lpfc_sli_disable_intr(phba);
7036
7037         return;
7038 }
7039
7040 /**
7041  * lpfc_sli4_unset_hba - Unset SLI4 hba device initialization.
7042  * @phba: pointer to lpfc hba data structure.
7043  *
7044  * This routine is invoked to unset the HBA device initialization steps to
7045  * a device with SLI-4 interface spec.
7046  **/
7047 static void
7048 lpfc_sli4_unset_hba(struct lpfc_hba *phba)
7049 {
7050         struct lpfc_vport *vport = phba->pport;
7051         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
7052
7053         spin_lock_irq(shost->host_lock);
7054         vport->load_flag |= FC_UNLOADING;
7055         spin_unlock_irq(shost->host_lock);
7056
7057         phba->pport->work_port_events = 0;
7058
7059         lpfc_sli4_hba_down(phba);
7060
7061         lpfc_sli4_disable_intr(phba);
7062
7063         return;
7064 }
7065
7066 /**
7067  * lpfc_sli4_hba_unset - Unset the fcoe hba
7068  * @phba: Pointer to HBA context object.
7069  *
7070  * This function is called in the SLI4 code path to reset the HBA's FCoE
7071  * function. The caller is not required to hold any lock. This routine
7072  * issues PCI function reset mailbox command to reset the FCoE function.
7073  * At the end of the function, it calls lpfc_hba_down_post function to
7074  * free any pending commands.
7075  **/
7076 static void
7077 lpfc_sli4_hba_unset(struct lpfc_hba *phba)
7078 {
7079         int wait_cnt = 0;
7080         LPFC_MBOXQ_t *mboxq;
7081
7082         lpfc_stop_hba_timers(phba);
7083         phba->sli4_hba.intr_enable = 0;
7084
7085         /*
7086          * Gracefully wait out the potential current outstanding asynchronous
7087          * mailbox command.
7088          */
7089
7090         /* First, block any pending async mailbox command from posted */
7091         spin_lock_irq(&phba->hbalock);
7092         phba->sli.sli_flag |= LPFC_SLI_ASYNC_MBX_BLK;
7093         spin_unlock_irq(&phba->hbalock);
7094         /* Now, trying to wait it out if we can */
7095         while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) {
7096                 msleep(10);
7097                 if (++wait_cnt > LPFC_ACTIVE_MBOX_WAIT_CNT)
7098                         break;
7099         }
7100         /* Forcefully release the outstanding mailbox command if timed out */
7101         if (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) {
7102                 spin_lock_irq(&phba->hbalock);
7103                 mboxq = phba->sli.mbox_active;
7104                 mboxq->u.mb.mbxStatus = MBX_NOT_FINISHED;
7105                 __lpfc_mbox_cmpl_put(phba, mboxq);
7106                 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
7107                 phba->sli.mbox_active = NULL;
7108                 spin_unlock_irq(&phba->hbalock);
7109         }
7110
7111         /* Tear down the queues in the HBA */
7112         lpfc_sli4_queue_unset(phba);
7113
7114         /* Disable PCI subsystem interrupt */
7115         lpfc_sli4_disable_intr(phba);
7116
7117         /* Stop kthread signal shall trigger work_done one more time */
7118         kthread_stop(phba->worker_thread);
7119
7120         /* Stop the SLI4 device port */
7121         phba->pport->work_port_events = 0;
7122 }
7123
7124  /**
7125  * lpfc_pc_sli4_params_get - Get the SLI4_PARAMS port capabilities.
7126  * @phba: Pointer to HBA context object.
7127  * @mboxq: Pointer to the mailboxq memory for the mailbox command response.
7128  *
7129  * This function is called in the SLI4 code path to read the port's
7130  * sli4 capabilities.
7131  *
7132  * This function may be be called from any context that can block-wait
7133  * for the completion.  The expectation is that this routine is called
7134  * typically from probe_one or from the online routine.
7135  **/
7136 int
7137 lpfc_pc_sli4_params_get(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
7138 {
7139         int rc;
7140         struct lpfc_mqe *mqe;
7141         struct lpfc_pc_sli4_params *sli4_params;
7142         uint32_t mbox_tmo;
7143
7144         rc = 0;
7145         mqe = &mboxq->u.mqe;
7146
7147         /* Read the port's SLI4 Parameters port capabilities */
7148         lpfc_sli4_params(mboxq);
7149         if (!phba->sli4_hba.intr_enable)
7150                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
7151         else {
7152                 mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_PORT_CAPABILITIES);
7153                 rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
7154         }
7155
7156         if (unlikely(rc))
7157                 return 1;
7158
7159         sli4_params = &phba->sli4_hba.pc_sli4_params;
7160         sli4_params->if_type = bf_get(if_type, &mqe->un.sli4_params);
7161         sli4_params->sli_rev = bf_get(sli_rev, &mqe->un.sli4_params);
7162         sli4_params->sli_family = bf_get(sli_family, &mqe->un.sli4_params);
7163         sli4_params->featurelevel_1 = bf_get(featurelevel_1,
7164                                              &mqe->un.sli4_params);
7165         sli4_params->featurelevel_2 = bf_get(featurelevel_2,
7166                                              &mqe->un.sli4_params);
7167         sli4_params->proto_types = mqe->un.sli4_params.word3;
7168         sli4_params->sge_supp_len = mqe->un.sli4_params.sge_supp_len;
7169         sli4_params->if_page_sz = bf_get(if_page_sz, &mqe->un.sli4_params);
7170         sli4_params->rq_db_window = bf_get(rq_db_window, &mqe->un.sli4_params);
7171         sli4_params->loopbk_scope = bf_get(loopbk_scope, &mqe->un.sli4_params);
7172         sli4_params->eq_pages_max = bf_get(eq_pages, &mqe->un.sli4_params);
7173         sli4_params->eqe_size = bf_get(eqe_size, &mqe->un.sli4_params);
7174         sli4_params->cq_pages_max = bf_get(cq_pages, &mqe->un.sli4_params);
7175         sli4_params->cqe_size = bf_get(cqe_size, &mqe->un.sli4_params);
7176         sli4_params->mq_pages_max = bf_get(mq_pages, &mqe->un.sli4_params);
7177         sli4_params->mqe_size = bf_get(mqe_size, &mqe->un.sli4_params);
7178         sli4_params->mq_elem_cnt = bf_get(mq_elem_cnt, &mqe->un.sli4_params);
7179         sli4_params->wq_pages_max = bf_get(wq_pages, &mqe->un.sli4_params);
7180         sli4_params->wqe_size = bf_get(wqe_size, &mqe->un.sli4_params);
7181         sli4_params->rq_pages_max = bf_get(rq_pages, &mqe->un.sli4_params);
7182         sli4_params->rqe_size = bf_get(rqe_size, &mqe->un.sli4_params);
7183         sli4_params->hdr_pages_max = bf_get(hdr_pages, &mqe->un.sli4_params);
7184         sli4_params->hdr_size = bf_get(hdr_size, &mqe->un.sli4_params);
7185         sli4_params->hdr_pp_align = bf_get(hdr_pp_align, &mqe->un.sli4_params);
7186         sli4_params->sgl_pages_max = bf_get(sgl_pages, &mqe->un.sli4_params);
7187         sli4_params->sgl_pp_align = bf_get(sgl_pp_align, &mqe->un.sli4_params);
7188         return rc;
7189 }
7190
7191 /**
7192  * lpfc_pci_probe_one_s3 - PCI probe func to reg SLI-3 device to PCI subsystem.
7193  * @pdev: pointer to PCI device
7194  * @pid: pointer to PCI device identifier
7195  *
7196  * This routine is to be called to attach a device with SLI-3 interface spec
7197  * to the PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
7198  * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
7199  * information of the device and driver to see if the driver state that it can
7200  * support this kind of device. If the match is successful, the driver core
7201  * invokes this routine. If this routine determines it can claim the HBA, it
7202  * does all the initialization that it needs to do to handle the HBA properly.
7203  *
7204  * Return code
7205  *      0 - driver can claim the device
7206  *      negative value - driver can not claim the device
7207  **/
7208 static int __devinit
7209 lpfc_pci_probe_one_s3(struct pci_dev *pdev, const struct pci_device_id *pid)
7210 {
7211         struct lpfc_hba   *phba;
7212         struct lpfc_vport *vport = NULL;
7213         struct Scsi_Host  *shost = NULL;
7214         int error;
7215         uint32_t cfg_mode, intr_mode;
7216
7217         /* Allocate memory for HBA structure */
7218         phba = lpfc_hba_alloc(pdev);
7219         if (!phba)
7220                 return -ENOMEM;
7221
7222         /* Perform generic PCI device enabling operation */
7223         error = lpfc_enable_pci_dev(phba);
7224         if (error) {
7225                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7226                                 "1401 Failed to enable pci device.\n");
7227                 goto out_free_phba;
7228         }
7229
7230         /* Set up SLI API function jump table for PCI-device group-0 HBAs */
7231         error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_LP);
7232         if (error)
7233                 goto out_disable_pci_dev;
7234
7235         /* Set up SLI-3 specific device PCI memory space */
7236         error = lpfc_sli_pci_mem_setup(phba);
7237         if (error) {
7238                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7239                                 "1402 Failed to set up pci memory space.\n");
7240                 goto out_disable_pci_dev;
7241         }
7242
7243         /* Set up phase-1 common device driver resources */
7244         error = lpfc_setup_driver_resource_phase1(phba);
7245         if (error) {
7246                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7247                                 "1403 Failed to set up driver resource.\n");
7248                 goto out_unset_pci_mem_s3;
7249         }
7250
7251         /* Set up SLI-3 specific device driver resources */
7252         error = lpfc_sli_driver_resource_setup(phba);
7253         if (error) {
7254                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7255                                 "1404 Failed to set up driver resource.\n");
7256                 goto out_unset_pci_mem_s3;
7257         }
7258
7259         /* Initialize and populate the iocb list per host */
7260         error = lpfc_init_iocb_list(phba, LPFC_IOCB_LIST_CNT);
7261         if (error) {
7262                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7263                                 "1405 Failed to initialize iocb list.\n");
7264                 goto out_unset_driver_resource_s3;
7265         }
7266
7267         /* Set up common device driver resources */
7268         error = lpfc_setup_driver_resource_phase2(phba);
7269         if (error) {
7270                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7271                                 "1406 Failed to set up driver resource.\n");
7272                 goto out_free_iocb_list;
7273         }
7274
7275         /* Create SCSI host to the physical port */
7276         error = lpfc_create_shost(phba);
7277         if (error) {
7278                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7279                                 "1407 Failed to create scsi host.\n");
7280                 goto out_unset_driver_resource;
7281         }
7282
7283         /* Configure sysfs attributes */
7284         vport = phba->pport;
7285         error = lpfc_alloc_sysfs_attr(vport);
7286         if (error) {
7287                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7288                                 "1476 Failed to allocate sysfs attr\n");
7289                 goto out_destroy_shost;
7290         }
7291
7292         shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */
7293         /* Now, trying to enable interrupt and bring up the device */
7294         cfg_mode = phba->cfg_use_msi;
7295         while (true) {
7296                 /* Put device to a known state before enabling interrupt */
7297                 lpfc_stop_port(phba);
7298                 /* Configure and enable interrupt */
7299                 intr_mode = lpfc_sli_enable_intr(phba, cfg_mode);
7300                 if (intr_mode == LPFC_INTR_ERROR) {
7301                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7302                                         "0431 Failed to enable interrupt.\n");
7303                         error = -ENODEV;
7304                         goto out_free_sysfs_attr;
7305                 }
7306                 /* SLI-3 HBA setup */
7307                 if (lpfc_sli_hba_setup(phba)) {
7308                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7309                                         "1477 Failed to set up hba\n");
7310                         error = -ENODEV;
7311                         goto out_remove_device;
7312                 }
7313
7314                 /* Wait 50ms for the interrupts of previous mailbox commands */
7315                 msleep(50);
7316                 /* Check active interrupts on message signaled interrupts */
7317                 if (intr_mode == 0 ||
7318                     phba->sli.slistat.sli_intr > LPFC_MSIX_VECTORS) {
7319                         /* Log the current active interrupt mode */
7320                         phba->intr_mode = intr_mode;
7321                         lpfc_log_intr_mode(phba, intr_mode);
7322                         break;
7323                 } else {
7324                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7325                                         "0447 Configure interrupt mode (%d) "
7326                                         "failed active interrupt test.\n",
7327                                         intr_mode);
7328                         /* Disable the current interrupt mode */
7329                         lpfc_sli_disable_intr(phba);
7330                         /* Try next level of interrupt mode */
7331                         cfg_mode = --intr_mode;
7332                 }
7333         }
7334
7335         /* Perform post initialization setup */
7336         lpfc_post_init_setup(phba);
7337
7338         /* Check if there are static vports to be created. */
7339         lpfc_create_static_vport(phba);
7340
7341         return 0;
7342
7343 out_remove_device:
7344         lpfc_unset_hba(phba);
7345 out_free_sysfs_attr:
7346         lpfc_free_sysfs_attr(vport);
7347 out_destroy_shost:
7348         lpfc_destroy_shost(phba);
7349 out_unset_driver_resource:
7350         lpfc_unset_driver_resource_phase2(phba);
7351 out_free_iocb_list:
7352         lpfc_free_iocb_list(phba);
7353 out_unset_driver_resource_s3:
7354         lpfc_sli_driver_resource_unset(phba);
7355 out_unset_pci_mem_s3:
7356         lpfc_sli_pci_mem_unset(phba);
7357 out_disable_pci_dev:
7358         lpfc_disable_pci_dev(phba);
7359         if (shost)
7360                 scsi_host_put(shost);
7361 out_free_phba:
7362         lpfc_hba_free(phba);
7363         return error;
7364 }
7365
7366 /**
7367  * lpfc_pci_remove_one_s3 - PCI func to unreg SLI-3 device from PCI subsystem.
7368  * @pdev: pointer to PCI device
7369  *
7370  * This routine is to be called to disattach a device with SLI-3 interface
7371  * spec from PCI subsystem. When an Emulex HBA with SLI-3 interface spec is
7372  * removed from PCI bus, it performs all the necessary cleanup for the HBA
7373  * device to be removed from the PCI subsystem properly.
7374  **/
7375 static void __devexit
7376 lpfc_pci_remove_one_s3(struct pci_dev *pdev)
7377 {
7378         struct Scsi_Host  *shost = pci_get_drvdata(pdev);
7379         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
7380         struct lpfc_vport **vports;
7381         struct lpfc_hba   *phba = vport->phba;
7382         int i;
7383         int bars = pci_select_bars(pdev, IORESOURCE_MEM);
7384
7385         spin_lock_irq(&phba->hbalock);
7386         vport->load_flag |= FC_UNLOADING;
7387         spin_unlock_irq(&phba->hbalock);
7388
7389         lpfc_free_sysfs_attr(vport);
7390
7391         /* Release all the vports against this physical port */
7392         vports = lpfc_create_vport_work_array(phba);
7393         if (vports != NULL)
7394                 for (i = 1; i <= phba->max_vports && vports[i] != NULL; i++)
7395                         fc_vport_terminate(vports[i]->fc_vport);
7396         lpfc_destroy_vport_work_array(phba, vports);
7397
7398         /* Remove FC host and then SCSI host with the physical port */
7399         fc_remove_host(shost);
7400         scsi_remove_host(shost);
7401         lpfc_cleanup(vport);
7402
7403         /*
7404          * Bring down the SLI Layer. This step disable all interrupts,
7405          * clears the rings, discards all mailbox commands, and resets
7406          * the HBA.
7407          */
7408
7409         /* HBA interrupt will be diabled after this call */
7410         lpfc_sli_hba_down(phba);
7411         /* Stop kthread signal shall trigger work_done one more time */
7412         kthread_stop(phba->worker_thread);
7413         /* Final cleanup of txcmplq and reset the HBA */
7414         lpfc_sli_brdrestart(phba);
7415
7416         lpfc_stop_hba_timers(phba);
7417         spin_lock_irq(&phba->hbalock);
7418         list_del_init(&vport->listentry);
7419         spin_unlock_irq(&phba->hbalock);
7420
7421         lpfc_debugfs_terminate(vport);
7422
7423         /* Disable interrupt */
7424         lpfc_sli_disable_intr(phba);
7425
7426         pci_set_drvdata(pdev, NULL);
7427         scsi_host_put(shost);
7428
7429         /*
7430          * Call scsi_free before mem_free since scsi bufs are released to their
7431          * corresponding pools here.
7432          */
7433         lpfc_scsi_free(phba);
7434         lpfc_mem_free_all(phba);
7435
7436         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
7437                           phba->hbqslimp.virt, phba->hbqslimp.phys);
7438
7439         /* Free resources associated with SLI2 interface */
7440         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
7441                           phba->slim2p.virt, phba->slim2p.phys);
7442
7443         /* unmap adapter SLIM and Control Registers */
7444         iounmap(phba->ctrl_regs_memmap_p);
7445         iounmap(phba->slim_memmap_p);
7446
7447         lpfc_hba_free(phba);
7448
7449         pci_release_selected_regions(pdev, bars);
7450         pci_disable_device(pdev);
7451 }
7452
7453 /**
7454  * lpfc_pci_suspend_one_s3 - PCI func to suspend SLI-3 device for power mgmnt
7455  * @pdev: pointer to PCI device
7456  * @msg: power management message
7457  *
7458  * This routine is to be called from the kernel's PCI subsystem to support
7459  * system Power Management (PM) to device with SLI-3 interface spec. When
7460  * PM invokes this method, it quiesces the device by stopping the driver's
7461  * worker thread for the device, turning off device's interrupt and DMA,
7462  * and bring the device offline. Note that as the driver implements the
7463  * minimum PM requirements to a power-aware driver's PM support for the
7464  * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
7465  * to the suspend() method call will be treated as SUSPEND and the driver will
7466  * fully reinitialize its device during resume() method call, the driver will
7467  * set device to PCI_D3hot state in PCI config space instead of setting it
7468  * according to the @msg provided by the PM.
7469  *
7470  * Return code
7471  *      0 - driver suspended the device
7472  *      Error otherwise
7473  **/
7474 static int
7475 lpfc_pci_suspend_one_s3(struct pci_dev *pdev, pm_message_t msg)
7476 {
7477         struct Scsi_Host *shost = pci_get_drvdata(pdev);
7478         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
7479
7480         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7481                         "0473 PCI device Power Management suspend.\n");
7482
7483         /* Bring down the device */
7484         lpfc_offline_prep(phba);
7485         lpfc_offline(phba);
7486         kthread_stop(phba->worker_thread);
7487
7488         /* Disable interrupt from device */
7489         lpfc_sli_disable_intr(phba);
7490
7491         /* Save device state to PCI config space */
7492         pci_save_state(pdev);
7493         pci_set_power_state(pdev, PCI_D3hot);
7494
7495         return 0;
7496 }
7497
7498 /**
7499  * lpfc_pci_resume_one_s3 - PCI func to resume SLI-3 device for power mgmnt
7500  * @pdev: pointer to PCI device
7501  *
7502  * This routine is to be called from the kernel's PCI subsystem to support
7503  * system Power Management (PM) to device with SLI-3 interface spec. When PM
7504  * invokes this method, it restores the device's PCI config space state and
7505  * fully reinitializes the device and brings it online. Note that as the
7506  * driver implements the minimum PM requirements to a power-aware driver's
7507  * PM for suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE,
7508  * FREEZE) to the suspend() method call will be treated as SUSPEND and the
7509  * driver will fully reinitialize its device during resume() method call,
7510  * the device will be set to PCI_D0 directly in PCI config space before
7511  * restoring the state.
7512  *
7513  * Return code
7514  *      0 - driver suspended the device
7515  *      Error otherwise
7516  **/
7517 static int
7518 lpfc_pci_resume_one_s3(struct pci_dev *pdev)
7519 {
7520         struct Scsi_Host *shost = pci_get_drvdata(pdev);
7521         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
7522         uint32_t intr_mode;
7523         int error;
7524
7525         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7526                         "0452 PCI device Power Management resume.\n");
7527
7528         /* Restore device state from PCI config space */
7529         pci_set_power_state(pdev, PCI_D0);
7530         pci_restore_state(pdev);
7531
7532         /*
7533          * As the new kernel behavior of pci_restore_state() API call clears
7534          * device saved_state flag, need to save the restored state again.
7535          */
7536         pci_save_state(pdev);
7537
7538         if (pdev->is_busmaster)
7539                 pci_set_master(pdev);
7540
7541         /* Startup the kernel thread for this host adapter. */
7542         phba->worker_thread = kthread_run(lpfc_do_work, phba,
7543                                         "lpfc_worker_%d", phba->brd_no);
7544         if (IS_ERR(phba->worker_thread)) {
7545                 error = PTR_ERR(phba->worker_thread);
7546                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7547                                 "0434 PM resume failed to start worker "
7548                                 "thread: error=x%x.\n", error);
7549                 return error;
7550         }
7551
7552         /* Configure and enable interrupt */
7553         intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
7554         if (intr_mode == LPFC_INTR_ERROR) {
7555                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7556                                 "0430 PM resume Failed to enable interrupt\n");
7557                 return -EIO;
7558         } else
7559                 phba->intr_mode = intr_mode;
7560
7561         /* Restart HBA and bring it online */
7562         lpfc_sli_brdrestart(phba);
7563         lpfc_online(phba);
7564
7565         /* Log the current active interrupt mode */
7566         lpfc_log_intr_mode(phba, phba->intr_mode);
7567
7568         return 0;
7569 }
7570
7571 /**
7572  * lpfc_sli_prep_dev_for_recover - Prepare SLI3 device for pci slot recover
7573  * @phba: pointer to lpfc hba data structure.
7574  *
7575  * This routine is called to prepare the SLI3 device for PCI slot recover. It
7576  * aborts and stops all the on-going I/Os on the pci device.
7577  **/
7578 static void
7579 lpfc_sli_prep_dev_for_recover(struct lpfc_hba *phba)
7580 {
7581         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7582                         "2723 PCI channel I/O abort preparing for recovery\n");
7583         /* Prepare for bringing HBA offline */
7584         lpfc_offline_prep(phba);
7585         /* Clear sli active flag to prevent sysfs access to HBA */
7586         spin_lock_irq(&phba->hbalock);
7587         phba->sli.sli_flag &= ~LPFC_SLI_ACTIVE;
7588         spin_unlock_irq(&phba->hbalock);
7589         /* Stop and flush all I/Os and bring HBA offline */
7590         lpfc_offline(phba);
7591 }
7592
7593 /**
7594  * lpfc_sli_prep_dev_for_reset - Prepare SLI3 device for pci slot reset
7595  * @phba: pointer to lpfc hba data structure.
7596  *
7597  * This routine is called to prepare the SLI3 device for PCI slot reset. It
7598  * disables the device interrupt and pci device, and aborts the internal FCP
7599  * pending I/Os.
7600  **/
7601 static void
7602 lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba)
7603 {
7604         struct lpfc_sli *psli = &phba->sli;
7605         struct lpfc_sli_ring  *pring;
7606
7607         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7608                         "2710 PCI channel disable preparing for reset\n");
7609         /* Disable interrupt and pci device */
7610         lpfc_sli_disable_intr(phba);
7611         pci_disable_device(phba->pcidev);
7612         /*
7613          * There may be I/Os dropped by the firmware.
7614          * Error iocb (I/O) on txcmplq and let the SCSI layer
7615          * retry it after re-establishing link.
7616          */
7617         pring = &psli->ring[psli->fcp_ring];
7618         lpfc_sli_abort_iocb_ring(phba, pring);
7619 }
7620
7621 /**
7622  * lpfc_sli_prep_dev_for_perm_failure - Prepare SLI3 dev for pci slot disable
7623  * @phba: pointer to lpfc hba data structure.
7624  *
7625  * This routine is called to prepare the SLI3 device for PCI slot permanently
7626  * disabling. It blocks the SCSI transport layer traffic and flushes the FCP
7627  * pending I/Os.
7628  **/
7629 static void
7630 lpfc_prep_dev_for_perm_failure(struct lpfc_hba *phba)
7631 {
7632         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7633                         "2711 PCI channel permanent disable for failure\n");
7634         /* Clean up all driver's outstanding SCSI I/Os */
7635         lpfc_sli_flush_fcp_rings(phba);
7636 }
7637
7638 /**
7639  * lpfc_io_error_detected_s3 - Method for handling SLI-3 device PCI I/O error
7640  * @pdev: pointer to PCI device.
7641  * @state: the current PCI connection state.
7642  *
7643  * This routine is called from the PCI subsystem for I/O error handling to
7644  * device with SLI-3 interface spec. This function is called by the PCI
7645  * subsystem after a PCI bus error affecting this device has been detected.
7646  * When this function is invoked, it will need to stop all the I/Os and
7647  * interrupt(s) to the device. Once that is done, it will return
7648  * PCI_ERS_RESULT_NEED_RESET for the PCI subsystem to perform proper recovery
7649  * as desired.
7650  *
7651  * Return codes
7652  *      PCI_ERS_RESULT_CAN_RECOVER - can be recovered with reset_link
7653  *      PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
7654  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
7655  **/
7656 static pci_ers_result_t
7657 lpfc_io_error_detected_s3(struct pci_dev *pdev, pci_channel_state_t state)
7658 {
7659         struct Scsi_Host *shost = pci_get_drvdata(pdev);
7660         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
7661
7662         /* Block all SCSI devices' I/Os on the host */
7663         lpfc_scsi_dev_block(phba);
7664
7665         switch (state) {
7666         case pci_channel_io_normal:
7667                 /* Non-fatal error, prepare for recovery */
7668                 lpfc_sli_prep_dev_for_recover(phba);
7669                 return PCI_ERS_RESULT_CAN_RECOVER;
7670         case pci_channel_io_frozen:
7671                 /* Fatal error, prepare for slot reset */
7672                 lpfc_sli_prep_dev_for_reset(phba);
7673                 return PCI_ERS_RESULT_NEED_RESET;
7674         case pci_channel_io_perm_failure:
7675                 /* Permanent failure, prepare for device down */
7676                 lpfc_prep_dev_for_perm_failure(phba);
7677                 return PCI_ERS_RESULT_DISCONNECT;
7678         default:
7679                 /* Unknown state, prepare and request slot reset */
7680                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7681                                 "0472 Unknown PCI error state: x%x\n", state);
7682                 lpfc_sli_prep_dev_for_reset(phba);
7683                 return PCI_ERS_RESULT_NEED_RESET;
7684         }
7685 }
7686
7687 /**
7688  * lpfc_io_slot_reset_s3 - Method for restarting PCI SLI-3 device from scratch.
7689  * @pdev: pointer to PCI device.
7690  *
7691  * This routine is called from the PCI subsystem for error handling to
7692  * device with SLI-3 interface spec. This is called after PCI bus has been
7693  * reset to restart the PCI card from scratch, as if from a cold-boot.
7694  * During the PCI subsystem error recovery, after driver returns
7695  * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
7696  * recovery and then call this routine before calling the .resume method
7697  * to recover the device. This function will initialize the HBA device,
7698  * enable the interrupt, but it will just put the HBA to offline state
7699  * without passing any I/O traffic.
7700  *
7701  * Return codes
7702  *      PCI_ERS_RESULT_RECOVERED - the device has been recovered
7703  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
7704  */
7705 static pci_ers_result_t
7706 lpfc_io_slot_reset_s3(struct pci_dev *pdev)
7707 {
7708         struct Scsi_Host *shost = pci_get_drvdata(pdev);
7709         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
7710         struct lpfc_sli *psli = &phba->sli;
7711         uint32_t intr_mode;
7712
7713         dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
7714         if (pci_enable_device_mem(pdev)) {
7715                 printk(KERN_ERR "lpfc: Cannot re-enable "
7716                         "PCI device after reset.\n");
7717                 return PCI_ERS_RESULT_DISCONNECT;
7718         }
7719
7720         pci_restore_state(pdev);
7721
7722         /*
7723          * As the new kernel behavior of pci_restore_state() API call clears
7724          * device saved_state flag, need to save the restored state again.
7725          */
7726         pci_save_state(pdev);
7727
7728         if (pdev->is_busmaster)
7729                 pci_set_master(pdev);
7730
7731         spin_lock_irq(&phba->hbalock);
7732         psli->sli_flag &= ~LPFC_SLI_ACTIVE;
7733         spin_unlock_irq(&phba->hbalock);
7734
7735         /* Configure and enable interrupt */
7736         intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode);
7737         if (intr_mode == LPFC_INTR_ERROR) {
7738                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7739                                 "0427 Cannot re-enable interrupt after "
7740                                 "slot reset.\n");
7741                 return PCI_ERS_RESULT_DISCONNECT;
7742         } else
7743                 phba->intr_mode = intr_mode;
7744
7745         /* Take device offline; this will perform cleanup */
7746         lpfc_offline(phba);
7747         lpfc_sli_brdrestart(phba);
7748
7749         /* Log the current active interrupt mode */
7750         lpfc_log_intr_mode(phba, phba->intr_mode);
7751
7752         return PCI_ERS_RESULT_RECOVERED;
7753 }
7754
7755 /**
7756  * lpfc_io_resume_s3 - Method for resuming PCI I/O operation on SLI-3 device.
7757  * @pdev: pointer to PCI device
7758  *
7759  * This routine is called from the PCI subsystem for error handling to device
7760  * with SLI-3 interface spec. It is called when kernel error recovery tells
7761  * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
7762  * error recovery. After this call, traffic can start to flow from this device
7763  * again.
7764  */
7765 static void
7766 lpfc_io_resume_s3(struct pci_dev *pdev)
7767 {
7768         struct Scsi_Host *shost = pci_get_drvdata(pdev);
7769         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
7770
7771         /* Bring the device online */
7772         lpfc_online(phba);
7773
7774         /* Clean up Advanced Error Reporting (AER) if needed */
7775         if (phba->hba_flag & HBA_AER_ENABLED)
7776                 pci_cleanup_aer_uncorrect_error_status(pdev);
7777 }
7778
7779 /**
7780  * lpfc_sli4_get_els_iocb_cnt - Calculate the # of ELS IOCBs to reserve
7781  * @phba: pointer to lpfc hba data structure.
7782  *
7783  * returns the number of ELS/CT IOCBs to reserve
7784  **/
7785 int
7786 lpfc_sli4_get_els_iocb_cnt(struct lpfc_hba *phba)
7787 {
7788         int max_xri = phba->sli4_hba.max_cfg_param.max_xri;
7789
7790         if (phba->sli_rev == LPFC_SLI_REV4) {
7791                 if (max_xri <= 100)
7792                         return 10;
7793                 else if (max_xri <= 256)
7794                         return 25;
7795                 else if (max_xri <= 512)
7796                         return 50;
7797                 else if (max_xri <= 1024)
7798                         return 100;
7799                 else
7800                         return 150;
7801         } else
7802                 return 0;
7803 }
7804
7805 /**
7806  * lpfc_pci_probe_one_s4 - PCI probe func to reg SLI-4 device to PCI subsys
7807  * @pdev: pointer to PCI device
7808  * @pid: pointer to PCI device identifier
7809  *
7810  * This routine is called from the kernel's PCI subsystem to device with
7811  * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is
7812  * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific
7813  * information of the device and driver to see if the driver state that it
7814  * can support this kind of device. If the match is successful, the driver
7815  * core invokes this routine. If this routine determines it can claim the HBA,
7816  * it does all the initialization that it needs to do to handle the HBA
7817  * properly.
7818  *
7819  * Return code
7820  *      0 - driver can claim the device
7821  *      negative value - driver can not claim the device
7822  **/
7823 static int __devinit
7824 lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
7825 {
7826         struct lpfc_hba   *phba;
7827         struct lpfc_vport *vport = NULL;
7828         struct Scsi_Host  *shost = NULL;
7829         int error;
7830         uint32_t cfg_mode, intr_mode;
7831         int mcnt;
7832
7833         /* Allocate memory for HBA structure */
7834         phba = lpfc_hba_alloc(pdev);
7835         if (!phba)
7836                 return -ENOMEM;
7837
7838         /* Perform generic PCI device enabling operation */
7839         error = lpfc_enable_pci_dev(phba);
7840         if (error) {
7841                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7842                                 "1409 Failed to enable pci device.\n");
7843                 goto out_free_phba;
7844         }
7845
7846         /* Set up SLI API function jump table for PCI-device group-1 HBAs */
7847         error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_OC);
7848         if (error)
7849                 goto out_disable_pci_dev;
7850
7851         /* Set up SLI-4 specific device PCI memory space */
7852         error = lpfc_sli4_pci_mem_setup(phba);
7853         if (error) {
7854                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7855                                 "1410 Failed to set up pci memory space.\n");
7856                 goto out_disable_pci_dev;
7857         }
7858
7859         /* Set up phase-1 common device driver resources */
7860         error = lpfc_setup_driver_resource_phase1(phba);
7861         if (error) {
7862                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7863                                 "1411 Failed to set up driver resource.\n");
7864                 goto out_unset_pci_mem_s4;
7865         }
7866
7867         /* Set up SLI-4 Specific device driver resources */
7868         error = lpfc_sli4_driver_resource_setup(phba);
7869         if (error) {
7870                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7871                                 "1412 Failed to set up driver resource.\n");
7872                 goto out_unset_pci_mem_s4;
7873         }
7874
7875         /* Initialize and populate the iocb list per host */
7876         error = lpfc_init_iocb_list(phba,
7877                         phba->sli4_hba.max_cfg_param.max_xri);
7878         if (error) {
7879                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7880                                 "1413 Failed to initialize iocb list.\n");
7881                 goto out_unset_driver_resource_s4;
7882         }
7883
7884         /* Set up common device driver resources */
7885         error = lpfc_setup_driver_resource_phase2(phba);
7886         if (error) {
7887                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7888                                 "1414 Failed to set up driver resource.\n");
7889                 goto out_free_iocb_list;
7890         }
7891
7892         /* Create SCSI host to the physical port */
7893         error = lpfc_create_shost(phba);
7894         if (error) {
7895                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7896                                 "1415 Failed to create scsi host.\n");
7897                 goto out_unset_driver_resource;
7898         }
7899
7900         /* Configure sysfs attributes */
7901         vport = phba->pport;
7902         error = lpfc_alloc_sysfs_attr(vport);
7903         if (error) {
7904                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7905                                 "1416 Failed to allocate sysfs attr\n");
7906                 goto out_destroy_shost;
7907         }
7908
7909         shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */
7910         /* Now, trying to enable interrupt and bring up the device */
7911         cfg_mode = phba->cfg_use_msi;
7912         while (true) {
7913                 /* Put device to a known state before enabling interrupt */
7914                 lpfc_stop_port(phba);
7915                 /* Configure and enable interrupt */
7916                 intr_mode = lpfc_sli4_enable_intr(phba, cfg_mode);
7917                 if (intr_mode == LPFC_INTR_ERROR) {
7918                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7919                                         "0426 Failed to enable interrupt.\n");
7920                         error = -ENODEV;
7921                         goto out_free_sysfs_attr;
7922                 }
7923                 /* Default to single FCP EQ for non-MSI-X */
7924                 if (phba->intr_type != MSIX)
7925                         phba->cfg_fcp_eq_count = 1;
7926                 /* Set up SLI-4 HBA */
7927                 if (lpfc_sli4_hba_setup(phba)) {
7928                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
7929                                         "1421 Failed to set up hba\n");
7930                         error = -ENODEV;
7931                         goto out_disable_intr;
7932                 }
7933
7934                 /* Send NOP mbx cmds for non-INTx mode active interrupt test */
7935                 if (intr_mode != 0)
7936                         mcnt = lpfc_sli4_send_nop_mbox_cmds(phba,
7937                                                             LPFC_ACT_INTR_CNT);
7938
7939                 /* Check active interrupts received only for MSI/MSI-X */
7940                 if (intr_mode == 0 ||
7941                     phba->sli.slistat.sli_intr >= LPFC_ACT_INTR_CNT) {
7942                         /* Log the current active interrupt mode */
7943                         phba->intr_mode = intr_mode;
7944                         lpfc_log_intr_mode(phba, intr_mode);
7945                         break;
7946                 }
7947                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7948                                 "0451 Configure interrupt mode (%d) "
7949                                 "failed active interrupt test.\n",
7950                                 intr_mode);
7951                 /* Unset the preivous SLI-4 HBA setup */
7952                 lpfc_sli4_unset_hba(phba);
7953                 /* Try next level of interrupt mode */
7954                 cfg_mode = --intr_mode;
7955         }
7956
7957         /* Perform post initialization setup */
7958         lpfc_post_init_setup(phba);
7959
7960         /* Check if there are static vports to be created. */
7961         lpfc_create_static_vport(phba);
7962
7963         return 0;
7964
7965 out_disable_intr:
7966         lpfc_sli4_disable_intr(phba);
7967 out_free_sysfs_attr:
7968         lpfc_free_sysfs_attr(vport);
7969 out_destroy_shost:
7970         lpfc_destroy_shost(phba);
7971 out_unset_driver_resource:
7972         lpfc_unset_driver_resource_phase2(phba);
7973 out_free_iocb_list:
7974         lpfc_free_iocb_list(phba);
7975 out_unset_driver_resource_s4:
7976         lpfc_sli4_driver_resource_unset(phba);
7977 out_unset_pci_mem_s4:
7978         lpfc_sli4_pci_mem_unset(phba);
7979 out_disable_pci_dev:
7980         lpfc_disable_pci_dev(phba);
7981         if (shost)
7982                 scsi_host_put(shost);
7983 out_free_phba:
7984         lpfc_hba_free(phba);
7985         return error;
7986 }
7987
7988 /**
7989  * lpfc_pci_remove_one_s4 - PCI func to unreg SLI-4 device from PCI subsystem
7990  * @pdev: pointer to PCI device
7991  *
7992  * This routine is called from the kernel's PCI subsystem to device with
7993  * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is
7994  * removed from PCI bus, it performs all the necessary cleanup for the HBA
7995  * device to be removed from the PCI subsystem properly.
7996  **/
7997 static void __devexit
7998 lpfc_pci_remove_one_s4(struct pci_dev *pdev)
7999 {
8000         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8001         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
8002         struct lpfc_vport **vports;
8003         struct lpfc_hba *phba = vport->phba;
8004         int i;
8005
8006         /* Mark the device unloading flag */
8007         spin_lock_irq(&phba->hbalock);
8008         vport->load_flag |= FC_UNLOADING;
8009         spin_unlock_irq(&phba->hbalock);
8010
8011         /* Free the HBA sysfs attributes */
8012         lpfc_free_sysfs_attr(vport);
8013
8014         /* Release all the vports against this physical port */
8015         vports = lpfc_create_vport_work_array(phba);
8016         if (vports != NULL)
8017                 for (i = 1; i <= phba->max_vports && vports[i] != NULL; i++)
8018                         fc_vport_terminate(vports[i]->fc_vport);
8019         lpfc_destroy_vport_work_array(phba, vports);
8020
8021         /* Remove FC host and then SCSI host with the physical port */
8022         fc_remove_host(shost);
8023         scsi_remove_host(shost);
8024
8025         /* Perform cleanup on the physical port */
8026         lpfc_cleanup(vport);
8027
8028         /*
8029          * Bring down the SLI Layer. This step disables all interrupts,
8030          * clears the rings, discards all mailbox commands, and resets
8031          * the HBA FCoE function.
8032          */
8033         lpfc_debugfs_terminate(vport);
8034         lpfc_sli4_hba_unset(phba);
8035
8036         spin_lock_irq(&phba->hbalock);
8037         list_del_init(&vport->listentry);
8038         spin_unlock_irq(&phba->hbalock);
8039
8040         /* Call scsi_free before lpfc_sli4_driver_resource_unset since scsi
8041          * buffers are released to their corresponding pools here.
8042          */
8043         lpfc_scsi_free(phba);
8044         lpfc_sli4_driver_resource_unset(phba);
8045
8046         /* Unmap adapter Control and Doorbell registers */
8047         lpfc_sli4_pci_mem_unset(phba);
8048
8049         /* Release PCI resources and disable device's PCI function */
8050         scsi_host_put(shost);
8051         lpfc_disable_pci_dev(phba);
8052
8053         /* Finally, free the driver's device data structure */
8054         lpfc_hba_free(phba);
8055
8056         return;
8057 }
8058
8059 /**
8060  * lpfc_pci_suspend_one_s4 - PCI func to suspend SLI-4 device for power mgmnt
8061  * @pdev: pointer to PCI device
8062  * @msg: power management message
8063  *
8064  * This routine is called from the kernel's PCI subsystem to support system
8065  * Power Management (PM) to device with SLI-4 interface spec. When PM invokes
8066  * this method, it quiesces the device by stopping the driver's worker
8067  * thread for the device, turning off device's interrupt and DMA, and bring
8068  * the device offline. Note that as the driver implements the minimum PM
8069  * requirements to a power-aware driver's PM support for suspend/resume -- all
8070  * the possible PM messages (SUSPEND, HIBERNATE, FREEZE) to the suspend()
8071  * method call will be treated as SUSPEND and the driver will fully
8072  * reinitialize its device during resume() method call, the driver will set
8073  * device to PCI_D3hot state in PCI config space instead of setting it
8074  * according to the @msg provided by the PM.
8075  *
8076  * Return code
8077  *      0 - driver suspended the device
8078  *      Error otherwise
8079  **/
8080 static int
8081 lpfc_pci_suspend_one_s4(struct pci_dev *pdev, pm_message_t msg)
8082 {
8083         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8084         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8085
8086         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8087                         "0298 PCI device Power Management suspend.\n");
8088
8089         /* Bring down the device */
8090         lpfc_offline_prep(phba);
8091         lpfc_offline(phba);
8092         kthread_stop(phba->worker_thread);
8093
8094         /* Disable interrupt from device */
8095         lpfc_sli4_disable_intr(phba);
8096
8097         /* Save device state to PCI config space */
8098         pci_save_state(pdev);
8099         pci_set_power_state(pdev, PCI_D3hot);
8100
8101         return 0;
8102 }
8103
8104 /**
8105  * lpfc_pci_resume_one_s4 - PCI func to resume SLI-4 device for power mgmnt
8106  * @pdev: pointer to PCI device
8107  *
8108  * This routine is called from the kernel's PCI subsystem to support system
8109  * Power Management (PM) to device with SLI-4 interface spac. When PM invokes
8110  * this method, it restores the device's PCI config space state and fully
8111  * reinitializes the device and brings it online. Note that as the driver
8112  * implements the minimum PM requirements to a power-aware driver's PM for
8113  * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE)
8114  * to the suspend() method call will be treated as SUSPEND and the driver
8115  * will fully reinitialize its device during resume() method call, the device
8116  * will be set to PCI_D0 directly in PCI config space before restoring the
8117  * state.
8118  *
8119  * Return code
8120  *      0 - driver suspended the device
8121  *      Error otherwise
8122  **/
8123 static int
8124 lpfc_pci_resume_one_s4(struct pci_dev *pdev)
8125 {
8126         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8127         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8128         uint32_t intr_mode;
8129         int error;
8130
8131         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
8132                         "0292 PCI device Power Management resume.\n");
8133
8134         /* Restore device state from PCI config space */
8135         pci_set_power_state(pdev, PCI_D0);
8136         pci_restore_state(pdev);
8137
8138         /*
8139          * As the new kernel behavior of pci_restore_state() API call clears
8140          * device saved_state flag, need to save the restored state again.
8141          */
8142         pci_save_state(pdev);
8143
8144         if (pdev->is_busmaster)
8145                 pci_set_master(pdev);
8146
8147          /* Startup the kernel thread for this host adapter. */
8148         phba->worker_thread = kthread_run(lpfc_do_work, phba,
8149                                         "lpfc_worker_%d", phba->brd_no);
8150         if (IS_ERR(phba->worker_thread)) {
8151                 error = PTR_ERR(phba->worker_thread);
8152                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8153                                 "0293 PM resume failed to start worker "
8154                                 "thread: error=x%x.\n", error);
8155                 return error;
8156         }
8157
8158         /* Configure and enable interrupt */
8159         intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode);
8160         if (intr_mode == LPFC_INTR_ERROR) {
8161                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8162                                 "0294 PM resume Failed to enable interrupt\n");
8163                 return -EIO;
8164         } else
8165                 phba->intr_mode = intr_mode;
8166
8167         /* Restart HBA and bring it online */
8168         lpfc_sli_brdrestart(phba);
8169         lpfc_online(phba);
8170
8171         /* Log the current active interrupt mode */
8172         lpfc_log_intr_mode(phba, phba->intr_mode);
8173
8174         return 0;
8175 }
8176
8177 /**
8178  * lpfc_io_error_detected_s4 - Method for handling PCI I/O error to SLI-4 device
8179  * @pdev: pointer to PCI device.
8180  * @state: the current PCI connection state.
8181  *
8182  * This routine is called from the PCI subsystem for error handling to device
8183  * with SLI-4 interface spec. This function is called by the PCI subsystem
8184  * after a PCI bus error affecting this device has been detected. When this
8185  * function is invoked, it will need to stop all the I/Os and interrupt(s)
8186  * to the device. Once that is done, it will return PCI_ERS_RESULT_NEED_RESET
8187  * for the PCI subsystem to perform proper recovery as desired.
8188  *
8189  * Return codes
8190  *      PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
8191  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
8192  **/
8193 static pci_ers_result_t
8194 lpfc_io_error_detected_s4(struct pci_dev *pdev, pci_channel_state_t state)
8195 {
8196         return PCI_ERS_RESULT_NEED_RESET;
8197 }
8198
8199 /**
8200  * lpfc_io_slot_reset_s4 - Method for restart PCI SLI-4 device from scratch
8201  * @pdev: pointer to PCI device.
8202  *
8203  * This routine is called from the PCI subsystem for error handling to device
8204  * with SLI-4 interface spec. It is called after PCI bus has been reset to
8205  * restart the PCI card from scratch, as if from a cold-boot. During the
8206  * PCI subsystem error recovery, after the driver returns
8207  * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error
8208  * recovery and then call this routine before calling the .resume method to
8209  * recover the device. This function will initialize the HBA device, enable
8210  * the interrupt, but it will just put the HBA to offline state without
8211  * passing any I/O traffic.
8212  *
8213  * Return codes
8214  *      PCI_ERS_RESULT_RECOVERED - the device has been recovered
8215  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
8216  */
8217 static pci_ers_result_t
8218 lpfc_io_slot_reset_s4(struct pci_dev *pdev)
8219 {
8220         return PCI_ERS_RESULT_RECOVERED;
8221 }
8222
8223 /**
8224  * lpfc_io_resume_s4 - Method for resuming PCI I/O operation to SLI-4 device
8225  * @pdev: pointer to PCI device
8226  *
8227  * This routine is called from the PCI subsystem for error handling to device
8228  * with SLI-4 interface spec. It is called when kernel error recovery tells
8229  * the lpfc driver that it is ok to resume normal PCI operation after PCI bus
8230  * error recovery. After this call, traffic can start to flow from this device
8231  * again.
8232  **/
8233 static void
8234 lpfc_io_resume_s4(struct pci_dev *pdev)
8235 {
8236         return;
8237 }
8238
8239 /**
8240  * lpfc_pci_probe_one - lpfc PCI probe func to reg dev to PCI subsystem
8241  * @pdev: pointer to PCI device
8242  * @pid: pointer to PCI device identifier
8243  *
8244  * This routine is to be registered to the kernel's PCI subsystem. When an
8245  * Emulex HBA device is presented on PCI bus, the kernel PCI subsystem looks
8246  * at PCI device-specific information of the device and driver to see if the
8247  * driver state that it can support this kind of device. If the match is
8248  * successful, the driver core invokes this routine. This routine dispatches
8249  * the action to the proper SLI-3 or SLI-4 device probing routine, which will
8250  * do all the initialization that it needs to do to handle the HBA device
8251  * properly.
8252  *
8253  * Return code
8254  *      0 - driver can claim the device
8255  *      negative value - driver can not claim the device
8256  **/
8257 static int __devinit
8258 lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
8259 {
8260         int rc;
8261         struct lpfc_sli_intf intf;
8262
8263         if (pci_read_config_dword(pdev, LPFC_SLI_INTF, &intf.word0))
8264                 return -ENODEV;
8265
8266         if ((bf_get(lpfc_sli_intf_valid, &intf) == LPFC_SLI_INTF_VALID) &&
8267             (bf_get(lpfc_sli_intf_slirev, &intf) == LPFC_SLI_INTF_REV_SLI4))
8268                 rc = lpfc_pci_probe_one_s4(pdev, pid);
8269         else
8270                 rc = lpfc_pci_probe_one_s3(pdev, pid);
8271
8272         return rc;
8273 }
8274
8275 /**
8276  * lpfc_pci_remove_one - lpfc PCI func to unreg dev from PCI subsystem
8277  * @pdev: pointer to PCI device
8278  *
8279  * This routine is to be registered to the kernel's PCI subsystem. When an
8280  * Emulex HBA is removed from PCI bus, the driver core invokes this routine.
8281  * This routine dispatches the action to the proper SLI-3 or SLI-4 device
8282  * remove routine, which will perform all the necessary cleanup for the
8283  * device to be removed from the PCI subsystem properly.
8284  **/
8285 static void __devexit
8286 lpfc_pci_remove_one(struct pci_dev *pdev)
8287 {
8288         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8289         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8290
8291         switch (phba->pci_dev_grp) {
8292         case LPFC_PCI_DEV_LP:
8293                 lpfc_pci_remove_one_s3(pdev);
8294                 break;
8295         case LPFC_PCI_DEV_OC:
8296                 lpfc_pci_remove_one_s4(pdev);
8297                 break;
8298         default:
8299                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8300                                 "1424 Invalid PCI device group: 0x%x\n",
8301                                 phba->pci_dev_grp);
8302                 break;
8303         }
8304         return;
8305 }
8306
8307 /**
8308  * lpfc_pci_suspend_one - lpfc PCI func to suspend dev for power management
8309  * @pdev: pointer to PCI device
8310  * @msg: power management message
8311  *
8312  * This routine is to be registered to the kernel's PCI subsystem to support
8313  * system Power Management (PM). When PM invokes this method, it dispatches
8314  * the action to the proper SLI-3 or SLI-4 device suspend routine, which will
8315  * suspend the device.
8316  *
8317  * Return code
8318  *      0 - driver suspended the device
8319  *      Error otherwise
8320  **/
8321 static int
8322 lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg)
8323 {
8324         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8325         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8326         int rc = -ENODEV;
8327
8328         switch (phba->pci_dev_grp) {
8329         case LPFC_PCI_DEV_LP:
8330                 rc = lpfc_pci_suspend_one_s3(pdev, msg);
8331                 break;
8332         case LPFC_PCI_DEV_OC:
8333                 rc = lpfc_pci_suspend_one_s4(pdev, msg);
8334                 break;
8335         default:
8336                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8337                                 "1425 Invalid PCI device group: 0x%x\n",
8338                                 phba->pci_dev_grp);
8339                 break;
8340         }
8341         return rc;
8342 }
8343
8344 /**
8345  * lpfc_pci_resume_one - lpfc PCI func to resume dev for power management
8346  * @pdev: pointer to PCI device
8347  *
8348  * This routine is to be registered to the kernel's PCI subsystem to support
8349  * system Power Management (PM). When PM invokes this method, it dispatches
8350  * the action to the proper SLI-3 or SLI-4 device resume routine, which will
8351  * resume the device.
8352  *
8353  * Return code
8354  *      0 - driver suspended the device
8355  *      Error otherwise
8356  **/
8357 static int
8358 lpfc_pci_resume_one(struct pci_dev *pdev)
8359 {
8360         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8361         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8362         int rc = -ENODEV;
8363
8364         switch (phba->pci_dev_grp) {
8365         case LPFC_PCI_DEV_LP:
8366                 rc = lpfc_pci_resume_one_s3(pdev);
8367                 break;
8368         case LPFC_PCI_DEV_OC:
8369                 rc = lpfc_pci_resume_one_s4(pdev);
8370                 break;
8371         default:
8372                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8373                                 "1426 Invalid PCI device group: 0x%x\n",
8374                                 phba->pci_dev_grp);
8375                 break;
8376         }
8377         return rc;
8378 }
8379
8380 /**
8381  * lpfc_io_error_detected - lpfc method for handling PCI I/O error
8382  * @pdev: pointer to PCI device.
8383  * @state: the current PCI connection state.
8384  *
8385  * This routine is registered to the PCI subsystem for error handling. This
8386  * function is called by the PCI subsystem after a PCI bus error affecting
8387  * this device has been detected. When this routine is invoked, it dispatches
8388  * the action to the proper SLI-3 or SLI-4 device error detected handling
8389  * routine, which will perform the proper error detected operation.
8390  *
8391  * Return codes
8392  *      PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
8393  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
8394  **/
8395 static pci_ers_result_t
8396 lpfc_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
8397 {
8398         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8399         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8400         pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
8401
8402         switch (phba->pci_dev_grp) {
8403         case LPFC_PCI_DEV_LP:
8404                 rc = lpfc_io_error_detected_s3(pdev, state);
8405                 break;
8406         case LPFC_PCI_DEV_OC:
8407                 rc = lpfc_io_error_detected_s4(pdev, state);
8408                 break;
8409         default:
8410                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8411                                 "1427 Invalid PCI device group: 0x%x\n",
8412                                 phba->pci_dev_grp);
8413                 break;
8414         }
8415         return rc;
8416 }
8417
8418 /**
8419  * lpfc_io_slot_reset - lpfc method for restart PCI dev from scratch
8420  * @pdev: pointer to PCI device.
8421  *
8422  * This routine is registered to the PCI subsystem for error handling. This
8423  * function is called after PCI bus has been reset to restart the PCI card
8424  * from scratch, as if from a cold-boot. When this routine is invoked, it
8425  * dispatches the action to the proper SLI-3 or SLI-4 device reset handling
8426  * routine, which will perform the proper device reset.
8427  *
8428  * Return codes
8429  *      PCI_ERS_RESULT_RECOVERED - the device has been recovered
8430  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
8431  **/
8432 static pci_ers_result_t
8433 lpfc_io_slot_reset(struct pci_dev *pdev)
8434 {
8435         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8436         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8437         pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT;
8438
8439         switch (phba->pci_dev_grp) {
8440         case LPFC_PCI_DEV_LP:
8441                 rc = lpfc_io_slot_reset_s3(pdev);
8442                 break;
8443         case LPFC_PCI_DEV_OC:
8444                 rc = lpfc_io_slot_reset_s4(pdev);
8445                 break;
8446         default:
8447                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8448                                 "1428 Invalid PCI device group: 0x%x\n",
8449                                 phba->pci_dev_grp);
8450                 break;
8451         }
8452         return rc;
8453 }
8454
8455 /**
8456  * lpfc_io_resume - lpfc method for resuming PCI I/O operation
8457  * @pdev: pointer to PCI device
8458  *
8459  * This routine is registered to the PCI subsystem for error handling. It
8460  * is called when kernel error recovery tells the lpfc driver that it is
8461  * OK to resume normal PCI operation after PCI bus error recovery. When
8462  * this routine is invoked, it dispatches the action to the proper SLI-3
8463  * or SLI-4 device io_resume routine, which will resume the device operation.
8464  **/
8465 static void
8466 lpfc_io_resume(struct pci_dev *pdev)
8467 {
8468         struct Scsi_Host *shost = pci_get_drvdata(pdev);
8469         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
8470
8471         switch (phba->pci_dev_grp) {
8472         case LPFC_PCI_DEV_LP:
8473                 lpfc_io_resume_s3(pdev);
8474                 break;
8475         case LPFC_PCI_DEV_OC:
8476                 lpfc_io_resume_s4(pdev);
8477                 break;
8478         default:
8479                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
8480                                 "1429 Invalid PCI device group: 0x%x\n",
8481                                 phba->pci_dev_grp);
8482                 break;
8483         }
8484         return;
8485 }
8486
8487 static struct pci_device_id lpfc_id_table[] = {
8488         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_VIPER,
8489                 PCI_ANY_ID, PCI_ANY_ID, },
8490         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_FIREFLY,
8491                 PCI_ANY_ID, PCI_ANY_ID, },
8492         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_THOR,
8493                 PCI_ANY_ID, PCI_ANY_ID, },
8494         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PEGASUS,
8495                 PCI_ANY_ID, PCI_ANY_ID, },
8496         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_CENTAUR,
8497                 PCI_ANY_ID, PCI_ANY_ID, },
8498         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_DRAGONFLY,
8499                 PCI_ANY_ID, PCI_ANY_ID, },
8500         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SUPERFLY,
8501                 PCI_ANY_ID, PCI_ANY_ID, },
8502         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_RFLY,
8503                 PCI_ANY_ID, PCI_ANY_ID, },
8504         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PFLY,
8505                 PCI_ANY_ID, PCI_ANY_ID, },
8506         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE,
8507                 PCI_ANY_ID, PCI_ANY_ID, },
8508         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_SCSP,
8509                 PCI_ANY_ID, PCI_ANY_ID, },
8510         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_DCSP,
8511                 PCI_ANY_ID, PCI_ANY_ID, },
8512         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS,
8513                 PCI_ANY_ID, PCI_ANY_ID, },
8514         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_SCSP,
8515                 PCI_ANY_ID, PCI_ANY_ID, },
8516         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_DCSP,
8517                 PCI_ANY_ID, PCI_ANY_ID, },
8518         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BMID,
8519                 PCI_ANY_ID, PCI_ANY_ID, },
8520         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BSMB,
8521                 PCI_ANY_ID, PCI_ANY_ID, },
8522         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR,
8523                 PCI_ANY_ID, PCI_ANY_ID, },
8524         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HORNET,
8525                 PCI_ANY_ID, PCI_ANY_ID, },
8526         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_SCSP,
8527                 PCI_ANY_ID, PCI_ANY_ID, },
8528         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_DCSP,
8529                 PCI_ANY_ID, PCI_ANY_ID, },
8530         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZMID,
8531                 PCI_ANY_ID, PCI_ANY_ID, },
8532         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZSMB,
8533                 PCI_ANY_ID, PCI_ANY_ID, },
8534         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_TFLY,
8535                 PCI_ANY_ID, PCI_ANY_ID, },
8536         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP101,
8537                 PCI_ANY_ID, PCI_ANY_ID, },
8538         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP10000S,
8539                 PCI_ANY_ID, PCI_ANY_ID, },
8540         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP11000S,
8541                 PCI_ANY_ID, PCI_ANY_ID, },
8542         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LPE11000S,
8543                 PCI_ANY_ID, PCI_ANY_ID, },
8544         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT,
8545                 PCI_ANY_ID, PCI_ANY_ID, },
8546         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_MID,
8547                 PCI_ANY_ID, PCI_ANY_ID, },
8548         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SMB,
8549                 PCI_ANY_ID, PCI_ANY_ID, },
8550         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_DCSP,
8551                 PCI_ANY_ID, PCI_ANY_ID, },
8552         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SCSP,
8553                 PCI_ANY_ID, PCI_ANY_ID, },
8554         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_S,
8555                 PCI_ANY_ID, PCI_ANY_ID, },
8556         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_VF,
8557                 PCI_ANY_ID, PCI_ANY_ID, },
8558         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_PF,
8559                 PCI_ANY_ID, PCI_ANY_ID, },
8560         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_S,
8561                 PCI_ANY_ID, PCI_ANY_ID, },
8562         {PCI_VENDOR_ID_SERVERENGINE, PCI_DEVICE_ID_TIGERSHARK,
8563                 PCI_ANY_ID, PCI_ANY_ID, },
8564         {PCI_VENDOR_ID_SERVERENGINE, PCI_DEVICE_ID_TOMCAT,
8565                 PCI_ANY_ID, PCI_ANY_ID, },
8566         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_FALCON,
8567                 PCI_ANY_ID, PCI_ANY_ID, },
8568         { 0 }
8569 };
8570
8571 MODULE_DEVICE_TABLE(pci, lpfc_id_table);
8572
8573 static struct pci_error_handlers lpfc_err_handler = {
8574         .error_detected = lpfc_io_error_detected,
8575         .slot_reset = lpfc_io_slot_reset,
8576         .resume = lpfc_io_resume,
8577 };
8578
8579 static struct pci_driver lpfc_driver = {
8580         .name           = LPFC_DRIVER_NAME,
8581         .id_table       = lpfc_id_table,
8582         .probe          = lpfc_pci_probe_one,
8583         .remove         = __devexit_p(lpfc_pci_remove_one),
8584         .suspend        = lpfc_pci_suspend_one,
8585         .resume         = lpfc_pci_resume_one,
8586         .err_handler    = &lpfc_err_handler,
8587 };
8588
8589 /**
8590  * lpfc_init - lpfc module initialization routine
8591  *
8592  * This routine is to be invoked when the lpfc module is loaded into the
8593  * kernel. The special kernel macro module_init() is used to indicate the
8594  * role of this routine to the kernel as lpfc module entry point.
8595  *
8596  * Return codes
8597  *   0 - successful
8598  *   -ENOMEM - FC attach transport failed
8599  *   all others - failed
8600  */
8601 static int __init
8602 lpfc_init(void)
8603 {
8604         int error = 0;
8605
8606         printk(LPFC_MODULE_DESC "\n");
8607         printk(LPFC_COPYRIGHT "\n");
8608
8609         if (lpfc_enable_npiv) {
8610                 lpfc_transport_functions.vport_create = lpfc_vport_create;
8611                 lpfc_transport_functions.vport_delete = lpfc_vport_delete;
8612         }
8613         lpfc_transport_template =
8614                                 fc_attach_transport(&lpfc_transport_functions);
8615         if (lpfc_transport_template == NULL)
8616                 return -ENOMEM;
8617         if (lpfc_enable_npiv) {
8618                 lpfc_vport_transport_template =
8619                         fc_attach_transport(&lpfc_vport_transport_functions);
8620                 if (lpfc_vport_transport_template == NULL) {
8621                         fc_release_transport(lpfc_transport_template);
8622                         return -ENOMEM;
8623                 }
8624         }
8625         error = pci_register_driver(&lpfc_driver);
8626         if (error) {
8627                 fc_release_transport(lpfc_transport_template);
8628                 if (lpfc_enable_npiv)
8629                         fc_release_transport(lpfc_vport_transport_template);
8630         }
8631
8632         return error;
8633 }
8634
8635 /**
8636  * lpfc_exit - lpfc module removal routine
8637  *
8638  * This routine is invoked when the lpfc module is removed from the kernel.
8639  * The special kernel macro module_exit() is used to indicate the role of
8640  * this routine to the kernel as lpfc module exit point.
8641  */
8642 static void __exit
8643 lpfc_exit(void)
8644 {
8645         pci_unregister_driver(&lpfc_driver);
8646         fc_release_transport(lpfc_transport_template);
8647         if (lpfc_enable_npiv)
8648                 fc_release_transport(lpfc_vport_transport_template);
8649         if (_dump_buf_data) {
8650                 printk(KERN_ERR "9062 BLKGRD: freeing %lu pages for "
8651                                 "_dump_buf_data at 0x%p\n",
8652                                 (1L << _dump_buf_data_order), _dump_buf_data);
8653                 free_pages((unsigned long)_dump_buf_data, _dump_buf_data_order);
8654         }
8655
8656         if (_dump_buf_dif) {
8657                 printk(KERN_ERR "9049 BLKGRD: freeing %lu pages for "
8658                                 "_dump_buf_dif at 0x%p\n",
8659                                 (1L << _dump_buf_dif_order), _dump_buf_dif);
8660                 free_pages((unsigned long)_dump_buf_dif, _dump_buf_dif_order);
8661         }
8662 }
8663
8664 module_init(lpfc_init);
8665 module_exit(lpfc_exit);
8666 MODULE_LICENSE("GPL");
8667 MODULE_DESCRIPTION(LPFC_MODULE_DESC);
8668 MODULE_AUTHOR("Emulex Corporation - tech.support@emulex.com");
8669 MODULE_VERSION("0:" LPFC_DRIVER_VERSION);