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