drivers/scsi/lpfc/lpfc_init.c

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