Quelle  qla_mbx.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * QLogic Fibre Channel HBA Driver
 * Copyright (c)  2003-2014 QLogic Corporation
 */
#include "qla_def.h"
#include "qla_target.h"

#include <linux/delay.h>
#include <linux/gfp.h>

#ifdef CONFIG_PPC
#define IS_PPCARCH      true
#else
#define IS_PPCARCH      false
#endif

static struct mb_cmd_name {
 uint16_t cmd;
 const char *str;
} mb_str[] = {
 {MBC_GET_PORT_DATABASE,  "GPDB"},
 {MBC_GET_ID_LIST,  "GIDList"},
 {MBC_GET_LINK_PRIV_STATS, "Stats"},
 {MBC_GET_RESOURCE_COUNTS, "ResCnt"},
};

static const char *mb_to_str(uint16_t cmd)
{
 int i;
 struct mb_cmd_name *e;

 for (i = 0; i < ARRAY_SIZE(mb_str); i++) {
  e = mb_str + i;
  if (cmd == e->cmd)
   return e->str;
 }
 return "unknown";
}

static struct rom_cmd {
 uint16_t cmd;
} rom_cmds[] = {
 { MBC_LOAD_RAM },
 { MBC_EXECUTE_FIRMWARE },
 { MBC_READ_RAM_WORD },
 { MBC_MAILBOX_REGISTER_TEST },
 { MBC_VERIFY_CHECKSUM },
 { MBC_GET_FIRMWARE_VERSION },
 { MBC_LOAD_RISC_RAM },
 { MBC_DUMP_RISC_RAM },
 { MBC_LOAD_RISC_RAM_EXTENDED },
 { MBC_DUMP_RISC_RAM_EXTENDED },
 { MBC_WRITE_RAM_WORD_EXTENDED },
 { MBC_READ_RAM_EXTENDED },
 { MBC_GET_RESOURCE_COUNTS },
 { MBC_SET_FIRMWARE_OPTION },
 { MBC_MID_INITIALIZE_FIRMWARE },
 { MBC_GET_FIRMWARE_STATE },
 { MBC_GET_MEM_OFFLOAD_CNTRL_STAT },
 { MBC_GET_RETRY_COUNT },
 { MBC_TRACE_CONTROL },
 { MBC_INITIALIZE_MULTIQ },
 { MBC_IOCB_COMMAND_A64 },
 { MBC_GET_ADAPTER_LOOP_ID },
 { MBC_READ_SFP },
 { MBC_SET_RNID_PARAMS },
 { MBC_GET_RNID_PARAMS },
 { MBC_GET_SET_ZIO_THRESHOLD },
};

static int is_rom_cmd(uint16_t cmd)
{
 int i;
 struct  rom_cmd *wc;

 for (i = 0; i < ARRAY_SIZE(rom_cmds); i++) {
  wc = rom_cmds + i;
  if (wc->cmd == cmd)
   return 1;
 }

 return 0;
}

/*
 * qla2x00_mailbox_command
 * Issue mailbox command and waits for completion.
 *
 * Input:
 * ha = adapter block pointer.
 * mcp = driver internal mbx struct pointer.
 *
 * Output:
 * mb[MAX_MAILBOX_REGISTER_COUNT] = returned mailbox data.
 *
 * Returns:
 * 0 : QLA_SUCCESS = cmd performed success
 * 1 : QLA_FUNCTION_FAILED   (error encountered)
 * 6 : QLA_FUNCTION_TIMEOUT (timeout condition encountered)
 *
 * Context:
 * Kernel context.
 */
static int
qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
{
 int  rval, i;
 unsigned long    flags = 0;
 device_reg_t *reg;
 uint8_t  abort_active, eeh_delay;
 uint8_t  io_lock_on;
 uint16_t command = 0;
 uint16_t *iptr;
 __le16 __iomem  *optr;
 uint32_t cnt;
 uint32_t mboxes;
 unsigned long wait_time;
 struct qla_hw_data *ha = vha->hw;
 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
 u32 chip_reset;


 ql_dbg(ql_dbg_mbx, vha, 0x1000, "Entered %s.\n", __func__);

 if (ha->pdev->error_state == pci_channel_io_perm_failure) {
  ql_log(ql_log_warn, vha, 0x1001,
      "PCI channel failed permanently, exiting.\n");
  return QLA_FUNCTION_TIMEOUT;
 }

 if (vha->device_flags & DFLG_DEV_FAILED) {
  ql_log(ql_log_warn, vha, 0x1002,
      "Device in failed state, exiting.\n");
  return QLA_FUNCTION_TIMEOUT;
 }

 /* if PCI error, then avoid mbx processing.*/
 if (test_bit(PFLG_DISCONNECTED, &base_vha->dpc_flags) &&
     test_bit(UNLOADING, &base_vha->dpc_flags)) {
  ql_log(ql_log_warn, vha, 0xd04e,
      "PCI error, exiting.\n");
  return QLA_FUNCTION_TIMEOUT;
 }
 eeh_delay = 0;
 reg = ha->iobase;
 io_lock_on = base_vha->flags.init_done;

 rval = QLA_SUCCESS;
 abort_active = test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
 chip_reset = ha->chip_reset;

 if (ha->flags.pci_channel_io_perm_failure) {
  ql_log(ql_log_warn, vha, 0x1003,
      "Perm failure on EEH timeout MBX, exiting.\n");
  return QLA_FUNCTION_TIMEOUT;
 }

 if (IS_P3P_TYPE(ha) && ha->flags.isp82xx_fw_hung) {
  /* Setting Link-Down error */
  mcp->mb[0] = MBS_LINK_DOWN_ERROR;
  ql_log(ql_log_warn, vha, 0x1004,
      "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
  return QLA_FUNCTION_TIMEOUT;
 }

 /* check if ISP abort is active and return cmd with timeout */
 if (((test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) ||
       test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) ||
       test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) &&
       !is_rom_cmd(mcp->mb[0])) || ha->flags.eeh_busy) {
  ql_log(ql_log_info, vha, 0x1005,
      "Cmd 0x%x aborted with timeout since ISP Abort is pending\n",
      mcp->mb[0]);
  return QLA_FUNCTION_TIMEOUT;
 }

 atomic_inc(&ha->num_pend_mbx_stage1);
 /*
 * Wait for active mailbox commands to finish by waiting at most tov
 * seconds. This is to serialize actual issuing of mailbox cmds during
 * non ISP abort time.
 */
 if (!wait_for_completion_timeout(&ha->mbx_cmd_comp, mcp->tov * HZ)) {
  /* Timeout occurred. Return error. */
  ql_log(ql_log_warn, vha, 0xd035,
      "Cmd access timeout, cmd=0x%x, Exiting.\n",
      mcp->mb[0]);
  vha->hw_err_cnt++;
  atomic_dec(&ha->num_pend_mbx_stage1);
  return QLA_FUNCTION_TIMEOUT;
 }
 atomic_dec(&ha->num_pend_mbx_stage1);
 if (ha->flags.purge_mbox || chip_reset != ha->chip_reset ||
     ha->flags.eeh_busy) {
  ql_log(ql_log_warn, vha, 0xd035,
         "Purge mbox: purge[%d] eeh[%d] cmd=0x%x, Exiting.\n",
         ha->flags.purge_mbox, ha->flags.eeh_busy, mcp->mb[0]);
  rval = QLA_ABORTED;
  goto premature_exit;
 }


 /* Save mailbox command for debug */
 ha->mcp = mcp;

 ql_dbg(ql_dbg_mbx, vha, 0x1006,
     "Prepare to issue mbox cmd=0x%x.\n", mcp->mb[0]);

 spin_lock_irqsave(&ha->hardware_lock, flags);

 if (ha->flags.purge_mbox || chip_reset != ha->chip_reset ||
     ha->flags.mbox_busy) {
  rval = QLA_ABORTED;
  spin_unlock_irqrestore(&ha->hardware_lock, flags);
  goto premature_exit;
 }
 ha->flags.mbox_busy = 1;

 /* Load mailbox registers. */
 if (IS_P3P_TYPE(ha))
  optr = ®->isp82.mailbox_in[0];
 else if (IS_FWI2_CAPABLE(ha) && !(IS_P3P_TYPE(ha)))
  optr = ®->isp24.mailbox0;
 else
  optr = MAILBOX_REG(ha, ®->isp, 0);

 iptr = mcp->mb;
 command = mcp->mb[0];
 mboxes = mcp->out_mb;

 ql_dbg(ql_dbg_mbx, vha, 0x1111,
     "Mailbox registers (OUT):\n");
 for (cnt = 0; cnt < ha->mbx_count; cnt++) {
  if (IS_QLA2200(ha) && cnt == 8)
   optr = MAILBOX_REG(ha, ®->isp, 8);
  if (mboxes & BIT_0) {
   ql_dbg(ql_dbg_mbx, vha, 0x1112,
       "mbox[%d]<-0x%04x\n", cnt, *iptr);
   wrt_reg_word(optr, *iptr);
  } else {
   wrt_reg_word(optr, 0);
  }

  mboxes >>= 1;
  optr++;
  iptr++;
 }

 ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1117,
     "I/O Address = %p.\n", optr);

 /* Issue set host interrupt command to send cmd out. */
 ha->flags.mbox_int = 0;
 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);

 /* Unlock mbx registers and wait for interrupt */
 ql_dbg(ql_dbg_mbx, vha, 0x100f,
     "Going to unlock irq & waiting for interrupts. "
     "jiffies=%lx.\n", jiffies);

 /* Wait for mbx cmd completion until timeout */
 atomic_inc(&ha->num_pend_mbx_stage2);
 if ((!abort_active && io_lock_on) || IS_NOPOLLING_TYPE(ha)) {
  set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);

  if (IS_P3P_TYPE(ha))
   wrt_reg_dword(®->isp82.hint, HINT_MBX_INT_PENDING);
  else if (IS_FWI2_CAPABLE(ha))
   wrt_reg_dword(®->isp24.hccr, HCCRX_SET_HOST_INT);
  else
   wrt_reg_word(®->isp.hccr, HCCR_SET_HOST_INT);
  spin_unlock_irqrestore(&ha->hardware_lock, flags);

  wait_time = jiffies;
  if (!wait_for_completion_timeout(&ha->mbx_intr_comp,
      mcp->tov * HZ)) {
   ql_dbg(ql_dbg_mbx, vha, 0x117a,
       "cmd=%x Timeout.\n", command);
   spin_lock_irqsave(&ha->hardware_lock, flags);
   clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
   spin_unlock_irqrestore(&ha->hardware_lock, flags);

   if (chip_reset != ha->chip_reset) {
    eeh_delay = ha->flags.eeh_busy ? 1 : 0;

    spin_lock_irqsave(&ha->hardware_lock, flags);
    ha->flags.mbox_busy = 0;
    spin_unlock_irqrestore(&ha->hardware_lock,
        flags);
    atomic_dec(&ha->num_pend_mbx_stage2);
    rval = QLA_ABORTED;
    goto premature_exit;
   }
  } else if (ha->flags.purge_mbox ||
      chip_reset != ha->chip_reset) {
   eeh_delay = ha->flags.eeh_busy ? 1 : 0;

   spin_lock_irqsave(&ha->hardware_lock, flags);
   ha->flags.mbox_busy = 0;
   spin_unlock_irqrestore(&ha->hardware_lock, flags);
   atomic_dec(&ha->num_pend_mbx_stage2);
   rval = QLA_ABORTED;
   goto premature_exit;
  }

  if (time_after(jiffies, wait_time + 5 * HZ))
   ql_log(ql_log_warn, vha, 0x1015, "cmd=0x%x, waited %d msecs\n",
       command, jiffies_to_msecs(jiffies - wait_time));
 } else {
  ql_dbg(ql_dbg_mbx, vha, 0x1011,
      "Cmd=%x Polling Mode.\n", command);

  if (IS_P3P_TYPE(ha)) {
   if (rd_reg_dword(®->isp82.hint) &
    HINT_MBX_INT_PENDING) {
    ha->flags.mbox_busy = 0;
    spin_unlock_irqrestore(&ha->hardware_lock,
     flags);
    atomic_dec(&ha->num_pend_mbx_stage2);
    ql_dbg(ql_dbg_mbx, vha, 0x1012,
        "Pending mailbox timeout, exiting.\n");
    vha->hw_err_cnt++;
    rval = QLA_FUNCTION_TIMEOUT;
    goto premature_exit;
   }
   wrt_reg_dword(®->isp82.hint, HINT_MBX_INT_PENDING);
  } else if (IS_FWI2_CAPABLE(ha))
   wrt_reg_dword(®->isp24.hccr, HCCRX_SET_HOST_INT);
  else
   wrt_reg_word(®->isp.hccr, HCCR_SET_HOST_INT);
  spin_unlock_irqrestore(&ha->hardware_lock, flags);

  wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */
  while (!ha->flags.mbox_int) {
   if (ha->flags.purge_mbox ||
       chip_reset != ha->chip_reset) {
    eeh_delay = ha->flags.eeh_busy ? 1 : 0;

    spin_lock_irqsave(&ha->hardware_lock, flags);
    ha->flags.mbox_busy = 0;
    spin_unlock_irqrestore(&ha->hardware_lock,
        flags);
    atomic_dec(&ha->num_pend_mbx_stage2);
    rval = QLA_ABORTED;
    goto premature_exit;
   }

   if (time_after(jiffies, wait_time))
    break;

   /* Check for pending interrupts. */
   qla2x00_poll(ha->rsp_q_map[0]);

   if (!ha->flags.mbox_int &&
       !(IS_QLA2200(ha) &&
       command == MBC_LOAD_RISC_RAM_EXTENDED))
    msleep(10);
  } /* while */
  ql_dbg(ql_dbg_mbx, vha, 0x1013,
      "Waited %d sec.\n",
      (uint)((jiffies - (wait_time - (mcp->tov * HZ)))/HZ));
 }
 atomic_dec(&ha->num_pend_mbx_stage2);

 /* Check whether we timed out */
 if (ha->flags.mbox_int) {
  uint16_t *iptr2;

  ql_dbg(ql_dbg_mbx, vha, 0x1014,
      "Cmd=%x completed.\n", command);

  /* Got interrupt. Clear the flag. */
  ha->flags.mbox_int = 0;
  clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);

  if (IS_P3P_TYPE(ha) && ha->flags.isp82xx_fw_hung) {
   spin_lock_irqsave(&ha->hardware_lock, flags);
   ha->flags.mbox_busy = 0;
   spin_unlock_irqrestore(&ha->hardware_lock, flags);

   /* Setting Link-Down error */
   mcp->mb[0] = MBS_LINK_DOWN_ERROR;
   ha->mcp = NULL;
   rval = QLA_FUNCTION_FAILED;
   ql_log(ql_log_warn, vha, 0xd048,
       "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
   goto premature_exit;
  }

  if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE) {
   ql_dbg(ql_dbg_mbx, vha, 0x11ff,
          "mb_out[0] = %#x <> %#x\n", ha->mailbox_out[0],
          MBS_COMMAND_COMPLETE);
   rval = QLA_FUNCTION_FAILED;
  }

  /* Load return mailbox registers. */
  iptr2 = mcp->mb;
  iptr = (uint16_t *)&ha->mailbox_out[0];
  mboxes = mcp->in_mb;

  ql_dbg(ql_dbg_mbx, vha, 0x1113,
      "Mailbox registers (IN):\n");
  for (cnt = 0; cnt < ha->mbx_count; cnt++) {
   if (mboxes & BIT_0) {
    *iptr2 = *iptr;
    ql_dbg(ql_dbg_mbx, vha, 0x1114,
        "mbox[%d]->0x%04x\n", cnt, *iptr2);
   }

   mboxes >>= 1;
   iptr2++;
   iptr++;
  }
 } else {

  uint16_t mb[8];
  uint32_t ictrl, host_status, hccr;
  uint16_t        w;

  if (IS_FWI2_CAPABLE(ha)) {
   mb[0] = rd_reg_word(®->isp24.mailbox0);
   mb[1] = rd_reg_word(®->isp24.mailbox1);
   mb[2] = rd_reg_word(®->isp24.mailbox2);
   mb[3] = rd_reg_word(®->isp24.mailbox3);
   mb[7] = rd_reg_word(®->isp24.mailbox7);
   ictrl = rd_reg_dword(®->isp24.ictrl);
   host_status = rd_reg_dword(®->isp24.host_status);
   hccr = rd_reg_dword(®->isp24.hccr);

   ql_log(ql_log_warn, vha, 0xd04c,
       "MBX Command timeout for cmd %x, iocontrol=%x jiffies=%lx "
       "mb[0-3]=[0x%x 0x%x 0x%x 0x%x] mb7 0x%x host_status 0x%x hccr 0x%x\n",
       command, ictrl, jiffies, mb[0], mb[1], mb[2], mb[3],
       mb[7], host_status, hccr);
   vha->hw_err_cnt++;

  } else {
   mb[0] = RD_MAILBOX_REG(ha, ®->isp, 0);
   ictrl = rd_reg_word(®->isp.ictrl);
   ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1119,
       "MBX Command timeout for cmd %x, iocontrol=%x jiffies=%lx "
       "mb[0]=0x%x\n", command, ictrl, jiffies, mb[0]);
   vha->hw_err_cnt++;
  }
  ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1019);

  /* Capture FW dump only, if PCI device active */
  if (!pci_channel_offline(vha->hw->pdev)) {
   pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
   if (w == 0xffff || ictrl == 0xffffffff ||
       (chip_reset != ha->chip_reset)) {
    /* This is special case if there is unload
 * of driver happening and if PCI device go
 * into bad state due to PCI error condition
 * then only PCI ERR flag would be set.
 * we will do premature exit for above case.
 */
    spin_lock_irqsave(&ha->hardware_lock, flags);
    ha->flags.mbox_busy = 0;
    spin_unlock_irqrestore(&ha->hardware_lock,
        flags);
    rval = QLA_FUNCTION_TIMEOUT;
    goto premature_exit;
   }

   /* Attempt to capture firmware dump for further
 * anallysis of the current formware state. we do not
 * need to do this if we are intentionally generating
 * a dump
 */
   if (mcp->mb[0] != MBC_GEN_SYSTEM_ERROR)
    qla2xxx_dump_fw(vha);
   rval = QLA_FUNCTION_TIMEOUT;
   }
 }
 spin_lock_irqsave(&ha->hardware_lock, flags);
 ha->flags.mbox_busy = 0;
 spin_unlock_irqrestore(&ha->hardware_lock, flags);

 /* Clean up */
 ha->mcp = NULL;

 if ((abort_active || !io_lock_on) && !IS_NOPOLLING_TYPE(ha)) {
  ql_dbg(ql_dbg_mbx, vha, 0x101a,
      "Checking for additional resp interrupt.\n");

  /* polling mode for non isp_abort commands. */
  qla2x00_poll(ha->rsp_q_map[0]);
 }

 if (rval == QLA_FUNCTION_TIMEOUT &&
     mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) {
  if (!io_lock_on || (mcp->flags & IOCTL_CMD) ||
      ha->flags.eeh_busy) {
   /* not in dpc. schedule it for dpc to take over. */
   ql_dbg(ql_dbg_mbx, vha, 0x101b,
       "Timeout, schedule isp_abort_needed.\n");

   if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
       !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
       !test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
    if (IS_QLA82XX(ha)) {
     ql_dbg(ql_dbg_mbx, vha, 0x112a,
         "disabling pause transmit on port "
         "0 & 1.\n");
     qla82xx_wr_32(ha,
         QLA82XX_CRB_NIU + 0x98,
         CRB_NIU_XG_PAUSE_CTL_P0|
         CRB_NIU_XG_PAUSE_CTL_P1);
    }
    ql_log(ql_log_info, base_vha, 0x101c,
        "Mailbox cmd timeout occurred, cmd=0x%x, "
        "mb[0]=0x%x, eeh_busy=0x%x. Scheduling ISP "
        "abort.\n", command, mcp->mb[0],
        ha->flags.eeh_busy);
    vha->hw_err_cnt++;
    set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
    qla2xxx_wake_dpc(vha);
   }
  } else if (current == ha->dpc_thread) {
   /* call abort directly since we are in the DPC thread */
   ql_dbg(ql_dbg_mbx, vha, 0x101d,
       "Timeout, calling abort_isp.\n");

   if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
       !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
       !test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
    if (IS_QLA82XX(ha)) {
     ql_dbg(ql_dbg_mbx, vha, 0x112b,
         "disabling pause transmit on port "
         "0 & 1.\n");
     qla82xx_wr_32(ha,
         QLA82XX_CRB_NIU + 0x98,
         CRB_NIU_XG_PAUSE_CTL_P0|
         CRB_NIU_XG_PAUSE_CTL_P1);
    }
    ql_log(ql_log_info, base_vha, 0x101e,
        "Mailbox cmd timeout occurred, cmd=0x%x, "
        "mb[0]=0x%x. Scheduling ISP abort ",
        command, mcp->mb[0]);
    vha->hw_err_cnt++;
    set_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
    clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
    /* Allow next mbx cmd to come in. */
    complete(&ha->mbx_cmd_comp);
    if (ha->isp_ops->abort_isp(vha) &&
        !ha->flags.eeh_busy) {
     /* Failed. retry later. */
     set_bit(ISP_ABORT_NEEDED,
         &vha->dpc_flags);
    }
    clear_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
    ql_dbg(ql_dbg_mbx, vha, 0x101f,
        "Finished abort_isp.\n");
    goto mbx_done;
   }
  }
 }

premature_exit:
 /* Allow next mbx cmd to come in. */
 complete(&ha->mbx_cmd_comp);

mbx_done:
 if (rval == QLA_ABORTED) {
  ql_log(ql_log_info, vha, 0xd035,
      "Chip Reset in progress. Purging Mbox cmd=0x%x.\n",
      mcp->mb[0]);
 } else if (rval) {
  if (ql2xextended_error_logging & (ql_dbg_disc|ql_dbg_mbx)) {
   pr_warn("%s [%s]-%04x:%ld: **** Failed=%x", QL_MSGHDR,
       dev_name(&ha->pdev->dev), 0x1020+0x800,
       vha->host_no, rval);
   mboxes = mcp->in_mb;
   cnt = 4;
   for (i = 0; i < ha->mbx_count && cnt; i++, mboxes >>= 1)
    if (mboxes & BIT_0) {
     printk(" mb[%u]=%x", i, mcp->mb[i]);
     cnt--;
    }
   pr_warn(" cmd=%x ****\n", command);
  }
  if (IS_FWI2_CAPABLE(ha) && !(IS_P3P_TYPE(ha))) {
   ql_dbg(ql_dbg_mbx, vha, 0x1198,
       "host_status=%#x intr_ctrl=%#x intr_status=%#x\n",
       rd_reg_dword(®->isp24.host_status),
       rd_reg_dword(®->isp24.ictrl),
       rd_reg_dword(®->isp24.istatus));
  } else {
   ql_dbg(ql_dbg_mbx, vha, 0x1206,
       "ctrl_status=%#x ictrl=%#x istatus=%#x\n",
       rd_reg_word(®->isp.ctrl_status),
       rd_reg_word(®->isp.ictrl),
       rd_reg_word(®->isp.istatus));
  }
 } else {
  ql_dbg(ql_dbg_mbx, base_vha, 0x1021, "Done %s.\n", __func__);
 }

 i = 500;
 while (i && eeh_delay && (ha->pci_error_state < QLA_PCI_SLOT_RESET)) {
  /*
 * The caller of this mailbox encounter pci error.
 * Hold the thread until PCIE link reset complete to make
 * sure caller does not unmap dma while recovery is
 * in progress.
 */
  msleep(1);
  i--;
 }
 return rval;
}

int
qla2x00_load_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t risc_addr,
    uint32_t risc_code_size)
{
 int rval;
 struct qla_hw_data *ha = vha->hw;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1022,
     "Entered %s.\n", __func__);

 if (MSW(risc_addr) || IS_FWI2_CAPABLE(ha)) {
  mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
  mcp->mb[8] = MSW(risc_addr);
  mcp->out_mb = MBX_8|MBX_0;
 } else {
  mcp->mb[0] = MBC_LOAD_RISC_RAM;
  mcp->out_mb = MBX_0;
 }
 mcp->mb[1] = LSW(risc_addr);
 mcp->mb[2] = MSW(req_dma);
 mcp->mb[3] = LSW(req_dma);
 mcp->mb[6] = MSW(MSD(req_dma));
 mcp->mb[7] = LSW(MSD(req_dma));
 mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
 if (IS_FWI2_CAPABLE(ha)) {
  mcp->mb[4] = MSW(risc_code_size);
  mcp->mb[5] = LSW(risc_code_size);
  mcp->out_mb |= MBX_5|MBX_4;
 } else {
  mcp->mb[4] = LSW(risc_code_size);
  mcp->out_mb |= MBX_4;
 }

 mcp->in_mb = MBX_1|MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x1023,
      "Failed=%x mb[0]=%x mb[1]=%x.\n",
      rval, mcp->mb[0], mcp->mb[1]);
  vha->hw_err_cnt++;
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1024,
      "Done %s.\n", __func__);
 }

 return rval;
}

#define NVME_ENABLE_FLAG BIT_3
#define EDIF_HW_SUPPORT  BIT_10

/*
 * qla2x00_execute_fw
 *     Start adapter firmware.
 *
 * Input:
 *     ha = adapter block pointer.
 *     TARGET_QUEUE_LOCK must be released.
 *     ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 *     qla2x00 local function return status code.
 *
 * Context:
 *     Kernel context.
 */
int
qla2x00_execute_fw(scsi_qla_host_t *vha, uint32_t risc_addr)
{
 int rval;
 struct qla_hw_data *ha = vha->hw;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;
 u8 semaphore = 0;
#define EXE_FW_FORCE_SEMAPHORE BIT_7
 u8 retry = 5;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1025,
     "Entered %s.\n", __func__);

again:
 mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
 mcp->out_mb = MBX_0;
 mcp->in_mb = MBX_0;
 if (IS_FWI2_CAPABLE(ha)) {
  mcp->mb[1] = MSW(risc_addr);
  mcp->mb[2] = LSW(risc_addr);
  mcp->mb[3] = 0;
  mcp->mb[4] = 0;
  mcp->mb[11] = 0;

  /* Enable BPM? */
  if (ha->flags.lr_detected) {
   mcp->mb[4] = BIT_0;
   if (IS_BPM_RANGE_CAPABLE(ha))
    mcp->mb[4] |=
        ha->lr_distance << LR_DIST_FW_POS;
  }

  if (ql2xnvmeenable && (IS_QLA27XX(ha) || IS_QLA28XX(ha)))
   mcp->mb[4] |= NVME_ENABLE_FLAG;

  if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
   struct nvram_81xx *nv = ha->nvram;
   /* set minimum speed if specified in nvram */
   if (nv->min_supported_speed >= 2 &&
       nv->min_supported_speed <= 5) {
    mcp->mb[4] |= BIT_4;
    mcp->mb[11] |= nv->min_supported_speed & 0xF;
    mcp->out_mb |= MBX_11;
    mcp->in_mb |= BIT_5;
    vha->min_supported_speed =
        nv->min_supported_speed;
   }

   if (IS_PPCARCH)
    mcp->mb[11] |= BIT_4;
  }

  if (ha->flags.exlogins_enabled)
   mcp->mb[4] |= ENABLE_EXTENDED_LOGIN;

  if (ha->flags.exchoffld_enabled)
   mcp->mb[4] |= ENABLE_EXCHANGE_OFFLD;

  if (semaphore)
   mcp->mb[11] |= EXE_FW_FORCE_SEMAPHORE;

  mcp->out_mb |= MBX_4 | MBX_3 | MBX_2 | MBX_1 | MBX_11;
  mcp->in_mb |= MBX_5 | MBX_3 | MBX_2 | MBX_1;
 } else {
  mcp->mb[1] = LSW(risc_addr);
  mcp->out_mb |= MBX_1;
  if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
   mcp->mb[2] = 0;
   mcp->out_mb |= MBX_2;
  }
 }

 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  if (IS_QLA28XX(ha) && rval == QLA_COMMAND_ERROR &&
      mcp->mb[1] == 0x27 && retry) {
   semaphore = 1;
   retry--;
   ql_dbg(ql_dbg_async, vha, 0x1026,
       "Exe FW: force semaphore.\n");
   goto again;
  }

  if (retry) {
   retry--;
   ql_dbg(ql_dbg_async, vha, 0x509d,
       "Exe FW retry: mb[0]=%x retry[%d]\n", mcp->mb[0], retry);
   goto again;
  }
  ql_dbg(ql_dbg_mbx, vha, 0x1026,
      "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
  vha->hw_err_cnt++;
  return rval;
 }

 if (!IS_FWI2_CAPABLE(ha))
  goto done;

 ha->fw_ability_mask = mcp->mb[3] << 16 | mcp->mb[2];
 ql_dbg(ql_dbg_mbx, vha, 0x119a,
     "fw_ability_mask=%x.\n", ha->fw_ability_mask);
 ql_dbg(ql_dbg_mbx, vha, 0x1027, "exchanges=%x.\n", mcp->mb[1]);
 if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
  ha->max_supported_speed = mcp->mb[2] & (BIT_0|BIT_1);
  ql_dbg(ql_dbg_mbx, vha, 0x119b, "max_supported_speed=%s.\n",
      ha->max_supported_speed == 0 ? "16Gps" :
      ha->max_supported_speed == 1 ? "32Gps" :
      ha->max_supported_speed == 2 ? "64Gps" : "unknown");
  if (vha->min_supported_speed) {
   ha->min_supported_speed = mcp->mb[5] &
       (BIT_0 | BIT_1 | BIT_2);
   ql_dbg(ql_dbg_mbx, vha, 0x119c,
       "min_supported_speed=%s.\n",
       ha->min_supported_speed == 6 ? "64Gps" :
       ha->min_supported_speed == 5 ? "32Gps" :
       ha->min_supported_speed == 4 ? "16Gps" :
       ha->min_supported_speed == 3 ? "8Gps" :
       ha->min_supported_speed == 2 ? "4Gps" : "unknown");
  }
 }

 if (IS_QLA28XX(ha) && (mcp->mb[5] & EDIF_HW_SUPPORT)) {
  ha->flags.edif_hw = 1;
  ql_log(ql_log_info, vha, 0xffff,
      "%s: edif HW\n", __func__);
 }

done:
 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1028,
     "Done %s.\n", __func__);

 return rval;
}

/*
 * qla_get_exlogin_status
 * Get extended login status
 * uses the memory offload control/status Mailbox
 *
 * Input:
 * ha: adapter state pointer.
 * fwopt: firmware options
 *
 * Returns:
 * qla2x00 local function status
 *
 * Context:
 * Kernel context.
 */
#define FETCH_XLOGINS_STAT 0x8
int
qla_get_exlogin_status(scsi_qla_host_t *vha, uint16_t *buf_sz,
 uint16_t *ex_logins_cnt)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118f,
     "Entered %s\n", __func__);

 memset(mcp->mb, 0 , sizeof(mcp->mb));
 mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
 mcp->mb[1] = FETCH_XLOGINS_STAT;
 mcp->out_mb = MBX_1|MBX_0;
 mcp->in_mb = MBX_10|MBX_4|MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;

 rval = qla2x00_mailbox_command(vha, mcp);
 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x1115, "Failed=%x.\n", rval);
 } else {
  *buf_sz = mcp->mb[4];
  *ex_logins_cnt = mcp->mb[10];

  ql_log(ql_log_info, vha, 0x1190,
      "buffer size 0x%x, exchange login count=%d\n",
      mcp->mb[4], mcp->mb[10]);

  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1116,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla_set_exlogin_mem_cfg
 * set extended login memory configuration
 * Mbx needs to be issues before init_cb is set
 *
 * Input:
 * ha: adapter state pointer.
 * buffer: buffer pointer
 * phys_addr: physical address of buffer
 * size: size of buffer
 * TARGET_QUEUE_LOCK must be released
 * ADAPTER_STATE_LOCK must be release
 *
 * Returns:
 * qla2x00 local funxtion status code.
 *
 * Context:
 * Kernel context.
 */
#define CONFIG_XLOGINS_MEM 0x9
int
qla_set_exlogin_mem_cfg(scsi_qla_host_t *vha, dma_addr_t phys_addr)
{
 int  rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;
 struct qla_hw_data *ha = vha->hw;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x111a,
     "Entered %s.\n", __func__);

 memset(mcp->mb, 0 , sizeof(mcp->mb));
 mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
 mcp->mb[1] = CONFIG_XLOGINS_MEM;
 mcp->mb[2] = MSW(phys_addr);
 mcp->mb[3] = LSW(phys_addr);
 mcp->mb[6] = MSW(MSD(phys_addr));
 mcp->mb[7] = LSW(MSD(phys_addr));
 mcp->mb[8] = MSW(ha->exlogin_size);
 mcp->mb[9] = LSW(ha->exlogin_size);
 mcp->out_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->in_mb = MBX_11|MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);
 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x111b,
         "EXlogin Failed=%x. MB0=%x MB11=%x\n",
         rval, mcp->mb[0], mcp->mb[11]);
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118c,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla_get_exchoffld_status
 * Get exchange offload status
 * uses the memory offload control/status Mailbox
 *
 * Input:
 * ha: adapter state pointer.
 * fwopt: firmware options
 *
 * Returns:
 * qla2x00 local function status
 *
 * Context:
 * Kernel context.
 */
#define FETCH_XCHOFFLD_STAT 0x2
int
qla_get_exchoffld_status(scsi_qla_host_t *vha, uint16_t *buf_sz,
 uint16_t *ex_logins_cnt)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1019,
     "Entered %s\n", __func__);

 memset(mcp->mb, 0 , sizeof(mcp->mb));
 mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
 mcp->mb[1] = FETCH_XCHOFFLD_STAT;
 mcp->out_mb = MBX_1|MBX_0;
 mcp->in_mb = MBX_10|MBX_4|MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;

 rval = qla2x00_mailbox_command(vha, mcp);
 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x1155, "Failed=%x.\n", rval);
 } else {
  *buf_sz = mcp->mb[4];
  *ex_logins_cnt = mcp->mb[10];

  ql_log(ql_log_info, vha, 0x118e,
      "buffer size 0x%x, exchange offload count=%d\n",
      mcp->mb[4], mcp->mb[10]);

  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1156,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla_set_exchoffld_mem_cfg
 * Set exchange offload memory configuration
 * Mbx needs to be issues before init_cb is set
 *
 * Input:
 * ha: adapter state pointer.
 * buffer: buffer pointer
 * phys_addr: physical address of buffer
 * size: size of buffer
 * TARGET_QUEUE_LOCK must be released
 * ADAPTER_STATE_LOCK must be release
 *
 * Returns:
 * qla2x00 local funxtion status code.
 *
 * Context:
 * Kernel context.
 */
#define CONFIG_XCHOFFLD_MEM 0x3
int
qla_set_exchoffld_mem_cfg(scsi_qla_host_t *vha)
{
 int  rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;
 struct qla_hw_data *ha = vha->hw;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1157,
     "Entered %s.\n", __func__);

 memset(mcp->mb, 0 , sizeof(mcp->mb));
 mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
 mcp->mb[1] = CONFIG_XCHOFFLD_MEM;
 mcp->mb[2] = MSW(ha->exchoffld_buf_dma);
 mcp->mb[3] = LSW(ha->exchoffld_buf_dma);
 mcp->mb[6] = MSW(MSD(ha->exchoffld_buf_dma));
 mcp->mb[7] = LSW(MSD(ha->exchoffld_buf_dma));
 mcp->mb[8] = MSW(ha->exchoffld_size);
 mcp->mb[9] = LSW(ha->exchoffld_size);
 mcp->out_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->in_mb = MBX_11|MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);
 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x1158, "Failed=%x.\n", rval);
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1192,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla2x00_get_fw_version
 * Get firmware version.
 *
 * Input:
 * ha: adapter state pointer.
 * major: pointer for major number.
 * minor: pointer for minor number.
 * subminor: pointer for subminor number.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_get_fw_version(scsi_qla_host_t *vha)
{
 int  rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;
 struct qla_hw_data *ha = vha->hw;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1029,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_GET_FIRMWARE_VERSION;
 mcp->out_mb = MBX_0;
 mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
 if (IS_QLA81XX(vha->hw) || IS_QLA8031(ha) || IS_QLA8044(ha))
  mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8;
 if (IS_FWI2_CAPABLE(ha))
  mcp->in_mb |= MBX_17|MBX_16|MBX_15;
 if (IS_QLA27XX(ha) || IS_QLA28XX(ha))
  mcp->in_mb |=
      MBX_25|MBX_24|MBX_23|MBX_22|MBX_21|MBX_20|MBX_19|MBX_18|
      MBX_14|MBX_13|MBX_11|MBX_10|MBX_9|MBX_8|MBX_7;

 mcp->flags = 0;
 mcp->tov = MBX_TOV_SECONDS;
 rval = qla2x00_mailbox_command(vha, mcp);
 if (rval != QLA_SUCCESS)
  goto failed;

 /* Return mailbox data. */
 ha->fw_major_version = mcp->mb[1];
 ha->fw_minor_version = mcp->mb[2];
 ha->fw_subminor_version = mcp->mb[3];
 ha->fw_attributes = mcp->mb[6];
 if (IS_QLA2100(vha->hw) || IS_QLA2200(vha->hw))
  ha->fw_memory_size = 0x1FFFF;  /* Defaults to 128KB. */
 else
  ha->fw_memory_size = (mcp->mb[5] << 16) | mcp->mb[4];

 if (IS_QLA81XX(vha->hw) || IS_QLA8031(vha->hw) || IS_QLA8044(ha)) {
  ha->mpi_version[0] = mcp->mb[10] & 0xff;
  ha->mpi_version[1] = mcp->mb[11] >> 8;
  ha->mpi_version[2] = mcp->mb[11] & 0xff;
  ha->mpi_capabilities = (mcp->mb[12] << 16) | mcp->mb[13];
  ha->phy_version[0] = mcp->mb[8] & 0xff;
  ha->phy_version[1] = mcp->mb[9] >> 8;
  ha->phy_version[2] = mcp->mb[9] & 0xff;
 }

 if (IS_FWI2_CAPABLE(ha)) {
  ha->fw_attributes_h = mcp->mb[15];
  ha->fw_attributes_ext[0] = mcp->mb[16];
  ha->fw_attributes_ext[1] = mcp->mb[17];
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1139,
      "%s: FW_attributes Upper: 0x%x, Lower: 0x%x.\n",
      __func__, mcp->mb[15], mcp->mb[6]);
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x112f,
      "%s: Ext_FwAttributes Upper: 0x%x, Lower: 0x%x.\n",
      __func__, mcp->mb[17], mcp->mb[16]);

  if (ha->fw_attributes_h & 0x4)
   ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118d,
       "%s: Firmware supports Extended Login 0x%x\n",
       __func__, ha->fw_attributes_h);

  if (ha->fw_attributes_h & 0x8)
   ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1191,
       "%s: Firmware supports Exchange Offload 0x%x\n",
       __func__, ha->fw_attributes_h);

  /*
 * FW supports nvme and driver load parameter requested nvme.
 * BIT 26 of fw_attributes indicates NVMe support.
 */
  if ((ha->fw_attributes_h &
      (FW_ATTR_H_NVME | FW_ATTR_H_NVME_UPDATED)) &&
   ql2xnvmeenable) {
   if (ha->fw_attributes_h & FW_ATTR_H_NVME_FBURST)
    vha->flags.nvme_first_burst = 1;

   vha->flags.nvme_enabled = 1;
   ql_log(ql_log_info, vha, 0xd302,
       "%s: FC-NVMe is Enabled (0x%x)\n",
        __func__, ha->fw_attributes_h);
  }

  /* BIT_13 of Extended FW Attributes informs about NVMe2 support */
  if (ha->fw_attributes_ext[0] & FW_ATTR_EXT0_NVME2) {
   ql_log(ql_log_info, vha, 0xd302,
          "Firmware supports NVMe2 0x%x\n",
          ha->fw_attributes_ext[0]);
   vha->flags.nvme2_enabled = 1;
  }

  if (IS_QLA28XX(ha) && ha->flags.edif_hw && ql2xsecenable &&
      (ha->fw_attributes_ext[0] & FW_ATTR_EXT0_EDIF)) {
   ha->flags.edif_enabled = 1;
   ql_log(ql_log_info, vha, 0xffff,
          "%s: edif is enabled\n", __func__);
  }
 }

 if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
  ha->serdes_version[0] = mcp->mb[7] & 0xff;
  ha->serdes_version[1] = mcp->mb[8] >> 8;
  ha->serdes_version[2] = mcp->mb[8] & 0xff;
  ha->mpi_version[0] = mcp->mb[10] & 0xff;
  ha->mpi_version[1] = mcp->mb[11] >> 8;
  ha->mpi_version[2] = mcp->mb[11] & 0xff;
  ha->pep_version[0] = mcp->mb[13] & 0xff;
  ha->pep_version[1] = mcp->mb[14] >> 8;
  ha->pep_version[2] = mcp->mb[14] & 0xff;
  ha->fw_shared_ram_start = (mcp->mb[19] << 16) | mcp->mb[18];
  ha->fw_shared_ram_end = (mcp->mb[21] << 16) | mcp->mb[20];
  ha->fw_ddr_ram_start = (mcp->mb[23] << 16) | mcp->mb[22];
  ha->fw_ddr_ram_end = (mcp->mb[25] << 16) | mcp->mb[24];
  if (IS_QLA28XX(ha)) {
   if (mcp->mb[16] & BIT_10)
    ha->flags.secure_fw = 1;

   ql_log(ql_log_info, vha, 0xffff,
       "Secure Flash Update in FW: %s\n",
       (ha->flags.secure_fw) ? "Supported" :
       "Not Supported");
  }

  if (ha->flags.scm_supported_a &&
      (ha->fw_attributes_ext[0] & FW_ATTR_EXT0_SCM_SUPPORTED)) {
   ha->flags.scm_supported_f = 1;
   ha->sf_init_cb->flags |= cpu_to_le16(BIT_13);
  }
  ql_log(ql_log_info, vha, 0x11a3, "SCM in FW: %s\n",
         (ha->flags.scm_supported_f) ? "Supported" :
         "Not Supported");

  if (vha->flags.nvme2_enabled) {
   /* set BIT_15 of special feature control block for SLER */
   ha->sf_init_cb->flags |= cpu_to_le16(BIT_15);
   /* set BIT_14 of special feature control block for PI CTRL*/
   ha->sf_init_cb->flags |= cpu_to_le16(BIT_14);
  }
 }

failed:
 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x102a, "Failed=%x.\n", rval);
 } else {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102b,
      "Done %s.\n", __func__);
 }
 return rval;
}

/*
 * qla2x00_get_fw_options
 * Set firmware options.
 *
 * Input:
 * ha = adapter block pointer.
 * fwopt = pointer for firmware options.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_get_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102c,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_GET_FIRMWARE_OPTION;
 mcp->out_mb = MBX_0;
 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x102d, "Failed=%x.\n", rval);
 } else {
  fwopts[0] = mcp->mb[0];
  fwopts[1] = mcp->mb[1];
  fwopts[2] = mcp->mb[2];
  fwopts[3] = mcp->mb[3];

  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102e,
      "Done %s.\n", __func__);
 }

 return rval;
}


/*
 * qla2x00_set_fw_options
 * Set firmware options.
 *
 * Input:
 * ha = adapter block pointer.
 * fwopt = pointer for firmware options.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_set_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102f,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_SET_FIRMWARE_OPTION;
 mcp->mb[1] = fwopts[1];
 mcp->mb[2] = fwopts[2];
 mcp->mb[3] = fwopts[3];
 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->in_mb = MBX_0;
 if (IS_FWI2_CAPABLE(vha->hw)) {
  mcp->in_mb |= MBX_1;
  mcp->mb[10] = fwopts[10];
  mcp->out_mb |= MBX_10;
 } else {
  mcp->mb[10] = fwopts[10];
  mcp->mb[11] = fwopts[11];
  mcp->mb[12] = 0; /* Undocumented, but used */
  mcp->out_mb |= MBX_12|MBX_11|MBX_10;
 }
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 fwopts[0] = mcp->mb[0];

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x1030,
      "Failed=%x (%x/%x).\n", rval, mcp->mb[0], mcp->mb[1]);
 } else {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1031,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla2x00_mbx_reg_test
 * Mailbox register wrap test.
 *
 * Input:
 * ha = adapter block pointer.
 * TARGET_QUEUE_LOCK must be released.
 * ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_mbx_reg_test(scsi_qla_host_t *vha)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1032,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
 mcp->mb[1] = 0xAAAA;
 mcp->mb[2] = 0x5555;
 mcp->mb[3] = 0xAA55;
 mcp->mb[4] = 0x55AA;
 mcp->mb[5] = 0xA5A5;
 mcp->mb[6] = 0x5A5A;
 mcp->mb[7] = 0x2525;
 mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval == QLA_SUCCESS) {
  if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
      mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA)
   rval = QLA_FUNCTION_FAILED;
  if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
      mcp->mb[7] != 0x2525)
   rval = QLA_FUNCTION_FAILED;
 }

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x1033, "Failed=%x.\n", rval);
  vha->hw_err_cnt++;
 } else {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1034,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla2x00_verify_checksum
 * Verify firmware checksum.
 *
 * Input:
 * ha = adapter block pointer.
 * TARGET_QUEUE_LOCK must be released.
 * ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_verify_checksum(scsi_qla_host_t *vha, uint32_t risc_addr)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1035,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_VERIFY_CHECKSUM;
 mcp->out_mb = MBX_0;
 mcp->in_mb = MBX_0;
 if (IS_FWI2_CAPABLE(vha->hw)) {
  mcp->mb[1] = MSW(risc_addr);
  mcp->mb[2] = LSW(risc_addr);
  mcp->out_mb |= MBX_2|MBX_1;
  mcp->in_mb |= MBX_2|MBX_1;
 } else {
  mcp->mb[1] = LSW(risc_addr);
  mcp->out_mb |= MBX_1;
  mcp->in_mb |= MBX_1;
 }

 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x1036,
      "Failed=%x chm sum=%x.\n", rval, IS_FWI2_CAPABLE(vha->hw) ?
      (mcp->mb[2] << 16) | mcp->mb[1] : mcp->mb[1]);
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1037,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla2x00_issue_iocb
 * Issue IOCB using mailbox command
 *
 * Input:
 * ha = adapter state pointer.
 * buffer = buffer pointer.
 * phys_addr = physical address of buffer.
 * size = size of buffer.
 * TARGET_QUEUE_LOCK must be released.
 * ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_issue_iocb_timeout(scsi_qla_host_t *vha, void *buffer,
    dma_addr_t phys_addr, size_t size, uint32_t tov)
{
 int  rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 if (!vha->hw->flags.fw_started)
  return QLA_INVALID_COMMAND;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1038,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_IOCB_COMMAND_A64;
 mcp->mb[1] = 0;
 mcp->mb[2] = MSW(LSD(phys_addr));
 mcp->mb[3] = LSW(LSD(phys_addr));
 mcp->mb[6] = MSW(MSD(phys_addr));
 mcp->mb[7] = LSW(MSD(phys_addr));
 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->in_mb = MBX_1|MBX_0;
 mcp->tov = tov;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x1039, "Failed=%x.\n", rval);
 } else {
  sts_entry_t *sts_entry = buffer;

  /* Mask reserved bits. */
  sts_entry->entry_status &=
      IS_FWI2_CAPABLE(vha->hw) ? RF_MASK_24XX : RF_MASK;
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103a,
      "Done %s (status=%x).\n", __func__,
      sts_entry->entry_status);
 }

 return rval;
}

int
qla2x00_issue_iocb(scsi_qla_host_t *vha, void *buffer, dma_addr_t phys_addr,
    size_t size)
{
 return qla2x00_issue_iocb_timeout(vha, buffer, phys_addr, size,
     MBX_TOV_SECONDS);
}

/*
 * qla2x00_abort_command
 * Abort command aborts a specified IOCB.
 *
 * Input:
 * ha = adapter block pointer.
 * sp = SB structure pointer.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_abort_command(srb_t *sp)
{
 unsigned long   flags = 0;
 int  rval;
 uint32_t handle = 0;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;
 fc_port_t *fcport = sp->fcport;
 scsi_qla_host_t *vha = fcport->vha;
 struct qla_hw_data *ha = vha->hw;
 struct req_que *req;
 struct scsi_cmnd *cmd = GET_CMD_SP(sp);

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103b,
     "Entered %s.\n", __func__);

 if (sp->qpair)
  req = sp->qpair->req;
 else
  req = vha->req;

 spin_lock_irqsave(&ha->hardware_lock, flags);
 for (handle = 1; handle < req->num_outstanding_cmds; handle++) {
  if (req->outstanding_cmds[handle] == sp)
   break;
 }
 spin_unlock_irqrestore(&ha->hardware_lock, flags);

 if (handle == req->num_outstanding_cmds) {
  /* command not found */
  return QLA_FUNCTION_FAILED;
 }

 mcp->mb[0] = MBC_ABORT_COMMAND;
 if (HAS_EXTENDED_IDS(ha))
  mcp->mb[1] = fcport->loop_id;
 else
  mcp->mb[1] = fcport->loop_id << 8;
 mcp->mb[2] = (uint16_t)handle;
 mcp->mb[3] = (uint16_t)(handle >> 16);
 mcp->mb[6] = (uint16_t)cmd->device->lun;
 mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->in_mb = MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x103c, "Failed=%x.\n", rval);
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103d,
      "Done %s.\n", __func__);
 }

 return rval;
}

int
qla2x00_abort_target(struct fc_port *fcport, uint64_t l, int tag)
{
 int rval, rval2;
 mbx_cmd_t  mc;
 mbx_cmd_t  *mcp = &mc;
 scsi_qla_host_t *vha;

 vha = fcport->vha;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103e,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_ABORT_TARGET;
 mcp->out_mb = MBX_9|MBX_2|MBX_1|MBX_0;
 if (HAS_EXTENDED_IDS(vha->hw)) {
  mcp->mb[1] = fcport->loop_id;
  mcp->mb[10] = 0;
  mcp->out_mb |= MBX_10;
 } else {
  mcp->mb[1] = fcport->loop_id << 8;
 }
 mcp->mb[2] = vha->hw->loop_reset_delay;
 mcp->mb[9] = vha->vp_idx;

 mcp->in_mb = MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);
 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103f,
      "Failed=%x.\n", rval);
 }

 /* Issue marker IOCB. */
 rval2 = qla2x00_marker(vha, vha->hw->base_qpair, fcport->loop_id, 0,
       MK_SYNC_ID);
 if (rval2 != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x1040,
      "Failed to issue marker IOCB (%x).\n", rval2);
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1041,
      "Done %s.\n", __func__);
 }

 return rval;
}

int
qla2x00_lun_reset(struct fc_port *fcport, uint64_t l, int tag)
{
 int rval, rval2;
 mbx_cmd_t  mc;
 mbx_cmd_t  *mcp = &mc;
 scsi_qla_host_t *vha;

 vha = fcport->vha;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1042,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_LUN_RESET;
 mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
 if (HAS_EXTENDED_IDS(vha->hw))
  mcp->mb[1] = fcport->loop_id;
 else
  mcp->mb[1] = fcport->loop_id << 8;
 mcp->mb[2] = (u32)l;
 mcp->mb[3] = 0;
 mcp->mb[9] = vha->vp_idx;

 mcp->in_mb = MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);
 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x1043, "Failed=%x.\n", rval);
 }

 /* Issue marker IOCB. */
 rval2 = qla2x00_marker(vha, vha->hw->base_qpair, fcport->loop_id, l,
        MK_SYNC_ID_LUN);
 if (rval2 != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x1044,
      "Failed to issue marker IOCB (%x).\n", rval2);
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1045,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla2x00_get_adapter_id
 * Get adapter ID and topology.
 *
 * Input:
 * ha = adapter block pointer.
 * id = pointer for loop ID.
 * al_pa = pointer for AL_PA.
 * area = pointer for area.
 * domain = pointer for domain.
 * top = pointer for topology.
 * TARGET_QUEUE_LOCK must be released.
 * ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_get_adapter_id(scsi_qla_host_t *vha, uint16_t *id, uint8_t *al_pa,
    uint8_t *area, uint8_t *domain, uint16_t *top, uint16_t *sw_cap)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1046,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
 mcp->mb[9] = vha->vp_idx;
 mcp->out_mb = MBX_9|MBX_0;
 mcp->in_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 if (IS_CNA_CAPABLE(vha->hw))
  mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10;
 if (IS_FWI2_CAPABLE(vha->hw))
  mcp->in_mb |= MBX_19|MBX_18|MBX_17|MBX_16;
 if (IS_QLA27XX(vha->hw) || IS_QLA28XX(vha->hw))
  mcp->in_mb |= MBX_15|MBX_21|MBX_22|MBX_23;

 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);
 if (mcp->mb[0] == MBS_COMMAND_ERROR)
  rval = QLA_COMMAND_ERROR;
 else if (mcp->mb[0] == MBS_INVALID_COMMAND)
  rval = QLA_INVALID_COMMAND;

 /* Return data. */
 *id = mcp->mb[1];
 *al_pa = LSB(mcp->mb[2]);
 *area = MSB(mcp->mb[2]);
 *domain = LSB(mcp->mb[3]);
 *top = mcp->mb[6];
 *sw_cap = mcp->mb[7];

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x1047, "Failed=%x.\n", rval);
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1048,
      "Done %s.\n", __func__);

  if (IS_CNA_CAPABLE(vha->hw)) {
   vha->fcoe_vlan_id = mcp->mb[9] & 0xfff;
   vha->fcoe_fcf_idx = mcp->mb[10];
   vha->fcoe_vn_port_mac[5] = mcp->mb[11] >> 8;
   vha->fcoe_vn_port_mac[4] = mcp->mb[11] & 0xff;
   vha->fcoe_vn_port_mac[3] = mcp->mb[12] >> 8;
   vha->fcoe_vn_port_mac[2] = mcp->mb[12] & 0xff;
   vha->fcoe_vn_port_mac[1] = mcp->mb[13] >> 8;
   vha->fcoe_vn_port_mac[0] = mcp->mb[13] & 0xff;
  }
  /* If FA-WWN supported */
  if (IS_FAWWN_CAPABLE(vha->hw)) {
   if (mcp->mb[7] & BIT_14) {
    vha->port_name[0] = MSB(mcp->mb[16]);
    vha->port_name[1] = LSB(mcp->mb[16]);
    vha->port_name[2] = MSB(mcp->mb[17]);
    vha->port_name[3] = LSB(mcp->mb[17]);
    vha->port_name[4] = MSB(mcp->mb[18]);
    vha->port_name[5] = LSB(mcp->mb[18]);
    vha->port_name[6] = MSB(mcp->mb[19]);
    vha->port_name[7] = LSB(mcp->mb[19]);
    fc_host_port_name(vha->host) =
        wwn_to_u64(vha->port_name);
    ql_dbg(ql_dbg_mbx, vha, 0x10ca,
        "FA-WWN acquired %016llx\n",
        wwn_to_u64(vha->port_name));
   }
  }

  if (IS_QLA27XX(vha->hw) || IS_QLA28XX(vha->hw)) {
   vha->bbcr = mcp->mb[15];
   if (mcp->mb[7] & SCM_EDC_ACC_RECEIVED) {
    ql_log(ql_log_info, vha, 0x11a4,
           "SCM: EDC ELS completed, flags 0x%x\n",
           mcp->mb[21]);
   }
   if (mcp->mb[7] & SCM_RDF_ACC_RECEIVED) {
    vha->hw->flags.scm_enabled = 1;
    vha->scm_fabric_connection_flags |=
        SCM_FLAG_RDF_COMPLETED;
    ql_log(ql_log_info, vha, 0x11a5,
           "SCM: RDF ELS completed, flags 0x%x\n",
           mcp->mb[23]);
   }
  }
 }

 return rval;
}

/*
 * qla2x00_get_retry_cnt
 * Get current firmware login retry count and delay.
 *
 * Input:
 * ha = adapter block pointer.
 * retry_cnt = pointer to login retry count.
 * tov = pointer to login timeout value.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
    uint16_t *r_a_tov)
{
 int rval;
 uint16_t ratov;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1049,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_GET_RETRY_COUNT;
 mcp->out_mb = MBX_0;
 mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x104a,
      "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
 } else {
  /* Convert returned data and check our values. */
  *r_a_tov = mcp->mb[3] / 2;
  ratov = (mcp->mb[3]/2) / 10;  /* mb[3] value is in 100ms */
  if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) {
   /* Update to the larger values */
   *retry_cnt = (uint8_t)mcp->mb[1];
   *tov = ratov;
  }

  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104b,
      "Done %s mb3=%d ratov=%d.\n", __func__, mcp->mb[3], ratov);
 }

 return rval;
}

/*
 * qla2x00_init_firmware
 * Initialize adapter firmware.
 *
 * Input:
 * ha = adapter block pointer.
 * dptr = Initialization control block pointer.
 * size = size of initialization control block.
 * TARGET_QUEUE_LOCK must be released.
 * ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_init_firmware(scsi_qla_host_t *vha, uint16_t size)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;
 struct qla_hw_data *ha = vha->hw;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104c,
     "Entered %s.\n", __func__);

 if (IS_P3P_TYPE(ha) && ql2xdbwr)
  qla82xx_wr_32(ha, (uintptr_t __force)ha->nxdb_wr_ptr,
   (0x04 | (ha->portnum << 5) | (0 << 8) | (0 << 16)));

 if (ha->flags.npiv_supported)
  mcp->mb[0] = MBC_MID_INITIALIZE_FIRMWARE;
 else
  mcp->mb[0] = MBC_INITIALIZE_FIRMWARE;

 mcp->mb[1] = 0;
 mcp->mb[2] = MSW(ha->init_cb_dma);
 mcp->mb[3] = LSW(ha->init_cb_dma);
 mcp->mb[6] = MSW(MSD(ha->init_cb_dma));
 mcp->mb[7] = LSW(MSD(ha->init_cb_dma));
 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 if (ha->ex_init_cb && ha->ex_init_cb->ex_version) {
  mcp->mb[1] = BIT_0;
  mcp->mb[10] = MSW(ha->ex_init_cb_dma);
  mcp->mb[11] = LSW(ha->ex_init_cb_dma);
  mcp->mb[12] = MSW(MSD(ha->ex_init_cb_dma));
  mcp->mb[13] = LSW(MSD(ha->ex_init_cb_dma));
  mcp->mb[14] = sizeof(*ha->ex_init_cb);
  mcp->out_mb |= MBX_14|MBX_13|MBX_12|MBX_11|MBX_10;
 }

 if (ha->flags.scm_supported_f || vha->flags.nvme2_enabled) {
  mcp->mb[1] |= BIT_1;
  mcp->mb[16] = MSW(ha->sf_init_cb_dma);
  mcp->mb[17] = LSW(ha->sf_init_cb_dma);
  mcp->mb[18] = MSW(MSD(ha->sf_init_cb_dma));
  mcp->mb[19] = LSW(MSD(ha->sf_init_cb_dma));
  mcp->mb[15] = sizeof(*ha->sf_init_cb);
  mcp->out_mb |= MBX_19|MBX_18|MBX_17|MBX_16|MBX_15;
 }

 /* 1 and 2 should normally be captured. */
 mcp->in_mb = MBX_2|MBX_1|MBX_0;
 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha))
  /* mb3 is additional info about the installed SFP. */
  mcp->in_mb  |= MBX_3;
 mcp->buf_size = size;
 mcp->flags = MBX_DMA_OUT;
 mcp->tov = MBX_TOV_SECONDS;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x104d,
      "Failed=%x mb[0]=%x, mb[1]=%x, mb[2]=%x, mb[3]=%x.\n",
      rval, mcp->mb[0], mcp->mb[1], mcp->mb[2], mcp->mb[3]);
  if (ha->init_cb) {
   ql_dbg(ql_dbg_mbx, vha, 0x104d, "init_cb:\n");
   ql_dump_buffer(ql_dbg_init + ql_dbg_verbose, vha,
       0x0104d, ha->init_cb, sizeof(*ha->init_cb));
  }
  if (ha->ex_init_cb && ha->ex_init_cb->ex_version) {
   ql_dbg(ql_dbg_mbx, vha, 0x104d, "ex_init_cb:\n");
   ql_dump_buffer(ql_dbg_init + ql_dbg_verbose, vha,
       0x0104d, ha->ex_init_cb, sizeof(*ha->ex_init_cb));
  }
 } else {
  if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
   if (mcp->mb[2] == 6 || mcp->mb[3] == 2)
    ql_dbg(ql_dbg_mbx, vha, 0x119d,
        "Invalid SFP/Validation Failed\n");
  }
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104e,
      "Done %s.\n", __func__);
 }

 return rval;
}


/*
 * qla2x00_get_port_database
 * Issue normal/enhanced get port database mailbox command
 * and copy device name as necessary.
 *
 * Input:
 * ha = adapter state pointer.
 * dev = structure pointer.
 * opt = enhanced cmd option byte.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;
 port_database_t *pd;
 struct port_database_24xx *pd24;
 dma_addr_t pd_dma;
 struct qla_hw_data *ha = vha->hw;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104f,
     "Entered %s.\n", __func__);

 pd24 = NULL;
 pd = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
 if (pd  == NULL) {
  ql_log(ql_log_warn, vha, 0x1050,
      "Failed to allocate port database structure.\n");
  fcport->query = 0;
  return QLA_MEMORY_ALLOC_FAILED;
 }

 mcp->mb[0] = MBC_GET_PORT_DATABASE;
 if (opt != 0 && !IS_FWI2_CAPABLE(ha))
  mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE;
 mcp->mb[2] = MSW(pd_dma);
 mcp->mb[3] = LSW(pd_dma);
 mcp->mb[6] = MSW(MSD(pd_dma));
 mcp->mb[7] = LSW(MSD(pd_dma));
 mcp->mb[9] = vha->vp_idx;
 mcp->out_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
 mcp->in_mb = MBX_0;
 if (IS_FWI2_CAPABLE(ha)) {
  mcp->mb[1] = fcport->loop_id;
  mcp->mb[10] = opt;
  mcp->out_mb |= MBX_10|MBX_1;
  mcp->in_mb |= MBX_1;
 } else if (HAS_EXTENDED_IDS(ha)) {
  mcp->mb[1] = fcport->loop_id;
  mcp->mb[10] = opt;
  mcp->out_mb |= MBX_10|MBX_1;
 } else {
  mcp->mb[1] = fcport->loop_id << 8 | opt;
  mcp->out_mb |= MBX_1;
 }
 mcp->buf_size = IS_FWI2_CAPABLE(ha) ?
     PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE;
 mcp->flags = MBX_DMA_IN;
 mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
 rval = qla2x00_mailbox_command(vha, mcp);
 if (rval != QLA_SUCCESS)
  goto gpd_error_out;

 if (IS_FWI2_CAPABLE(ha)) {
  uint64_t zero = 0;
  u8 current_login_state, last_login_state;

  pd24 = (struct port_database_24xx *) pd;

  /* Check for logged in state. */
  if (NVME_TARGET(ha, fcport)) {
   current_login_state = pd24->current_login_state >> 4;
   last_login_state = pd24->last_login_state >> 4;
  } else {
   current_login_state = pd24->current_login_state & 0xf;
   last_login_state = pd24->last_login_state & 0xf;
  }
  fcport->current_login_state = pd24->current_login_state;
  fcport->last_login_state = pd24->last_login_state;

  /* Check for logged in state. */
  if (current_login_state != PDS_PRLI_COMPLETE &&
      last_login_state != PDS_PRLI_COMPLETE) {
   ql_dbg(ql_dbg_mbx, vha, 0x119a,
       "Unable to verify login-state (%x/%x) for loop_id %x.\n",
       current_login_state, last_login_state,
       fcport->loop_id);
   rval = QLA_FUNCTION_FAILED;

   if (!fcport->query)
    goto gpd_error_out;
  }

  if (fcport->loop_id == FC_NO_LOOP_ID ||
      (memcmp(fcport->port_name, (uint8_t *)&zero, 8) &&
       memcmp(fcport->port_name, pd24->port_name, 8))) {
   /* We lost the device mid way. */
   rval = QLA_NOT_LOGGED_IN;
   goto gpd_error_out;
  }

  /* Names are little-endian. */
  memcpy(fcport->node_name, pd24->node_name, WWN_SIZE);
  memcpy(fcport->port_name, pd24->port_name, WWN_SIZE);

  /* Get port_id of device. */
  fcport->d_id.b.domain = pd24->port_id[0];
  fcport->d_id.b.area = pd24->port_id[1];
  fcport->d_id.b.al_pa = pd24->port_id[2];
  fcport->d_id.b.rsvd_1 = 0;

  /* If not target must be initiator or unknown type. */
  if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0)
   fcport->port_type = FCT_INITIATOR;
  else
   fcport->port_type = FCT_TARGET;

  /* Passback COS information. */
  fcport->supported_classes = (pd24->flags & PDF_CLASS_2) ?
    FC_COS_CLASS2 : FC_COS_CLASS3;

  if (pd24->prli_svc_param_word_3[0] & BIT_7)
   fcport->flags |= FCF_CONF_COMP_SUPPORTED;
 } else {
  uint64_t zero = 0;

  /* Check for logged in state. */
  if (pd->master_state != PD_STATE_PORT_LOGGED_IN &&
      pd->slave_state != PD_STATE_PORT_LOGGED_IN) {
   ql_dbg(ql_dbg_mbx, vha, 0x100a,
       "Unable to verify login-state (%x/%x) - "
       "portid=%02x%02x%02x.\n", pd->master_state,
       pd->slave_state, fcport->d_id.b.domain,
       fcport->d_id.b.area, fcport->d_id.b.al_pa);
   rval = QLA_FUNCTION_FAILED;
   goto gpd_error_out;
  }

  if (fcport->loop_id == FC_NO_LOOP_ID ||
      (memcmp(fcport->port_name, (uint8_t *)&zero, 8) &&
       memcmp(fcport->port_name, pd->port_name, 8))) {
   /* We lost the device mid way. */
   rval = QLA_NOT_LOGGED_IN;
   goto gpd_error_out;
  }

  /* Names are little-endian. */
  memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
  memcpy(fcport->port_name, pd->port_name, WWN_SIZE);

  /* Get port_id of device. */
  fcport->d_id.b.domain = pd->port_id[0];
  fcport->d_id.b.area = pd->port_id[3];
  fcport->d_id.b.al_pa = pd->port_id[2];
  fcport->d_id.b.rsvd_1 = 0;

  /* If not target must be initiator or unknown type. */
  if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
   fcport->port_type = FCT_INITIATOR;
  else
   fcport->port_type = FCT_TARGET;

  /* Passback COS information. */
  fcport->supported_classes = (pd->options & BIT_4) ?
      FC_COS_CLASS2 : FC_COS_CLASS3;
 }

gpd_error_out:
 dma_pool_free(ha->s_dma_pool, pd, pd_dma);
 fcport->query = 0;

 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x1052,
      "Failed=%x mb[0]=%x mb[1]=%x.\n", rval,
      mcp->mb[0], mcp->mb[1]);
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1053,
      "Done %s.\n", __func__);
 }

 return rval;
}

int
qla24xx_get_port_database(scsi_qla_host_t *vha, u16 nport_handle,
 struct port_database_24xx *pdb)
{
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;
 dma_addr_t pdb_dma;
 int rval;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1115,
     "Entered %s.\n", __func__);

 memset(pdb, 0, sizeof(*pdb));

 pdb_dma = dma_map_single(&vha->hw->pdev->dev, pdb,
     sizeof(*pdb), DMA_FROM_DEVICE);
 if (dma_mapping_error(&vha->hw->pdev->dev, pdb_dma)) {
  ql_log(ql_log_warn, vha, 0x1116, "Failed to map dma buffer.\n");
  return QLA_MEMORY_ALLOC_FAILED;
 }

 mcp->mb[0] = MBC_GET_PORT_DATABASE;
 mcp->mb[1] = nport_handle;
 mcp->mb[2] = MSW(LSD(pdb_dma));
 mcp->mb[3] = LSW(LSD(pdb_dma));
 mcp->mb[6] = MSW(MSD(pdb_dma));
 mcp->mb[7] = LSW(MSD(pdb_dma));
 mcp->mb[9] = 0;
 mcp->mb[10] = 0;
 mcp->out_mb = MBX_10|MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->in_mb = MBX_1|MBX_0;
 mcp->buf_size = sizeof(*pdb);
 mcp->flags = MBX_DMA_IN;
 mcp->tov = vha->hw->login_timeout * 2;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x111a,
      "Failed=%x mb[0]=%x mb[1]=%x.\n",
      rval, mcp->mb[0], mcp->mb[1]);
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x111b,
      "Done %s.\n", __func__);
 }

 dma_unmap_single(&vha->hw->pdev->dev, pdb_dma,
     sizeof(*pdb), DMA_FROM_DEVICE);

 return rval;
}

/*
 * qla2x00_get_firmware_state
 * Get adapter firmware state.
 *
 * Input:
 * ha = adapter block pointer.
 * dptr = pointer for firmware state.
 * TARGET_QUEUE_LOCK must be released.
 * ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;
 struct qla_hw_data *ha = vha->hw;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1054,
     "Entered %s.\n", __func__);

 if (!ha->flags.fw_started)
  return QLA_FUNCTION_FAILED;

 mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
 mcp->out_mb = MBX_0;
 if (IS_FWI2_CAPABLE(vha->hw))
  mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
 else
  mcp->in_mb = MBX_1|MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 /* Return firmware states. */
 states[0] = mcp->mb[1];
 if (IS_FWI2_CAPABLE(vha->hw)) {
  states[1] = mcp->mb[2];
  states[2] = mcp->mb[3];  /* SFP info */
  states[3] = mcp->mb[4];
  states[4] = mcp->mb[5];
  states[5] = mcp->mb[6];  /* DPORT status */
 }

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x1055, "Failed=%x.\n", rval);
 } else {
  if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
   if (mcp->mb[2] == 6 || mcp->mb[3] == 2)
    ql_dbg(ql_dbg_mbx, vha, 0x119e,
        "Invalid SFP/Validation Failed\n");
  }
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1056,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla2x00_get_port_name
 * Issue get port name mailbox command.
 * Returned name is in big endian format.
 *
 * Input:
 * ha = adapter block pointer.
 * loop_id = loop ID of device.
 * name = pointer for name.
 * TARGET_QUEUE_LOCK must be released.
 * ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_get_port_name(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t *name,
    uint8_t opt)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1057,
     "Entered %s.\n", __func__);

 mcp->mb[0] = MBC_GET_PORT_NAME;
 mcp->mb[9] = vha->vp_idx;
 mcp->out_mb = MBX_9|MBX_1|MBX_0;
 if (HAS_EXTENDED_IDS(vha->hw)) {
  mcp->mb[1] = loop_id;
  mcp->mb[10] = opt;
  mcp->out_mb |= MBX_10;
 } else {
  mcp->mb[1] = loop_id << 8 | opt;
 }

 mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x1058, "Failed=%x.\n", rval);
 } else {
  if (name != NULL) {
   /* This function returns name in big endian. */
   name[0] = MSB(mcp->mb[2]);
   name[1] = LSB(mcp->mb[2]);
   name[2] = MSB(mcp->mb[3]);
   name[3] = LSB(mcp->mb[3]);
   name[4] = MSB(mcp->mb[6]);
   name[5] = LSB(mcp->mb[6]);
   name[6] = MSB(mcp->mb[7]);
   name[7] = LSB(mcp->mb[7]);
  }

  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1059,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla24xx_link_initialization
 * Issue link initialization mailbox command.
 *
 * Input:
 * ha = adapter block pointer.
 * TARGET_QUEUE_LOCK must be released.
 * ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla24xx_link_initialize(scsi_qla_host_t *vha)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1152,
     "Entered %s.\n", __func__);

 if (!IS_FWI2_CAPABLE(vha->hw) || IS_CNA_CAPABLE(vha->hw))
  return QLA_FUNCTION_FAILED;

 mcp->mb[0] = MBC_LINK_INITIALIZATION;
 mcp->mb[1] = BIT_4;
 if (vha->hw->operating_mode == LOOP)
  mcp->mb[1] |= BIT_6;
 else
  mcp->mb[1] |= BIT_5;
 mcp->mb[2] = 0;
 mcp->mb[3] = 0;
 mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->in_mb = MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  ql_dbg(ql_dbg_mbx, vha, 0x1153, "Failed=%x.\n", rval);
 } else {
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1154,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla2x00_lip_reset
 * Issue LIP reset mailbox command.
 *
 * Input:
 * ha = adapter block pointer.
 * TARGET_QUEUE_LOCK must be released.
 * ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_lip_reset(scsi_qla_host_t *vha)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_disc, vha, 0x105a,
     "Entered %s.\n", __func__);

 if (IS_CNA_CAPABLE(vha->hw)) {
  /* Logout across all FCFs. */
  mcp->mb[0] = MBC_LIP_FULL_LOGIN;
  mcp->mb[1] = BIT_1;
  mcp->mb[2] = 0;
  mcp->out_mb = MBX_2|MBX_1|MBX_0;
 } else if (IS_FWI2_CAPABLE(vha->hw)) {
  mcp->mb[0] = MBC_LIP_FULL_LOGIN;
  mcp->mb[1] = BIT_4;
  mcp->mb[2] = 0;
  mcp->mb[3] = vha->hw->loop_reset_delay;
  mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
 } else {
  mcp->mb[0] = MBC_LIP_RESET;
  mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
  if (HAS_EXTENDED_IDS(vha->hw)) {
   mcp->mb[1] = 0x00ff;
   mcp->mb[10] = 0;
   mcp->out_mb |= MBX_10;
  } else {
   mcp->mb[1] = 0xff00;
  }
  mcp->mb[2] = vha->hw->loop_reset_delay;
  mcp->mb[3] = 0;
 }
 mcp->in_mb = MBX_0;
 mcp->tov = MBX_TOV_SECONDS;
 mcp->flags = 0;
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x105b, "Failed=%x.\n", rval);
 } else {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105c,
      "Done %s.\n", __func__);
 }

 return rval;
}

/*
 * qla2x00_send_sns
 * Send SNS command.
 *
 * Input:
 * ha = adapter block pointer.
 * sns = pointer for command.
 * cmd_size = command size.
 * buf_size = response/command size.
 * TARGET_QUEUE_LOCK must be released.
 * ADAPTER_STATE_LOCK must be released.
 *
 * Returns:
 * qla2x00 local function return status code.
 *
 * Context:
 * Kernel context.
 */
int
qla2x00_send_sns(scsi_qla_host_t *vha, dma_addr_t sns_phys_address,
    uint16_t cmd_size, size_t buf_size)
{
 int rval;
 mbx_cmd_t mc;
 mbx_cmd_t *mcp = &mc;

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105d,
     "Entered %s.\n", __func__);

 ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105e,
     "Retry cnt=%d ratov=%d total tov=%d.\n",
     vha->hw->retry_count, vha->hw->login_timeout, mcp->tov);

 mcp->mb[0] = MBC_SEND_SNS_COMMAND;
 mcp->mb[1] = cmd_size;
 mcp->mb[2] = MSW(sns_phys_address);
 mcp->mb[3] = LSW(sns_phys_address);
 mcp->mb[6] = MSW(MSD(sns_phys_address));
 mcp->mb[7] = LSW(MSD(sns_phys_address));
 mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
 mcp->in_mb = MBX_0|MBX_1;
 mcp->buf_size = buf_size;
 mcp->flags = MBX_DMA_OUT|MBX_DMA_IN;
 mcp->tov = (vha->hw->login_timeout * 2) + (vha->hw->login_timeout / 2);
 rval = qla2x00_mailbox_command(vha, mcp);

 if (rval != QLA_SUCCESS) {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx, vha, 0x105f,
      "Failed=%x mb[0]=%x mb[1]=%x.\n",
      rval, mcp->mb[0], mcp->mb[1]);
 } else {
  /*EMPTY*/
  ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1060,
      "Done %s.\n", __func__);
 }

 return rval;
}

int
qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
--> --------------------

--> maximum size reached

--> --------------------