git.oblomov.eu Git - linux-2.6/blob - 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                                   SCSI_NL_VID_TYPE_PCI
 837                                   | PCI_VENDOR_ID_EMULEX);
 838
 839         if (phba->work_hs & HS_FFER6) {
 840                 /* Re-establishing Link */
 841                 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
 842                                 "1301 Re-establishing Link "
 843                                 "Data: x%x x%x x%x\n",
 844                                 phba->work_hs,
 845                                 phba->work_status[0], phba->work_status[1]);
 846
 847                 spin_lock_irq(&phba->hbalock);
 848                 psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
 849                 spin_unlock_irq(&phba->hbalock);
 850
 851                 /*
 852                 * Firmware stops when it triggled erratt with HS_FFER6.
 853                 * That could cause the I/Os dropped by the firmware.
 854                 * Error iocb (I/O) on txcmplq and let the SCSI layer
 855                 * retry it after re-establishing link.
 856                 */
 857                 pring = &psli->ring[psli->fcp_ring];
 858                 lpfc_sli_abort_iocb_ring(phba, pring);
 859
 860                 /*
 861                  * There was a firmware error.  Take the hba offline and then
 862                  * attempt to restart it.
 863                  */
 864                 lpfc_offline_prep(phba);
 865                 lpfc_offline(phba);
 866                 lpfc_sli_brdrestart(phba);
 867                 if (lpfc_online(phba) == 0) {   /* Initialize the HBA */
 868                         lpfc_unblock_mgmt_io(phba);
 869                         return;
 870                 }
 871                 lpfc_unblock_mgmt_io(phba);
 872         } else if (phba->work_hs & HS_CRIT_TEMP) {
 873                 temperature = readl(phba->MBslimaddr + TEMPERATURE_OFFSET);
 874                 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT;
 875                 temp_event_data.event_code = LPFC_CRIT_TEMP;
 876                 temp_event_data.data = (uint32_t)temperature;
 877
 878                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 879                                 "0406 Adapter maximum temperature exceeded "
 880                                 "(%ld), taking this port offline "
 881                                 "Data: x%x x%x x%x\n",
 882                                 temperature, phba->work_hs,
 883                                 phba->work_status[0], phba->work_status[1]);
 884
 885                 shost = lpfc_shost_from_vport(phba->pport);
 886                 fc_host_post_vendor_event(shost, fc_get_event_number(),
 887                                           sizeof(temp_event_data),
 888                                           (char *) &temp_event_data,
 889                                           SCSI_NL_VID_TYPE_PCI
 890                                           | PCI_VENDOR_ID_EMULEX);
 891
 892                 spin_lock_irq(&phba->hbalock);
 893                 phba->over_temp_state = HBA_OVER_TEMP;
 894                 spin_unlock_irq(&phba->hbalock);
 895                 lpfc_offline_eratt(phba);
 896
 897         } else {
 898                 /* The if clause above forces this code path when the status
 899                  * failure is a value other than FFER6. Do not call the offline
 900                  * twice. This is the adapter hardware error path.
 901                  */
 902                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
 903                                 "0457 Adapter Hardware Error "
 904                                 "Data: x%x x%x x%x\n",
 905                                 phba->work_hs,
 906                                 phba->work_status[0], phba->work_status[1]);
 907
 908                 event_data = FC_REG_DUMP_EVENT;
 909                 shost = lpfc_shost_from_vport(vport);
 910                 fc_host_post_vendor_event(shost, fc_get_event_number(),
 911                                 sizeof(event_data), (char *) &event_data,
 912                                 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
 913
 914                 lpfc_offline_eratt(phba);
 915         }
 916         return;
 917 }
 918
 919 /**
 920  * lpfc_handle_latt: The HBA link event handler.
 921  * @phba: pointer to lpfc hba data structure.
 922  *
 923  * This routine is invoked from the worker thread to handle a HBA host
 924  * attention link event.
 925  **/
 926 void
 927 lpfc_handle_latt(struct lpfc_hba *phba)
 928 {
 929         struct lpfc_vport *vport = phba->pport;
 930         struct lpfc_sli   *psli = &phba->sli;
 931         LPFC_MBOXQ_t *pmb;
 932         volatile uint32_t control;
 933         struct lpfc_dmabuf *mp;
 934         int rc = 0;
 935
 936         pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 937         if (!pmb) {
 938                 rc = 1;
 939                 goto lpfc_handle_latt_err_exit;
 940         }
 941
 942         mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
 943         if (!mp) {
 944                 rc = 2;
 945                 goto lpfc_handle_latt_free_pmb;
 946         }
 947
 948         mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
 949         if (!mp->virt) {
 950                 rc = 3;
 951                 goto lpfc_handle_latt_free_mp;
 952         }
 953
 954         /* Cleanup any outstanding ELS commands */
 955         lpfc_els_flush_all_cmd(phba);
 956
 957         psli->slistat.link_event++;
 958         lpfc_read_la(phba, pmb, mp);
 959         pmb->mbox_cmpl = lpfc_mbx_cmpl_read_la;
 960         pmb->vport = vport;
 961         /* Block ELS IOCBs until we have processed this mbox command */
 962         phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT;
 963         rc = lpfc_sli_issue_mbox (phba, pmb, MBX_NOWAIT);
 964         if (rc == MBX_NOT_FINISHED) {
 965                 rc = 4;
 966                 goto lpfc_handle_latt_free_mbuf;
 967         }
 968
 969         /* Clear Link Attention in HA REG */
 970         spin_lock_irq(&phba->hbalock);
 971         writel(HA_LATT, phba->HAregaddr);
 972         readl(phba->HAregaddr); /* flush */
 973         spin_unlock_irq(&phba->hbalock);
 974
 975         return;
 976
 977 lpfc_handle_latt_free_mbuf:
 978         phba->sli.ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT;
 979         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 980 lpfc_handle_latt_free_mp:
 981         kfree(mp);
 982 lpfc_handle_latt_free_pmb:
 983         mempool_free(pmb, phba->mbox_mem_pool);
 984 lpfc_handle_latt_err_exit:
 985         /* Enable Link attention interrupts */
 986         spin_lock_irq(&phba->hbalock);
 987         psli->sli_flag |= LPFC_PROCESS_LA;
 988         control = readl(phba->HCregaddr);
 989         control |= HC_LAINT_ENA;
 990         writel(control, phba->HCregaddr);
 991         readl(phba->HCregaddr); /* flush */
 992
 993         /* Clear Link Attention in HA REG */
 994         writel(HA_LATT, phba->HAregaddr);
 995         readl(phba->HAregaddr); /* flush */
 996         spin_unlock_irq(&phba->hbalock);
 997         lpfc_linkdown(phba);
 998         phba->link_state = LPFC_HBA_ERROR;
 999
1000         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1001                      "0300 LATT: Cannot issue READ_LA: Data:%d\n", rc);
1002
1003         return;
1004 }
1005
1006 /**
1007  * lpfc_parse_vpd: Parse VPD (Vital Product Data).
1008  * @phba: pointer to lpfc hba data structure.
1009  * @vpd: pointer to the vital product data.
1010  * @len: length of the vital product data in bytes.
1011  *
1012  * This routine parses the Vital Product Data (VPD). The VPD is treated as
1013  * an array of characters. In this routine, the ModelName, ProgramType, and
1014  * ModelDesc, etc. fields of the phba data structure will be populated.
1015  *
1016  * Return codes
1017  *   0 - pointer to the VPD passed in is NULL
1018  *   1 - success
1019  **/
1020 static int
1021 lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len)
1022 {
1023         uint8_t lenlo, lenhi;
1024         int Length;
1025         int i, j;
1026         int finished = 0;
1027         int index = 0;
1028
1029         if (!vpd)
1030                 return 0;
1031
1032         /* Vital Product */
1033         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
1034                         "0455 Vital Product Data: x%x x%x x%x x%x\n",
1035                         (uint32_t) vpd[0], (uint32_t) vpd[1], (uint32_t) vpd[2],
1036                         (uint32_t) vpd[3]);
1037         while (!finished && (index < (len - 4))) {
1038                 switch (vpd[index]) {
1039                 case 0x82:
1040                 case 0x91:
1041                         index += 1;
1042                         lenlo = vpd[index];
1043                         index += 1;
1044                         lenhi = vpd[index];
1045                         index += 1;
1046                         i = ((((unsigned short)lenhi) << 8) + lenlo);
1047                         index += i;
1048                         break;
1049                 case 0x90:
1050                         index += 1;
1051                         lenlo = vpd[index];
1052                         index += 1;
1053                         lenhi = vpd[index];
1054                         index += 1;
1055                         Length = ((((unsigned short)lenhi) << 8) + lenlo);
1056                         if (Length > len - index)
1057                                 Length = len - index;
1058                         while (Length > 0) {
1059                         /* Look for Serial Number */
1060                         if ((vpd[index] == 'S') && (vpd[index+1] == 'N')) {
1061                                 index += 2;
1062                                 i = vpd[index];
1063                                 index += 1;
1064                                 j = 0;
1065                                 Length -= (3+i);
1066                                 while(i--) {
1067                                         phba->SerialNumber[j++] = vpd[index++];
1068                                         if (j == 31)
1069                                                 break;
1070                                 }
1071                                 phba->SerialNumber[j] = 0;
1072                                 continue;
1073                         }
1074                         else if ((vpd[index] == 'V') && (vpd[index+1] == '1')) {
1075                                 phba->vpd_flag |= VPD_MODEL_DESC;
1076                                 index += 2;
1077                                 i = vpd[index];
1078                                 index += 1;
1079                                 j = 0;
1080                                 Length -= (3+i);
1081                                 while(i--) {
1082                                         phba->ModelDesc[j++] = vpd[index++];
1083                                         if (j == 255)
1084                                                 break;
1085                                 }
1086                                 phba->ModelDesc[j] = 0;
1087                                 continue;
1088                         }
1089                         else if ((vpd[index] == 'V') && (vpd[index+1] == '2')) {
1090                                 phba->vpd_flag |= VPD_MODEL_NAME;
1091                                 index += 2;
1092                                 i = vpd[index];
1093                                 index += 1;
1094                                 j = 0;
1095                                 Length -= (3+i);
1096                                 while(i--) {
1097                                         phba->ModelName[j++] = vpd[index++];
1098                                         if (j == 79)
1099                                                 break;
1100                                 }
1101                                 phba->ModelName[j] = 0;
1102                                 continue;
1103                         }
1104                         else if ((vpd[index] == 'V') && (vpd[index+1] == '3')) {
1105                                 phba->vpd_flag |= VPD_PROGRAM_TYPE;
1106                                 index += 2;
1107                                 i = vpd[index];
1108                                 index += 1;
1109                                 j = 0;
1110                                 Length -= (3+i);
1111                                 while(i--) {
1112                                         phba->ProgramType[j++] = vpd[index++];
1113                                         if (j == 255)
1114                                                 break;
1115                                 }
1116                                 phba->ProgramType[j] = 0;
1117                                 continue;
1118                         }
1119                         else if ((vpd[index] == 'V') && (vpd[index+1] == '4')) {
1120                                 phba->vpd_flag |= VPD_PORT;
1121                                 index += 2;
1122                                 i = vpd[index];
1123                                 index += 1;
1124                                 j = 0;
1125                                 Length -= (3+i);
1126                                 while(i--) {
1127                                 phba->Port[j++] = vpd[index++];
1128                                 if (j == 19)
1129                                         break;
1130                                 }
1131                                 phba->Port[j] = 0;
1132                                 continue;
1133                         }
1134                         else {
1135                                 index += 2;
1136                                 i = vpd[index];
1137                                 index += 1;
1138                                 index += i;
1139                                 Length -= (3 + i);
1140                         }
1141                 }
1142                 finished = 0;
1143                 break;
1144                 case 0x78:
1145                         finished = 1;
1146                         break;
1147                 default:
1148                         index ++;
1149                         break;
1150                 }
1151         }
1152
1153         return(1);
1154 }
1155
1156 /**
1157  * lpfc_get_hba_model_desc: Retrieve HBA device model name and description.
1158  * @phba: pointer to lpfc hba data structure.
1159  * @mdp: pointer to the data structure to hold the derived model name.
1160  * @descp: pointer to the data structure to hold the derived description.
1161  *
1162  * This routine retrieves HBA's description based on its registered PCI device
1163  * ID. The @descp passed into this function points to an array of 256 chars. It
1164  * shall be returned with the model name, maximum speed, and the host bus type.
1165  * The @mdp passed into this function points to an array of 80 chars. When the
1166  * function returns, the @mdp will be filled with the model name.
1167  **/
1168 static void
1169 lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
1170 {
1171         lpfc_vpd_t *vp;
1172         uint16_t dev_id = phba->pcidev->device;
1173         int max_speed;
1174         int GE = 0;
1175         struct {
1176                 char * name;
1177                 int    max_speed;
1178                 char * bus;
1179         } m = {"<Unknown>", 0, ""};
1180
1181         if (mdp && mdp[0] != '\0'
1182                 && descp && descp[0] != '\0')
1183                 return;
1184
1185         if (phba->lmt & LMT_10Gb)
1186                 max_speed = 10;
1187         else if (phba->lmt & LMT_8Gb)
1188                 max_speed = 8;
1189         else if (phba->lmt & LMT_4Gb)
1190                 max_speed = 4;
1191         else if (phba->lmt & LMT_2Gb)
1192                 max_speed = 2;
1193         else
1194                 max_speed = 1;
1195
1196         vp = &phba->vpd;
1197
1198         switch (dev_id) {
1199         case PCI_DEVICE_ID_FIREFLY:
1200                 m = (typeof(m)){"LP6000", max_speed, "PCI"};
1201                 break;
1202         case PCI_DEVICE_ID_SUPERFLY:
1203                 if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3)
1204                         m = (typeof(m)){"LP7000", max_speed,  "PCI"};
1205                 else
1206                         m = (typeof(m)){"LP7000E", max_speed, "PCI"};
1207                 break;
1208         case PCI_DEVICE_ID_DRAGONFLY:
1209                 m = (typeof(m)){"LP8000", max_speed, "PCI"};
1210                 break;
1211         case PCI_DEVICE_ID_CENTAUR:
1212                 if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID)
1213                         m = (typeof(m)){"LP9002", max_speed, "PCI"};
1214                 else
1215                         m = (typeof(m)){"LP9000", max_speed, "PCI"};
1216                 break;
1217         case PCI_DEVICE_ID_RFLY:
1218                 m = (typeof(m)){"LP952", max_speed, "PCI"};
1219                 break;
1220         case PCI_DEVICE_ID_PEGASUS:
1221                 m = (typeof(m)){"LP9802", max_speed, "PCI-X"};
1222                 break;
1223         case PCI_DEVICE_ID_THOR:
1224                 m = (typeof(m)){"LP10000", max_speed, "PCI-X"};
1225                 break;
1226         case PCI_DEVICE_ID_VIPER:
1227                 m = (typeof(m)){"LPX1000", max_speed,  "PCI-X"};
1228                 break;
1229         case PCI_DEVICE_ID_PFLY:
1230                 m = (typeof(m)){"LP982", max_speed, "PCI-X"};
1231                 break;
1232         case PCI_DEVICE_ID_TFLY:
1233                 m = (typeof(m)){"LP1050", max_speed, "PCI-X"};
1234                 break;
1235         case PCI_DEVICE_ID_HELIOS:
1236                 m = (typeof(m)){"LP11000", max_speed, "PCI-X2"};
1237                 break;
1238         case PCI_DEVICE_ID_HELIOS_SCSP:
1239                 m = (typeof(m)){"LP11000-SP", max_speed, "PCI-X2"};
1240                 break;
1241         case PCI_DEVICE_ID_HELIOS_DCSP:
1242                 m = (typeof(m)){"LP11002-SP", max_speed, "PCI-X2"};
1243                 break;
1244         case PCI_DEVICE_ID_NEPTUNE:
1245                 m = (typeof(m)){"LPe1000", max_speed, "PCIe"};
1246                 break;
1247         case PCI_DEVICE_ID_NEPTUNE_SCSP:
1248                 m = (typeof(m)){"LPe1000-SP", max_speed, "PCIe"};
1249                 break;
1250         case PCI_DEVICE_ID_NEPTUNE_DCSP:
1251                 m = (typeof(m)){"LPe1002-SP", max_speed, "PCIe"};
1252                 break;
1253         case PCI_DEVICE_ID_BMID:
1254                 m = (typeof(m)){"LP1150", max_speed, "PCI-X2"};
1255                 break;
1256         case PCI_DEVICE_ID_BSMB:
1257                 m = (typeof(m)){"LP111", max_speed, "PCI-X2"};
1258                 break;
1259         case PCI_DEVICE_ID_ZEPHYR:
1260                 m = (typeof(m)){"LPe11000", max_speed, "PCIe"};
1261                 break;
1262         case PCI_DEVICE_ID_ZEPHYR_SCSP:
1263                 m = (typeof(m)){"LPe11000", max_speed, "PCIe"};
1264                 break;
1265         case PCI_DEVICE_ID_ZEPHYR_DCSP:
1266                 m = (typeof(m)){"LPe11002-SP", max_speed, "PCIe"};
1267                 break;
1268         case PCI_DEVICE_ID_ZMID:
1269                 m = (typeof(m)){"LPe1150", max_speed, "PCIe"};
1270                 break;
1271         case PCI_DEVICE_ID_ZSMB:
1272                 m = (typeof(m)){"LPe111", max_speed, "PCIe"};
1273                 break;
1274         case PCI_DEVICE_ID_LP101:
1275                 m = (typeof(m)){"LP101", max_speed, "PCI-X"};
1276                 break;
1277         case PCI_DEVICE_ID_LP10000S:
1278                 m = (typeof(m)){"LP10000-S", max_speed, "PCI"};
1279                 break;
1280         case PCI_DEVICE_ID_LP11000S:
1281                 m = (typeof(m)){"LP11000-S", max_speed,
1282                         "PCI-X2"};
1283                 break;
1284         case PCI_DEVICE_ID_LPE11000S:
1285                 m = (typeof(m)){"LPe11000-S", max_speed,
1286                         "PCIe"};
1287                 break;
1288         case PCI_DEVICE_ID_SAT:
1289                 m = (typeof(m)){"LPe12000", max_speed, "PCIe"};
1290                 break;
1291         case PCI_DEVICE_ID_SAT_MID:
1292                 m = (typeof(m)){"LPe1250", max_speed, "PCIe"};
1293                 break;
1294         case PCI_DEVICE_ID_SAT_SMB:
1295                 m = (typeof(m)){"LPe121", max_speed, "PCIe"};
1296                 break;
1297         case PCI_DEVICE_ID_SAT_DCSP:
1298                 m = (typeof(m)){"LPe12002-SP", max_speed, "PCIe"};
1299                 break;
1300         case PCI_DEVICE_ID_SAT_SCSP:
1301                 m = (typeof(m)){"LPe12000-SP", max_speed, "PCIe"};
1302                 break;
1303         case PCI_DEVICE_ID_SAT_S:
1304                 m = (typeof(m)){"LPe12000-S", max_speed, "PCIe"};
1305                 break;
1306         case PCI_DEVICE_ID_HORNET:
1307                 m = (typeof(m)){"LP21000", max_speed, "PCIe"};
1308                 GE = 1;
1309                 break;
1310         case PCI_DEVICE_ID_PROTEUS_VF:
1311                 m = (typeof(m)) {"LPev12000", max_speed, "PCIe IOV"};
1312                 break;
1313         case PCI_DEVICE_ID_PROTEUS_PF:
1314                 m = (typeof(m)) {"LPev12000", max_speed, "PCIe IOV"};
1315                 break;
1316         case PCI_DEVICE_ID_PROTEUS_S:
1317                 m = (typeof(m)) {"LPemv12002-S", max_speed, "PCIe IOV"};
1318                 break;
1319         default:
1320                 m = (typeof(m)){ NULL };
1321                 break;
1322         }
1323
1324         if (mdp && mdp[0] == '\0')
1325                 snprintf(mdp, 79,"%s", m.name);
1326         if (descp && descp[0] == '\0')
1327                 snprintf(descp, 255,
1328                         "Emulex %s %d%s %s %s",
1329                         m.name, m.max_speed,
1330                         (GE) ? "GE" : "Gb",
1331                         m.bus,
1332                         (GE) ? "FCoE Adapter" : "Fibre Channel Adapter");
1333 }
1334
1335 /**
1336  * lpfc_post_buffer: Post IOCB(s) with DMA buffer descriptor(s) to a IOCB ring.
1337  * @phba: pointer to lpfc hba data structure.
1338  * @pring: pointer to a IOCB ring.
1339  * @cnt: the number of IOCBs to be posted to the IOCB ring.
1340  *
1341  * This routine posts a given number of IOCBs with the associated DMA buffer
1342  * descriptors specified by the cnt argument to the given IOCB ring.
1343  *
1344  * Return codes
1345  *   The number of IOCBs NOT able to be posted to the IOCB ring.
1346  **/
1347 int
1348 lpfc_post_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, int cnt)
1349 {
1350         IOCB_t *icmd;
1351         struct lpfc_iocbq *iocb;
1352         struct lpfc_dmabuf *mp1, *mp2;
1353
1354         cnt += pring->missbufcnt;
1355
1356         /* While there are buffers to post */
1357         while (cnt > 0) {
1358                 /* Allocate buffer for  command iocb */
1359                 iocb = lpfc_sli_get_iocbq(phba);
1360                 if (iocb == NULL) {
1361                         pring->missbufcnt = cnt;
1362                         return cnt;
1363                 }
1364                 icmd = &iocb->iocb;
1365
1366                 /* 2 buffers can be posted per command */
1367                 /* Allocate buffer to post */
1368                 mp1 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1369                 if (mp1)
1370                     mp1->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp1->phys);
1371                 if (!mp1 || !mp1->virt) {
1372                         kfree(mp1);
1373                         lpfc_sli_release_iocbq(phba, iocb);
1374                         pring->missbufcnt = cnt;
1375                         return cnt;
1376                 }
1377
1378                 INIT_LIST_HEAD(&mp1->list);
1379                 /* Allocate buffer to post */
1380                 if (cnt > 1) {
1381                         mp2 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL);
1382                         if (mp2)
1383                                 mp2->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
1384                                                             &mp2->phys);
1385                         if (!mp2 || !mp2->virt) {
1386                                 kfree(mp2);
1387                                 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1388                                 kfree(mp1);
1389                                 lpfc_sli_release_iocbq(phba, iocb);
1390                                 pring->missbufcnt = cnt;
1391                                 return cnt;
1392                         }
1393
1394                         INIT_LIST_HEAD(&mp2->list);
1395                 } else {
1396                         mp2 = NULL;
1397                 }
1398
1399                 icmd->un.cont64[0].addrHigh = putPaddrHigh(mp1->phys);
1400                 icmd->un.cont64[0].addrLow = putPaddrLow(mp1->phys);
1401                 icmd->un.cont64[0].tus.f.bdeSize = FCELSSIZE;
1402                 icmd->ulpBdeCount = 1;
1403                 cnt--;
1404                 if (mp2) {
1405                         icmd->un.cont64[1].addrHigh = putPaddrHigh(mp2->phys);
1406                         icmd->un.cont64[1].addrLow = putPaddrLow(mp2->phys);
1407                         icmd->un.cont64[1].tus.f.bdeSize = FCELSSIZE;
1408                         cnt--;
1409                         icmd->ulpBdeCount = 2;
1410                 }
1411
1412                 icmd->ulpCommand = CMD_QUE_RING_BUF64_CN;
1413                 icmd->ulpLe = 1;
1414
1415                 if (lpfc_sli_issue_iocb(phba, pring, iocb, 0) == IOCB_ERROR) {
1416                         lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1417                         kfree(mp1);
1418                         cnt++;
1419                         if (mp2) {
1420                                 lpfc_mbuf_free(phba, mp2->virt, mp2->phys);
1421                                 kfree(mp2);
1422                                 cnt++;
1423                         }
1424                         lpfc_sli_release_iocbq(phba, iocb);
1425                         pring->missbufcnt = cnt;
1426                         return cnt;
1427                 }
1428                 lpfc_sli_ringpostbuf_put(phba, pring, mp1);
1429                 if (mp2)
1430                         lpfc_sli_ringpostbuf_put(phba, pring, mp2);
1431         }
1432         pring->missbufcnt = 0;
1433         return 0;
1434 }
1435
1436 /**
1437  * lpfc_post_rcv_buf: Post the initial receive IOCB buffers to ELS ring.
1438  * @phba: pointer to lpfc hba data structure.
1439  *
1440  * This routine posts initial receive IOCB buffers to the ELS ring. The
1441  * current number of initial IOCB buffers specified by LPFC_BUF_RING0 is
1442  * set to 64 IOCBs.
1443  *
1444  * Return codes
1445  *   0 - success (currently always success)
1446  **/
1447 static int
1448 lpfc_post_rcv_buf(struct lpfc_hba *phba)
1449 {
1450         struct lpfc_sli *psli = &phba->sli;
1451
1452         /* Ring 0, ELS / CT buffers */
1453         lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], LPFC_BUF_RING0);
1454         /* Ring 2 - FCP no buffers needed */
1455
1456         return 0;
1457 }
1458
1459 #define S(N,V) (((V)<<(N))|((V)>>(32-(N))))
1460
1461 /**
1462  * lpfc_sha_init: Set up initial array of hash table entries.
1463  * @HashResultPointer: pointer to an array as hash table.
1464  *
1465  * This routine sets up the initial values to the array of hash table entries
1466  * for the LC HBAs.
1467  **/
1468 static void
1469 lpfc_sha_init(uint32_t * HashResultPointer)
1470 {
1471         HashResultPointer[0] = 0x67452301;
1472         HashResultPointer[1] = 0xEFCDAB89;
1473         HashResultPointer[2] = 0x98BADCFE;
1474         HashResultPointer[3] = 0x10325476;
1475         HashResultPointer[4] = 0xC3D2E1F0;
1476 }
1477
1478 /**
1479  * lpfc_sha_iterate: Iterate initial hash table with the working hash table.
1480  * @HashResultPointer: pointer to an initial/result hash table.
1481  * @HashWorkingPointer: pointer to an working hash table.
1482  *
1483  * This routine iterates an initial hash table pointed by @HashResultPointer
1484  * with the values from the working hash table pointeed by @HashWorkingPointer.
1485  * The results are putting back to the initial hash table, returned through
1486  * the @HashResultPointer as the result hash table.
1487  **/
1488 static void
1489 lpfc_sha_iterate(uint32_t * HashResultPointer, uint32_t * HashWorkingPointer)
1490 {
1491         int t;
1492         uint32_t TEMP;
1493         uint32_t A, B, C, D, E;
1494         t = 16;
1495         do {
1496                 HashWorkingPointer[t] =
1497                     S(1,
1498                       HashWorkingPointer[t - 3] ^ HashWorkingPointer[t -
1499                                                                      8] ^
1500                       HashWorkingPointer[t - 14] ^ HashWorkingPointer[t - 16]);
1501         } while (++t <= 79);
1502         t = 0;
1503         A = HashResultPointer[0];
1504         B = HashResultPointer[1];
1505         C = HashResultPointer[2];
1506         D = HashResultPointer[3];
1507         E = HashResultPointer[4];
1508
1509         do {
1510                 if (t < 20) {
1511                         TEMP = ((B & C) | ((~B) & D)) + 0x5A827999;
1512                 } else if (t < 40) {
1513                         TEMP = (B ^ C ^ D) + 0x6ED9EBA1;
1514                 } else if (t < 60) {
1515                         TEMP = ((B & C) | (B & D) | (C & D)) + 0x8F1BBCDC;
1516                 } else {
1517                         TEMP = (B ^ C ^ D) + 0xCA62C1D6;
1518                 }
1519                 TEMP += S(5, A) + E + HashWorkingPointer[t];
1520                 E = D;
1521                 D = C;
1522                 C = S(30, B);
1523                 B = A;
1524                 A = TEMP;
1525         } while (++t <= 79);
1526
1527         HashResultPointer[0] += A;
1528         HashResultPointer[1] += B;
1529         HashResultPointer[2] += C;
1530         HashResultPointer[3] += D;
1531         HashResultPointer[4] += E;
1532
1533 }
1534
1535 /**
1536  * lpfc_challenge_key: Create challenge key based on WWPN of the HBA.
1537  * @RandomChallenge: pointer to the entry of host challenge random number array.
1538  * @HashWorking: pointer to the entry of the working hash array.
1539  *
1540  * This routine calculates the working hash array referred by @HashWorking
1541  * from the challenge random numbers associated with the host, referred by
1542  * @RandomChallenge. The result is put into the entry of the working hash
1543  * array and returned by reference through @HashWorking.
1544  **/
1545 static void
1546 lpfc_challenge_key(uint32_t * RandomChallenge, uint32_t * HashWorking)
1547 {
1548         *HashWorking = (*RandomChallenge ^ *HashWorking);
1549 }
1550
1551 /**
1552  * lpfc_hba_init: Perform special handling for LC HBA initialization.
1553  * @phba: pointer to lpfc hba data structure.
1554  * @hbainit: pointer to an array of unsigned 32-bit integers.
1555  *
1556  * This routine performs the special handling for LC HBA initialization.
1557  **/
1558 void
1559 lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit)
1560 {
1561         int t;
1562         uint32_t *HashWorking;
1563         uint32_t *pwwnn = (uint32_t *) phba->wwnn;
1564
1565         HashWorking = kcalloc(80, sizeof(uint32_t), GFP_KERNEL);
1566         if (!HashWorking)
1567                 return;
1568
1569         HashWorking[0] = HashWorking[78] = *pwwnn++;
1570         HashWorking[1] = HashWorking[79] = *pwwnn;
1571
1572         for (t = 0; t < 7; t++)
1573                 lpfc_challenge_key(phba->RandomData + t, HashWorking + t);
1574
1575         lpfc_sha_init(hbainit);
1576         lpfc_sha_iterate(hbainit, HashWorking);
1577         kfree(HashWorking);
1578 }
1579
1580 /**
1581  * lpfc_cleanup: Performs vport cleanups before deleting a vport.
1582  * @vport: pointer to a virtual N_Port data structure.
1583  *
1584  * This routine performs the necessary cleanups before deleting the @vport.
1585  * It invokes the discovery state machine to perform necessary state
1586  * transitions and to release the ndlps associated with the @vport. Note,
1587  * the physical port is treated as @vport 0.
1588  **/
1589 void
1590 lpfc_cleanup(struct lpfc_vport *vport)
1591 {
1592         struct lpfc_hba   *phba = vport->phba;
1593         struct lpfc_nodelist *ndlp, *next_ndlp;
1594         int i = 0;
1595
1596         if (phba->link_state > LPFC_LINK_DOWN)
1597                 lpfc_port_link_failure(vport);
1598
1599         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
1600                 if (!NLP_CHK_NODE_ACT(ndlp)) {
1601                         ndlp = lpfc_enable_node(vport, ndlp,
1602                                                 NLP_STE_UNUSED_NODE);
1603                         if (!ndlp)
1604                                 continue;
1605                         spin_lock_irq(&phba->ndlp_lock);
1606                         NLP_SET_FREE_REQ(ndlp);
1607                         spin_unlock_irq(&phba->ndlp_lock);
1608                         /* Trigger the release of the ndlp memory */
1609                         lpfc_nlp_put(ndlp);
1610                         continue;
1611                 }
1612                 spin_lock_irq(&phba->ndlp_lock);
1613                 if (NLP_CHK_FREE_REQ(ndlp)) {
1614                         /* The ndlp should not be in memory free mode already */
1615                         spin_unlock_irq(&phba->ndlp_lock);
1616                         continue;
1617                 } else
1618                         /* Indicate request for freeing ndlp memory */
1619                         NLP_SET_FREE_REQ(ndlp);
1620                 spin_unlock_irq(&phba->ndlp_lock);
1621
1622                 if (vport->port_type != LPFC_PHYSICAL_PORT &&
1623                     ndlp->nlp_DID == Fabric_DID) {
1624                         /* Just free up ndlp with Fabric_DID for vports */
1625                         lpfc_nlp_put(ndlp);
1626                         continue;
1627                 }
1628
1629                 if (ndlp->nlp_type & NLP_FABRIC)
1630                         lpfc_disc_state_machine(vport, ndlp, NULL,
1631                                         NLP_EVT_DEVICE_RECOVERY);
1632
1633                 lpfc_disc_state_machine(vport, ndlp, NULL,
1634                                              NLP_EVT_DEVICE_RM);
1635
1636         }
1637
1638         /* At this point, ALL ndlp's should be gone
1639          * because of the previous NLP_EVT_DEVICE_RM.
1640          * Lets wait for this to happen, if needed.
1641          */
1642         while (!list_empty(&vport->fc_nodes)) {
1643
1644                 if (i++ > 3000) {
1645                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
1646                                 "0233 Nodelist not empty\n");
1647                         list_for_each_entry_safe(ndlp, next_ndlp,
1648                                                 &vport->fc_nodes, nlp_listp) {
1649                                 lpfc_printf_vlog(ndlp->vport, KERN_ERR,
1650                                                 LOG_NODE,
1651                                                 "0282 did:x%x ndlp:x%p "
1652                                                 "usgmap:x%x refcnt:%d\n",
1653                                                 ndlp->nlp_DID, (void *)ndlp,
1654                                                 ndlp->nlp_usg_map,
1655                                                 atomic_read(
1656                                                         &ndlp->kref.refcount));
1657                         }
1658                         break;
1659                 }
1660
1661                 /* Wait for any activity on ndlps to settle */
1662                 msleep(10);
1663         }
1664         return;
1665 }
1666
1667 /**
1668  * lpfc_stop_vport_timers: Stop all the timers associated with a vport.
1669  * @vport: pointer to a virtual N_Port data structure.
1670  *
1671  * This routine stops all the timers associated with a @vport. This function
1672  * is invoked before disabling or deleting a @vport. Note that the physical
1673  * port is treated as @vport 0.
1674  **/
1675 void
1676 lpfc_stop_vport_timers(struct lpfc_vport *vport)
1677 {
1678         del_timer_sync(&vport->els_tmofunc);
1679         del_timer_sync(&vport->fc_fdmitmo);
1680         lpfc_can_disctmo(vport);
1681         return;
1682 }
1683
1684 /**
1685  * lpfc_stop_phba_timers: Stop all the timers associated with an HBA.
1686  * @phba: pointer to lpfc hba data structure.
1687  *
1688  * This routine stops all the timers associated with a HBA. This function is
1689  * invoked before either putting a HBA offline or unloading the driver.
1690  **/
1691 static void
1692 lpfc_stop_phba_timers(struct lpfc_hba *phba)
1693 {
1694         del_timer_sync(&phba->fcp_poll_timer);
1695         lpfc_stop_vport_timers(phba->pport);
1696         del_timer_sync(&phba->sli.mbox_tmo);
1697         del_timer_sync(&phba->fabric_block_timer);
1698         phba->hb_outstanding = 0;
1699         del_timer_sync(&phba->hb_tmofunc);
1700         del_timer_sync(&phba->eratt_poll);
1701         return;
1702 }
1703
1704 /**
1705  * lpfc_block_mgmt_io: Mark a HBA's management interface as blocked.
1706  * @phba: pointer to lpfc hba data structure.
1707  *
1708  * This routine marks a HBA's management interface as blocked. Once the HBA's
1709  * management interface is marked as blocked, all the user space access to
1710  * the HBA, whether they are from sysfs interface or libdfc interface will
1711  * all be blocked. The HBA is set to block the management interface when the
1712  * driver prepares the HBA interface for online or offline.
1713  **/
1714 static void
1715 lpfc_block_mgmt_io(struct lpfc_hba * phba)
1716 {
1717         unsigned long iflag;
1718
1719         spin_lock_irqsave(&phba->hbalock, iflag);
1720         phba->sli.sli_flag |= LPFC_BLOCK_MGMT_IO;
1721         spin_unlock_irqrestore(&phba->hbalock, iflag);
1722 }
1723
1724 /**
1725  * lpfc_online: Initialize and bring a HBA online.
1726  * @phba: pointer to lpfc hba data structure.
1727  *
1728  * This routine initializes the HBA and brings a HBA online. During this
1729  * process, the management interface is blocked to prevent user space access
1730  * to the HBA interfering with the driver initialization.
1731  *
1732  * Return codes
1733  *   0 - successful
1734  *   1 - failed
1735  **/
1736 int
1737 lpfc_online(struct lpfc_hba *phba)
1738 {
1739         struct lpfc_vport *vport = phba->pport;
1740         struct lpfc_vport **vports;
1741         int i;
1742
1743         if (!phba)
1744                 return 0;
1745
1746         if (!(vport->fc_flag & FC_OFFLINE_MODE))
1747                 return 0;
1748
1749         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1750                         "0458 Bring Adapter online\n");
1751
1752         lpfc_block_mgmt_io(phba);
1753
1754         if (!lpfc_sli_queue_setup(phba)) {
1755                 lpfc_unblock_mgmt_io(phba);
1756                 return 1;
1757         }
1758
1759         if (lpfc_sli_hba_setup(phba)) { /* Initialize the HBA */
1760                 lpfc_unblock_mgmt_io(phba);
1761                 return 1;
1762         }
1763
1764         vports = lpfc_create_vport_work_array(phba);
1765         if (vports != NULL)
1766                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1767                         struct Scsi_Host *shost;
1768                         shost = lpfc_shost_from_vport(vports[i]);
1769                         spin_lock_irq(shost->host_lock);
1770                         vports[i]->fc_flag &= ~FC_OFFLINE_MODE;
1771                         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
1772                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
1773                         spin_unlock_irq(shost->host_lock);
1774                 }
1775                 lpfc_destroy_vport_work_array(phba, vports);
1776
1777         lpfc_unblock_mgmt_io(phba);
1778         return 0;
1779 }
1780
1781 /**
1782  * lpfc_unblock_mgmt_io: Mark a HBA's management interface to be not blocked.
1783  * @phba: pointer to lpfc hba data structure.
1784  *
1785  * This routine marks a HBA's management interface as not blocked. Once the
1786  * HBA's management interface is marked as not blocked, all the user space
1787  * access to the HBA, whether they are from sysfs interface or libdfc
1788  * interface will be allowed. The HBA is set to block the management interface
1789  * when the driver prepares the HBA interface for online or offline and then
1790  * set to unblock the management interface afterwards.
1791  **/
1792 void
1793 lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
1794 {
1795         unsigned long iflag;
1796
1797         spin_lock_irqsave(&phba->hbalock, iflag);
1798         phba->sli.sli_flag &= ~LPFC_BLOCK_MGMT_IO;
1799         spin_unlock_irqrestore(&phba->hbalock, iflag);
1800 }
1801
1802 /**
1803  * lpfc_offline_prep: Prepare a HBA to be brought offline.
1804  * @phba: pointer to lpfc hba data structure.
1805  *
1806  * This routine is invoked to prepare a HBA to be brought offline. It performs
1807  * unregistration login to all the nodes on all vports and flushes the mailbox
1808  * queue to make it ready to be brought offline.
1809  **/
1810 void
1811 lpfc_offline_prep(struct lpfc_hba * phba)
1812 {
1813         struct lpfc_vport *vport = phba->pport;
1814         struct lpfc_nodelist  *ndlp, *next_ndlp;
1815         struct lpfc_vport **vports;
1816         int i;
1817
1818         if (vport->fc_flag & FC_OFFLINE_MODE)
1819                 return;
1820
1821         lpfc_block_mgmt_io(phba);
1822
1823         lpfc_linkdown(phba);
1824
1825         /* Issue an unreg_login to all nodes on all vports */
1826         vports = lpfc_create_vport_work_array(phba);
1827         if (vports != NULL) {
1828                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1829                         struct Scsi_Host *shost;
1830
1831                         if (vports[i]->load_flag & FC_UNLOADING)
1832                                 continue;
1833                         shost = lpfc_shost_from_vport(vports[i]);
1834                         list_for_each_entry_safe(ndlp, next_ndlp,
1835                                                  &vports[i]->fc_nodes,
1836                                                  nlp_listp) {
1837                                 if (!NLP_CHK_NODE_ACT(ndlp))
1838                                         continue;
1839                                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
1840                                         continue;
1841                                 if (ndlp->nlp_type & NLP_FABRIC) {
1842                                         lpfc_disc_state_machine(vports[i], ndlp,
1843                                                 NULL, NLP_EVT_DEVICE_RECOVERY);
1844                                         lpfc_disc_state_machine(vports[i], ndlp,
1845                                                 NULL, NLP_EVT_DEVICE_RM);
1846                                 }
1847                                 spin_lock_irq(shost->host_lock);
1848                                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
1849                                 spin_unlock_irq(shost->host_lock);
1850                                 lpfc_unreg_rpi(vports[i], ndlp);
1851                         }
1852                 }
1853         }
1854         lpfc_destroy_vport_work_array(phba, vports);
1855
1856         lpfc_sli_flush_mbox_queue(phba);
1857 }
1858
1859 /**
1860  * lpfc_offline: Bring a HBA offline.
1861  * @phba: pointer to lpfc hba data structure.
1862  *
1863  * This routine actually brings a HBA offline. It stops all the timers
1864  * associated with the HBA, brings down the SLI layer, and eventually
1865  * marks the HBA as in offline state for the upper layer protocol.
1866  **/
1867 void
1868 lpfc_offline(struct lpfc_hba *phba)
1869 {
1870         struct Scsi_Host  *shost;
1871         struct lpfc_vport **vports;
1872         int i;
1873
1874         if (phba->pport->fc_flag & FC_OFFLINE_MODE)
1875                 return;
1876
1877         /* stop all timers associated with this hba */
1878         lpfc_stop_phba_timers(phba);
1879         vports = lpfc_create_vport_work_array(phba);
1880         if (vports != NULL)
1881                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++)
1882                         lpfc_stop_vport_timers(vports[i]);
1883         lpfc_destroy_vport_work_array(phba, vports);
1884         lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1885                         "0460 Bring Adapter offline\n");
1886         /* Bring down the SLI Layer and cleanup.  The HBA is offline
1887            now.  */
1888         lpfc_sli_hba_down(phba);
1889         spin_lock_irq(&phba->hbalock);
1890         phba->work_ha = 0;
1891         spin_unlock_irq(&phba->hbalock);
1892         vports = lpfc_create_vport_work_array(phba);
1893         if (vports != NULL)
1894                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1895                         shost = lpfc_shost_from_vport(vports[i]);
1896                         spin_lock_irq(shost->host_lock);
1897                         vports[i]->work_port_events = 0;
1898                         vports[i]->fc_flag |= FC_OFFLINE_MODE;
1899                         spin_unlock_irq(shost->host_lock);
1900                 }
1901         lpfc_destroy_vport_work_array(phba, vports);
1902 }
1903
1904 /**
1905  * lpfc_scsi_free: Free all the SCSI buffers and IOCBs from driver lists.
1906  * @phba: pointer to lpfc hba data structure.
1907  *
1908  * This routine is to free all the SCSI buffers and IOCBs from the driver
1909  * list back to kernel. It is called from lpfc_pci_remove_one to free
1910  * the internal resources before the device is removed from the system.
1911  *
1912  * Return codes
1913  *   0 - successful (for now, it always returns 0)
1914  **/
1915 static int
1916 lpfc_scsi_free(struct lpfc_hba *phba)
1917 {
1918         struct lpfc_scsi_buf *sb, *sb_next;
1919         struct lpfc_iocbq *io, *io_next;
1920
1921         spin_lock_irq(&phba->hbalock);
1922         /* Release all the lpfc_scsi_bufs maintained by this host. */
1923         list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) {
1924                 list_del(&sb->list);
1925                 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
1926                               sb->dma_handle);
1927                 kfree(sb);
1928                 phba->total_scsi_bufs--;
1929         }
1930
1931         /* Release all the lpfc_iocbq entries maintained by this host. */
1932         list_for_each_entry_safe(io, io_next, &phba->lpfc_iocb_list, list) {
1933                 list_del(&io->list);
1934                 kfree(io);
1935                 phba->total_iocbq_bufs--;
1936         }
1937
1938         spin_unlock_irq(&phba->hbalock);
1939
1940         return 0;
1941 }
1942
1943 /**
1944  * lpfc_create_port: Create an FC port.
1945  * @phba: pointer to lpfc hba data structure.
1946  * @instance: a unique integer ID to this FC port.
1947  * @dev: pointer to the device data structure.
1948  *
1949  * This routine creates a FC port for the upper layer protocol. The FC port
1950  * can be created on top of either a physical port or a virtual port provided
1951  * by the HBA. This routine also allocates a SCSI host data structure (shost)
1952  * and associates the FC port created before adding the shost into the SCSI
1953  * layer.
1954  *
1955  * Return codes
1956  *   @vport - pointer to the virtual N_Port data structure.
1957  *   NULL - port create failed.
1958  **/
1959 struct lpfc_vport *
1960 lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
1961 {
1962         struct lpfc_vport *vport;
1963         struct Scsi_Host  *shost;
1964         int error = 0;
1965
1966         if (dev != &phba->pcidev->dev)
1967                 shost = scsi_host_alloc(&lpfc_vport_template,
1968                                         sizeof(struct lpfc_vport));
1969         else
1970                 shost = scsi_host_alloc(&lpfc_template,
1971                                         sizeof(struct lpfc_vport));
1972         if (!shost)
1973                 goto out;
1974
1975         vport = (struct lpfc_vport *) shost->hostdata;
1976         vport->phba = phba;
1977         vport->load_flag |= FC_LOADING;
1978         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
1979         vport->fc_rscn_flush = 0;
1980
1981         lpfc_get_vport_cfgparam(vport);
1982         shost->unique_id = instance;
1983         shost->max_id = LPFC_MAX_TARGET;
1984         shost->max_lun = vport->cfg_max_luns;
1985         shost->this_id = -1;
1986         shost->max_cmd_len = 16;
1987         /*
1988          * Set initial can_queue value since 0 is no longer supported and
1989          * scsi_add_host will fail. This will be adjusted later based on the
1990          * max xri value determined in hba setup.
1991          */
1992         shost->can_queue = phba->cfg_hba_queue_depth - 10;
1993         if (dev != &phba->pcidev->dev) {
1994                 shost->transportt = lpfc_vport_transport_template;
1995                 vport->port_type = LPFC_NPIV_PORT;
1996         } else {
1997                 shost->transportt = lpfc_transport_template;
1998                 vport->port_type = LPFC_PHYSICAL_PORT;
1999         }
2000
2001         /* Initialize all internally managed lists. */
2002         INIT_LIST_HEAD(&vport->fc_nodes);
2003         spin_lock_init(&vport->work_port_lock);
2004
2005         init_timer(&vport->fc_disctmo);
2006         vport->fc_disctmo.function = lpfc_disc_timeout;
2007         vport->fc_disctmo.data = (unsigned long)vport;
2008
2009         init_timer(&vport->fc_fdmitmo);
2010         vport->fc_fdmitmo.function = lpfc_fdmi_tmo;
2011         vport->fc_fdmitmo.data = (unsigned long)vport;
2012
2013         init_timer(&vport->els_tmofunc);
2014         vport->els_tmofunc.function = lpfc_els_timeout;
2015         vport->els_tmofunc.data = (unsigned long)vport;
2016
2017         error = scsi_add_host(shost, dev);
2018         if (error)
2019                 goto out_put_shost;
2020
2021         spin_lock_irq(&phba->hbalock);
2022         list_add_tail(&vport->listentry, &phba->port_list);
2023         spin_unlock_irq(&phba->hbalock);
2024         return vport;
2025
2026 out_put_shost:
2027         scsi_host_put(shost);
2028 out:
2029         return NULL;
2030 }
2031
2032 /**
2033  * destroy_port: Destroy an FC port.
2034  * @vport: pointer to an lpfc virtual N_Port data structure.
2035  *
2036  * This routine destroys a FC port from the upper layer protocol. All the
2037  * resources associated with the port are released.
2038  **/
2039 void
2040 destroy_port(struct lpfc_vport *vport)
2041 {
2042         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2043         struct lpfc_hba  *phba = vport->phba;
2044
2045         kfree(vport->vname);
2046
2047         lpfc_debugfs_terminate(vport);
2048         fc_remove_host(shost);
2049         scsi_remove_host(shost);
2050
2051         spin_lock_irq(&phba->hbalock);
2052         list_del_init(&vport->listentry);
2053         spin_unlock_irq(&phba->hbalock);
2054
2055         lpfc_cleanup(vport);
2056         return;
2057 }
2058
2059 /**
2060  * lpfc_get_instance: Get a unique integer ID.
2061  *
2062  * This routine allocates a unique integer ID from lpfc_hba_index pool. It
2063  * uses the kernel idr facility to perform the task.
2064  *
2065  * Return codes:
2066  *   instance - a unique integer ID allocated as the new instance.
2067  *   -1 - lpfc get instance failed.
2068  **/
2069 int
2070 lpfc_get_instance(void)
2071 {
2072         int instance = 0;
2073
2074         /* Assign an unused number */
2075         if (!idr_pre_get(&lpfc_hba_index, GFP_KERNEL))
2076                 return -1;
2077         if (idr_get_new(&lpfc_hba_index, NULL, &instance))
2078                 return -1;
2079         return instance;
2080 }
2081
2082 /**
2083  * lpfc_scan_finished: method for SCSI layer to detect whether scan is done.
2084  * @shost: pointer to SCSI host data structure.
2085  * @time: elapsed time of the scan in jiffies.
2086  *
2087  * This routine is called by the SCSI layer with a SCSI host to determine
2088  * whether the scan host is finished.
2089  *
2090  * Note: there is no scan_start function as adapter initialization will have
2091  * asynchronously kicked off the link initialization.
2092  *
2093  * Return codes
2094  *   0 - SCSI host scan is not over yet.
2095  *   1 - SCSI host scan is over.
2096  **/
2097 int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
2098 {
2099         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2100         struct lpfc_hba   *phba = vport->phba;
2101         int stat = 0;
2102
2103         spin_lock_irq(shost->host_lock);
2104
2105         if (vport->load_flag & FC_UNLOADING) {
2106                 stat = 1;
2107                 goto finished;
2108         }
2109         if (time >= 30 * HZ) {
2110                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2111                                 "0461 Scanning longer than 30 "
2112                                 "seconds.  Continuing initialization\n");
2113                 stat = 1;
2114                 goto finished;
2115         }
2116         if (time >= 15 * HZ && phba->link_state <= LPFC_LINK_DOWN) {
2117                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2118                                 "0465 Link down longer than 15 "
2119                                 "seconds.  Continuing initialization\n");
2120                 stat = 1;
2121                 goto finished;
2122         }
2123
2124         if (vport->port_state != LPFC_VPORT_READY)
2125                 goto finished;
2126         if (vport->num_disc_nodes || vport->fc_prli_sent)
2127                 goto finished;
2128         if (vport->fc_map_cnt == 0 && time < 2 * HZ)
2129                 goto finished;
2130         if ((phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) != 0)
2131                 goto finished;
2132
2133         stat = 1;
2134
2135 finished:
2136         spin_unlock_irq(shost->host_lock);
2137         return stat;
2138 }
2139
2140 /**
2141  * lpfc_host_attrib_init: Initialize SCSI host attributes on a FC port.
2142  * @shost: pointer to SCSI host data structure.
2143  *
2144  * This routine initializes a given SCSI host attributes on a FC port. The
2145  * SCSI host can be either on top of a physical port or a virtual port.
2146  **/
2147 void lpfc_host_attrib_init(struct Scsi_Host *shost)
2148 {
2149         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2150         struct lpfc_hba   *phba = vport->phba;
2151         /*
2152          * Set fixed host attributes.  Must done after lpfc_sli_hba_setup().
2153          */
2154
2155         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
2156         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
2157         fc_host_supported_classes(shost) = FC_COS_CLASS3;
2158
2159         memset(fc_host_supported_fc4s(shost), 0,
2160                sizeof(fc_host_supported_fc4s(shost)));
2161         fc_host_supported_fc4s(shost)[2] = 1;
2162         fc_host_supported_fc4s(shost)[7] = 1;
2163
2164         lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
2165                                  sizeof fc_host_symbolic_name(shost));
2166
2167         fc_host_supported_speeds(shost) = 0;
2168         if (phba->lmt & LMT_10Gb)
2169                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT;
2170         if (phba->lmt & LMT_8Gb)
2171                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_8GBIT;
2172         if (phba->lmt & LMT_4Gb)
2173                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_4GBIT;
2174         if (phba->lmt & LMT_2Gb)
2175                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_2GBIT;
2176         if (phba->lmt & LMT_1Gb)
2177                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_1GBIT;
2178
2179         fc_host_maxframe_size(shost) =
2180                 (((uint32_t) vport->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
2181                 (uint32_t) vport->fc_sparam.cmn.bbRcvSizeLsb;
2182
2183         /* This value is also unchanging */
2184         memset(fc_host_active_fc4s(shost), 0,
2185                sizeof(fc_host_active_fc4s(shost)));
2186         fc_host_active_fc4s(shost)[2] = 1;
2187         fc_host_active_fc4s(shost)[7] = 1;
2188
2189         fc_host_max_npiv_vports(shost) = phba->max_vpi;
2190         spin_lock_irq(shost->host_lock);
2191         vport->load_flag &= ~FC_LOADING;
2192         spin_unlock_irq(shost->host_lock);
2193 }
2194
2195 /**
2196  * lpfc_enable_msix: Enable MSI-X interrupt mode.
2197  * @phba: pointer to lpfc hba data structure.
2198  *
2199  * This routine is invoked to enable the MSI-X interrupt vectors. The kernel
2200  * function pci_enable_msix() is called to enable the MSI-X vectors. Note that
2201  * pci_enable_msix(), once invoked, enables either all or nothing, depending
2202  * on the current availability of PCI vector resources. The device driver is
2203  * responsible for calling the individual request_irq() to register each MSI-X
2204  * vector with a interrupt handler, which is done in this function. Note that
2205  * later when device is unloading, the driver should always call free_irq()
2206  * on all MSI-X vectors it has done request_irq() on before calling
2207  * pci_disable_msix(). Failure to do so results in a BUG_ON() and a device
2208  * will be left with MSI-X enabled and leaks its vectors.
2209  *
2210  * Return codes
2211  *   0 - sucessful
2212  *   other values - error
2213  **/
2214 static int
2215 lpfc_enable_msix(struct lpfc_hba *phba)
2216 {
2217         int rc, i;
2218         LPFC_MBOXQ_t *pmb;
2219
2220         /* Set up MSI-X multi-message vectors */
2221         for (i = 0; i < LPFC_MSIX_VECTORS; i++)
2222                 phba->msix_entries[i].entry = i;
2223
2224         /* Configure MSI-X capability structure */
2225         rc = pci_enable_msix(phba->pcidev, phba->msix_entries,
2226                                 ARRAY_SIZE(phba->msix_entries));
2227         if (rc) {
2228                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2229                                 "0420 Enable MSI-X failed (%d), continuing "
2230                                 "with MSI\n", rc);
2231                 goto msi_fail_out;
2232         } else
2233                 for (i = 0; i < LPFC_MSIX_VECTORS; i++)
2234                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2235                                         "0477 MSI-X entry[%d]: vector=x%x "
2236                                         "message=%d\n", i,
2237                                         phba->msix_entries[i].vector,
2238                                         phba->msix_entries[i].entry);
2239         /*
2240          * Assign MSI-X vectors to interrupt handlers
2241          */
2242
2243         /* vector-0 is associated to slow-path handler */
2244         rc = request_irq(phba->msix_entries[0].vector, &lpfc_sp_intr_handler,
2245                          IRQF_SHARED, LPFC_SP_DRIVER_HANDLER_NAME, phba);
2246         if (rc) {
2247                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2248                                 "0421 MSI-X slow-path request_irq failed "
2249                                 "(%d), continuing with MSI\n", rc);
2250                 goto msi_fail_out;
2251         }
2252
2253         /* vector-1 is associated to fast-path handler */
2254         rc = request_irq(phba->msix_entries[1].vector, &lpfc_fp_intr_handler,
2255                          IRQF_SHARED, LPFC_FP_DRIVER_HANDLER_NAME, phba);
2256
2257         if (rc) {
2258                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2259                                 "0429 MSI-X fast-path request_irq failed "
2260                                 "(%d), continuing with MSI\n", rc);
2261                 goto irq_fail_out;
2262         }
2263
2264         /*
2265          * Configure HBA MSI-X attention conditions to messages
2266          */
2267         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2268
2269         if (!pmb) {
2270                 rc = -ENOMEM;
2271                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2272                                 "0474 Unable to allocate memory for issuing "
2273                                 "MBOX_CONFIG_MSI command\n");
2274                 goto mem_fail_out;
2275         }
2276         rc = lpfc_config_msi(phba, pmb);
2277         if (rc)
2278                 goto mbx_fail_out;
2279         rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
2280         if (rc != MBX_SUCCESS) {
2281                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
2282                                 "0351 Config MSI mailbox command failed, "
2283                                 "mbxCmd x%x, mbxStatus x%x\n",
2284                                 pmb->mb.mbxCommand, pmb->mb.mbxStatus);
2285                 goto mbx_fail_out;
2286         }
2287
2288         /* Free memory allocated for mailbox command */
2289         mempool_free(pmb, phba->mbox_mem_pool);
2290         return rc;
2291
2292 mbx_fail_out:
2293         /* Free memory allocated for mailbox command */
2294         mempool_free(pmb, phba->mbox_mem_pool);
2295
2296 mem_fail_out:
2297         /* free the irq already requested */
2298         free_irq(phba->msix_entries[1].vector, phba);
2299
2300 irq_fail_out:
2301         /* free the irq already requested */
2302         free_irq(phba->msix_entries[0].vector, phba);
2303
2304 msi_fail_out:
2305         /* Unconfigure MSI-X capability structure */
2306         pci_disable_msix(phba->pcidev);
2307         return rc;
2308 }
2309
2310 /**
2311  * lpfc_disable_msix: Disable MSI-X interrupt mode.
2312  * @phba: pointer to lpfc hba data structure.
2313  *
2314  * This routine is invoked to release the MSI-X vectors and then disable the
2315  * MSI-X interrupt mode.
2316  **/
2317 static void
2318 lpfc_disable_msix(struct lpfc_hba *phba)
2319 {
2320         int i;
2321
2322         /* Free up MSI-X multi-message vectors */
2323         for (i = 0; i < LPFC_MSIX_VECTORS; i++)
2324                 free_irq(phba->msix_entries[i].vector, phba);
2325         /* Disable MSI-X */
2326         pci_disable_msix(phba->pcidev);
2327 }
2328
2329 /**
2330  * lpfc_pci_probe_one: lpfc PCI probe func to register device to PCI subsystem.
2331  * @pdev: pointer to PCI device
2332  * @pid: pointer to PCI device identifier
2333  *
2334  * This routine is to be registered to the kernel's PCI subsystem. When an
2335  * Emulex HBA is presented in PCI bus, the kernel PCI subsystem looks at
2336  * PCI device-specific information of the device and driver to see if the
2337  * driver state that it can support this kind of device. If the match is
2338  * successful, the driver core invokes this routine. If this routine
2339  * determines it can claim the HBA, it does all the initialization that it
2340  * needs to do to handle the HBA properly.
2341  *
2342  * Return code
2343  *   0 - driver can claim the device
2344  *   negative value - driver can not claim the device
2345  **/
2346 static int __devinit
2347 lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
2348 {
2349         struct lpfc_vport *vport = NULL;
2350         struct lpfc_hba   *phba;
2351         struct lpfc_sli   *psli;
2352         struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL;
2353         struct Scsi_Host  *shost = NULL;
2354         void *ptr;
2355         unsigned long bar0map_len, bar2map_len;
2356         int error = -ENODEV, retval;
2357         int  i, hbq_count;
2358         uint16_t iotag;
2359         int bars = pci_select_bars(pdev, IORESOURCE_MEM);
2360         struct lpfc_adapter_event_header adapter_event;
2361
2362         if (pci_enable_device_mem(pdev))
2363                 goto out;
2364         if (pci_request_selected_regions(pdev, bars, LPFC_DRIVER_NAME))
2365                 goto out_disable_device;
2366
2367         phba = kzalloc(sizeof (struct lpfc_hba), GFP_KERNEL);
2368         if (!phba)
2369                 goto out_release_regions;
2370
2371         atomic_set(&phba->fast_event_count, 0);
2372         spin_lock_init(&phba->hbalock);
2373
2374         /* Initialize ndlp management spinlock */
2375         spin_lock_init(&phba->ndlp_lock);
2376
2377         phba->pcidev = pdev;
2378
2379         /* Assign an unused board number */
2380         if ((phba->brd_no = lpfc_get_instance()) < 0)
2381                 goto out_free_phba;
2382
2383         INIT_LIST_HEAD(&phba->port_list);
2384         init_waitqueue_head(&phba->wait_4_mlo_m_q);
2385         /*
2386          * Get all the module params for configuring this host and then
2387          * establish the host.
2388          */
2389         lpfc_get_cfgparam(phba);
2390         phba->max_vpi = LPFC_MAX_VPI;
2391
2392         /* Initialize timers used by driver */
2393         init_timer(&phba->hb_tmofunc);
2394         phba->hb_tmofunc.function = lpfc_hb_timeout;
2395         phba->hb_tmofunc.data = (unsigned long)phba;
2396
2397         psli = &phba->sli;
2398         init_timer(&psli->mbox_tmo);
2399         psli->mbox_tmo.function = lpfc_mbox_timeout;
2400         psli->mbox_tmo.data = (unsigned long) phba;
2401         init_timer(&phba->fcp_poll_timer);
2402         phba->fcp_poll_timer.function = lpfc_poll_timeout;
2403         phba->fcp_poll_timer.data = (unsigned long) phba;
2404         init_timer(&phba->fabric_block_timer);
2405         phba->fabric_block_timer.function = lpfc_fabric_block_timeout;
2406         phba->fabric_block_timer.data = (unsigned long) phba;
2407         init_timer(&phba->eratt_poll);
2408         phba->eratt_poll.function = lpfc_poll_eratt;
2409         phba->eratt_poll.data = (unsigned long) phba;
2410
2411         pci_set_master(pdev);
2412         pci_try_set_mwi(pdev);
2413
2414         if (pci_set_dma_mask(phba->pcidev, DMA_64BIT_MASK) != 0)
2415                 if (pci_set_dma_mask(phba->pcidev, DMA_32BIT_MASK) != 0)
2416                         goto out_idr_remove;
2417
2418         /*
2419          * Get the bus address of Bar0 and Bar2 and the number of bytes
2420          * required by each mapping.
2421          */
2422         phba->pci_bar0_map = pci_resource_start(phba->pcidev, 0);
2423         bar0map_len        = pci_resource_len(phba->pcidev, 0);
2424
2425         phba->pci_bar2_map = pci_resource_start(phba->pcidev, 2);
2426         bar2map_len        = pci_resource_len(phba->pcidev, 2);
2427
2428         /* Map HBA SLIM to a kernel virtual address. */
2429         phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len);
2430         if (!phba->slim_memmap_p) {
2431                 error = -ENODEV;
2432                 dev_printk(KERN_ERR, &pdev->dev,
2433                            "ioremap failed for SLIM memory.\n");
2434                 goto out_idr_remove;
2435         }
2436
2437         /* Map HBA Control Registers to a kernel virtual address. */
2438         phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len);
2439         if (!phba->ctrl_regs_memmap_p) {
2440                 error = -ENODEV;
2441                 dev_printk(KERN_ERR, &pdev->dev,
2442                            "ioremap failed for HBA control registers.\n");
2443                 goto out_iounmap_slim;
2444         }
2445
2446         /* Allocate memory for SLI-2 structures */
2447         phba->slim2p.virt = dma_alloc_coherent(&phba->pcidev->dev,
2448                                                SLI2_SLIM_SIZE,
2449                                                &phba->slim2p.phys,
2450                                                GFP_KERNEL);
2451         if (!phba->slim2p.virt)
2452                 goto out_iounmap;
2453
2454         memset(phba->slim2p.virt, 0, SLI2_SLIM_SIZE);
2455         phba->mbox = phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, mbx);
2456         phba->pcb = (phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, pcb));
2457         phba->IOCBs = (phba->slim2p.virt +
2458                        offsetof(struct lpfc_sli2_slim, IOCBs));
2459
2460         phba->hbqslimp.virt = dma_alloc_coherent(&phba->pcidev->dev,
2461                                                  lpfc_sli_hbq_size(),
2462                                                  &phba->hbqslimp.phys,
2463                                                  GFP_KERNEL);
2464         if (!phba->hbqslimp.virt)
2465                 goto out_free_slim;
2466
2467         hbq_count = lpfc_sli_hbq_count();
2468         ptr = phba->hbqslimp.virt;
2469         for (i = 0; i < hbq_count; ++i) {
2470                 phba->hbqs[i].hbq_virt = ptr;
2471                 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list);
2472                 ptr += (lpfc_hbq_defs[i]->entry_count *
2473                         sizeof(struct lpfc_hbq_entry));
2474         }
2475         phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc;
2476         phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer  = lpfc_els_hbq_free;
2477
2478         memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size());
2479
2480         INIT_LIST_HEAD(&phba->hbqbuf_in_list);
2481
2482         /* Initialize the SLI Layer to run with lpfc HBAs. */
2483         lpfc_sli_setup(phba);
2484         lpfc_sli_queue_setup(phba);
2485
2486         retval = lpfc_mem_alloc(phba);
2487         if (retval) {
2488                 error = retval;
2489                 goto out_free_hbqslimp;
2490         }
2491
2492         /* Initialize and populate the iocb list per host.  */
2493         INIT_LIST_HEAD(&phba->lpfc_iocb_list);
2494         for (i = 0; i < LPFC_IOCB_LIST_CNT; i++) {
2495                 iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL);
2496                 if (iocbq_entry == NULL) {
2497                         printk(KERN_ERR "%s: only allocated %d iocbs of "
2498                                 "expected %d count. Unloading driver.\n",
2499                                 __func__, i, LPFC_IOCB_LIST_CNT);
2500                         error = -ENOMEM;
2501                         goto out_free_iocbq;
2502                 }
2503
2504                 iotag = lpfc_sli_next_iotag(phba, iocbq_entry);
2505                 if (iotag == 0) {
2506                         kfree (iocbq_entry);
2507                         printk(KERN_ERR "%s: failed to allocate IOTAG. "
2508                                "Unloading driver.\n",
2509                                 __func__);
2510                         error = -ENOMEM;
2511                         goto out_free_iocbq;
2512                 }
2513
2514                 spin_lock_irq(&phba->hbalock);
2515                 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list);
2516                 phba->total_iocbq_bufs++;
2517                 spin_unlock_irq(&phba->hbalock);
2518         }
2519
2520         /* Initialize HBA structure */
2521         phba->fc_edtov = FF_DEF_EDTOV;
2522         phba->fc_ratov = FF_DEF_RATOV;
2523         phba->fc_altov = FF_DEF_ALTOV;
2524         phba->fc_arbtov = FF_DEF_ARBTOV;
2525
2526         INIT_LIST_HEAD(&phba->work_list);
2527         phba->work_ha_mask = (HA_ERATT | HA_MBATT | HA_LATT);
2528         phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4));
2529
2530         /* Initialize the wait queue head for the kernel thread */
2531         init_waitqueue_head(&phba->work_waitq);
2532
2533         /* Startup the kernel thread for this host adapter. */
2534         phba->worker_thread = kthread_run(lpfc_do_work, phba,
2535                                        "lpfc_worker_%d", phba->brd_no);
2536         if (IS_ERR(phba->worker_thread)) {
2537                 error = PTR_ERR(phba->worker_thread);
2538                 goto out_free_iocbq;
2539         }
2540
2541         /* Initialize the list of scsi buffers used by driver for scsi IO. */
2542         spin_lock_init(&phba->scsi_buf_list_lock);
2543         INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list);
2544
2545         /* Initialize list of fabric iocbs */
2546         INIT_LIST_HEAD(&phba->fabric_iocb_list);
2547
2548         /* Initialize list to save ELS buffers */
2549         INIT_LIST_HEAD(&phba->elsbuf);
2550
2551         vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev);
2552         if (!vport)
2553                 goto out_kthread_stop;
2554
2555         shost = lpfc_shost_from_vport(vport);
2556         phba->pport = vport;
2557         lpfc_debugfs_initialize(vport);
2558
2559         pci_set_drvdata(pdev, shost);
2560         phba->intr_type = NONE;
2561
2562         phba->MBslimaddr = phba->slim_memmap_p;
2563         phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
2564         phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
2565         phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
2566         phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
2567
2568         /* Configure and enable interrupt */
2569         if (phba->cfg_use_msi == 2) {
2570                 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
2571                 error = lpfc_sli_config_port(phba, 3);
2572                 if (error)
2573                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2574                                 "0427 Firmware not capable of SLI 3 mode.\n");
2575                 else {
2576                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2577                                 "0426 Firmware capable of SLI 3 mode.\n");
2578                         /* Now, try to enable MSI-X interrupt mode */
2579                         error = lpfc_enable_msix(phba);
2580                         if (!error) {
2581                                 phba->intr_type = MSIX;
2582                                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2583                                                 "0430 enable MSI-X mode.\n");
2584                         }
2585                 }
2586         }
2587
2588         /* Fallback to MSI if MSI-X initialization failed */
2589         if (phba->cfg_use_msi >= 1 && phba->intr_type == NONE) {
2590                 retval = pci_enable_msi(phba->pcidev);
2591                 if (!retval) {
2592                         phba->intr_type = MSI;
2593                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2594                                         "0473 enable MSI mode.\n");
2595                 } else
2596                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2597                                         "0452 enable IRQ mode.\n");
2598         }
2599
2600         /* MSI-X is the only case the doesn't need to call request_irq */
2601         if (phba->intr_type != MSIX) {
2602                 retval = request_irq(phba->pcidev->irq, lpfc_intr_handler,
2603                                      IRQF_SHARED, LPFC_DRIVER_NAME, phba);
2604                 if (retval) {
2605                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT, "0451 Enable "
2606                                         "interrupt handler failed\n");
2607                         error = retval;
2608                         goto out_disable_msi;
2609                 } else if (phba->intr_type != MSI)
2610                         phba->intr_type = INTx;
2611         }
2612
2613         if (lpfc_alloc_sysfs_attr(vport)) {
2614                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2615                                 "1476 Failed to allocate sysfs attr\n");
2616                 error = -ENOMEM;
2617                 goto out_free_irq;
2618         }
2619
2620         if (lpfc_sli_hba_setup(phba)) {
2621                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2622                                 "1477 Failed to set up hba\n");
2623                 error = -ENODEV;
2624                 goto out_remove_device;
2625         }
2626
2627         /*
2628          * hba setup may have changed the hba_queue_depth so we need to adjust
2629          * the value of can_queue.
2630          */
2631         shost->can_queue = phba->cfg_hba_queue_depth - 10;
2632
2633         lpfc_host_attrib_init(shost);
2634
2635         if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
2636                 spin_lock_irq(shost->host_lock);
2637                 lpfc_poll_start_timer(phba);
2638                 spin_unlock_irq(shost->host_lock);
2639         }
2640
2641         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2642                         "0428 Perform SCSI scan\n");
2643         /* Send board arrival event to upper layer */
2644         adapter_event.event_type = FC_REG_ADAPTER_EVENT;
2645         adapter_event.subcategory = LPFC_EVENT_ARRIVAL;
2646         fc_host_post_vendor_event(shost, fc_get_event_number(),
2647                 sizeof(adapter_event),
2648                 (char *) &adapter_event,
2649                 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
2650
2651         scsi_scan_host(shost);
2652
2653         return 0;
2654
2655 out_remove_device:
2656         lpfc_free_sysfs_attr(vport);
2657         spin_lock_irq(shost->host_lock);
2658         vport->load_flag |= FC_UNLOADING;
2659         spin_unlock_irq(shost->host_lock);
2660 out_free_irq:
2661         lpfc_stop_phba_timers(phba);
2662         phba->pport->work_port_events = 0;
2663
2664         if (phba->intr_type == MSIX)
2665                 lpfc_disable_msix(phba);
2666         else
2667                 free_irq(phba->pcidev->irq, phba);
2668
2669 out_disable_msi:
2670         if (phba->intr_type == MSI)
2671                 pci_disable_msi(phba->pcidev);
2672         destroy_port(vport);
2673 out_kthread_stop:
2674         kthread_stop(phba->worker_thread);
2675 out_free_iocbq:
2676         list_for_each_entry_safe(iocbq_entry, iocbq_next,
2677                                                 &phba->lpfc_iocb_list, list) {
2678                 kfree(iocbq_entry);
2679                 phba->total_iocbq_bufs--;
2680         }
2681         lpfc_mem_free(phba);
2682 out_free_hbqslimp:
2683         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
2684                           phba->hbqslimp.virt, phba->hbqslimp.phys);
2685 out_free_slim:
2686         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
2687                           phba->slim2p.virt, phba->slim2p.phys);
2688 out_iounmap:
2689         iounmap(phba->ctrl_regs_memmap_p);
2690 out_iounmap_slim:
2691         iounmap(phba->slim_memmap_p);
2692 out_idr_remove:
2693         idr_remove(&lpfc_hba_index, phba->brd_no);
2694 out_free_phba:
2695         kfree(phba);
2696 out_release_regions:
2697         pci_release_selected_regions(pdev, bars);
2698 out_disable_device:
2699         pci_disable_device(pdev);
2700 out:
2701         pci_set_drvdata(pdev, NULL);
2702         if (shost)
2703                 scsi_host_put(shost);
2704         return error;
2705 }
2706
2707 /**
2708  * lpfc_pci_remove_one: lpfc PCI func to unregister device from PCI subsystem.
2709  * @pdev: pointer to PCI device
2710  *
2711  * This routine is to be registered to the kernel's PCI subsystem. When an
2712  * Emulex HBA is removed from PCI bus. It perform all the necessary cleanup
2713  * for the HBA device to be removed from the PCI subsystem properly.
2714  **/
2715 static void __devexit
2716 lpfc_pci_remove_one(struct pci_dev *pdev)
2717 {
2718         struct Scsi_Host  *shost = pci_get_drvdata(pdev);
2719         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2720         struct lpfc_hba   *phba = vport->phba;
2721         int bars = pci_select_bars(pdev, IORESOURCE_MEM);
2722
2723         spin_lock_irq(&phba->hbalock);
2724         vport->load_flag |= FC_UNLOADING;
2725         spin_unlock_irq(&phba->hbalock);
2726
2727         kfree(vport->vname);
2728         lpfc_free_sysfs_attr(vport);
2729
2730         kthread_stop(phba->worker_thread);
2731
2732         fc_remove_host(shost);
2733         scsi_remove_host(shost);
2734         lpfc_cleanup(vport);
2735
2736         /*
2737          * Bring down the SLI Layer. This step disable all interrupts,
2738          * clears the rings, discards all mailbox commands, and resets
2739          * the HBA.
2740          */
2741         lpfc_sli_hba_down(phba);
2742         lpfc_sli_brdrestart(phba);
2743
2744         lpfc_stop_phba_timers(phba);
2745         spin_lock_irq(&phba->hbalock);
2746         list_del_init(&vport->listentry);
2747         spin_unlock_irq(&phba->hbalock);
2748
2749         lpfc_debugfs_terminate(vport);
2750
2751         if (phba->intr_type == MSIX)
2752                 lpfc_disable_msix(phba);
2753         else {
2754                 free_irq(phba->pcidev->irq, phba);
2755                 if (phba->intr_type == MSI)
2756                         pci_disable_msi(phba->pcidev);
2757         }
2758
2759         pci_set_drvdata(pdev, NULL);
2760         scsi_host_put(shost);
2761
2762         /*
2763          * Call scsi_free before mem_free since scsi bufs are released to their
2764          * corresponding pools here.
2765          */
2766         lpfc_scsi_free(phba);
2767         lpfc_mem_free(phba);
2768
2769         dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(),
2770                           phba->hbqslimp.virt, phba->hbqslimp.phys);
2771
2772         /* Free resources associated with SLI2 interface */
2773         dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE,
2774                           phba->slim2p.virt, phba->slim2p.phys);
2775
2776         /* unmap adapter SLIM and Control Registers */
2777         iounmap(phba->ctrl_regs_memmap_p);
2778         iounmap(phba->slim_memmap_p);
2779
2780         idr_remove(&lpfc_hba_index, phba->brd_no);
2781
2782         kfree(phba);
2783
2784         pci_release_selected_regions(pdev, bars);
2785         pci_disable_device(pdev);
2786 }
2787
2788 /**
2789  * lpfc_io_error_detected: Driver method for handling PCI I/O error detected.
2790  * @pdev: pointer to PCI device.
2791  * @state: the current PCI connection state.
2792  *
2793  * This routine is registered to the PCI subsystem for error handling. This
2794  * function is called by the PCI subsystem after a PCI bus error affecting
2795  * this device has been detected. When this function is invoked, it will
2796  * need to stop all the I/Os and interrupt(s) to the device. Once that is
2797  * done, it will return PCI_ERS_RESULT_NEED_RESET for the PCI subsystem to
2798  * perform proper recovery as desired.
2799  *
2800  * Return codes
2801  *   PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
2802  *   PCI_ERS_RESULT_DISCONNECT - device could not be recovered
2803  **/
2804 static pci_ers_result_t lpfc_io_error_detected(struct pci_dev *pdev,
2805                                 pci_channel_state_t state)
2806 {
2807         struct Scsi_Host *shost = pci_get_drvdata(pdev);
2808         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2809         struct lpfc_sli *psli = &phba->sli;
2810         struct lpfc_sli_ring  *pring;
2811
2812         if (state == pci_channel_io_perm_failure) {
2813                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2814                                 "0472 PCI channel I/O permanent failure\n");
2815                 /* Block all SCSI devices' I/Os on the host */
2816                 lpfc_scsi_dev_block(phba);
2817                 /* Clean up all driver's outstanding SCSI I/Os */
2818                 lpfc_sli_flush_fcp_rings(phba);
2819                 return PCI_ERS_RESULT_DISCONNECT;
2820         }
2821
2822         pci_disable_device(pdev);
2823         /*
2824          * There may be I/Os dropped by the firmware.
2825          * Error iocb (I/O) on txcmplq and let the SCSI layer
2826          * retry it after re-establishing link.
2827          */
2828         pring = &psli->ring[psli->fcp_ring];
2829         lpfc_sli_abort_iocb_ring(phba, pring);
2830
2831         if (phba->intr_type == MSIX)
2832                 lpfc_disable_msix(phba);
2833         else {
2834                 free_irq(phba->pcidev->irq, phba);
2835                 if (phba->intr_type == MSI)
2836                         pci_disable_msi(phba->pcidev);
2837         }
2838
2839         /* Request a slot reset. */
2840         return PCI_ERS_RESULT_NEED_RESET;
2841 }
2842
2843 /**
2844  * lpfc_io_slot_reset: Restart a PCI device from scratch.
2845  * @pdev: pointer to PCI device.
2846  *
2847  * This routine is registered to the PCI subsystem for error handling. This is
2848  * called after PCI bus has been reset to restart the PCI card from scratch,
2849  * as if from a cold-boot. During the PCI subsystem error recovery, after the
2850  * driver returns PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform
2851  * proper error recovery and then call this routine before calling the .resume
2852  * method to recover the device. This function will initialize the HBA device,
2853  * enable the interrupt, but it will just put the HBA to offline state without
2854  * passing any I/O traffic.
2855  *
2856  * Return codes
2857  *   PCI_ERS_RESULT_RECOVERED - the device has been recovered
2858  *   PCI_ERS_RESULT_DISCONNECT - device could not be recovered
2859  */
2860 static pci_ers_result_t lpfc_io_slot_reset(struct pci_dev *pdev)
2861 {
2862         struct Scsi_Host *shost = pci_get_drvdata(pdev);
2863         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2864         struct lpfc_sli *psli = &phba->sli;
2865         int error, retval;
2866
2867         dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
2868         if (pci_enable_device_mem(pdev)) {
2869                 printk(KERN_ERR "lpfc: Cannot re-enable "
2870                         "PCI device after reset.\n");
2871                 return PCI_ERS_RESULT_DISCONNECT;
2872         }
2873
2874         pci_set_master(pdev);
2875
2876         spin_lock_irq(&phba->hbalock);
2877         psli->sli_flag &= ~LPFC_SLI2_ACTIVE;
2878         spin_unlock_irq(&phba->hbalock);
2879
2880         /* Enable configured interrupt method */
2881         phba->intr_type = NONE;
2882         if (phba->cfg_use_msi == 2) {
2883                 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
2884                 error = lpfc_sli_config_port(phba, 3);
2885                 if (error)
2886                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2887                                 "0478 Firmware not capable of SLI 3 mode.\n");
2888                 else {
2889                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2890                                 "0479 Firmware capable of SLI 3 mode.\n");
2891                         /* Now, try to enable MSI-X interrupt mode */
2892                         error = lpfc_enable_msix(phba);
2893                         if (!error) {
2894                                 phba->intr_type = MSIX;
2895                                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2896                                                 "0480 enable MSI-X mode.\n");
2897                         }
2898                 }
2899         }
2900
2901         /* Fallback to MSI if MSI-X initialization failed */
2902         if (phba->cfg_use_msi >= 1 && phba->intr_type == NONE) {
2903                 retval = pci_enable_msi(phba->pcidev);
2904                 if (!retval) {
2905                         phba->intr_type = MSI;
2906                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2907                                         "0481 enable MSI mode.\n");
2908                 } else
2909                         lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2910                                         "0470 enable IRQ mode.\n");
2911         }
2912
2913         /* MSI-X is the only case the doesn't need to call request_irq */
2914         if (phba->intr_type != MSIX) {
2915                 retval = request_irq(phba->pcidev->irq, lpfc_intr_handler,
2916                                      IRQF_SHARED, LPFC_DRIVER_NAME, phba);
2917                 if (retval) {
2918                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2919                                         "0471 Enable interrupt handler "
2920                                         "failed\n");
2921                 } else if (phba->intr_type != MSI)
2922                         phba->intr_type = INTx;
2923         }
2924
2925         /* Take device offline; this will perform cleanup */
2926         lpfc_offline(phba);
2927         lpfc_sli_brdrestart(phba);
2928
2929         return PCI_ERS_RESULT_RECOVERED;
2930 }
2931
2932 /**
2933  * lpfc_io_resume: Resume PCI I/O operation.
2934  * @pdev: pointer to PCI device
2935  *
2936  * This routine is registered to the PCI subsystem for error handling. It is
2937  * called when kernel error recovery tells the lpfc driver that it is ok to
2938  * resume normal PCI operation after PCI bus error recovery. After this call,
2939  * traffic can start to flow from this device again.
2940  */
2941 static void lpfc_io_resume(struct pci_dev *pdev)
2942 {
2943         struct Scsi_Host *shost = pci_get_drvdata(pdev);
2944         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2945
2946         lpfc_online(phba);
2947 }
2948
2949 static struct pci_device_id lpfc_id_table[] = {
2950         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_VIPER,
2951                 PCI_ANY_ID, PCI_ANY_ID, },
2952         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_FIREFLY,
2953                 PCI_ANY_ID, PCI_ANY_ID, },
2954         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_THOR,
2955                 PCI_ANY_ID, PCI_ANY_ID, },
2956         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PEGASUS,
2957                 PCI_ANY_ID, PCI_ANY_ID, },
2958         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_CENTAUR,
2959                 PCI_ANY_ID, PCI_ANY_ID, },
2960         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_DRAGONFLY,
2961                 PCI_ANY_ID, PCI_ANY_ID, },
2962         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SUPERFLY,
2963                 PCI_ANY_ID, PCI_ANY_ID, },
2964         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_RFLY,
2965                 PCI_ANY_ID, PCI_ANY_ID, },
2966         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PFLY,
2967                 PCI_ANY_ID, PCI_ANY_ID, },
2968         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE,
2969                 PCI_ANY_ID, PCI_ANY_ID, },
2970         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_SCSP,
2971                 PCI_ANY_ID, PCI_ANY_ID, },
2972         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_DCSP,
2973                 PCI_ANY_ID, PCI_ANY_ID, },
2974         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS,
2975                 PCI_ANY_ID, PCI_ANY_ID, },
2976         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_SCSP,
2977                 PCI_ANY_ID, PCI_ANY_ID, },
2978         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_DCSP,
2979                 PCI_ANY_ID, PCI_ANY_ID, },
2980         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BMID,
2981                 PCI_ANY_ID, PCI_ANY_ID, },
2982         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BSMB,
2983                 PCI_ANY_ID, PCI_ANY_ID, },
2984         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR,
2985                 PCI_ANY_ID, PCI_ANY_ID, },
2986         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HORNET,
2987                 PCI_ANY_ID, PCI_ANY_ID, },
2988         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_SCSP,
2989                 PCI_ANY_ID, PCI_ANY_ID, },
2990         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_DCSP,
2991                 PCI_ANY_ID, PCI_ANY_ID, },
2992         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZMID,
2993                 PCI_ANY_ID, PCI_ANY_ID, },
2994         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZSMB,
2995                 PCI_ANY_ID, PCI_ANY_ID, },
2996         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_TFLY,
2997                 PCI_ANY_ID, PCI_ANY_ID, },
2998         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP101,
2999                 PCI_ANY_ID, PCI_ANY_ID, },
3000         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP10000S,
3001                 PCI_ANY_ID, PCI_ANY_ID, },
3002         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP11000S,
3003                 PCI_ANY_ID, PCI_ANY_ID, },
3004         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LPE11000S,
3005                 PCI_ANY_ID, PCI_ANY_ID, },
3006         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT,
3007                 PCI_ANY_ID, PCI_ANY_ID, },
3008         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_MID,
3009                 PCI_ANY_ID, PCI_ANY_ID, },
3010         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SMB,
3011                 PCI_ANY_ID, PCI_ANY_ID, },
3012         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_DCSP,
3013                 PCI_ANY_ID, PCI_ANY_ID, },
3014         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SCSP,
3015                 PCI_ANY_ID, PCI_ANY_ID, },
3016         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_S,
3017                 PCI_ANY_ID, PCI_ANY_ID, },
3018         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_VF,
3019                 PCI_ANY_ID, PCI_ANY_ID, },
3020         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_PF,
3021                 PCI_ANY_ID, PCI_ANY_ID, },
3022         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_S,
3023                 PCI_ANY_ID, PCI_ANY_ID, },
3024         { 0 }
3025 };
3026
3027 MODULE_DEVICE_TABLE(pci, lpfc_id_table);
3028
3029 static struct pci_error_handlers lpfc_err_handler = {
3030         .error_detected = lpfc_io_error_detected,
3031         .slot_reset = lpfc_io_slot_reset,
3032         .resume = lpfc_io_resume,
3033 };
3034
3035 static struct pci_driver lpfc_driver = {
3036         .name           = LPFC_DRIVER_NAME,
3037         .id_table       = lpfc_id_table,
3038         .probe          = lpfc_pci_probe_one,
3039         .remove         = __devexit_p(lpfc_pci_remove_one),
3040         .err_handler    = &lpfc_err_handler,
3041 };
3042
3043 /**
3044  * lpfc_init: lpfc module initialization routine.
3045  *
3046  * This routine is to be invoked when the lpfc module is loaded into the
3047  * kernel. The special kernel macro module_init() is used to indicate the
3048  * role of this routine to the kernel as lpfc module entry point.
3049  *
3050  * Return codes
3051  *   0 - successful
3052  *   -ENOMEM - FC attach transport failed
3053  *   all others - failed
3054  */
3055 static int __init
3056 lpfc_init(void)
3057 {
3058         int error = 0;
3059
3060         printk(LPFC_MODULE_DESC "\n");
3061         printk(LPFC_COPYRIGHT "\n");
3062
3063         if (lpfc_enable_npiv) {
3064                 lpfc_transport_functions.vport_create = lpfc_vport_create;
3065                 lpfc_transport_functions.vport_delete = lpfc_vport_delete;
3066         }
3067         lpfc_transport_template =
3068                                 fc_attach_transport(&lpfc_transport_functions);
3069         if (lpfc_transport_template == NULL)
3070                 return -ENOMEM;
3071         if (lpfc_enable_npiv) {
3072                 lpfc_vport_transport_template =
3073                         fc_attach_transport(&lpfc_vport_transport_functions);
3074                 if (lpfc_vport_transport_template == NULL) {
3075                         fc_release_transport(lpfc_transport_template);
3076                         return -ENOMEM;
3077                 }
3078         }
3079         error = pci_register_driver(&lpfc_driver);
3080         if (error) {
3081                 fc_release_transport(lpfc_transport_template);
3082                 if (lpfc_enable_npiv)
3083                         fc_release_transport(lpfc_vport_transport_template);
3084         }
3085
3086         return error;
3087 }
3088
3089 /**
3090  * lpfc_exit: lpfc module removal routine.
3091  *
3092  * This routine is invoked when the lpfc module is removed from the kernel.
3093  * The special kernel macro module_exit() is used to indicate the role of
3094  * this routine to the kernel as lpfc module exit point.
3095  */
3096 static void __exit
3097 lpfc_exit(void)
3098 {
3099         pci_unregister_driver(&lpfc_driver);
3100         fc_release_transport(lpfc_transport_template);
3101         if (lpfc_enable_npiv)
3102                 fc_release_transport(lpfc_vport_transport_template);
3103 }
3104
3105 module_init(lpfc_init);
3106 module_exit(lpfc_exit);
3107 MODULE_LICENSE("GPL");
3108 MODULE_DESCRIPTION(LPFC_MODULE_DESC);
3109 MODULE_AUTHOR("Emulex Corporation - tech.support@emulex.com");
3110 MODULE_VERSION("0:" LPFC_DRIVER_VERSION);