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-2008 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
  32 #include <scsi/scsi.h>
  33 #include <scsi/scsi_device.h>
  34 #include <scsi/scsi_host.h>
  35 #include <scsi/scsi_transport_fc.h>
  36
  37 #include "lpfc_hw.h"
  38 #include "lpfc_sli.h"
  39 #include "lpfc_nl.h"
  40 #include "lpfc_disc.h"
  41 #include "lpfc_scsi.h"
  42 #include "lpfc.h"
  43 #include "lpfc_logmsg.h"
  44 #include "lpfc_crtn.h"
  45 #include "lpfc_vport.h"
  46 #include "lpfc_version.h"
  47
  48 static int lpfc_parse_vpd(struct lpfc_hba *, uint8_t *, int);
  49 static void lpfc_get_hba_model_desc(struct lpfc_hba *, uint8_t *, uint8_t *);
  50 static int lpfc_post_rcv_buf(struct lpfc_hba *);
  51
  52 static struct scsi_transport_template *lpfc_transport_template = NULL;
  53 static struct scsi_transport_template *lpfc_vport_transport_template = NULL;
  54 static DEFINE_IDR(lpfc_hba_index);
  55
  56 /**
  57  * lpfc_config_port_prep: Perform lpfc initialization prior to config port.
  58  * @phba: pointer to lpfc hba data structure.
  59  *
  60  * This routine will do LPFC initialization prior to issuing the CONFIG_PORT
  61  * mailbox command. It retrieves the revision information from the HBA and
  62  * collects the Vital Product Data (VPD) about the HBA for preparing the
  63  * configuration of the HBA.
  64  *
  65  * Return codes:
  66  *   0 - success.
  67  *   -ERESTART - requests the SLI layer to reset the HBA and try again.
  68  *   Any other value - indicates an error.
  69  **/
  70 int
  71 lpfc_config_port_prep(struct lpfc_hba *phba)
  72 {
  73         lpfc_vpd_t *vp = &phba->vpd;
  74         int i = 0, rc;
  75         LPFC_MBOXQ_t *pmb;
  76         MAILBOX_t *mb;
  77         char *lpfc_vpd_data = NULL;
  78         uint16_t offset = 0;
  79         static char licensed[56] =
  80                     "key unlock for use with gnu public licensed code only\0";
  81         static int init_key = 1;
  82
  83         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
  84         if (!pmb) {
  85                 phba->link_state = LPFC_HBA_ERROR;
  86                 return -ENOMEM;
  87         }
  88
  89         mb = &pmb->mb;
  90         phba->link_state = LPFC_INIT_MBX_CMDS;
  91
  92         if (lpfc_is_LC_HBA(phba->pcidev->device)) {
  93                 if (init_key) {
  94                         uint32_t *ptext = (uint32_t *) licensed;
  95
  96                         for (i = 0; i < 56; i += sizeof (uint32_t), ptext++)
  97                                 *ptext = cpu_to_be32(*ptext);
  98                         init_key = 0;
  99                 }
 100
 101                 lpfc_read_nv(phba, pmb);
 102                 memset((char*)mb->un.varRDnvp.rsvd3, 0,
 103                         sizeof (mb->un.varRDnvp.rsvd3));
 104                 memcpy((char*)mb->un.varRDnvp.rsvd3, licensed,
 105                          sizeof (licensed));
 106
 107                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 108
 109                 if (rc != MBX_SUCCESS) {
 110                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
 111                                         "0324 Config Port initialization "
 112                                         "error, mbxCmd x%x READ_NVPARM, "
 113                                         "mbxStatus x%x\n",
 114                                         mb->mbxCommand, mb->mbxStatus);
 115                         mempool_free(pmb, phba->mbox_mem_pool);
 116                         return -ERESTART;
 117                 }
 118                 memcpy(phba->wwnn, (char *)mb->un.varRDnvp.nodename,
 119                        sizeof(phba->wwnn));
 120                 memcpy(phba->wwpn, (char *)mb->un.varRDnvp.portname,
 121                        sizeof(phba->wwpn));
 122         }
 123
 124         phba->sli3_options = 0x0;
 125
 126         /* Setup and issue mailbox READ REV command */
 127         lpfc_read_rev(phba, pmb);
 128         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 129         if (rc != MBX_SUCCESS) {
 130                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 131                                 "0439 Adapter failed to init, mbxCmd x%x "
 132                                 "READ_REV, mbxStatus x%x\n",
 133                                 mb->mbxCommand, mb->mbxStatus);
 134                 mempool_free( pmb, phba->mbox_mem_pool);
 135                 return -ERESTART;
 136         }
 137
 138
 139         /*
 140          * The value of rr must be 1 since the driver set the cv field to 1.
 141          * This setting requires the FW to set all revision fields.
 142          */
 143         if (mb->un.varRdRev.rr == 0) {
 144                 vp->rev.rBit = 0;
 145                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 146                                 "0440 Adapter failed to init, READ_REV has "
 147                                 "missing revision information.\n");
 148                 mempool_free(pmb, phba->mbox_mem_pool);
 149                 return -ERESTART;
 150         }
 151
 152         if (phba->sli_rev == 3 && !mb->un.varRdRev.v3rsp) {
 153                 mempool_free(pmb, phba->mbox_mem_pool);
 154                 return -EINVAL;
 155         }
 156
 157         /* Save information as VPD data */
 158         vp->rev.rBit = 1;
 159         memcpy(&vp->sli3Feat, &mb->un.varRdRev.sli3Feat, sizeof(uint32_t));
 160         vp->rev.sli1FwRev = mb->un.varRdRev.sli1FwRev;
 161         memcpy(vp->rev.sli1FwName, (char*) mb->un.varRdRev.sli1FwName, 16);
 162         vp->rev.sli2FwRev = mb->un.varRdRev.sli2FwRev;
 163         memcpy(vp->rev.sli2FwName, (char *) mb->un.varRdRev.sli2FwName, 16);
 164         vp->rev.biuRev = mb->un.varRdRev.biuRev;
 165         vp->rev.smRev = mb->un.varRdRev.smRev;
 166         vp->rev.smFwRev = mb->un.varRdRev.un.smFwRev;
 167         vp->rev.endecRev = mb->un.varRdRev.endecRev;
 168         vp->rev.fcphHigh = mb->un.varRdRev.fcphHigh;
 169         vp->rev.fcphLow = mb->un.varRdRev.fcphLow;
 170         vp->rev.feaLevelHigh = mb->un.varRdRev.feaLevelHigh;
 171         vp->rev.feaLevelLow = mb->un.varRdRev.feaLevelLow;
 172         vp->rev.postKernRev = mb->un.varRdRev.postKernRev;
 173         vp->rev.opFwRev = mb->un.varRdRev.opFwRev;
 174
 175         /* If the sli feature level is less then 9, we must
 176          * tear down all RPIs and VPIs on link down if NPIV
 177          * is enabled.
 178          */
 179         if (vp->rev.feaLevelHigh < 9)
 180                 phba->sli3_options |= LPFC_SLI3_VPORT_TEARDOWN;
 181
 182         if (lpfc_is_LC_HBA(phba->pcidev->device))
 183                 memcpy(phba->RandomData, (char *)&mb->un.varWords[24],
 184                                                 sizeof (phba->RandomData));
 185
 186         /* Get adapter VPD information */
 187         lpfc_vpd_data = kmalloc(DMP_VPD_SIZE, GFP_KERNEL);
 188         if (!lpfc_vpd_data)
 189                 goto out_free_mbox;
 190
 191         do {
 192                 lpfc_dump_mem(phba, pmb, offset);
 193                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 194
 195                 if (rc != MBX_SUCCESS) {
 196                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
 197                                         "0441 VPD not present on adapter, "
 198                                         "mbxCmd x%x DUMP VPD, mbxStatus x%x\n",
 199                                         mb->mbxCommand, mb->mbxStatus);
 200                         mb->un.varDmp.word_cnt = 0;
 201                 }
 202                 if (mb->un.varDmp.word_cnt > DMP_VPD_SIZE - offset)
 203                         mb->un.varDmp.word_cnt = DMP_VPD_SIZE - offset;
 204                 lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
 205                                       lpfc_vpd_data + offset,
 206                                       mb->un.varDmp.word_cnt);
 207                 offset += mb->un.varDmp.word_cnt;
 208         } while (mb->un.varDmp.word_cnt && offset < DMP_VPD_SIZE);
 209         lpfc_parse_vpd(phba, lpfc_vpd_data, offset);
 210
 211         kfree(lpfc_vpd_data);
 212 out_free_mbox:
 213         mempool_free(pmb, phba->mbox_mem_pool);
 214         return 0;
 215 }
 216
 217 /**
 218  * lpfc_config_async_cmpl: Completion handler for config async event mbox cmd.
 219  * @phba: pointer to lpfc hba data structure.
 220  * @pmboxq: pointer to the driver internal queue element for mailbox command.
 221  *
 222  * This is the completion handler for driver's configuring asynchronous event
 223  * mailbox command to the device. If the mailbox command returns successfully,
 224  * it will set internal async event support flag to 1; otherwise, it will
 225  * set internal async event support flag to 0.
 226  **/
 227 static void
 228 lpfc_config_async_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
 229 {
 230         if (pmboxq->mb.mbxStatus == MBX_SUCCESS)
 231                 phba->temp_sensor_support = 1;
 232         else
 233                 phba->temp_sensor_support = 0;
 234         mempool_free(pmboxq, phba->mbox_mem_pool);
 235         return;
 236 }
 237
 238 /**
 239  * lpfc_config_port_post: Perform lpfc initialization after config port.
 240  * @phba: pointer to lpfc hba data structure.
 241  *
 242  * This routine will do LPFC initialization after the CONFIG_PORT mailbox
 243  * command call. It performs all internal resource and state setups on the
 244  * port: post IOCB buffers, enable appropriate host interrupt attentions,
 245  * ELS ring timers, etc.
 246  *
 247  * Return codes
 248  *   0 - success.
 249  *   Any other value - error.
 250  **/
 251 int
 252 lpfc_config_port_post(struct lpfc_hba *phba)
 253 {
 254         struct lpfc_vport *vport = phba->pport;
 255         LPFC_MBOXQ_t *pmb;
 256         MAILBOX_t *mb;
 257         struct lpfc_dmabuf *mp;
 258         struct lpfc_sli *psli = &phba->sli;
 259         uint32_t status, timeout;
 260         int i, j;
 261         int rc;
 262
 263         spin_lock_irq(&phba->hbalock);
 264         /*
 265          * If the Config port completed correctly the HBA is not
 266          * over heated any more.
 267          */
 268         if (phba->over_temp_state == HBA_OVER_TEMP)
 269                 phba->over_temp_state = HBA_NORMAL_TEMP;
 270         spin_unlock_irq(&phba->hbalock);
 271
 272         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 273         if (!pmb) {
 274                 phba->link_state = LPFC_HBA_ERROR;
 275                 return -ENOMEM;
 276         }
 277         mb = &pmb->mb;
 278
 279         /* Get login parameters for NID.  */
 280         lpfc_read_sparam(phba, pmb, 0);
 281         pmb->vport = vport;
 282         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
 283                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 284                                 "0448 Adapter failed init, mbxCmd x%x "
 285                                 "READ_SPARM mbxStatus x%x\n",
 286                                 mb->mbxCommand, mb->mbxStatus);
 287                 phba->link_state = LPFC_HBA_ERROR;
 288                 mp = (struct lpfc_dmabuf *) pmb->context1;
 289                 mempool_free( pmb, phba->mbox_mem_pool);
 290                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
 291                 kfree(mp);
 292                 return -EIO;
 293         }
 294
 295         mp = (struct lpfc_dmabuf *) pmb->context1;
 296
 297         memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
 298         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 299         kfree(mp);
 300         pmb->context1 = NULL;
 301
 302         if (phba->cfg_soft_wwnn)
 303                 u64_to_wwn(phba->cfg_soft_wwnn,
 304                            vport->fc_sparam.nodeName.u.wwn);
 305         if (phba->cfg_soft_wwpn)
 306                 u64_to_wwn(phba->cfg_soft_wwpn,
 307                            vport->fc_sparam.portName.u.wwn);
 308         memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
 309                sizeof (struct lpfc_name));
 310         memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
 311                sizeof (struct lpfc_name));
 312         /* If no serial number in VPD data, use low 6 bytes of WWNN */
 313         /* This should be consolidated into parse_vpd ? - mr */
 314         if (phba->SerialNumber[0] == 0) {
 315                 uint8_t *outptr;
 316
 317                 outptr = &vport->fc_nodename.u.s.IEEE[0];
 318                 for (i = 0; i < 12; i++) {
 319                         status = *outptr++;
 320                         j = ((status & 0xf0) >> 4);
 321                         if (j <= 9)
 322                                 phba->SerialNumber[i] =
 323                                     (char)((uint8_t) 0x30 + (uint8_t) j);
 324                         else
 325                                 phba->SerialNumber[i] =
 326                                     (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
 327                         i++;
 328                         j = (status & 0xf);
 329                         if (j <= 9)
 330                                 phba->SerialNumber[i] =
 331                                     (char)((uint8_t) 0x30 + (uint8_t) j);
 332                         else
 333                                 phba->SerialNumber[i] =
 334                                     (char)((uint8_t) 0x61 + (uint8_t) (j - 10));
 335                 }
 336         }
 337
 338         lpfc_read_config(phba, pmb);
 339         pmb->vport = vport;
 340         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
 341                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 342                                 "0453 Adapter failed to init, mbxCmd x%x "
 343                                 "READ_CONFIG, mbxStatus x%x\n",
 344                                 mb->mbxCommand, mb->mbxStatus);
 345                 phba->link_state = LPFC_HBA_ERROR;
 346                 mempool_free( pmb, phba->mbox_mem_pool);
 347                 return -EIO;
 348         }
 349
 350         /* Reset the DFT_HBA_Q_DEPTH to the max xri  */
 351         if (phba->cfg_hba_queue_depth > (mb->un.varRdConfig.max_xri+1))
 352                 phba->cfg_hba_queue_depth =
 353                         mb->un.varRdConfig.max_xri + 1;
 354
 355         phba->lmt = mb->un.varRdConfig.lmt;
 356
 357         /* Get the default values for Model Name and Description */
 358         lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
 359
 360         if ((phba->cfg_link_speed > LINK_SPEED_10G)
 361             || ((phba->cfg_link_speed == LINK_SPEED_1G)
 362                 && !(phba->lmt & LMT_1Gb))
 363             || ((phba->cfg_link_speed == LINK_SPEED_2G)
 364                 && !(phba->lmt & LMT_2Gb))
 365             || ((phba->cfg_link_speed == LINK_SPEED_4G)
 366                 && !(phba->lmt & LMT_4Gb))
 367             || ((phba->cfg_link_speed == LINK_SPEED_8G)
 368                 && !(phba->lmt & LMT_8Gb))
 369             || ((phba->cfg_link_speed == LINK_SPEED_10G)
 370                 && !(phba->lmt & LMT_10Gb))) {
 371                 /* Reset link speed to auto */
 372                 lpfc_printf_log(phba, KERN_WARNING, LOG_LINK_EVENT,
 373                         "1302 Invalid speed for this board: "
 374                         "Reset link speed to auto: x%x\n",
 375                         phba->cfg_link_speed);
 376                         phba->cfg_link_speed = LINK_SPEED_AUTO;
 377         }
 378
 379         phba->link_state = LPFC_LINK_DOWN;
 380
 381         /* Only process IOCBs on ELS ring till hba_state is READY */
 382         if (psli->ring[psli->extra_ring].cmdringaddr)
 383                 psli->ring[psli->extra_ring].flag |= LPFC_STOP_IOCB_EVENT;
 384         if (psli->ring[psli->fcp_ring].cmdringaddr)
 385                 psli->ring[psli->fcp_ring].flag |= LPFC_STOP_IOCB_EVENT;
 386         if (psli->ring[psli->next_ring].cmdringaddr)
 387                 psli->ring[psli->next_ring].flag |= LPFC_STOP_IOCB_EVENT;
 388
 389         /* Post receive buffers for desired rings */
 390         if (phba->sli_rev != 3)
 391                 lpfc_post_rcv_buf(phba);
 392
 393         /*
 394          * Configure HBA MSI-X attention conditions to messages if MSI-X mode
 395          */
 396         if (phba->intr_type == MSIX) {
 397                 rc = lpfc_config_msi(phba, pmb);
 398                 if (rc) {
 399                         mempool_free(pmb, phba->mbox_mem_pool);
 400                         return -EIO;
 401                 }
 402                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
 403                 if (rc != MBX_SUCCESS) {
 404                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
 405                                         "0352 Config MSI mailbox command "
 406                                         "failed, mbxCmd x%x, mbxStatus x%x\n",
 407                                         pmb->mb.mbxCommand, pmb->mb.mbxStatus);
 408                         mempool_free(pmb, phba->mbox_mem_pool);
 409                         return -EIO;
 410                 }
 411         }
 412
 413         /* Initialize ERATT handling flag */
 414         phba->hba_flag &= ~HBA_ERATT_HANDLED;
 415
 416         /* Enable appropriate host interrupts */
 417         spin_lock_irq(&phba->hbalock);
 418         status = readl(phba->HCregaddr);
 419         status |= HC_MBINT_ENA | HC_ERINT_ENA | HC_LAINT_ENA;
 420         if (psli->num_rings > 0)
 421                 status |= HC_R0INT_ENA;
 422         if (psli->num_rings > 1)
 423                 status |= HC_R1INT_ENA;
 424         if (psli->num_rings > 2)
 425                 status |= HC_R2INT_ENA;
 426         if (psli->num_rings > 3)
 427                 status |= HC_R3INT_ENA;
 428
 429         if ((phba->cfg_poll & ENABLE_FCP_RING_POLLING) &&
 430             (phba->cfg_poll & DISABLE_FCP_RING_INT))
 431                 status &= ~(HC_R0INT_ENA);
 432
 433         writel(status, phba->HCregaddr);
 434         readl(phba->HCregaddr); /* flush */
 435         spin_unlock_irq(&phba->hbalock);
 436
 437         /* Set up ring-0 (ELS) timer */
 438         timeout = phba->fc_ratov * 2;
 439         mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
 440         /* Set up heart beat (HB) timer */
 441         mod_timer(&phba->hb_tmofunc, jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
 442         phba->hb_outstanding = 0;
 443         phba->last_completion_time = jiffies;
 444         /* Set up error attention (ERATT) polling timer */
 445         mod_timer(&phba->eratt_poll, jiffies + HZ * LPFC_ERATT_POLL_INTERVAL);
 446
 447         lpfc_init_link(phba, pmb, phba->cfg_topology, phba->cfg_link_speed);
 448         pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 449         lpfc_set_loopback_flag(phba);
 450         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 451         if (rc != MBX_SUCCESS) {
 452                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 453                                 "0454 Adapter failed to init, mbxCmd x%x "
 454                                 "INIT_LINK, mbxStatus x%x\n",
 455                                 mb->mbxCommand, mb->mbxStatus);
 456
 457                 /* Clear all interrupt enable conditions */
 458                 writel(0, phba->HCregaddr);
 459                 readl(phba->HCregaddr); /* flush */
 460                 /* Clear all pending interrupts */
 461                 writel(0xffffffff, phba->HAregaddr);
 462                 readl(phba->HAregaddr); /* flush */
 463
 464                 phba->link_state = LPFC_HBA_ERROR;
 465                 if (rc != MBX_BUSY)
 466                         mempool_free(pmb, phba->mbox_mem_pool);
 467                 return -EIO;
 468         }
 469         /* MBOX buffer will be freed in mbox compl */
 470         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 471         lpfc_config_async(phba, pmb, LPFC_ELS_RING);
 472         pmb->mbox_cmpl = lpfc_config_async_cmpl;
 473         pmb->vport = phba->pport;
 474         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
 475
 476         if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
 477                 lpfc_printf_log(phba,
 478                                 KERN_ERR,
 479                                 LOG_INIT,
 480                                 "0456 Adapter failed to issue "
 481                                 "ASYNCEVT_ENABLE mbox status x%x \n.",
 482                                 rc);
 483                 mempool_free(pmb, phba->mbox_mem_pool);
 484         }
 485         return 0;
 486 }
 487
 488 /**
 489  * lpfc_hba_down_prep: Perform lpfc uninitialization prior to HBA reset.
 490  * @phba: pointer to lpfc HBA data structure.
 491  *
 492  * This routine will do LPFC uninitialization before the HBA is reset when
 493  * bringing down the SLI Layer.
 494  *
 495  * Return codes
 496  *   0 - success.
 497  *   Any other value - error.
 498  **/
 499 int
 500 lpfc_hba_down_prep(struct lpfc_hba *phba)
 501 {
 502         struct lpfc_vport **vports;
 503         int i;
 504         /* Disable interrupts */
 505         writel(0, phba->HCregaddr);
 506         readl(phba->HCregaddr); /* flush */
 507
 508         if (phba->pport->load_flag & FC_UNLOADING)
 509                 lpfc_cleanup_discovery_resources(phba->pport);
 510         else {
 511                 vports = lpfc_create_vport_work_array(phba);
 512                 if (vports != NULL)
 513                         for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++)
 514                                 lpfc_cleanup_discovery_resources(vports[i]);
 515                 lpfc_destroy_vport_work_array(phba, vports);
 516         }
 517         return 0;
 518 }
 519
 520 /**
 521  * lpfc_hba_down_post: Perform lpfc uninitialization after HBA reset.
 522  * @phba: pointer to lpfc HBA data structure.
 523  *
 524  * This routine will do uninitialization after the HBA is reset when bring
 525  * down the SLI Layer.
 526  *
 527  * Return codes
 528  *   0 - sucess.
 529  *   Any other value - error.
 530  **/
 531 int
 532 lpfc_hba_down_post(struct lpfc_hba *phba)
 533 {
 534         struct lpfc_sli *psli = &phba->sli;
 535         struct lpfc_sli_ring *pring;
 536         struct lpfc_dmabuf *mp, *next_mp;
 537         struct lpfc_iocbq *iocb;
 538         IOCB_t *cmd = NULL;
 539         LIST_HEAD(completions);
 540         int i;
 541
 542         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
 543                 lpfc_sli_hbqbuf_free_all(phba);
 544         else {
 545                 /* Cleanup preposted buffers on the ELS ring */
 546                 pring = &psli->ring[LPFC_ELS_RING];
 547                 list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) {
 548                         list_del(&mp->list);
 549                         pring->postbufq_cnt--;
 550                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 551                         kfree(mp);
 552                 }
 553         }
 554
 555         spin_lock_irq(&phba->hbalock);
 556         for (i = 0; i < psli->num_rings; i++) {
 557                 pring = &psli->ring[i];
 558
 559                 /* At this point in time the HBA is either reset or DOA. Either
 560                  * way, nothing should be on txcmplq as it will NEVER complete.
 561                  */
 562                 list_splice_init(&pring->txcmplq, &completions);
 563                 pring->txcmplq_cnt = 0;
 564                 spin_unlock_irq(&phba->hbalock);
 565
 566                 while (!list_empty(&completions)) {
 567                         iocb = list_get_first(&completions, struct lpfc_iocbq,
 568                                 list);
 569                         cmd = &iocb->iocb;
 570                         list_del_init(&iocb->list);
 571
 572                         if (!iocb->iocb_cmpl)
 573                                 lpfc_sli_release_iocbq(phba, iocb);
 574                         else {
 575                                 cmd->ulpStatus = IOSTAT_LOCAL_REJECT;
 576                                 cmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
 577                                 (iocb->iocb_cmpl) (phba, iocb, iocb);
 578                         }
 579                 }
 580
 581                 lpfc_sli_abort_iocb_ring(phba, pring);
 582                 spin_lock_irq(&phba->hbalock);
 583         }
 584         spin_unlock_irq(&phba->hbalock);
 585
 586         return 0;
 587 }
 588
 589 /**
 590  * lpfc_hb_timeout: The HBA-timer timeout handler.
 591  * @ptr: unsigned long holds the pointer to lpfc hba data structure.
 592  *
 593  * This is the HBA-timer timeout handler registered to the lpfc driver. When
 594  * this timer fires, a HBA timeout event shall be posted to the lpfc driver
 595  * work-port-events bitmap and the worker thread is notified. This timeout
 596  * event will be used by the worker thread to invoke the actual timeout
 597  * handler routine, lpfc_hb_timeout_handler. Any periodical operations will
 598  * be performed in the timeout handler and the HBA timeout event bit shall
 599  * be cleared by the worker thread after it has taken the event bitmap out.
 600  **/
 601 static void
 602 lpfc_hb_timeout(unsigned long ptr)
 603 {
 604         struct lpfc_hba *phba;
 605         uint32_t tmo_posted;
 606         unsigned long iflag;
 607
 608         phba = (struct lpfc_hba *)ptr;
 609
 610         /* Check for heart beat timeout conditions */
 611         spin_lock_irqsave(&phba->pport->work_port_lock, iflag);
 612         tmo_posted = phba->pport->work_port_events & WORKER_HB_TMO;
 613         if (!tmo_posted)
 614                 phba->pport->work_port_events |= WORKER_HB_TMO;
 615         spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag);
 616
 617         /* Tell the worker thread there is work to do */
 618         if (!tmo_posted)
 619                 lpfc_worker_wake_up(phba);
 620         return;
 621 }
 622
 623 /**
 624  * lpfc_hb_mbox_cmpl: The lpfc heart-beat mailbox command callback function.
 625  * @phba: pointer to lpfc hba data structure.
 626  * @pmboxq: pointer to the driver internal queue element for mailbox command.
 627  *
 628  * This is the callback function to the lpfc heart-beat mailbox command.
 629  * If configured, the lpfc driver issues the heart-beat mailbox command to
 630  * the HBA every LPFC_HB_MBOX_INTERVAL (current 5) seconds. At the time the
 631  * heart-beat mailbox command is issued, the driver shall set up heart-beat
 632  * timeout timer to LPFC_HB_MBOX_TIMEOUT (current 30) seconds and marks
 633  * heart-beat outstanding state. Once the mailbox command comes back and
 634  * no error conditions detected, the heart-beat mailbox command timer is
 635  * reset to LPFC_HB_MBOX_INTERVAL seconds and the heart-beat outstanding
 636  * state is cleared for the next heart-beat. If the timer expired with the
 637  * heart-beat outstanding state set, the driver will put the HBA offline.
 638  **/
 639 static void
 640 lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
 641 {
 642         unsigned long drvr_flag;
 643
 644         spin_lock_irqsave(&phba->hbalock, drvr_flag);
 645         phba->hb_outstanding = 0;
 646         spin_unlock_irqrestore(&phba->hbalock, drvr_flag);
 647
 648         /* Check and reset heart-beat timer is necessary */
 649         mempool_free(pmboxq, phba->mbox_mem_pool);
 650         if (!(phba->pport->fc_flag & FC_OFFLINE_MODE) &&
 651                 !(phba->link_state == LPFC_HBA_ERROR) &&
 652                 !(phba->pport->load_flag & FC_UNLOADING))
 653                 mod_timer(&phba->hb_tmofunc,
 654                         jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
 655         return;
 656 }
 657
 658 /**
 659  * lpfc_hb_timeout_handler: The HBA-timer timeout handler.
 660  * @phba: pointer to lpfc hba data structure.
 661  *
 662  * This is the actual HBA-timer timeout handler to be invoked by the worker
 663  * thread whenever the HBA timer fired and HBA-timeout event posted. This
 664  * handler performs any periodic operations needed for the device. If such
 665  * periodic event has already been attended to either in the interrupt handler
 666  * or by processing slow-ring or fast-ring events within the HBA-timer
 667  * timeout window (LPFC_HB_MBOX_INTERVAL), this handler just simply resets
 668  * the timer for the next timeout period. If lpfc heart-beat mailbox command
 669  * is configured and there is no heart-beat mailbox command outstanding, a
 670  * heart-beat mailbox is issued and timer set properly. Otherwise, if there
 671  * has been a heart-beat mailbox command outstanding, the HBA shall be put
 672  * to offline.
 673  **/
 674 void
 675 lpfc_hb_timeout_handler(struct lpfc_hba *phba)
 676 {
 677         LPFC_MBOXQ_t *pmboxq;
 678         struct lpfc_dmabuf *buf_ptr;
 679         int retval;
 680         struct lpfc_sli *psli = &phba->sli;
 681         LIST_HEAD(completions);
 682
 683         if ((phba->link_state == LPFC_HBA_ERROR) ||
 684                 (phba->pport->load_flag & FC_UNLOADING) ||
 685                 (phba->pport->fc_flag & FC_OFFLINE_MODE))
 686                 return;
 687
 688         spin_lock_irq(&phba->pport->work_port_lock);
 689         /* If the timer is already canceled do nothing */
 690         if (!(phba->pport->work_port_events & WORKER_HB_TMO)) {
 691                 spin_unlock_irq(&phba->pport->work_port_lock);
 692                 return;
 693         }
 694
 695         if (time_after(phba->last_completion_time + LPFC_HB_MBOX_INTERVAL * HZ,
 696                 jiffies)) {
 697                 spin_unlock_irq(&phba->pport->work_port_lock);
 698                 if (!phba->hb_outstanding)
 699                         mod_timer(&phba->hb_tmofunc,
 700                                 jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
 701                 else
 702                         mod_timer(&phba->hb_tmofunc,
 703                                 jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
 704                 return;
 705         }
 706         spin_unlock_irq(&phba->pport->work_port_lock);
 707
 708         if (phba->elsbuf_cnt &&
 709                 (phba->elsbuf_cnt == phba->elsbuf_prev_cnt)) {
 710                 spin_lock_irq(&phba->hbalock);
 711                 list_splice_init(&phba->elsbuf, &completions);
 712                 phba->elsbuf_cnt = 0;
 713                 phba->elsbuf_prev_cnt = 0;
 714                 spin_unlock_irq(&phba->hbalock);
 715
 716                 while (!list_empty(&completions)) {
 717                         list_remove_head(&completions, buf_ptr,
 718                                 struct lpfc_dmabuf, list);
 719                         lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys);
 720                         kfree(buf_ptr);
 721                 }
 722         }
 723         phba->elsbuf_prev_cnt = phba->elsbuf_cnt;
 724
 725         /* If there is no heart beat outstanding, issue a heartbeat command */
 726         if (phba->cfg_enable_hba_heartbeat) {
 727                 if (!phba->hb_outstanding) {
 728                         pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
 729                         if (!pmboxq) {
 730                                 mod_timer(&phba->hb_tmofunc,
 731                                           jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
 732                                 return;
 733                         }
 734
 735                         lpfc_heart_beat(phba, pmboxq);
 736                         pmboxq->mbox_cmpl = lpfc_hb_mbox_cmpl;
 737                         pmboxq->vport = phba->pport;
 738                         retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
 739
 740                         if (retval != MBX_BUSY && retval != MBX_SUCCESS) {
 741                                 mempool_free(pmboxq, phba->mbox_mem_pool);
 742                                 mod_timer(&phba->hb_tmofunc,
 743                                           jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
 744                                 return;
 745                         }
 746                         mod_timer(&phba->hb_tmofunc,
 747                                   jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
 748                         phba->hb_outstanding = 1;
 749                         return;
 750                 } else {
 751                         /*
 752                         * If heart beat timeout called with hb_outstanding set
 753                         * we need to take the HBA offline.
 754                         */
 755                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 756                                         "0459 Adapter heartbeat failure, "
 757                                         "taking this port offline.\n");
 758
 759                         spin_lock_irq(&phba->hbalock);
 760                         psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
 761                         spin_unlock_irq(&phba->hbalock);
 762
 763                         lpfc_offline_prep(phba);
 764                         lpfc_offline(phba);
 765                         lpfc_unblock_mgmt_io(phba);
 766                         phba->link_state = LPFC_HBA_ERROR;
 767                         lpfc_hba_down_post(phba);
 768                 }
 769         }
 770 }
 771
 772 /**
 773  * lpfc_offline_eratt: Bring lpfc offline on hardware error attention.
 774  * @phba: pointer to lpfc hba data structure.
 775  *
 776  * This routine is called to bring the HBA offline when HBA hardware error
 777  * other than Port Error 6 has been detected.
 778  **/
 779 static void
 780 lpfc_offline_eratt(struct lpfc_hba *phba)
 781 {
 782         struct lpfc_sli   *psli = &phba->sli;
 783
 784         spin_lock_irq(&phba->hbalock);
 785         psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
 786         spin_unlock_irq(&phba->hbalock);
 787         lpfc_offline_prep(phba);
 788
 789         lpfc_offline(phba);
 790         lpfc_reset_barrier(phba);
 791         lpfc_sli_brdreset(phba);
 792         lpfc_hba_down_post(phba);
 793         lpfc_sli_brdready(phba, HS_MBRDY);
 794         lpfc_unblock_mgmt_io(phba);
 795         phba->link_state = LPFC_HBA_ERROR;
 796         return;
 797 }
 798
 799 /**
 800  * lpfc_handle_eratt: The HBA hardware error handler.
 801  * @phba: pointer to lpfc hba data structure.
 802  *
 803  * This routine is invoked to handle the following HBA hardware error
 804  * conditions:
 805  * 1 - HBA error attention interrupt
 806  * 2 - DMA ring index out of range
 807  * 3 - Mailbox command came back as unknown
 808  **/
 809 void
 810 lpfc_handle_eratt(struct lpfc_hba *phba)
 811 {
 812         struct lpfc_vport *vport = phba->pport;
 813         struct lpfc_sli   *psli = &phba->sli;
 814         struct lpfc_sli_ring  *pring;
 815         uint32_t event_data;
 816         unsigned long temperature;
 817         struct temp_event temp_event_data;
 818         struct Scsi_Host  *shost;
 819         struct lpfc_board_event_header board_event;
 820
 821         /* If the pci channel is offline, ignore possible errors,
 822          * since we cannot communicate with the pci card anyway. */
 823         if (pci_channel_offline(phba->pcidev))
 824                 return;
 825         /* If resets are disabled then leave the HBA alone and return */
 826         if (!phba->cfg_enable_hba_reset)
 827                 return;
 828
 829         /* Send an internal error event to mgmt application */
 830         board_event.event_type = FC_REG_BOARD_EVENT;
 831         board_event.subcategory = LPFC_EVENT_PORTINTERR;
 832         shost = lpfc_shost_from_vport(phba->pport);
 833         fc_host_post_vendor_event(shost, fc_get_event_number(),
 834                                   sizeof(board_event),
 835                                   (char *) &board_event,
 836                                   LPFC_NL_VENDOR_ID);
 837
 838         if (phba->work_hs & HS_FFER6) {
 839                 /* Re-establishing Link */
 840                 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
 841                                 "1301 Re-establishing Link "
 842                                 "Data: x%x x%x x%x\n",
 843                                 phba->work_hs,
 844                                 phba->work_status[0], phba->work_status[1]);
 845
 846                 spin_lock_irq(&phba->hbalock);
 847                 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
 848                 spin_unlock_irq(&phba->hbalock);
 849
 850                 /*
 851                 * Firmware stops when it triggled erratt with HS_FFER6.
 852                 * That could cause the I/Os dropped by the firmware.
 853                 * Error iocb (I/O) on txcmplq and let the SCSI layer
 854                 * retry it after re-establishing link.
 855                 */
 856                 pring = &psli->ring[psli->fcp_ring];
 857                 lpfc_sli_abort_iocb_ring(phba, pring);
 858
 859                 /*
 860                  * There was a firmware error.  Take the hba offline and then
 861                  * attempt to restart it.
 862                  */
 863                 lpfc_offline_prep(phba);
 864                 lpfc_offline(phba);
 865                 lpfc_sli_brdrestart(phba);
 866                 if (lpfc_online(phba) == 0) {   /* Initialize the HBA */
 867                         lpfc_unblock_mgmt_io(phba);
 868                         return;
 869                 }
 870                 lpfc_unblock_mgmt_io(phba);
 871         } else if (phba->work_hs & HS_CRIT_TEMP) {
 872                 temperature = readl(phba->MBslimaddr + TEMPERATURE_OFFSET);
 873                 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
 874                 temp_event_data.event_code = LPFC_CRIT_TEMP;
 875                 temp_event_data.data = (uint32_t)temperature;
 876
 877                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 878                                 "0406 Adapter maximum temperature exceeded "
 879                                 "(%ld), taking this port offline "
 880                                 "Data: x%x x%x x%x\n",
 881                                 temperature, phba->work_hs,
 882                                 phba->work_status[0], phba->work_status[1]);
 883
 884                 shost = lpfc_shost_from_vport(phba->pport);
 885                 fc_host_post_vendor_event(shost, fc_get_event_number(),
 886                                           sizeof(temp_event_data),
 887                                           (char *) &temp_event_data,
 888                                           SCSI_NL_VID_TYPE_PCI
 889                                           | PCI_VENDOR_ID_EMULEX);
 890
 891                 spin_lock_irq(&phba->hbalock);
 892                 phba->over_temp_state = HBA_OVER_TEMP;
 893                 spin_unlock_irq(&phba->hbalock);
 894                 lpfc_offline_eratt(phba);
 895
 896         } else {
 897                 /* The if clause above forces this code path when the status
 898                  * failure is a value other than FFER6. Do not call the offline
 899                  * twice. This is the adapter hardware error path.
 900                  */
 901                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 902                                 "0457 Adapter Hardware Error "
 903                                 "Data: x%x x%x x%x\n",
 904                                 phba->work_hs,
 905                                 phba->work_status[0], phba->work_status[1]);
 906
 907                 event_data = FC_REG_DUMP_EVENT;
 908                 shost = lpfc_shost_from_vport(vport);
 909                 fc_host_post_vendor_event(shost, fc_get_event_number(),
 910                                 sizeof(event_data), (char *) &event_data,
 911                                 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
 912
 913                 lpfc_offline_eratt(phba);
 914         }
 915         return;
 916 }
 917
 918 /**
 919  * lpfc_handle_latt: The HBA link event handler.
 920  * @phba: pointer to lpfc hba data structure.
 921  *
 922  * This routine is invoked from the worker thread to handle a HBA host
 923  * attention link event.
 924  **/
 925 void
 926 lpfc_handle_latt(struct lpfc_hba *phba)
 927 {
 928         struct lpfc_vport *vport = phba->pport;
 929         struct lpfc_sli   *psli = &phba->sli;
 930         LPFC_MBOXQ_t *pmb;
 931         volatile uint32_t control;
 932         struct lpfc_dmabuf *mp;
 933         int rc = 0;
 934
 935         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 936         if (!pmb) {
 937                 rc = 1;
 938                 goto lpfc_handle_latt_err_exit;
 939         }
 940
 941         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
 942         if (!mp) {
 943                 rc = 2;
 944                 goto lpfc_handle_latt_free_pmb;
 945         }
 946
 947         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
 948         if (!mp->virt) {
 949                 rc = 3;
 950                 goto lpfc_handle_latt_free_mp;
 951         }
 952
 953         /* Cleanup any outstanding ELS commands */
 954         lpfc_els_flush_all_cmd(phba);
 955
 956         psli->slistat.link_event++;
 957         lpfc_read_la(phba, pmb, mp);
 958         pmb->mbox_cmpl = lpfc_mbx_cmpl_read_la;
 959         pmb->vport = vport;
 960         /* Block ELS IOCBs until we have processed this mbox command */
 961         phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
 962         rc = lpfc_sli_issue_mbox (phba, pmb, MBX_NOWAIT);
 963         if (rc == MBX_NOT_FINISHED) {
 964                 rc = 4;
 965                 goto lpfc_handle_latt_free_mbuf;
 966         }
 967
 968         /* Clear Link Attention in HA REG */
 969         spin_lock_irq(&phba->hbalock);
 970         writel(HA_LATT, phba->HAregaddr);
 971         readl(phba->HAregaddr); /* flush */
 972         spin_unlock_irq(&phba->hbalock);
 973
 974         return;
 975
 976 lpfc_handle_latt_free_mbuf:
 977         phba->sli.ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT;
 978         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 979 lpfc_handle_latt_free_mp:
 980         kfree(mp);
 981 lpfc_handle_latt_free_pmb:
 982         mempool_free(pmb, phba->mbox_mem_pool);
 983 lpfc_handle_latt_err_exit:
 984         /* Enable Link attention interrupts */
 985         spin_lock_irq(&phba->hbalock);
 986         psli->sli_flag |= LPFC_PROCESS_LA;
 987         control = readl(phba->HCregaddr);
 988         control |= HC_LAINT_ENA;
 989         writel(control, phba->HCregaddr);
 990         readl(phba->HCregaddr); /* flush */
 991
 992         /* Clear Link Attention in HA REG */
 993         writel(HA_LATT, phba->HAregaddr);
 994         readl(phba->HAregaddr); /* flush */
 995         spin_unlock_irq(&phba->hbalock);
 996         lpfc_linkdown(phba);
 997         phba->link_state = LPFC_HBA_ERROR;
 998
 999         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1000                      "0300 LATT: Cannot issue READ_LA: Data:%d\n", rc);
1001
1002         return;
1003 }
1004
1005 /**
1006  * lpfc_parse_vpd: Parse VPD (Vital Product Data).
1007  * @phba: pointer to lpfc hba data structure.
1008  * @vpd: pointer to the vital product data.
1009  * @len: length of the vital product data in bytes.
1010  *
1011  * This routine parses the Vital Product Data (VPD). The VPD is treated as
1012  * an array of characters. In this routine, the ModelName, ProgramType, and
1013  * ModelDesc, etc. fields of the phba data structure will be populated.
1014  *
1015  * Return codes
1016  *   0 - pointer to the VPD passed in is NULL
1017  *   1 - success
1018  **/
1019 static int
1020 lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len)
1021 {
1022         uint8_t lenlo, lenhi;
1023         int Length;
1024         int i, j;
1025         int finished = 0;
1026         int index = 0;
1027
1028         if (!vpd)
1029                 return 0;
1030
1031         /* Vital Product */
1032         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1033                         "0455 Vital Product Data: x%x x%x x%x x%x\n",
1034                         (uint32_t) vpd[0], (uint32_t) vpd[1], (uint32_t) vpd[2],
1035                         (uint32_t) vpd[3]);
1036         while (!finished && (index < (len - 4))) {
1037                 switch (vpd[index]) {
1038                 case 0x82:
1039                 case 0x91:
1040                         index += 1;
1041                         lenlo = vpd[index];
1042                         index += 1;
1043                         lenhi = vpd[index];
1044                         index += 1;
1045                         i = ((((unsigned short)lenhi) << 8) + lenlo);
1046                         index += i;
1047                         break;
1048                 case 0x90:
1049                         index += 1;
1050                         lenlo = vpd[index];
1051                         index += 1;
1052                         lenhi = vpd[index];
1053                         index += 1;
1054                         Length = ((((unsigned short)lenhi) << 8) + lenlo);
1055                         if (Length > len - index)
1056                                 Length = len - index;
1057                         while (Length > 0) {
1058                         /* Look for Serial Number */
1059                         if ((vpd[index] == 'S') && (vpd[index+1] == 'N')) {
1060                                 index += 2;
1061                                 i = vpd[index];
1062                                 index += 1;
1063                                 j = 0;
1064                                 Length -= (3+i);
1065                                 while(i--) {
1066                                         phba->SerialNumber[j++] = vpd[index++];
1067                                         if (j == 31)
1068                                                 break;
1069                                 }
1070                                 phba->SerialNumber[j] = 0;
1071                                 continue;
1072                         }
1073                         else if ((vpd[index] == 'V') && (vpd[index+1] == '1')) {
1074                                 phba->vpd_flag |= VPD_MODEL_DESC;
1075                                 index += 2;
1076                                 i = vpd[index];
1077                                 index += 1;
1078                                 j = 0;
1079                                 Length -= (3+i);
1080                                 while(i--) {
1081                                         phba->ModelDesc[j++] = vpd[index++];
1082                                         if (j == 255)
1083                                                 break;
1084                                 }
1085                                 phba->ModelDesc[j] = 0;
1086                                 continue;
1087                         }
1088                         else if ((vpd[index] == 'V') && (vpd[index+1] == '2')) {
1089                                 phba->vpd_flag |= VPD_MODEL_NAME;
1090                                 index += 2;
1091                                 i = vpd[index];
1092                                 index += 1;
1093                                 j = 0;
1094                                 Length -= (3+i);
1095                                 while(i--) {
1096                                         phba->ModelName[j++] = vpd[index++];
1097                                         if (j == 79)
1098                                                 break;
1099                                 }
1100                                 phba->ModelName[j] = 0;
1101                                 continue;
1102                         }
1103                         else if ((vpd[index] == 'V') && (vpd[index+1] == '3')) {
1104                                 phba->vpd_flag |= VPD_PROGRAM_TYPE;
1105                                 index += 2;
1106                                 i = vpd[index];
1107                                 index += 1;
1108                                 j = 0;
1109                                 Length -= (3+i);
1110                                 while(i--) {
1111                                         phba->ProgramType[j++] = vpd[index++];
1112                                         if (j == 255)
1113                                                 break;
1114                                 }
1115                                 phba->ProgramType[j] = 0;
1116                                 continue;
1117                         }
1118                         else if ((vpd[index] == 'V') && (vpd[index+1] == '4')) {
1119                                 phba->vpd_flag |= VPD_PORT;
1120                                 index += 2;
1121                                 i = vpd[index];
1122                                 index += 1;
1123                                 j = 0;
1124                                 Length -= (3+i);
1125                                 while(i--) {
1126                                 phba->Port[j++] = vpd[index++];
1127                                 if (j == 19)
1128                                         break;
1129                                 }
1130                                 phba->Port[j] = 0;
1131                                 continue;
1132                         }
1133                         else {
1134                                 index += 2;
1135                                 i = vpd[index];
1136                                 index += 1;
1137                                 index += i;
1138                                 Length -= (3 + i);
1139                         }
1140                 }
1141                 finished = 0;
1142                 break;
1143                 case 0x78:
1144                         finished = 1;
1145                         break;
1146                 default:
1147                         index ++;
1148                         break;
1149                 }
1150         }
1151
1152         return(1);
1153 }
1154
1155 /**
1156  * lpfc_get_hba_model_desc: Retrieve HBA device model name and description.
1157  * @phba: pointer to lpfc hba data structure.
1158  * @mdp: pointer to the data structure to hold the derived model name.
1159  * @descp: pointer to the data structure to hold the derived description.
1160  *
1161  * This routine retrieves HBA's description based on its registered PCI device
1162  * ID. The @descp passed into this function points to an array of 256 chars. It
1163  * shall be returned with the model name, maximum speed, and the host bus type.
1164  * The @mdp passed into this function points to an array of 80 chars. When the
1165  * function returns, the @mdp will be filled with the model name.
1166  **/
1167 static void
1168 lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
1169 {
1170         lpfc_vpd_t *vp;
1171         uint16_t dev_id = phba->pcidev->device;
1172         int max_speed;
1173         int GE = 0;
1174         struct {
1175                 char * name;
1176                 int    max_speed;
1177                 char * bus;
1178         } m = {"<Unknown>", 0, ""};
1179
1180         if (mdp && mdp[0] != '\0'
1181                 && descp && descp[0] != '\0')
1182                 return;
1183
1184         if (phba->lmt & LMT_10Gb)
1185                 max_speed = 10;
1186         else if (phba->lmt & LMT_8Gb)
1187                 max_speed = 8;
1188         else if (phba->lmt & LMT_4Gb)
1189                 max_speed = 4;
1190         else if (phba->lmt & LMT_2Gb)
1191                 max_speed = 2;
1192         else
1193                 max_speed = 1;
1194
1195         vp = &phba->vpd;
1196
1197         switch (dev_id) {
1198         case PCI_DEVICE_ID_FIREFLY:
1199                 m = (typeof(m)){"LP6000", max_speed, "PCI"};
1200                 break;
1201         case PCI_DEVICE_ID_SUPERFLY:
1202                 if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3)
1203                         m = (typeof(m)){"LP7000", max_speed,  "PCI"};
1204                 else
1205                         m = (typeof(m)){"LP7000E", max_speed, "PCI"};
1206                 break;
1207         case PCI_DEVICE_ID_DRAGONFLY:
1208                 m = (typeof(m)){"LP8000", max_speed, "PCI"};
1209                 break;
1210         case PCI_DEVICE_ID_CENTAUR:
1211                 if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID)
1212                         m = (typeof(m)){"LP9002", max_speed, "PCI"};
1213                 else
1214                         m = (typeof(m)){"LP9000", max_speed, "PCI"};
1215                 break;
1216         case PCI_DEVICE_ID_RFLY:
1217                 m = (typeof(m)){"LP952", max_speed, "PCI"};
1218                 break;
1219         case PCI_DEVICE_ID_PEGASUS:
1220                 m = (typeof(m)){"LP9802", max_speed, "PCI-X"};
1221                 break;
1222         case PCI_DEVICE_ID_THOR:
1223                 m = (typeof(m)){"LP10000", max_speed, "PCI-X"};
1224                 break;
1225         case PCI_DEVICE_ID_VIPER:
1226                 m = (typeof(m)){"LPX1000", max_speed,  "PCI-X"};
1227                 break;
1228         case PCI_DEVICE_ID_PFLY:
1229                 m = (typeof(m)){"LP982", max_speed, "PCI-X"};
1230                 break;
1231         case PCI_DEVICE_ID_TFLY:
1232                 m = (typeof(m)){"LP1050", max_speed, "PCI-X"};
1233                 break;
1234         case PCI_DEVICE_ID_HELIOS:
1235                 m = (typeof(m)){"LP11000", max_speed, "PCI-X2"};
1236                 break;
1237         case PCI_DEVICE_ID_HELIOS_SCSP:
1238                 m = (typeof(m)){"LP11000-SP", max_speed, "PCI-X2"};
1239                 break;
1240         case PCI_DEVICE_ID_HELIOS_DCSP:
1241                 m = (typeof(m)){"LP11002-SP", max_speed, "PCI-X2"};
1242                 break;
1243         case PCI_DEVICE_ID_NEPTUNE:
1244                 m = (typeof(m)){"LPe1000", max_speed, "PCIe"};
1245                 break;
1246         case PCI_DEVICE_ID_NEPTUNE_SCSP:
1247                 m = (typeof(m)){"LPe1000-SP", max_speed, "PCIe"};
1248                 break;
1249         case PCI_DEVICE_ID_NEPTUNE_DCSP:
1250                 m = (typeof(m)){"LPe1002-SP", max_speed, "PCIe"};
1251                 break;
1252         case PCI_DEVICE_ID_BMID:
1253                 m = (typeof(m)){"LP1150", max_speed, "PCI-X2"};
1254                 break;
1255         case PCI_DEVICE_ID_BSMB:
1256                 m = (typeof(m)){"LP111", max_speed, "PCI-X2"};
1257                 break;
1258         case PCI_DEVICE_ID_ZEPHYR:
1259                 m = (typeof(m)){"LPe11000", max_speed, "PCIe"};
1260                 break;
1261         case PCI_DEVICE_ID_ZEPHYR_SCSP:
1262                 m = (typeof(m)){"LPe11000", max_speed, "PCIe"};
1263                 break;
1264         case PCI_DEVICE_ID_ZEPHYR_DCSP:
1265                 m = (typeof(m)){"LPe11002-SP", max_speed, "PCIe"};
1266                 break;
1267         case PCI_DEVICE_ID_ZMID:
1268                 m = (typeof(m)){"LPe1150", max_speed, "PCIe"};
1269                 break;
1270         case PCI_DEVICE_ID_ZSMB:
1271                 m = (typeof(m)){"LPe111", max_speed, "PCIe"};
1272                 break;
1273         case PCI_DEVICE_ID_LP101:
1274                 m = (typeof(m)){"LP101", max_speed, "PCI-X"};
1275                 break;
1276         case PCI_DEVICE_ID_LP10000S:
1277                 m = (typeof(m)){"LP10000-S", max_speed, "PCI"};
1278                 break;
1279         case PCI_DEVICE_ID_LP11000S:
1280                 m = (typeof(m)){"LP11000-S", max_speed,
1281                         "PCI-X2"};
1282                 break;
1283         case PCI_DEVICE_ID_LPE11000S:
1284                 m = (typeof(m)){"LPe11000-S", max_speed,
1285                         "PCIe"};
1286                 break;
1287         case PCI_DEVICE_ID_SAT:
1288                 m = (typeof(m)){"LPe12000", max_speed, "PCIe"};
1289                 break;
1290         case PCI_DEVICE_ID_SAT_MID:
1291                 m = (typeof(m)){"LPe1250", max_speed, "PCIe"};
1292                 break;
1293         case PCI_DEVICE_ID_SAT_SMB:
1294                 m = (typeof(m)){"LPe121", max_speed, "PCIe"};
1295                 break;
1296         case PCI_DEVICE_ID_SAT_DCSP:
1297                 m = (typeof(m)){"LPe12002-SP", max_speed, "PCIe"};
1298                 break;
1299         case PCI_DEVICE_ID_SAT_SCSP:
1300                 m = (typeof(m)){"LPe12000-SP", max_speed, "PCIe"};
1301                 break;
1302         case PCI_DEVICE_ID_SAT_S:
1303                 m = (typeof(m)){"LPe12000-S", max_speed, "PCIe"};
1304                 break;
1305         case PCI_DEVICE_ID_HORNET:
1306                 m = (typeof(m)){"LP21000", max_speed, "PCIe"};
1307                 GE = 1;
1308                 break;
1309         case PCI_DEVICE_ID_PROTEUS_VF:
1310                 m = (typeof(m)) {"LPev12000", max_speed, "PCIe IOV"};
1311                 break;
1312         case PCI_DEVICE_ID_PROTEUS_PF:
1313                 m = (typeof(m)) {"LPev12000", max_speed, "PCIe IOV"};
1314                 break;
1315         case PCI_DEVICE_ID_PROTEUS_S:
1316                 m = (typeof(m)) {"LPemv12002-S", max_speed, "PCIe IOV"};
1317                 break;
1318         default:
1319                 m = (typeof(m)){ NULL };
1320                 break;
1321         }
1322
1323         if (mdp && mdp[0] == '\0')
1324                 snprintf(mdp, 79,"%s", m.name);
1325         if (descp && descp[0] == '\0')
1326                 snprintf(descp, 255,
1327                         "Emulex %s %d%s %s %s",
1328                         m.name, m.max_speed,
1329                         (GE) ? "GE" : "Gb",
1330                         m.bus,
1331                         (GE) ? "FCoE Adapter" : "Fibre Channel Adapter");
1332 }
1333
1334 /**
1335  * lpfc_post_buffer: Post IOCB(s) with DMA buffer descriptor(s) to a IOCB ring.
1336  * @phba: pointer to lpfc hba data structure.
1337  * @pring: pointer to a IOCB ring.
1338  * @cnt: the number of IOCBs to be posted to the IOCB ring.
1339  *
1340  * This routine posts a given number of IOCBs with the associated DMA buffer
1341  * descriptors specified by the cnt argument to the given IOCB ring.
1342  *
1343  * Return codes
1344  *   The number of IOCBs NOT able to be posted to the IOCB ring.
1345  **/
1346 int
1347 lpfc_post_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, int cnt)
1348 {
1349         IOCB_t *icmd;
1350         struct lpfc_iocbq *iocb;
1351         struct lpfc_dmabuf *mp1, *mp2;
1352
1353         cnt += pring->missbufcnt;
1354
1355         /* While there are buffers to post */
1356         while (cnt > 0) {
1357                 /* Allocate buffer for  command iocb */
1358                 iocb = lpfc_sli_get_iocbq(phba);
1359                 if (iocb == NULL) {
1360                         pring->missbufcnt = cnt;
1361                         return cnt;
1362                 }
1363                 icmd = &iocb->iocb;
1364
1365                 /* 2 buffers can be posted per command */
1366                 /* Allocate buffer to post */
1367                 mp1 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1368                 if (mp1)
1369                     mp1->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp1->phys);
1370                 if (!mp1 || !mp1->virt) {
1371                         kfree(mp1);
1372                         lpfc_sli_release_iocbq(phba, iocb);
1373                         pring->missbufcnt = cnt;
1374                         return cnt;
1375                 }
1376
1377                 INIT_LIST_HEAD(&mp1->list);
1378                 /* Allocate buffer to post */
1379                 if (cnt > 1) {
1380                         mp2 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1381                         if (mp2)
1382                                 mp2->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
1383                                                             &mp2->phys);
1384                         if (!mp2 || !mp2->virt) {
1385                                 kfree(mp2);
1386                                 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1387                                 kfree(mp1);
1388                                 lpfc_sli_release_iocbq(phba, iocb);
1389                                 pring->missbufcnt = cnt;
1390                                 return cnt;
1391                         }
1392
1393                         INIT_LIST_HEAD(&mp2->list);
1394                 } else {
1395                         mp2 = NULL;
1396                 }
1397
1398                 icmd->un.cont64[0].addrHigh = putPaddrHigh(mp1->phys);
1399                 icmd->un.cont64[0].addrLow = putPaddrLow(mp1->phys);
1400                 icmd->un.cont64[0].tus.f.bdeSize = FCELSSIZE;
1401                 icmd->ulpBdeCount = 1;
1402                 cnt--;
1403                 if (mp2) {
1404                         icmd->un.cont64[1].addrHigh = putPaddrHigh(mp2->phys);
1405                         icmd->un.cont64[1].addrLow = putPaddrLow(mp2->phys);
1406                         icmd->un.cont64[1].tus.f.bdeSize = FCELSSIZE;
1407                         cnt--;
1408                         icmd->ulpBdeCount = 2;
1409                 }
1410
1411                 icmd->ulpCommand = CMD_QUE_RING_BUF64_CN;
1412                 icmd->ulpLe = 1;
1413
1414                 if (lpfc_sli_issue_iocb(phba, pring, iocb, 0) == IOCB_ERROR) {
1415                         lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1416                         kfree(mp1);
1417                         cnt++;
1418                         if (mp2) {
1419                                 lpfc_mbuf_free(phba, mp2->virt, mp2->phys);
1420                                 kfree(mp2);
1421                                 cnt++;
1422                         }
1423                         lpfc_sli_release_iocbq(phba, iocb);
1424                         pring->missbufcnt = cnt;
1425                         return cnt;
1426                 }
1427                 lpfc_sli_ringpostbuf_put(phba, pring, mp1);
1428                 if (mp2)
1429                         lpfc_sli_ringpostbuf_put(phba, pring, mp2);
1430         }
1431         pring->missbufcnt = 0;
1432         return 0;
1433 }
1434
1435 /**
1436  * lpfc_post_rcv_buf: Post the initial receive IOCB buffers to ELS ring.
1437  * @phba: pointer to lpfc hba data structure.
1438  *
1439  * This routine posts initial receive IOCB buffers to the ELS ring. The
1440  * current number of initial IOCB buffers specified by LPFC_BUF_RING0 is
1441  * set to 64 IOCBs.
1442  *
1443  * Return codes
1444  *   0 - success (currently always success)
1445  **/
1446 static int
1447 lpfc_post_rcv_buf(struct lpfc_hba *phba)
1448 {
1449         struct lpfc_sli *psli = &phba->sli;
1450
1451         /* Ring 0, ELS / CT buffers */
1452         lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], LPFC_BUF_RING0);
1453         /* Ring 2 - FCP no buffers needed */
1454
1455         return 0;
1456 }
1457
1458 #define S(N,V) (((V)<<(N))|((V)>>(32-(N))))
1459
1460 /**
1461  * lpfc_sha_init: Set up initial array of hash table entries.
1462  * @HashResultPointer: pointer to an array as hash table.
1463  *
1464  * This routine sets up the initial values to the array of hash table entries
1465  * for the LC HBAs.
1466  **/
1467 static void
1468 lpfc_sha_init(uint32_t * HashResultPointer)
1469 {
1470         HashResultPointer[0] = 0x67452301;
1471         HashResultPointer[1] = 0xEFCDAB89;
1472         HashResultPointer[2] = 0x98BADCFE;
1473         HashResultPointer[3] = 0x10325476;
1474         HashResultPointer[4] = 0xC3D2E1F0;
1475 }
1476
1477 /**
1478  * lpfc_sha_iterate: Iterate initial hash table with the working hash table.
1479  * @HashResultPointer: pointer to an initial/result hash table.
1480  * @HashWorkingPointer: pointer to an working hash table.
1481  *
1482  * This routine iterates an initial hash table pointed by @HashResultPointer
1483  * with the values from the working hash table pointeed by @HashWorkingPointer.
1484  * The results are putting back to the initial hash table, returned through
1485  * the @HashResultPointer as the result hash table.
1486  **/
1487 static void
1488 lpfc_sha_iterate(uint32_t * HashResultPointer, uint32_t * HashWorkingPointer)
1489 {
1490         int t;
1491         uint32_t TEMP;
1492         uint32_t A, B, C, D, E;
1493         t = 16;
1494         do {
1495                 HashWorkingPointer[t] =
1496                     S(1,
1497                       HashWorkingPointer[t - 3] ^ HashWorkingPointer[t -
1498                                                                      8] ^
1499                       HashWorkingPointer[t - 14] ^ HashWorkingPointer[t - 16]);
1500         } while (++t <= 79);
1501         t = 0;
1502         A = HashResultPointer[0];
1503         B = HashResultPointer[1];
1504         C = HashResultPointer[2];
1505         D = HashResultPointer[3];
1506         E = HashResultPointer[4];
1507
1508         do {
1509                 if (t < 20) {
1510                         TEMP = ((B & C) | ((~B) & D)) + 0x5A827999;
1511                 } else if (t < 40) {
1512                         TEMP = (B ^ C ^ D) + 0x6ED9EBA1;
1513                 } else if (t < 60) {
1514                         TEMP = ((B & C) | (B & D) | (C & D)) + 0x8F1BBCDC;
1515                 } else {
1516                         TEMP = (B ^ C ^ D) + 0xCA62C1D6;
1517                 }
1518                 TEMP += S(5, A) + E + HashWorkingPointer[t];
1519                 E = D;
1520                 D = C;
1521                 C = S(30, B);
1522                 B = A;
1523                 A = TEMP;
1524         } while (++t <= 79);
1525
1526         HashResultPointer[0] += A;
1527         HashResultPointer[1] += B;
1528         HashResultPointer[2] += C;
1529         HashResultPointer[3] += D;
1530         HashResultPointer[4] += E;
1531
1532 }
1533
1534 /**
1535  * lpfc_challenge_key: Create challenge key based on WWPN of the HBA.
1536  * @RandomChallenge: pointer to the entry of host challenge random number array.
1537  * @HashWorking: pointer to the entry of the working hash array.
1538  *
1539  * This routine calculates the working hash array referred by @HashWorking
1540  * from the challenge random numbers associated with the host, referred by
1541  * @RandomChallenge. The result is put into the entry of the working hash
1542  * array and returned by reference through @HashWorking.
1543  **/
1544 static void
1545 lpfc_challenge_key(uint32_t * RandomChallenge, uint32_t * HashWorking)
1546 {
1547         *HashWorking = (*RandomChallenge ^ *HashWorking);
1548 }
1549
1550 /**
1551  * lpfc_hba_init: Perform special handling for LC HBA initialization.
1552  * @phba: pointer to lpfc hba data structure.
1553  * @hbainit: pointer to an array of unsigned 32-bit integers.
1554  *
1555  * This routine performs the special handling for LC HBA initialization.
1556  **/
1557 void
1558 lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit)
1559 {
1560         int t;
1561         uint32_t *HashWorking;
1562         uint32_t *pwwnn = (uint32_t *) phba->wwnn;
1563
1564         HashWorking = kcalloc(80, sizeof(uint32_t), GFP_KERNEL);
1565         if (!HashWorking)
1566                 return;
1567
1568         HashWorking[0] = HashWorking[78] = *pwwnn++;
1569         HashWorking[1] = HashWorking[79] = *pwwnn;
1570
1571         for (t = 0; t < 7; t++)
1572                 lpfc_challenge_key(phba->RandomData + t, HashWorking + t);
1573
1574         lpfc_sha_init(hbainit);
1575         lpfc_sha_iterate(hbainit, HashWorking);
1576         kfree(HashWorking);
1577 }
1578
1579 /**
1580  * lpfc_cleanup: Performs vport cleanups before deleting a vport.
1581  * @vport: pointer to a virtual N_Port data structure.
1582  *
1583  * This routine performs the necessary cleanups before deleting the @vport.
1584  * It invokes the discovery state machine to perform necessary state
1585  * transitions and to release the ndlps associated with the @vport. Note,
1586  * the physical port is treated as @vport 0.
1587  **/
1588 void
1589 lpfc_cleanup(struct lpfc_vport *vport)
1590 {
1591         struct lpfc_hba   *phba = vport->phba;
1592         struct lpfc_nodelist *ndlp, *next_ndlp;
1593         int i = 0;
1594
1595         if (phba->link_state > LPFC_LINK_DOWN)
1596                 lpfc_port_link_failure(vport);
1597
1598         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
1599                 if (!NLP_CHK_NODE_ACT(ndlp)) {
1600                         ndlp = lpfc_enable_node(vport, ndlp,
1601                                                 NLP_STE_UNUSED_NODE);
1602                         if (!ndlp)
1603                                 continue;
1604                         spin_lock_irq(&phba->ndlp_lock);
1605                         NLP_SET_FREE_REQ(ndlp);
1606                         spin_unlock_irq(&phba->ndlp_lock);
1607                         /* Trigger the release of the ndlp memory */
1608                         lpfc_nlp_put(ndlp);
1609                         continue;
1610                 }
1611                 spin_lock_irq(&phba->ndlp_lock);
1612                 if (NLP_CHK_FREE_REQ(ndlp)) {
1613                         /* The ndlp should not be in memory free mode already */
1614                         spin_unlock_irq(&phba->ndlp_lock);
1615                         continue;
1616                 } else
1617                         /* Indicate request for freeing ndlp memory */
1618                         NLP_SET_FREE_REQ(ndlp);
1619                 spin_unlock_irq(&phba->ndlp_lock);
1620
1621                 if (vport->port_type != LPFC_PHYSICAL_PORT &&
1622                     ndlp->nlp_DID == Fabric_DID) {
1623                         /* Just free up ndlp with Fabric_DID for vports */
1624                         lpfc_nlp_put(ndlp);
1625                         continue;
1626                 }
1627
1628                 if (ndlp->nlp_type & NLP_FABRIC)
1629                         lpfc_disc_state_machine(vport, ndlp, NULL,
1630                                         NLP_EVT_DEVICE_RECOVERY);
1631
1632                 lpfc_disc_state_machine(vport, ndlp, NULL,
1633                                              NLP_EVT_DEVICE_RM);
1634
1635         }
1636
1637         /* At this point, ALL ndlp's should be gone
1638          * because of the previous NLP_EVT_DEVICE_RM.
1639          * Lets wait for this to happen, if needed.
1640          */
1641         while (!list_empty(&vport->fc_nodes)) {
1642
1643                 if (i++ > 3000) {
1644                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
1645                                 "0233 Nodelist not empty\n");
1646                         list_for_each_entry_safe(ndlp, next_ndlp,
1647                                                 &vport->fc_nodes, nlp_listp) {
1648                                 lpfc_printf_vlog(ndlp->vport, KERN_ERR,
1649                                                 LOG_NODE,
1650                                                 "0282 did:x%x ndlp:x%p "
1651                                                 "usgmap:x%x refcnt:%d\n",
1652                                                 ndlp->nlp_DID, (void *)ndlp,
1653                                                 ndlp->nlp_usg_map,
1654                                                 atomic_read(
1655                                                         &ndlp->kref.refcount));
1656                         }
1657                         break;
1658                 }
1659
1660                 /* Wait for any activity on ndlps to settle */
1661                 msleep(10);
1662         }
1663         return;
1664 }
1665
1666 /**
1667  * lpfc_stop_vport_timers: Stop all the timers associated with a vport.
1668  * @vport: pointer to a virtual N_Port data structure.
1669  *
1670  * This routine stops all the timers associated with a @vport. This function
1671  * is invoked before disabling or deleting a @vport. Note that the physical
1672  * port is treated as @vport 0.
1673  **/
1674 void
1675 lpfc_stop_vport_timers(struct lpfc_vport *vport)
1676 {
1677         del_timer_sync(&vport->els_tmofunc);
1678         del_timer_sync(&vport->fc_fdmitmo);
1679         lpfc_can_disctmo(vport);
1680         return;
1681 }
1682
1683 /**
1684  * lpfc_stop_phba_timers: Stop all the timers associated with an HBA.
1685  * @phba: pointer to lpfc hba data structure.
1686  *
1687  * This routine stops all the timers associated with a HBA. This function is
1688  * invoked before either putting a HBA offline or unloading the driver.
1689  **/
1690 static void
1691 lpfc_stop_phba_timers(struct lpfc_hba *phba)
1692 {
1693         del_timer_sync(&phba->fcp_poll_timer);
1694         lpfc_stop_vport_timers(phba->pport);
1695         del_timer_sync(&phba->sli.mbox_tmo);
1696         del_timer_sync(&phba->fabric_block_timer);
1697         phba->hb_outstanding = 0;
1698         del_timer_sync(&phba->hb_tmofunc);
1699         del_timer_sync(&phba->eratt_poll);
1700         return;
1701 }
1702
1703 /**
1704  * lpfc_block_mgmt_io: Mark a HBA's management interface as blocked.
1705  * @phba: pointer to lpfc hba data structure.
1706  *
1707  * This routine marks a HBA's management interface as blocked. Once the HBA's
1708  * management interface is marked as blocked, all the user space access to
1709  * the HBA, whether they are from sysfs interface or libdfc interface will
1710  * all be blocked. The HBA is set to block the management interface when the
1711  * driver prepares the HBA interface for online or offline.
1712  **/
1713 static void
1714 lpfc_block_mgmt_io(struct lpfc_hba * phba)
1715 {
1716         unsigned long iflag;
1717
1718         spin_lock_irqsave(&phba->hbalock, iflag);
1719         phba->sli.sli_flag |= LPFC_BLOCK_MGMT_IO;
1720         spin_unlock_irqrestore(&phba->hbalock, iflag);
1721 }
1722
1723 /**
1724  * lpfc_online: Initialize and bring a HBA online.
1725  * @phba: pointer to lpfc hba data structure.
1726  *
1727  * This routine initializes the HBA and brings a HBA online. During this
1728  * process, the management interface is blocked to prevent user space access
1729  * to the HBA interfering with the driver initialization.
1730  *
1731  * Return codes
1732  *   0 - successful
1733  *   1 - failed
1734  **/
1735 int
1736 lpfc_online(struct lpfc_hba *phba)
1737 {
1738         struct lpfc_vport *vport = phba->pport;
1739         struct lpfc_vport **vports;
1740         int i;
1741
1742         if (!phba)
1743                 return 0;
1744
1745         if (!(vport->fc_flag & FC_OFFLINE_MODE))
1746                 return 0;
1747
1748         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1749                         "0458 Bring Adapter online\n");
1750
1751         lpfc_block_mgmt_io(phba);
1752
1753         if (!lpfc_sli_queue_setup(phba)) {
1754                 lpfc_unblock_mgmt_io(phba);
1755                 return 1;
1756         }
1757
1758         if (lpfc_sli_hba_setup(phba)) { /* Initialize the HBA */
1759                 lpfc_unblock_mgmt_io(phba);
1760                 return 1;
1761         }
1762
1763         vports = lpfc_create_vport_work_array(phba);
1764         if (vports != NULL)
1765                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1766                         struct Scsi_Host *shost;
1767                         shost = lpfc_shost_from_vport(vports[i]);
1768                         spin_lock_irq(shost->host_lock);
1769                         vports[i]->fc_flag &= ~FC_OFFLINE_MODE;
1770                         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
1771                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
1772                         spin_unlock_irq(shost->host_lock);
1773                 }
1774                 lpfc_destroy_vport_work_array(phba, vports);
1775
1776         lpfc_unblock_mgmt_io(phba);
1777         return 0;
1778 }
1779
1780 /**
1781  * lpfc_unblock_mgmt_io: Mark a HBA's management interface to be not blocked.
1782  * @phba: pointer to lpfc hba data structure.
1783  *
1784  * This routine marks a HBA's management interface as not blocked. Once the
1785  * HBA's management interface is marked as not blocked, all the user space
1786  * access to the HBA, whether they are from sysfs interface or libdfc
1787  * interface will be allowed. The HBA is set to block the management interface
1788  * when the driver prepares the HBA interface for online or offline and then
1789  * set to unblock the management interface afterwards.
1790  **/
1791 void
1792 lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
1793 {
1794         unsigned long iflag;
1795
1796         spin_lock_irqsave(&phba->hbalock, iflag);
1797         phba->sli.sli_flag &= ~LPFC_BLOCK_MGMT_IO;
1798         spin_unlock_irqrestore(&phba->hbalock, iflag);
1799 }
1800
1801 /**
1802  * lpfc_offline_prep: Prepare a HBA to be brought offline.
1803  * @phba: pointer to lpfc hba data structure.
1804  *
1805  * This routine is invoked to prepare a HBA to be brought offline. It performs
1806  * unregistration login to all the nodes on all vports and flushes the mailbox
1807  * queue to make it ready to be brought offline.
1808  **/
1809 void
1810 lpfc_offline_prep(struct lpfc_hba * phba)
1811 {
1812         struct lpfc_vport *vport = phba->pport;
1813         struct lpfc_nodelist  *ndlp, *next_ndlp;
1814         struct lpfc_vport **vports;
1815         int i;
1816
1817         if (vport->fc_flag & FC_OFFLINE_MODE)
1818                 return;
1819
1820         lpfc_block_mgmt_io(phba);
1821
1822         lpfc_linkdown(phba);
1823
1824         /* Issue an unreg_login to all nodes on all vports */
1825         vports = lpfc_create_vport_work_array(phba);
1826         if (vports != NULL) {
1827                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1828                         struct Scsi_Host *shost;
1829
1830                         if (vports[i]->load_flag & FC_UNLOADING)
1831                                 continue;
1832                         shost = lpfc_shost_from_vport(vports[i]);
1833                         list_for_each_entry_safe(ndlp, next_ndlp,
1834                                                  &vports[i]->fc_nodes,
1835                                                  nlp_listp) {
1836                                 if (!NLP_CHK_NODE_ACT(ndlp))
1837                                         continue;
1838                                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
1839                                         continue;
1840                                 if (ndlp->nlp_type & NLP_FABRIC) {
1841                                         lpfc_disc_state_machine(vports[i], ndlp,
1842                                                 NULL, NLP_EVT_DEVICE_RECOVERY);
1843                                         lpfc_disc_state_machine(vports[i], ndlp,
1844                                                 NULL, NLP_EVT_DEVICE_RM);
1845                                 }
1846                                 spin_lock_irq(shost->host_lock);
1847                                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
1848                                 spin_unlock_irq(shost->host_lock);
1849                                 lpfc_unreg_rpi(vports[i], ndlp);
1850                         }
1851                 }
1852         }
1853         lpfc_destroy_vport_work_array(phba, vports);
1854
1855         lpfc_sli_flush_mbox_queue(phba);
1856 }
1857
1858 /**
1859  * lpfc_offline: Bring a HBA offline.
1860  * @phba: pointer to lpfc hba data structure.
1861  *
1862  * This routine actually brings a HBA offline. It stops all the timers
1863  * associated with the HBA, brings down the SLI layer, and eventually
1864  * marks the HBA as in offline state for the upper layer protocol.
1865  **/
1866 void
1867 lpfc_offline(struct lpfc_hba *phba)
1868 {
1869         struct Scsi_Host  *shost;
1870         struct lpfc_vport **vports;
1871         int i;
1872
1873         if (phba->pport->fc_flag & FC_OFFLINE_MODE)
1874                 return;
1875
1876         /* stop all timers associated with this hba */
1877         lpfc_stop_phba_timers(phba);
1878         vports = lpfc_create_vport_work_array(phba);
1879         if (vports != NULL)
1880                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++)
1881                         lpfc_stop_vport_timers(vports[i]);
1882         lpfc_destroy_vport_work_array(phba, vports);
1883         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1884                         "0460 Bring Adapter offline\n");
1885         /* Bring down the SLI Layer and cleanup.  The HBA is offline
1886            now.  */
1887         lpfc_sli_hba_down(phba);
1888         spin_lock_irq(&phba->hbalock);
1889         phba->work_ha = 0;
1890         spin_unlock_irq(&phba->hbalock);
1891         vports = lpfc_create_vport_work_array(phba);
1892         if (vports != NULL)
1893                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1894                         shost = lpfc_shost_from_vport(vports[i]);
1895                         spin_lock_irq(shost->host_lock);
1896                         vports[i]->work_port_events = 0;
1897                         vports[i]->fc_flag |= FC_OFFLINE_MODE;
1898                         spin_unlock_irq(shost->host_lock);
1899                 }
1900         lpfc_destroy_vport_work_array(phba, vports);
1901 }
1902
1903 /**
1904  * lpfc_scsi_free: Free all the SCSI buffers and IOCBs from driver lists.
1905  * @phba: pointer to lpfc hba data structure.
1906  *
1907  * This routine is to free all the SCSI buffers and IOCBs from the driver
1908  * list back to kernel. It is called from lpfc_pci_remove_one to free
1909  * the internal resources before the device is removed from the system.
1910  *
1911  * Return codes
1912  *   0 - successful (for now, it always returns 0)
1913  **/
1914 static int
1915 lpfc_scsi_free(struct lpfc_hba *phba)
1916 {
1917         struct lpfc_scsi_buf *sb, *sb_next;
1918         struct lpfc_iocbq *io, *io_next;
1919
1920         spin_lock_irq(&phba->hbalock);
1921         /* Release all the lpfc_scsi_bufs maintained by this host. */
1922         list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) {
1923                 list_del(&sb->list);
1924                 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
1925                               sb->dma_handle);
1926                 kfree(sb);
1927                 phba->total_scsi_bufs--;
1928         }
1929
1930         /* Release all the lpfc_iocbq entries maintained by this host. */
1931         list_for_each_entry_safe(io, io_next, &phba->lpfc_iocb_list, list) {
1932                 list_del(&io->list);
1933                 kfree(io);
1934                 phba->total_iocbq_bufs--;
1935         }
1936
1937         spin_unlock_irq(&phba->hbalock);
1938
1939         return 0;
1940 }
1941
1942 /**
1943  * lpfc_create_port: Create an FC port.
1944  * @phba: pointer to lpfc hba data structure.
1945  * @instance: a unique integer ID to this FC port.
1946  * @dev: pointer to the device data structure.
1947  *
1948  * This routine creates a FC port for the upper layer protocol. The FC port
1949  * can be created on top of either a physical port or a virtual port provided
1950  * by the HBA. This routine also allocates a SCSI host data structure (shost)
1951  * and associates the FC port created before adding the shost into the SCSI
1952  * layer.
1953  *
1954  * Return codes
1955  *   @vport - pointer to the virtual N_Port data structure.
1956  *   NULL - port create failed.
1957  **/
1958 struct lpfc_vport *
1959 lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
1960 {
1961         struct lpfc_vport *vport;
1962         struct Scsi_Host  *shost;
1963         int error = 0;
1964
1965         if (dev != &phba->pcidev->dev)
1966                 shost = scsi_host_alloc(&lpfc_vport_template,
1967                                         sizeof(struct lpfc_vport));
1968         else
1969                 shost = scsi_host_alloc(&lpfc_template,
1970                                         sizeof(struct lpfc_vport));
1971         if (!shost)
1972                 goto out;
1973
1974         vport = (struct lpfc_vport *) shost->hostdata;
1975         vport->phba = phba;
1976         vport->load_flag |= FC_LOADING;
1977         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
1978         vport->fc_rscn_flush = 0;
1979
1980         lpfc_get_vport_cfgparam(vport);
1981         shost->unique_id = instance;
1982         shost->max_id = LPFC_MAX_TARGET;
1983         shost->max_lun = vport->cfg_max_luns;
1984         shost->this_id = -1;
1985         shost->max_cmd_len = 16;
1986         /*
1987          * Set initial can_queue value since 0 is no longer supported and
1988          * scsi_add_host will fail. This will be adjusted later based on the
1989          * max xri value determined in hba setup.
1990          */
1991         shost->can_queue = phba->cfg_hba_queue_depth - 10;
1992         if (dev != &phba->pcidev->dev) {
1993                 shost->transportt = lpfc_vport_transport_template;
1994                 vport->port_type = LPFC_NPIV_PORT;
1995         } else {
1996                 shost->transportt = lpfc_transport_template;
1997                 vport->port_type = LPFC_PHYSICAL_PORT;
1998         }
1999
2000         /* Initialize all internally managed lists. */
2001         INIT_LIST_HEAD(&vport->fc_nodes);
2002         spin_lock_init(&vport->work_port_lock);
2003
2004         init_timer(&vport->fc_disctmo);
2005         vport->fc_disctmo.function = lpfc_disc_timeout;
2006         vport->fc_disctmo.data = (unsigned long)vport;
2007
2008         init_timer(&vport->fc_fdmitmo);
2009         vport->fc_fdmitmo.function = lpfc_fdmi_tmo;
2010         vport->fc_fdmitmo.data = (unsigned long)vport;
2011
2012         init_timer(&vport->els_tmofunc);
2013         vport->els_tmofunc.function = lpfc_els_timeout;
2014         vport->els_tmofunc.data = (unsigned long)vport;
2015
2016         error = scsi_add_host(shost, dev);
2017         if (error)
2018                 goto out_put_shost;
2019
2020         spin_lock_irq(&phba->hbalock);
2021         list_add_tail(&vport->listentry, &phba->port_list);
2022         spin_unlock_irq(&phba->hbalock);
2023         return vport;
2024
2025 out_put_shost:
2026         scsi_host_put(shost);
2027 out:
2028         return NULL;
2029 }
2030
2031 /**
2032  * destroy_port: Destroy an FC port.
2033  * @vport: pointer to an lpfc virtual N_Port data structure.
2034  *
2035  * This routine destroys a FC port from the upper layer protocol. All the
2036  * resources associated with the port are released.
2037  **/
2038 void
2039 destroy_port(struct lpfc_vport *vport)
2040 {
2041         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2042         struct lpfc_hba  *phba = vport->phba;
2043
2044         kfree(vport->vname);
2045
2046         lpfc_debugfs_terminate(vport);
2047         fc_remove_host(shost);
2048         scsi_remove_host(shost);
2049
2050         spin_lock_irq(&phba->hbalock);
2051         list_del_init(&vport->listentry);
2052         spin_unlock_irq(&phba->hbalock);
2053
2054         lpfc_cleanup(vport);
2055         return;
2056 }
2057
2058 /**
2059  * lpfc_get_instance: Get a unique integer ID.
2060  *
2061  * This routine allocates a unique integer ID from lpfc_hba_index pool. It
2062  * uses the kernel idr facility to perform the task.
2063  *
2064  * Return codes:
2065  *   instance - a unique integer ID allocated as the new instance.
2066  *   -1 - lpfc get instance failed.
2067  **/
2068 int
2069 lpfc_get_instance(void)
2070 {
2071         int instance = 0;
2072
2073         /* Assign an unused number */
2074         if (!idr_pre_get(&lpfc_hba_index, GFP_KERNEL))
2075                 return -1;
2076         if (idr_get_new(&lpfc_hba_index, NULL, &instance))
2077                 return -1;
2078         return instance;
2079 }
2080
2081 /**
2082  * lpfc_scan_finished: method for SCSI layer to detect whether scan is done.
2083  * @shost: pointer to SCSI host data structure.
2084  * @time: elapsed time of the scan in jiffies.
2085  *
2086  * This routine is called by the SCSI layer with a SCSI host to determine
2087  * whether the scan host is finished.
2088  *
2089  * Note: there is no scan_start function as adapter initialization will have
2090  * asynchronously kicked off the link initialization.
2091  *
2092  * Return codes
2093  *   0 - SCSI host scan is not over yet.
2094  *   1 - SCSI host scan is over.
2095  **/
2096 int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
2097 {
2098         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2099         struct lpfc_hba   *phba = vport->phba;
2100         int stat = 0;
2101
2102         spin_lock_irq(shost->host_lock);
2103
2104         if (vport->load_flag & FC_UNLOADING) {
2105                 stat = 1;
2106                 goto finished;
2107         }
2108         if (time >= 30 * HZ) {
2109                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2110                                 "0461 Scanning longer than 30 "
2111                                 "seconds.  Continuing initialization\n");
2112                 stat = 1;
2113                 goto finished;
2114         }
2115         if (time >= 15 * HZ && phba->link_state <= LPFC_LINK_DOWN) {
2116                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2117                                 "0465 Link down longer than 15 "
2118                                 "seconds.  Continuing initialization\n");
2119                 stat = 1;
2120                 goto finished;
2121         }
2122
2123         if (vport->port_state != LPFC_VPORT_READY)
2124                 goto finished;
2125         if (vport->num_disc_nodes || vport->fc_prli_sent)
2126                 goto finished;
2127         if (vport->fc_map_cnt == 0 && time < 2 * HZ)
2128                 goto finished;
2129         if ((phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) != 0)
2130                 goto finished;
2131
2132         stat = 1;
2133
2134 finished:
2135         spin_unlock_irq(shost->host_lock);
2136         return stat;
2137 }
2138
2139 /**
2140  * lpfc_host_attrib_init: Initialize SCSI host attributes on a FC port.
2141  * @shost: pointer to SCSI host data structure.
2142  *
2143  * This routine initializes a given SCSI host attributes on a FC port. The
2144  * SCSI host can be either on top of a physical port or a virtual port.
2145  **/
2146 void lpfc_host_attrib_init(struct Scsi_Host *shost)
2147 {
2148         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2149         struct lpfc_hba   *phba = vport->phba;
2150         /*
2151          * Set fixed host attributes.  Must done after lpfc_sli_hba_setup().
2152          */
2153
2154         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
2155         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
2156         fc_host_supported_classes(shost) = FC_COS_CLASS3;
2157
2158         memset(fc_host_supported_fc4s(shost), 0,
2159                sizeof(fc_host_supported_fc4s(shost)));
2160         fc_host_supported_fc4s(shost)[2] = 1;
2161         fc_host_supported_fc4s(shost)[7] = 1;
2162
2163         lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
2164                                  sizeof fc_host_symbolic_name(shost));
2165
2166         fc_host_supported_speeds(shost) = 0;
2167         if (phba->lmt & LMT_10Gb)
2168                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT;
2169         if (phba->lmt & LMT_8Gb)
2170                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_8GBIT;
2171         if (phba->lmt & LMT_4Gb)
2172                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_4GBIT;
2173         if (phba->lmt & LMT_2Gb)
2174                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_2GBIT;
2175         if (phba->lmt & LMT_1Gb)
2176                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_1GBIT;
2177
2178         fc_host_maxframe_size(shost) =
2179                 (((uint32_t) vport->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
2180                 (uint32_t) vport->fc_sparam.cmn.bbRcvSizeLsb;
2181
2182         /* This value is also unchanging */
2183         memset(fc_host_active_fc4s(shost), 0,
2184                sizeof(fc_host_active_fc4s(shost)));
2185         fc_host_active_fc4s(shost)[2] = 1;
2186         fc_host_active_fc4s(shost)[7] = 1;
2187
2188         fc_host_max_npiv_vports(shost) = phba->max_vpi;
2189         spin_lock_irq(shost->host_lock);
2190         vport->load_flag &= ~FC_LOADING;
2191         spin_unlock_irq(shost->host_lock);
2192 }
2193
2194 /**
2195  * lpfc_enable_msix: Enable MSI-X interrupt mode.
2196  * @phba: pointer to lpfc hba data structure.
2197  *
2198  * This routine is invoked to enable the MSI-X interrupt vectors. The kernel
2199  * function pci_enable_msix() is called to enable the MSI-X vectors. Note that
2200  * pci_enable_msix(), once invoked, enables either all or nothing, depending
2201  * on the current availability of PCI vector resources. The device driver is
2202  * responsible for calling the individual request_irq() to register each MSI-X
2203  * vector with a interrupt handler, which is done in this function. Note that
2204  * later when device is unloading, the driver should always call free_irq()
2205  * on all MSI-X vectors it has done request_irq() on before calling
2206  * pci_disable_msix(). Failure to do so results in a BUG_ON() and a device
2207  * will be left with MSI-X enabled and leaks its vectors.
2208  *
2209  * Return codes
2210  *   0 - sucessful
2211  *   other values - error
2212  **/
2213 static int
2214 lpfc_enable_msix(struct lpfc_hba *phba)
2215 {
2216         int rc, i;
2217         LPFC_MBOXQ_t *pmb;
2218
2219         /* Set up MSI-X multi-message vectors */
2220         for (i = 0; i < LPFC_MSIX_VECTORS; i++)
2221                 phba->msix_entries[i].entry = i;
2222
2223         /* Configure MSI-X capability structure */
2224         rc = pci_enable_msix(phba->pcidev, phba->msix_entries,
2225                                 ARRAY_SIZE(phba->msix_entries));
2226         if (rc) {
2227                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2228                                 "0420 Enable MSI-X failed (%d), continuing "
2229                                 "with MSI\n", rc);
2230                 goto msi_fail_out;
2231         } else
2232                 for (i = 0; i < LPFC_MSIX_VECTORS; i++)
2233                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2234                                         "0477 MSI-X entry[%d]: vector=x%x "
2235                                         "message=%d\n", i,
2236                                         phba->msix_entries[i].vector,
2237                                         phba->msix_entries[i].entry);
2238         /*
2239          * Assign MSI-X vectors to interrupt handlers
2240          */
2241
2242         /* vector-0 is associated to slow-path handler */
2243         rc = request_irq(phba->msix_entries[0].vector, &lpfc_sp_intr_handler,
2244                          IRQF_SHARED, LPFC_SP_DRIVER_HANDLER_NAME, phba);
2245         if (rc) {
2246                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2247                                 "0421 MSI-X slow-path request_irq failed "
2248                                 "(%d), continuing with MSI\n", rc);
2249                 goto msi_fail_out;
2250         }
2251
2252         /* vector-1 is associated to fast-path handler */
2253         rc = request_irq(phba->msix_entries[1].vector, &lpfc_fp_intr_handler,
2254                          IRQF_SHARED, LPFC_FP_DRIVER_HANDLER_NAME, phba);
2255
2256         if (rc) {
2257                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2258                                 "0429 MSI-X fast-path request_irq failed "
2259                                 "(%d), continuing with MSI\n", rc);
2260                 goto irq_fail_out;
2261         }
2262
2263         /*
2264          * Configure HBA MSI-X attention conditions to messages
2265          */
2266         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2267
2268         if (!pmb) {
2269                 rc = -ENOMEM;
2270                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2271                                 "0474 Unable to allocate memory for issuing "
2272                                 "MBOX_CONFIG_MSI command\n");
2273                 goto mem_fail_out;
2274         }
2275         rc = lpfc_config_msi(phba, pmb);
2276         if (rc)
2277                 goto mbx_fail_out;
2278         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
2279         if (rc != MBX_SUCCESS) {
2280                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
2281                                 "0351 Config MSI mailbox command failed, "
2282                                 "mbxCmd x%x, mbxStatus x%x\n",
2283                                 pmb->mb.mbxCommand, pmb->mb.mbxStatus);
2284                 goto mbx_fail_out;
2285         }
2286
2287         /* Free memory allocated for mailbox command */
2288         mempool_free(pmb, phba->mbox_mem_pool);
2289         return rc;
2290
2291 mbx_fail_out:
2292         /* Free memory allocated for mailbox command */
2293         mempool_free(pmb, phba->mbox_mem_pool);
2294
2295 mem_fail_out:
2296         /* free the irq already requested */
2297         free_irq(phba->msix_entries[1].vector, phba);
2298
2299 irq_fail_out:
2300         /* free the irq already requested */
2301         free_irq(phba->msix_entries[0].vector, phba);
2302
2303 msi_fail_out:
2304         /* Unconfigure MSI-X capability structure */
2305         pci_disable_msix(phba->pcidev);
2306         return rc;
2307 }
2308
2309 /**
2310  * lpfc_disable_msix: Disable MSI-X interrupt mode.
2311  * @phba: pointer to lpfc hba data structure.
2312  *
2313  * This routine is invoked to release the MSI-X vectors and then disable the
2314  * MSI-X interrupt mode.
2315  **/
2316 static void
2317 lpfc_disable_msix(struct lpfc_hba *phba)
2318 {
2319         int i;
2320
2321         /* Free up MSI-X multi-message vectors */
2322         for (i = 0; i < LPFC_MSIX_VECTORS; i++)
2323                 free_irq(phba->msix_entries[i].vector, phba);
2324         /* Disable MSI-X */
2325         pci_disable_msix(phba->pcidev);
2326 }
2327
2328 /**
2329  * lpfc_pci_probe_one: lpfc PCI probe func to register device to PCI subsystem.
2330  * @pdev: pointer to PCI device
2331  * @pid: pointer to PCI device identifier
2332  *
2333  * This routine is to be registered to the kernel's PCI subsystem. When an
2334  * Emulex HBA is presented in PCI bus, the kernel PCI subsystem looks at
2335  * PCI device-specific information of the device and driver to see if the
2336  * driver state that it can support this kind of device. If the match is
2337  * successful, the driver core invokes this routine. If this routine
2338  * determines it can claim the HBA, it does all the initialization that it
2339  * needs to do to handle the HBA properly.
2340  *
2341  * Return code
2342  *   0 - driver can claim the device
2343  *   negative value - driver can not claim the device
2344  **/
2345 static int __devinit
2346 lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
2347 {
2348         struct lpfc_vport *vport = NULL;
2349         struct lpfc_hba   *phba;
2350         struct lpfc_sli   *psli;
2351         struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL;
2352         struct Scsi_Host  *shost = NULL;
2353         void *ptr;
2354         unsigned long bar0map_len, bar2map_len;
2355         int error = -ENODEV, retval;
2356         int  i, hbq_count;
2357         uint16_t iotag;
2358         int bars = pci_select_bars(pdev, IORESOURCE_MEM);
2359         struct lpfc_adapter_event_header adapter_event;
2360
2361         if (pci_enable_device_mem(pdev))
2362                 goto out;
2363         if (pci_request_selected_regions(pdev, bars, LPFC_DRIVER_NAME))
2364                 goto out_disable_device;
2365
2366         phba = kzalloc(sizeof (struct lpfc_hba), GFP_KERNEL);
2367         if (!phba)
2368                 goto out_release_regions;
2369
2370         atomic_set(&phba->fast_event_count, 0);
2371         spin_lock_init(&phba->hbalock);
2372
2373         /* Initialize ndlp management spinlock */
2374         spin_lock_init(&phba->ndlp_lock);
2375
2376         phba->pcidev = pdev;
2377
2378         /* Assign an unused board number */
2379         if ((phba->brd_no = lpfc_get_instance()) < 0)
2380                 goto out_free_phba;
2381
2382         INIT_LIST_HEAD(&phba->port_list);
2383         init_waitqueue_head(&phba->wait_4_mlo_m_q);
2384         /*
2385          * Get all the module params for configuring this host and then
2386          * establish the host.
2387          */
2388         lpfc_get_cfgparam(phba);
2389         phba->max_vpi = LPFC_MAX_VPI;
2390
2391         /* Initialize timers used by driver */
2392         init_timer(&phba->hb_tmofunc);
2393         phba->hb_tmofunc.function = lpfc_hb_timeout;
2394         phba->hb_tmofunc.data = (unsigned long)phba;
2395
2396         psli = &phba->sli;
2397         init_timer(&psli->mbox_tmo);
2398         psli->mbox_tmo.function = lpfc_mbox_timeout;
2399         psli->mbox_tmo.data = (unsigned long) phba;
2400         init_timer(&phba->fcp_poll_timer);
2401         phba->fcp_poll_timer.function = lpfc_poll_timeout;
2402         phba->fcp_poll_timer.data = (unsigned long) phba;
2403         init_timer(&phba->fabric_block_timer);
2404         phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
2405         phba->fabric_block_timer.data = (unsigned long) phba;
2406         init_timer(&phba->eratt_poll);
2407         phba->eratt_poll.function = lpfc_poll_eratt;
2408         phba->eratt_poll.data = (unsigned long) phba;
2409
2410         pci_set_master(pdev);
2411         pci_try_set_mwi(pdev);
2412
2413         if (pci_set_dma_mask(phba->pcidev, DMA_64BIT_MASK) != 0)
2414                 if (pci_set_dma_mask(phba->pcidev, DMA_32BIT_MASK) != 0)
2415                         goto out_idr_remove;
2416
2417         /*
2418          * Get the bus address of Bar0 and Bar2 and the number of bytes
2419          * required by each mapping.
2420          */
2421         phba->pci_bar0_map = pci_resource_start(phba->pcidev, 0);
2422         bar0map_len        = pci_resource_len(phba->pcidev, 0);
2423
2424         phba->pci_bar2_map = pci_resource_start(phba->pcidev, 2);
2425         bar2map_len        = pci_resource_len(phba->pcidev, 2);
2426
2427         /* Map HBA SLIM to a kernel virtual address. */
2428         phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len);
2429         if (!phba->slim_memmap_p) {
2430                 error = -ENODEV;
2431                 dev_printk(KERN_ERR, &pdev->dev,
2432                            "ioremap failed for SLIM memory.\n");
2433                 goto out_idr_remove;
2434         }
2435
2436         /* Map HBA Control Registers to a kernel virtual address. */
2437         phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len);
2438         if (!phba->ctrl_regs_memmap_p) {
2439                 error = -ENODEV;
2440                 dev_printk(KERN_ERR, &pdev->dev,
2441                            "ioremap failed for HBA control registers.\n");
2442                 goto out_iounmap_slim;
2443         }
2444
2445         /* Allocate memory for SLI-2 structures */
2446         phba->slim2p.virt = dma_alloc_coherent(&phba->pcidev->dev,
2447                                                SLI2_SLIM_SIZE,
2448                                                &phba->slim2p.phys,
2449                                                GFP_KERNEL);
2450         if (!phba->slim2p.virt)
2451                 goto out_iounmap;
2452
2453         memset(phba->slim2p.virt, 0, SLI2_SLIM_SIZE);
2454         phba->mbox = phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, mbx);
2455         phba->pcb = (phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, pcb));
2456         phba->IOCBs = (phba->slim2p.virt +
2457                        offsetof(struct lpfc_sli2_slim, IOCBs));
2458
2459         phba->hbqslimp.virt = dma_alloc_coherent(&phba->pcidev->dev,
2460                                                  lpfc_sli_hbq_size(),
2461                                                  &phba->hbqslimp.phys,
2462                                                  GFP_KERNEL);
2463         if (!phba->hbqslimp.virt)
2464                 goto out_free_slim;
2465
2466         hbq_count = lpfc_sli_hbq_count();
2467         ptr = phba->hbqslimp.virt;
2468         for (i = 0; i < hbq_count; ++i) {
2469                 phba->hbqs[i].hbq_virt = ptr;
2470                 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
2471                 ptr += (lpfc_hbq_defs[i]->entry_count *
2472                         sizeof(struct lpfc_hbq_entry));
2473         }
2474         phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc;
2475         phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer  = lpfc_els_hbq_free;
2476
2477         memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size());
2478
2479         INIT_LIST_HEAD(&phba->hbqbuf_in_list);
2480
2481         /* Initialize the SLI Layer to run with lpfc HBAs. */
2482         lpfc_sli_setup(phba);
2483         lpfc_sli_queue_setup(phba);
2484
2485         retval = lpfc_mem_alloc(phba);
2486         if (retval) {
2487                 error = retval;
2488                 goto out_free_hbqslimp;
2489         }
2490
2491         /* Initialize and populate the iocb list per host.  */
2492         INIT_LIST_HEAD(&phba->lpfc_iocb_list);
2493         for (i = 0; i < LPFC_IOCB_LIST_CNT; i++) {
2494                 iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL);
2495                 if (iocbq_entry == NULL) {
2496                         printk(KERN_ERR "%s: only allocated %d iocbs of "
2497                                 "expected %d count. Unloading driver.\n",
2498                                 __func__, i, LPFC_IOCB_LIST_CNT);
2499                         error = -ENOMEM;
2500                         goto out_free_iocbq;
2501                 }
2502
2503                 iotag = lpfc_sli_next_iotag(phba, iocbq_entry);
2504                 if (iotag == 0) {
2505                         kfree (iocbq_entry);
2506                         printk(KERN_ERR "%s: failed to allocate IOTAG. "
2507                                "Unloading driver.\n",
2508                                 __func__);
2509                         error = -ENOMEM;
2510                         goto out_free_iocbq;
2511                 }
2512
2513                 spin_lock_irq(&phba->hbalock);
2514                 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list);
2515                 phba->total_iocbq_bufs++;
2516                 spin_unlock_irq(&phba->hbalock);
2517         }
2518
2519         /* Initialize HBA structure */
2520         phba->fc_edtov = FF_DEF_EDTOV;
2521         phba->fc_ratov = FF_DEF_RATOV;
2522         phba->fc_altov = FF_DEF_ALTOV;
2523         phba->fc_arbtov = FF_DEF_ARBTOV;
2524
2525         INIT_LIST_HEAD(&phba->work_list);
2526         phba->work_ha_mask = (HA_ERATT | HA_MBATT | HA_LATT);
2527         phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4));
2528
2529         /* Initialize the wait queue head for the kernel thread */
2530         init_waitqueue_head(&phba->work_waitq);
2531
2532         /* Startup the kernel thread for this host adapter. */
2533         phba->worker_thread = kthread_run(lpfc_do_work, phba,
2534                                        "lpfc_worker_%d", phba->brd_no);
2535         if (IS_ERR(phba->worker_thread)) {
2536                 error = PTR_ERR(phba->worker_thread);
2537                 goto out_free_iocbq;
2538         }
2539
2540         /* Initialize the list of scsi buffers used by driver for scsi IO. */
2541         spin_lock_init(&phba->scsi_buf_list_lock);
2542         INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list);
2543
2544         /* Initialize list of fabric iocbs */
2545         INIT_LIST_HEAD(&phba->fabric_iocb_list);
2546
2547         /* Initialize list to save ELS buffers */
2548         INIT_LIST_HEAD(&phba->elsbuf);
2549
2550         vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev);
2551         if (!vport)
2552                 goto out_kthread_stop;
2553
2554         shost = lpfc_shost_from_vport(vport);
2555         phba->pport = vport;
2556         lpfc_debugfs_initialize(vport);
2557
2558         pci_set_drvdata(pdev, shost);
2559         phba->intr_type = NONE;
2560
2561         phba->MBslimaddr = phba->slim_memmap_p;
2562         phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
2563         phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
2564         phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
2565         phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
2566
2567         /* Configure and enable interrupt */
2568         if (phba->cfg_use_msi == 2) {
2569                 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
2570                 error = lpfc_sli_config_port(phba, 3);
2571                 if (error)
2572                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2573                                 "0427 Firmware not capable of SLI 3 mode.\n");
2574                 else {
2575                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2576                                 "0426 Firmware capable of SLI 3 mode.\n");
2577                         /* Now, try to enable MSI-X interrupt mode */
2578                         error = lpfc_enable_msix(phba);
2579                         if (!error) {
2580                                 phba->intr_type = MSIX;
2581                                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2582                                                 "0430 enable MSI-X mode.\n");
2583                         }
2584                 }
2585         }
2586
2587         /* Fallback to MSI if MSI-X initialization failed */
2588         if (phba->cfg_use_msi >= 1 && phba->intr_type == NONE) {
2589                 retval = pci_enable_msi(phba->pcidev);
2590                 if (!retval) {
2591                         phba->intr_type = MSI;
2592                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2593                                         "0473 enable MSI mode.\n");
2594                 } else
2595                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2596                                         "0452 enable IRQ mode.\n");
2597         }
2598
2599         /* MSI-X is the only case the doesn't need to call request_irq */
2600         if (phba->intr_type != MSIX) {
2601                 retval = request_irq(phba->pcidev->irq, lpfc_intr_handler,
2602                                      IRQF_SHARED, LPFC_DRIVER_NAME, phba);
2603                 if (retval) {
2604                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, "0451 Enable "
2605                                         "interrupt handler failed\n");
2606                         error = retval;
2607                         goto out_disable_msi;
2608                 } else if (phba->intr_type != MSI)
2609                         phba->intr_type = INTx;
2610         }
2611
2612         if (lpfc_alloc_sysfs_attr(vport)) {
2613                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2614                                 "1476 Failed to allocate sysfs attr\n");
2615                 error = -ENOMEM;
2616                 goto out_free_irq;
2617         }
2618
2619         if (lpfc_sli_hba_setup(phba)) {
2620                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2621                                 "1477 Failed to set up hba\n");
2622                 error = -ENODEV;
2623                 goto out_remove_device;
2624         }
2625
2626         /*
2627          * hba setup may have changed the hba_queue_depth so we need to adjust
2628          * the value of can_queue.
2629          */
2630         shost->can_queue = phba->cfg_hba_queue_depth - 10;
2631
2632         lpfc_host_attrib_init(shost);
2633
2634         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
2635                 spin_lock_irq(shost->host_lock);
2636                 lpfc_poll_start_timer(phba);
2637                 spin_unlock_irq(shost->host_lock);
2638         }
2639
2640         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2641                         "0428 Perform SCSI scan\n");
2642         /* Send board arrival event to upper layer */
2643         adapter_event.event_type = FC_REG_ADAPTER_EVENT;
2644         adapter_event.subcategory = LPFC_EVENT_ARRIVAL;
2645         fc_host_post_vendor_event(shost, fc_get_event_number(),
2646                 sizeof(adapter_event),
2647                 (char *) &adapter_event,
2648                 LPFC_NL_VENDOR_ID);
2649
2650         scsi_scan_host(shost);
2651
2652         return 0;
2653
2654 out_remove_device:
2655         lpfc_free_sysfs_attr(vport);
2656         spin_lock_irq(shost->host_lock);
2657         vport->load_flag |= FC_UNLOADING;
2658         spin_unlock_irq(shost->host_lock);
2659 out_free_irq:
2660         lpfc_stop_phba_timers(phba);
2661         phba->pport->work_port_events = 0;
2662
2663         if (phba->intr_type == MSIX)
2664                 lpfc_disable_msix(phba);
2665         else
2666                 free_irq(phba->pcidev->irq, phba);
2667
2668 out_disable_msi:
2669         if (phba->intr_type == MSI)
2670                 pci_disable_msi(phba->pcidev);
2671         destroy_port(vport);
2672 out_kthread_stop:
2673         kthread_stop(phba->worker_thread);
2674 out_free_iocbq:
2675         list_for_each_entry_safe(iocbq_entry, iocbq_next,
2676                                                 &phba->lpfc_iocb_list, list) {
2677                 kfree(iocbq_entry);
2678                 phba->total_iocbq_bufs--;
2679         }
2680         lpfc_mem_free(phba);
2681 out_free_hbqslimp:
2682         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
2683                           phba->hbqslimp.virt, phba->hbqslimp.phys);
2684 out_free_slim:
2685         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
2686                           phba->slim2p.virt, phba->slim2p.phys);
2687 out_iounmap:
2688         iounmap(phba->ctrl_regs_memmap_p);
2689 out_iounmap_slim:
2690         iounmap(phba->slim_memmap_p);
2691 out_idr_remove:
2692         idr_remove(&lpfc_hba_index, phba->brd_no);
2693 out_free_phba:
2694         kfree(phba);
2695 out_release_regions:
2696         pci_release_selected_regions(pdev, bars);
2697 out_disable_device:
2698         pci_disable_device(pdev);
2699 out:
2700         pci_set_drvdata(pdev, NULL);
2701         if (shost)
2702                 scsi_host_put(shost);
2703         return error;
2704 }
2705
2706 /**
2707  * lpfc_pci_remove_one: lpfc PCI func to unregister device from PCI subsystem.
2708  * @pdev: pointer to PCI device
2709  *
2710  * This routine is to be registered to the kernel's PCI subsystem. When an
2711  * Emulex HBA is removed from PCI bus. It perform all the necessary cleanup
2712  * for the HBA device to be removed from the PCI subsystem properly.
2713  **/
2714 static void __devexit
2715 lpfc_pci_remove_one(struct pci_dev *pdev)
2716 {
2717         struct Scsi_Host  *shost = pci_get_drvdata(pdev);
2718         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2719         struct lpfc_hba   *phba = vport->phba;
2720         int bars = pci_select_bars(pdev, IORESOURCE_MEM);
2721
2722         spin_lock_irq(&phba->hbalock);
2723         vport->load_flag |= FC_UNLOADING;
2724         spin_unlock_irq(&phba->hbalock);
2725
2726         kfree(vport->vname);
2727         lpfc_free_sysfs_attr(vport);
2728
2729         kthread_stop(phba->worker_thread);
2730
2731         fc_remove_host(shost);
2732         scsi_remove_host(shost);
2733         lpfc_cleanup(vport);
2734
2735         /*
2736          * Bring down the SLI Layer. This step disable all interrupts,
2737          * clears the rings, discards all mailbox commands, and resets
2738          * the HBA.
2739          */
2740         lpfc_sli_hba_down(phba);
2741         lpfc_sli_brdrestart(phba);
2742
2743         lpfc_stop_phba_timers(phba);
2744         spin_lock_irq(&phba->hbalock);
2745         list_del_init(&vport->listentry);
2746         spin_unlock_irq(&phba->hbalock);
2747
2748         lpfc_debugfs_terminate(vport);
2749
2750         if (phba->intr_type == MSIX)
2751                 lpfc_disable_msix(phba);
2752         else {
2753                 free_irq(phba->pcidev->irq, phba);
2754                 if (phba->intr_type == MSI)
2755                         pci_disable_msi(phba->pcidev);
2756         }
2757
2758         pci_set_drvdata(pdev, NULL);
2759         scsi_host_put(shost);
2760
2761         /*
2762          * Call scsi_free before mem_free since scsi bufs are released to their
2763          * corresponding pools here.
2764          */
2765         lpfc_scsi_free(phba);
2766         lpfc_mem_free(phba);
2767
2768         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
2769                           phba->hbqslimp.virt, phba->hbqslimp.phys);
2770
2771         /* Free resources associated with SLI2 interface */
2772         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
2773                           phba->slim2p.virt, phba->slim2p.phys);
2774
2775         /* unmap adapter SLIM and Control Registers */
2776         iounmap(phba->ctrl_regs_memmap_p);
2777         iounmap(phba->slim_memmap_p);
2778
2779         idr_remove(&lpfc_hba_index, phba->brd_no);
2780
2781         kfree(phba);
2782
2783         pci_release_selected_regions(pdev, bars);
2784         pci_disable_device(pdev);
2785 }
2786
2787 /**
2788  * lpfc_io_error_detected: Driver method for handling PCI I/O error detected.
2789  * @pdev: pointer to PCI device.
2790  * @state: the current PCI connection state.
2791  *
2792  * This routine is registered to the PCI subsystem for error handling. This
2793  * function is called by the PCI subsystem after a PCI bus error affecting
2794  * this device has been detected. When this function is invoked, it will
2795  * need to stop all the I/Os and interrupt(s) to the device. Once that is
2796  * done, it will return PCI_ERS_RESULT_NEED_RESET for the PCI subsystem to
2797  * perform proper recovery as desired.
2798  *
2799  * Return codes
2800  *   PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
2801  *   PCI_ERS_RESULT_DISCONNECT - device could not be recovered
2802  **/
2803 static pci_ers_result_t lpfc_io_error_detected(struct pci_dev *pdev,
2804                                 pci_channel_state_t state)
2805 {
2806         struct Scsi_Host *shost = pci_get_drvdata(pdev);
2807         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2808         struct lpfc_sli *psli = &phba->sli;
2809         struct lpfc_sli_ring  *pring;
2810
2811         if (state == pci_channel_io_perm_failure) {
2812                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2813                                 "0472 PCI channel I/O permanent failure\n");
2814                 /* Block all SCSI devices' I/Os on the host */
2815                 lpfc_scsi_dev_block(phba);
2816                 /* Clean up all driver's outstanding SCSI I/Os */
2817                 lpfc_sli_flush_fcp_rings(phba);
2818                 return PCI_ERS_RESULT_DISCONNECT;
2819         }
2820
2821         pci_disable_device(pdev);
2822         /*
2823          * There may be I/Os dropped by the firmware.
2824          * Error iocb (I/O) on txcmplq and let the SCSI layer
2825          * retry it after re-establishing link.
2826          */
2827         pring = &psli->ring[psli->fcp_ring];
2828         lpfc_sli_abort_iocb_ring(phba, pring);
2829
2830         if (phba->intr_type == MSIX)
2831                 lpfc_disable_msix(phba);
2832         else {
2833                 free_irq(phba->pcidev->irq, phba);
2834                 if (phba->intr_type == MSI)
2835                         pci_disable_msi(phba->pcidev);
2836         }
2837
2838         /* Request a slot reset. */
2839         return PCI_ERS_RESULT_NEED_RESET;
2840 }
2841
2842 /**
2843  * lpfc_io_slot_reset: Restart a PCI device from scratch.
2844  * @pdev: pointer to PCI device.
2845  *
2846  * This routine is registered to the PCI subsystem for error handling. This is
2847  * called after PCI bus has been reset to restart the PCI card from scratch,
2848  * as if from a cold-boot. During the PCI subsystem error recovery, after the
2849  * driver returns PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform
2850  * proper error recovery and then call this routine before calling the .resume
2851  * method to recover the device. This function will initialize the HBA device,
2852  * enable the interrupt, but it will just put the HBA to offline state without
2853  * passing any I/O traffic.
2854  *
2855  * Return codes
2856  *   PCI_ERS_RESULT_RECOVERED - the device has been recovered
2857  *   PCI_ERS_RESULT_DISCONNECT - device could not be recovered
2858  */
2859 static pci_ers_result_t lpfc_io_slot_reset(struct pci_dev *pdev)
2860 {
2861         struct Scsi_Host *shost = pci_get_drvdata(pdev);
2862         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2863         struct lpfc_sli *psli = &phba->sli;
2864         int error, retval;
2865
2866         dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
2867         if (pci_enable_device_mem(pdev)) {
2868                 printk(KERN_ERR "lpfc: Cannot re-enable "
2869                         "PCI device after reset.\n");
2870                 return PCI_ERS_RESULT_DISCONNECT;
2871         }
2872
2873         pci_set_master(pdev);
2874
2875         spin_lock_irq(&phba->hbalock);
2876         psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
2877         spin_unlock_irq(&phba->hbalock);
2878
2879         /* Enable configured interrupt method */
2880         phba->intr_type = NONE;
2881         if (phba->cfg_use_msi == 2) {
2882                 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
2883                 error = lpfc_sli_config_port(phba, 3);
2884                 if (error)
2885                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2886                                 "0478 Firmware not capable of SLI 3 mode.\n");
2887                 else {
2888                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2889                                 "0479 Firmware capable of SLI 3 mode.\n");
2890                         /* Now, try to enable MSI-X interrupt mode */
2891                         error = lpfc_enable_msix(phba);
2892                         if (!error) {
2893                                 phba->intr_type = MSIX;
2894                                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2895                                                 "0480 enable MSI-X mode.\n");
2896                         }
2897                 }
2898         }
2899
2900         /* Fallback to MSI if MSI-X initialization failed */
2901         if (phba->cfg_use_msi >= 1 && phba->intr_type == NONE) {
2902                 retval = pci_enable_msi(phba->pcidev);
2903                 if (!retval) {
2904                         phba->intr_type = MSI;
2905                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2906                                         "0481 enable MSI mode.\n");
2907                 } else
2908                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2909                                         "0470 enable IRQ mode.\n");
2910         }
2911
2912         /* MSI-X is the only case the doesn't need to call request_irq */
2913         if (phba->intr_type != MSIX) {
2914                 retval = request_irq(phba->pcidev->irq, lpfc_intr_handler,
2915                                      IRQF_SHARED, LPFC_DRIVER_NAME, phba);
2916                 if (retval) {
2917                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2918                                         "0471 Enable interrupt handler "
2919                                         "failed\n");
2920                 } else if (phba->intr_type != MSI)
2921                         phba->intr_type = INTx;
2922         }
2923
2924         /* Take device offline; this will perform cleanup */
2925         lpfc_offline(phba);
2926         lpfc_sli_brdrestart(phba);
2927
2928         return PCI_ERS_RESULT_RECOVERED;
2929 }
2930
2931 /**
2932  * lpfc_io_resume: Resume PCI I/O operation.
2933  * @pdev: pointer to PCI device
2934  *
2935  * This routine is registered to the PCI subsystem for error handling. It is
2936  * called when kernel error recovery tells the lpfc driver that it is ok to
2937  * resume normal PCI operation after PCI bus error recovery. After this call,
2938  * traffic can start to flow from this device again.
2939  */
2940 static void lpfc_io_resume(struct pci_dev *pdev)
2941 {
2942         struct Scsi_Host *shost = pci_get_drvdata(pdev);
2943         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2944
2945         lpfc_online(phba);
2946 }
2947
2948 static struct pci_device_id lpfc_id_table[] = {
2949         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_VIPER,
2950                 PCI_ANY_ID, PCI_ANY_ID, },
2951         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_FIREFLY,
2952                 PCI_ANY_ID, PCI_ANY_ID, },
2953         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_THOR,
2954                 PCI_ANY_ID, PCI_ANY_ID, },
2955         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PEGASUS,
2956                 PCI_ANY_ID, PCI_ANY_ID, },
2957         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_CENTAUR,
2958                 PCI_ANY_ID, PCI_ANY_ID, },
2959         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_DRAGONFLY,
2960                 PCI_ANY_ID, PCI_ANY_ID, },
2961         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SUPERFLY,
2962                 PCI_ANY_ID, PCI_ANY_ID, },
2963         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_RFLY,
2964                 PCI_ANY_ID, PCI_ANY_ID, },
2965         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PFLY,
2966                 PCI_ANY_ID, PCI_ANY_ID, },
2967         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE,
2968                 PCI_ANY_ID, PCI_ANY_ID, },
2969         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_SCSP,
2970                 PCI_ANY_ID, PCI_ANY_ID, },
2971         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_DCSP,
2972                 PCI_ANY_ID, PCI_ANY_ID, },
2973         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS,
2974                 PCI_ANY_ID, PCI_ANY_ID, },
2975         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_SCSP,
2976                 PCI_ANY_ID, PCI_ANY_ID, },
2977         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_DCSP,
2978                 PCI_ANY_ID, PCI_ANY_ID, },
2979         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BMID,
2980                 PCI_ANY_ID, PCI_ANY_ID, },
2981         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BSMB,
2982                 PCI_ANY_ID, PCI_ANY_ID, },
2983         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR,
2984                 PCI_ANY_ID, PCI_ANY_ID, },
2985         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HORNET,
2986                 PCI_ANY_ID, PCI_ANY_ID, },
2987         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_SCSP,
2988                 PCI_ANY_ID, PCI_ANY_ID, },
2989         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_DCSP,
2990                 PCI_ANY_ID, PCI_ANY_ID, },
2991         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZMID,
2992                 PCI_ANY_ID, PCI_ANY_ID, },
2993         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZSMB,
2994                 PCI_ANY_ID, PCI_ANY_ID, },
2995         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_TFLY,
2996                 PCI_ANY_ID, PCI_ANY_ID, },
2997         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP101,
2998                 PCI_ANY_ID, PCI_ANY_ID, },
2999         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP10000S,
3000                 PCI_ANY_ID, PCI_ANY_ID, },
3001         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP11000S,
3002                 PCI_ANY_ID, PCI_ANY_ID, },
3003         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LPE11000S,
3004                 PCI_ANY_ID, PCI_ANY_ID, },
3005         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT,
3006                 PCI_ANY_ID, PCI_ANY_ID, },
3007         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_MID,
3008                 PCI_ANY_ID, PCI_ANY_ID, },
3009         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SMB,
3010                 PCI_ANY_ID, PCI_ANY_ID, },
3011         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_DCSP,
3012                 PCI_ANY_ID, PCI_ANY_ID, },
3013         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SCSP,
3014                 PCI_ANY_ID, PCI_ANY_ID, },
3015         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_S,
3016                 PCI_ANY_ID, PCI_ANY_ID, },
3017         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_VF,
3018                 PCI_ANY_ID, PCI_ANY_ID, },
3019         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_PF,
3020                 PCI_ANY_ID, PCI_ANY_ID, },
3021         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_S,
3022                 PCI_ANY_ID, PCI_ANY_ID, },
3023         { 0 }
3024 };
3025
3026 MODULE_DEVICE_TABLE(pci, lpfc_id_table);
3027
3028 static struct pci_error_handlers lpfc_err_handler = {
3029         .error_detected = lpfc_io_error_detected,
3030         .slot_reset = lpfc_io_slot_reset,
3031         .resume = lpfc_io_resume,
3032 };
3033
3034 static struct pci_driver lpfc_driver = {
3035         .name           = LPFC_DRIVER_NAME,
3036         .id_table       = lpfc_id_table,
3037         .probe          = lpfc_pci_probe_one,
3038         .remove         = __devexit_p(lpfc_pci_remove_one),
3039         .err_handler    = &lpfc_err_handler,
3040 };
3041
3042 /**
3043  * lpfc_init: lpfc module initialization routine.
3044  *
3045  * This routine is to be invoked when the lpfc module is loaded into the
3046  * kernel. The special kernel macro module_init() is used to indicate the
3047  * role of this routine to the kernel as lpfc module entry point.
3048  *
3049  * Return codes
3050  *   0 - successful
3051  *   -ENOMEM - FC attach transport failed
3052  *   all others - failed
3053  */
3054 static int __init
3055 lpfc_init(void)
3056 {
3057         int error = 0;
3058
3059         printk(LPFC_MODULE_DESC "\n");
3060         printk(LPFC_COPYRIGHT "\n");
3061
3062         if (lpfc_enable_npiv) {
3063                 lpfc_transport_functions.vport_create = lpfc_vport_create;
3064                 lpfc_transport_functions.vport_delete = lpfc_vport_delete;
3065         }
3066         lpfc_transport_template =
3067                                 fc_attach_transport(&lpfc_transport_functions);
3068         if (lpfc_transport_template == NULL)
3069                 return -ENOMEM;
3070         if (lpfc_enable_npiv) {
3071                 lpfc_vport_transport_template =
3072                         fc_attach_transport(&lpfc_vport_transport_functions);
3073                 if (lpfc_vport_transport_template == NULL) {
3074                         fc_release_transport(lpfc_transport_template);
3075                         return -ENOMEM;
3076                 }
3077         }
3078         error = pci_register_driver(&lpfc_driver);
3079         if (error) {
3080                 fc_release_transport(lpfc_transport_template);
3081                 if (lpfc_enable_npiv)
3082                         fc_release_transport(lpfc_vport_transport_template);
3083         }
3084
3085         return error;
3086 }
3087
3088 /**
3089  * lpfc_exit: lpfc module removal routine.
3090  *
3091  * This routine is invoked when the lpfc module is removed from the kernel.
3092  * The special kernel macro module_exit() is used to indicate the role of
3093  * this routine to the kernel as lpfc module exit point.
3094  */
3095 static void __exit
3096 lpfc_exit(void)
3097 {
3098         pci_unregister_driver(&lpfc_driver);
3099         fc_release_transport(lpfc_transport_template);
3100         if (lpfc_enable_npiv)
3101                 fc_release_transport(lpfc_vport_transport_template);
3102 }
3103
3104 module_init(lpfc_init);
3105 module_exit(lpfc_exit);
3106 MODULE_LICENSE("GPL");
3107 MODULE_DESCRIPTION(LPFC_MODULE_DESC);
3108 MODULE_AUTHOR("Emulex Corporation - tech.support@emulex.com");
3109 MODULE_VERSION("0:" LPFC_DRIVER_VERSION);