[SCSI] qla2xxx: Implemeted beacon on/off for ISP82XX.
[linux-2.6.git] / drivers / scsi / qla2xxx / qla_mbx.c
index 3402746..3b3cec9 100644 (file)
@@ -1,12 +1,13 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2008 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
 #include "qla_def.h"
 
 #include <linux/delay.h>
+#include <linux/gfp.h>
 
 
 /*
  *     Kernel context.
  */
 static int
-qla2x00_mailbox_command(scsi_qla_host_t *pvha, mbx_cmd_t *mcp)
+qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
 {
        int             rval;
        unsigned long    flags = 0;
        device_reg_t __iomem *reg;
        uint8_t         abort_active;
        uint8_t         io_lock_on;
-       uint16_t        command;
+       uint16_t        command = 0;
        uint16_t        *iptr;
        uint16_t __iomem *optr;
        uint32_t        cnt;
        uint32_t        mboxes;
        unsigned long   wait_time;
-       scsi_qla_host_t *ha = to_qla_parent(pvha);
+       struct qla_hw_data *ha = vha->hw;
+       scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
+
+       ql_dbg(ql_dbg_mbx, base_vha, 0x1000, "Entered %s.\n", __func__);
+
+       if (ha->pdev->error_state > pci_channel_io_frozen) {
+               ql_log(ql_log_warn, base_vha, 0x1001,
+                   "error_state is greater than pci_channel_io_frozen, "
+                   "exiting.\n");
+               return QLA_FUNCTION_TIMEOUT;
+       }
+
+       if (vha->device_flags & DFLG_DEV_FAILED) {
+               ql_log(ql_log_warn, base_vha, 0x1002,
+                   "Device in failed state, exiting.\n");
+               return QLA_FUNCTION_TIMEOUT;
+       }
 
        reg = ha->iobase;
-       io_lock_on = ha->flags.init_done;
+       io_lock_on = base_vha->flags.init_done;
 
        rval = QLA_SUCCESS;
-       abort_active = test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
+       abort_active = test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
+
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, pvha->host_no));
+       if (ha->flags.pci_channel_io_perm_failure) {
+               ql_log(ql_log_warn, base_vha, 0x1003,
+                   "Perm failure on EEH timeout MBX, exiting.\n");
+               return QLA_FUNCTION_TIMEOUT;
+       }
+
+       if (ha->flags.isp82xx_fw_hung) {
+               /* Setting Link-Down error */
+               mcp->mb[0] = MBS_LINK_DOWN_ERROR;
+               ql_log(ql_log_warn, base_vha, 0x1004,
+                   "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
+               rval = QLA_FUNCTION_FAILED;
+               goto premature_exit;
+       }
 
        /*
         * 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 (!abort_active) {
-               if (!wait_for_completion_timeout(&ha->mbx_cmd_comp,
-                   mcp->tov * HZ)) {
-                       /* Timeout occurred. Return error. */
-                       DEBUG2_3_11(printk("%s(%ld): cmd access timeout. "
-                           "Exiting.\n", __func__, ha->host_no));
-                       return QLA_FUNCTION_TIMEOUT;
-               }
+       if (!wait_for_completion_timeout(&ha->mbx_cmd_comp, mcp->tov * HZ)) {
+               /* Timeout occurred. Return error. */
+               ql_log(ql_log_warn, base_vha, 0x1005,
+                   "Cmd access timeout, Exiting.\n");
+               return QLA_FUNCTION_TIMEOUT;
        }
 
        ha->flags.mbox_busy = 1;
        /* Save mailbox command for debug */
        ha->mcp = mcp;
 
-       DEBUG11(printk("scsi(%ld): prepare to issue mbox cmd=0x%x.\n",
-           ha->host_no, mcp->mb[0]));
+       ql_dbg(ql_dbg_mbx, base_vha, 0x1006,
+           "Prepare to issue mbox cmd=0x%x.\n", mcp->mb[0]);
 
        spin_lock_irqsave(&ha->hardware_lock, flags);
 
        /* Load mailbox registers. */
-       if (IS_FWI2_CAPABLE(ha))
+       if (IS_QLA82XX(ha))
+               optr = (uint16_t __iomem *)&reg->isp82.mailbox_in[0];
+       else if (IS_FWI2_CAPABLE(ha) && !IS_QLA82XX(ha))
                optr = (uint16_t __iomem *)&reg->isp24.mailbox0;
        else
                optr = (uint16_t __iomem *)MAILBOX_REG(ha, &reg->isp, 0);
@@ -98,34 +128,48 @@ qla2x00_mailbox_command(scsi_qla_host_t *pvha, mbx_cmd_t *mcp)
                iptr++;
        }
 
-#if defined(QL_DEBUG_LEVEL_1)
-       printk("%s(%ld): Loaded MBX registers (displayed in bytes) = \n",
-           __func__, ha->host_no);
-       qla2x00_dump_buffer((uint8_t *)mcp->mb, 16);
-       printk("\n");
-       qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x10), 16);
-       printk("\n");
-       qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x20), 8);
-       printk("\n");
-       printk("%s(%ld): I/O address = %p.\n", __func__, ha->host_no, optr);
-       qla2x00_dump_regs(ha);
-#endif
+       ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1111,
+           "Loaded MBX registers (displayed in bytes) =.\n");
+       ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1112,
+           (uint8_t *)mcp->mb, 16);
+       ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1113,
+           ".\n");
+       ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1114,
+           ((uint8_t *)mcp->mb + 0x10), 16);
+       ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1115,
+           ".\n");
+       ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1116,
+           ((uint8_t *)mcp->mb + 0x20), 8);
+       ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1117,
+           "I/O Address = %p.\n", optr);
+       ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x100e);
 
        /* 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 */
-       DEBUG11(printk("%s(%ld): going to unlock irq & waiting for interrupt. "
-           "jiffies=%lx.\n", __func__, ha->host_no, jiffies));
+       ql_dbg(ql_dbg_mbx, base_vha, 0x100f,
+           "Going to unlock irq & waiting for interrupts. "
+           "jiffies=%lx.\n", jiffies);
 
        /* Wait for mbx cmd completion until timeout */
 
-       if (!abort_active && io_lock_on) {
-
+       if ((!abort_active && io_lock_on) || IS_NOPOLLING_TYPE(ha)) {
                set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
 
-               if (IS_FWI2_CAPABLE(ha))
+               if (IS_QLA82XX(ha)) {
+                       if (RD_REG_DWORD(&reg->isp82.hint) &
+                               HINT_MBX_INT_PENDING) {
+                               spin_unlock_irqrestore(&ha->hardware_lock,
+                                       flags);
+                               ql_dbg(ql_dbg_mbx, base_vha, 0x1010,
+                                   "Pending mailbox timeout, exiting.\n");
+                               rval = QLA_FUNCTION_TIMEOUT;
+                               goto premature_exit;
+                       }
+                       WRT_REG_DWORD(&reg->isp82.hint, HINT_MBX_INT_PENDING);
+               } else if (IS_FWI2_CAPABLE(ha))
                        WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
                else
                        WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
@@ -136,10 +180,21 @@ qla2x00_mailbox_command(scsi_qla_host_t *pvha, mbx_cmd_t *mcp)
                clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
 
        } else {
-               DEBUG3_11(printk("%s(%ld): cmd=%x POLLING MODE.\n", __func__,
-                   ha->host_no, command));
-
-               if (IS_FWI2_CAPABLE(ha))
+               ql_dbg(ql_dbg_mbx, base_vha, 0x1011,
+                   "Cmd=%x Polling Mode.\n", command);
+
+               if (IS_QLA82XX(ha)) {
+                       if (RD_REG_DWORD(&reg->isp82.hint) &
+                               HINT_MBX_INT_PENDING) {
+                               spin_unlock_irqrestore(&ha->hardware_lock,
+                                       flags);
+                               ql_dbg(ql_dbg_mbx, base_vha, 0x1012,
+                                   "Pending mailbox timeout, exiting.\n");
+                               rval = QLA_FUNCTION_TIMEOUT;
+                               goto premature_exit;
+                       }
+                       WRT_REG_DWORD(&reg->isp82.hint, HINT_MBX_INT_PENDING);
+               } else if (IS_FWI2_CAPABLE(ha))
                        WRT_REG_DWORD(&reg->isp24.hccr, HCCRX_SET_HOST_INT);
                else
                        WRT_REG_WORD(&reg->isp.hccr, HCCR_SET_HOST_INT);
@@ -151,25 +206,40 @@ qla2x00_mailbox_command(scsi_qla_host_t *pvha, mbx_cmd_t *mcp)
                                break;
 
                        /* Check for pending interrupts. */
-                       qla2x00_poll(ha);
+                       qla2x00_poll(ha->rsp_q_map[0]);
 
-                       if (command != MBC_LOAD_RISC_RAM_EXTENDED &&
-                           !ha->flags.mbox_int)
+                       if (!ha->flags.mbox_int &&
+                           !(IS_QLA2200(ha) &&
+                           command == MBC_LOAD_RISC_RAM_EXTENDED))
                                msleep(10);
                } /* while */
+               ql_dbg(ql_dbg_mbx, base_vha, 0x1013,
+                   "Waited %d sec.\n",
+                   (uint)((jiffies - (wait_time - (mcp->tov * HZ)))/HZ));
        }
 
        /* Check whether we timed out */
        if (ha->flags.mbox_int) {
                uint16_t *iptr2;
 
-               DEBUG3_11(printk("%s(%ld): cmd %x completed.\n", __func__,
-                   ha->host_no, command));
+               ql_dbg(ql_dbg_mbx, base_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 (ha->flags.isp82xx_fw_hung) {
+                       ha->flags.mbox_busy = 0;
+                       /* Setting Link-Down error */
+                       mcp->mb[0] = MBS_LINK_DOWN_ERROR;
+                       ha->mcp = NULL;
+                       rval = QLA_FUNCTION_FAILED;
+                       ql_log(ql_log_warn, base_vha, 0x1015,
+                           "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
+                       goto premature_exit;
+               }
+
                if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE)
                        rval = QLA_FUNCTION_FAILED;
 
@@ -187,8 +257,6 @@ qla2x00_mailbox_command(scsi_qla_host_t *pvha, mbx_cmd_t *mcp)
                }
        } else {
 
-#if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3) || \
-               defined(QL_DEBUG_LEVEL_11)
                uint16_t mb0;
                uint32_t ictrl;
 
@@ -199,14 +267,13 @@ qla2x00_mailbox_command(scsi_qla_host_t *pvha, mbx_cmd_t *mcp)
                        mb0 = RD_MAILBOX_REG(ha, &reg->isp, 0);
                        ictrl = RD_REG_WORD(&reg->isp.ictrl);
                }
-               printk("%s(%ld): **** MB Command Timeout for cmd %x ****\n",
-                   __func__, ha->host_no, command);
-               printk("%s(%ld): icontrol=%x jiffies=%lx\n", __func__,
-                   ha->host_no, ictrl, jiffies);
-               printk("%s(%ld): *** mailbox[0] = 0x%x ***\n", __func__,
-                   ha->host_no, mb0);
-               qla2x00_dump_regs(ha);
-#endif
+               ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1119,
+                   "MBX Command timeout for cmd %x.\n", command);
+               ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x111a,
+                   "iocontrol=%x jiffies=%lx.\n", ictrl, jiffies);
+               ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x111b,
+                   "mb[0] = 0x%x.\n", mb0);
+               ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1019);
 
                rval = QLA_FUNCTION_TIMEOUT;
        }
@@ -216,75 +283,85 @@ qla2x00_mailbox_command(scsi_qla_host_t *pvha, mbx_cmd_t *mcp)
        /* Clean up */
        ha->mcp = NULL;
 
-       if (abort_active || !io_lock_on) {
-               DEBUG11(printk("%s(%ld): checking for additional resp "
-                   "interrupt.\n", __func__, ha->host_no));
+       if ((abort_active || !io_lock_on) && !IS_NOPOLLING_TYPE(ha)) {
+               ql_dbg(ql_dbg_mbx, base_vha, 0x101a,
+                   "Checking for additional resp interrupt.\n");
 
                /* polling mode for non isp_abort commands. */
-               qla2x00_poll(ha);
+               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)) {
+               if (!io_lock_on || (mcp->flags & IOCTL_CMD) ||
+                   ha->flags.eeh_busy) {
                        /* not in dpc. schedule it for dpc to take over. */
-                       DEBUG(printk("%s(%ld): timeout schedule "
-                           "isp_abort_needed.\n", __func__, ha->host_no));
-                       DEBUG2_3_11(printk("%s(%ld): timeout schedule "
-                           "isp_abort_needed.\n", __func__, ha->host_no));
-                       qla_printk(KERN_WARNING, ha,
-                           "Mailbox command timeout occurred. Scheduling ISP "
-                           "abort.\n");
-                       set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
-                       qla2xxx_wake_dpc(ha);
+                       ql_dbg(ql_dbg_mbx, base_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)) {
+
+                               ql_log(ql_log_info, base_vha, 0x101c,
+                                   "Mailbox cmd timeout occured. "
+                                   "Scheduling ISP abort eeh_busy=0x%x.\n",
+                                       ha->flags.eeh_busy);
+                               set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                               qla2xxx_wake_dpc(vha);
+                       }
                } else if (!abort_active) {
                        /* call abort directly since we are in the DPC thread */
-                       DEBUG(printk("%s(%ld): timeout calling abort_isp\n",
-                           __func__, ha->host_no));
-                       DEBUG2_3_11(printk("%s(%ld): timeout calling "
-                           "abort_isp\n", __func__, ha->host_no));
-                       qla_printk(KERN_WARNING, ha,
-                           "Mailbox command timeout occurred. Issuing ISP "
-                           "abort.\n");
-
-                       set_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
-                       clear_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
-                       if (qla2x00_abort_isp(ha)) {
-                               /* Failed. retry later. */
-                               set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
+                       ql_dbg(ql_dbg_mbx, base_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)) {
+
+                               ql_log(ql_log_info, base_vha, 0x101e,
+                                   "Mailbox cmd timeout occured. "
+                                   "Scheduling ISP abort.\n");
+
+                               set_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
+                               clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                               if (ha->isp_ops->abort_isp(vha)) {
+                                       /* Failed. retry later. */
+                                       set_bit(ISP_ABORT_NEEDED,
+                                           &vha->dpc_flags);
+                               }
+                               clear_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
+                               ql_dbg(ql_dbg_mbx, base_vha, 0x101f,
+                                   "Finished abort_isp.\n");
                        }
-                       clear_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags);
-                       DEBUG(printk("%s(%ld): finished abort_isp\n", __func__,
-                           ha->host_no));
-                       DEBUG2_3_11(printk("%s(%ld): finished abort_isp\n",
-                           __func__, ha->host_no));
                }
        }
 
+premature_exit:
        /* Allow next mbx cmd to come in. */
-       if (!abort_active)
-               complete(&ha->mbx_cmd_comp);
+       complete(&ha->mbx_cmd_comp);
 
        if (rval) {
-               DEBUG2_3_11(printk("%s(%ld): **** FAILED. mbx0=%x, mbx1=%x, "
-                   "mbx2=%x, cmd=%x ****\n", __func__, ha->host_no,
-                   mcp->mb[0], mcp->mb[1], mcp->mb[2], command));
+               ql_dbg(ql_dbg_mbx, base_vha, 0x1020,
+                   "**** Failed mbx[0]=%x, mb[1]=%x, mb[2]=%x, cmd=%x ****.\n",
+                   mcp->mb[0], mcp->mb[1], mcp->mb[2], command);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, base_vha, 0x1021, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
 int
-qla2x00_load_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint32_t risc_addr,
+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;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1022, "Entered %s.\n", __func__);
 
        if (MSW(risc_addr) || IS_FWI2_CAPABLE(ha)) {
                mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
@@ -312,18 +389,19 @@ qla2x00_load_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint32_t risc_addr,
        mcp->in_mb = MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
-                   ha->host_no, rval, mcp->mb[0]));
+               ql_dbg(ql_dbg_mbx, vha, 0x1023,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1024, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
+#define        EXTENDED_BB_CREDITS     BIT_0
 /*
  * qla2x00_execute_fw
  *     Start adapter firmware.
@@ -340,13 +418,14 @@ qla2x00_load_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint32_t risc_addr,
  *     Kernel context.
  */
 int
-qla2x00_execute_fw(scsi_qla_host_t *ha, uint32_t risc_addr)
+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;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1025, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
        mcp->out_mb = MBX_0;
@@ -355,7 +434,12 @@ qla2x00_execute_fw(scsi_qla_host_t *ha, uint32_t risc_addr)
                mcp->mb[1] = MSW(risc_addr);
                mcp->mb[2] = LSW(risc_addr);
                mcp->mb[3] = 0;
-               mcp->mb[4] = 0;
+               if (IS_QLA81XX(ha)) {
+                       struct nvram_81xx *nv = ha->nvram;
+                       mcp->mb[4] = (nv->enhanced_features &
+                           EXTENDED_BB_CREDITS);
+               } else
+                       mcp->mb[4] = 0;
                mcp->out_mb |= MBX_4|MBX_3|MBX_2|MBX_1;
                mcp->in_mb |= MBX_1;
        } else {
@@ -369,18 +453,17 @@ qla2x00_execute_fw(scsi_qla_host_t *ha, uint32_t risc_addr)
 
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
-                   ha->host_no, rval, mcp->mb[0]));
+               ql_dbg(ql_dbg_mbx, vha, 0x1026,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
        } else {
                if (IS_FWI2_CAPABLE(ha)) {
-                       DEBUG11(printk("%s(%ld): done exchanges=%x.\n",
-                           __func__, ha->host_no, mcp->mb[1]));
+                       ql_dbg(ql_dbg_mbx, vha, 0x1027,
+                           "Done exchanges=%x.\n", mcp->mb[1]);
                } else {
-                       DEBUG11(printk("%s(%ld): done.\n", __func__,
-                           ha->host_no));
+                       ql_dbg(ql_dbg_mbx, vha, 0x1028, "Done %s.\n", __func__);
                }
        }
 
@@ -403,41 +486,55 @@ qla2x00_execute_fw(scsi_qla_host_t *ha, uint32_t risc_addr)
  * Context:
  *     Kernel context.
  */
-void
-qla2x00_get_fw_version(scsi_qla_host_t *ha, uint16_t *major, uint16_t *minor,
-    uint16_t *subminor, uint16_t *attributes, uint32_t *memory)
+int
+qla2x00_get_fw_version(scsi_qla_host_t *vha, uint16_t *major, uint16_t *minor,
+    uint16_t *subminor, uint16_t *attributes, uint32_t *memory, uint8_t *mpi,
+    uint32_t *mpi_caps, uint8_t *phy)
 {
        int             rval;
        mbx_cmd_t       mc;
        mbx_cmd_t       *mcp = &mc;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, 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))
+               mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8;
        mcp->flags = 0;
        mcp->tov = MBX_TOV_SECONDS;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
+       if (rval != QLA_SUCCESS)
+               goto failed;
 
        /* Return mailbox data. */
        *major = mcp->mb[1];
        *minor = mcp->mb[2];
        *subminor = mcp->mb[3];
        *attributes = mcp->mb[6];
-       if (IS_QLA2100(ha) || IS_QLA2200(ha))
+       if (IS_QLA2100(vha->hw) || IS_QLA2200(vha->hw))
                *memory = 0x1FFFF;                      /* Defaults to 128KB. */
        else
                *memory = (mcp->mb[5] << 16) | mcp->mb[4];
-
+       if (IS_QLA81XX(vha->hw)) {
+               mpi[0] = mcp->mb[10] & 0xff;
+               mpi[1] = mcp->mb[11] >> 8;
+               mpi[2] = mcp->mb[11] & 0xff;
+               *mpi_caps = (mcp->mb[12] << 16) | mcp->mb[13];
+               phy[0] = mcp->mb[8] & 0xff;
+               phy[1] = mcp->mb[9] >> 8;
+               phy[2] = mcp->mb[9] & 0xff;
+       }
+failed:
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x102a, "Failed=%x.\n", rval);
        } else {
                /*EMPTY*/
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x102b, "Done %s.\n", __func__);
        }
+       return rval;
 }
 
 /*
@@ -455,32 +552,31 @@ qla2x00_get_fw_version(scsi_qla_host_t *ha, uint16_t *major, uint16_t *minor,
  *     Kernel context.
  */
 int
-qla2x00_get_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts)
+qla2x00_get_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, 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(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               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];
 
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x102e, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -502,13 +598,13 @@ qla2x00_get_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts)
  *     Kernel context.
  */
 int
-qla2x00_set_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts)
+qla2x00_set_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x102f, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_SET_FIRMWARE_OPTION;
        mcp->mb[1] = fwopts[1];
@@ -516,7 +612,7 @@ qla2x00_set_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts)
        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(ha)) {
+       if (IS_FWI2_CAPABLE(vha->hw)) {
                mcp->in_mb |= MBX_1;
        } else {
                mcp->mb[10] = fwopts[10];
@@ -526,17 +622,17 @@ qla2x00_set_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts)
        }
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        fwopts[0] = mcp->mb[0];
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("%s(%ld): failed=%x (%x/%x).\n", __func__,
-                   ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+               ql_dbg(ql_dbg_mbx, vha, 0x1030,
+                   "Failed=%x (%x/%x).\n", rval, mcp->mb[0], mcp->mb[1]);
        } else {
                /*EMPTY*/
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1031, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -558,13 +654,13 @@ qla2x00_set_fw_options(scsi_qla_host_t *ha, uint16_t *fwopts)
  *     Kernel context.
  */
 int
-qla2x00_mbx_reg_test(scsi_qla_host_t *ha)
+qla2x00_mbx_reg_test(scsi_qla_host_t *vha)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("qla2x00_mbx_reg_test(%ld): entered.\n", ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1032, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
        mcp->mb[1] = 0xAAAA;
@@ -578,7 +674,7 @@ qla2x00_mbx_reg_test(scsi_qla_host_t *ha)
        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(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval == QLA_SUCCESS) {
                if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
@@ -587,24 +683,14 @@ qla2x00_mbx_reg_test(scsi_qla_host_t *ha)
                if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
                    mcp->mb[7] != 0x2525)
                        rval = QLA_FUNCTION_FAILED;
-               if (rval == QLA_FUNCTION_FAILED) {
-                       struct device_reg_24xx __iomem *reg =
-                           &ha->iobase->isp24;
-
-                       qla2xxx_hw_event_log(ha, HW_EVENT_ISP_ERR, 0,
-                           LSW(RD_REG_DWORD(&reg->hccr)),
-                           LSW(RD_REG_DWORD(&reg->istatus)));
-               }
        }
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("qla2x00_mbx_reg_test(%ld): failed=%x.\n",
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x1033, "Failed=%x.\n", rval);
        } else {
                /*EMPTY*/
-               DEBUG11(printk("qla2x00_mbx_reg_test(%ld): done.\n",
-                   ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1034, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -626,18 +712,18 @@ qla2x00_mbx_reg_test(scsi_qla_host_t *ha)
  *     Kernel context.
  */
 int
-qla2x00_verify_checksum(scsi_qla_host_t *ha, uint32_t risc_addr)
+qla2x00_verify_checksum(scsi_qla_host_t *vha, uint32_t risc_addr)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, 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(ha)) {
+       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;
@@ -650,14 +736,14 @@ qla2x00_verify_checksum(scsi_qla_host_t *ha, uint32_t risc_addr)
 
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x chk sum=%x.\n", __func__,
-                   ha->host_no, rval, IS_FWI2_CAPABLE(ha) ?
-                   (mcp->mb[2] << 16) | mcp->mb[1]: mcp->mb[1]));
+               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 {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1037, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -681,14 +767,16 @@ qla2x00_verify_checksum(scsi_qla_host_t *ha, uint32_t risc_addr)
  * Context:
  *     Kernel context.
  */
-static int
-qla2x00_issue_iocb_timeout(scsi_qla_host_t *ha, void *buffer,
+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;
 
+       ql_dbg(ql_dbg_mbx, vha, 0x1038, "Entered %s.\n", __func__);
+
        mcp->mb[0] = MBC_IOCB_COMMAND_A64;
        mcp->mb[1] = 0;
        mcp->mb[2] = MSW(phys_addr);
@@ -699,30 +787,28 @@ qla2x00_issue_iocb_timeout(scsi_qla_host_t *ha, void *buffer,
        mcp->in_mb = MBX_2|MBX_0;
        mcp->tov = tov;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n",
-                   ha->host_no, rval));
-               DEBUG2(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n",
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x1039, "Failed=%x.\n", rval);
        } else {
                sts_entry_t *sts_entry = (sts_entry_t *) buffer;
 
                /* Mask reserved bits. */
                sts_entry->entry_status &=
-                   IS_FWI2_CAPABLE(ha) ? RF_MASK_24XX :RF_MASK;
+                   IS_FWI2_CAPABLE(vha->hw) ? RF_MASK_24XX : RF_MASK;
+               ql_dbg(ql_dbg_mbx, vha, 0x103a, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
 int
-qla2x00_issue_iocb(scsi_qla_host_t *ha, void *buffer, dma_addr_t phys_addr,
+qla2x00_issue_iocb(scsi_qla_host_t *vha, void *buffer, dma_addr_t phys_addr,
     size_t size)
 {
-       return qla2x00_issue_iocb_timeout(ha, buffer, phys_addr, size,
+       return qla2x00_issue_iocb_timeout(vha, buffer, phys_addr, size,
            MBX_TOV_SECONDS);
 }
 
@@ -741,22 +827,23 @@ qla2x00_issue_iocb(scsi_qla_host_t *ha, void *buffer, dma_addr_t phys_addr,
  *     Kernel context.
  */
 int
-qla2x00_abort_command(scsi_qla_host_t *ha, srb_t *sp)
+qla2x00_abort_command(srb_t *sp)
 {
        unsigned long   flags = 0;
-       fc_port_t       *fcport;
        int             rval;
-       uint32_t        handle;
+       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 = vha->req;
 
-       DEBUG11(printk("qla2x00_abort_command(%ld): entered.\n", ha->host_no));
-
-       fcport = sp->fcport;
+       ql_dbg(ql_dbg_mbx, vha, 0x103b, "Entered %s.\n", __func__);
 
        spin_lock_irqsave(&ha->hardware_lock, flags);
        for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
-               if (ha->outstanding_cmds[handle] == sp)
+               if (req->outstanding_cmds[handle] == sp)
                        break;
        }
        spin_unlock_irqrestore(&ha->hardware_lock, flags);
@@ -778,101 +865,109 @@ qla2x00_abort_command(scsi_qla_host_t *ha, srb_t *sp)
        mcp->in_mb = MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("qla2x00_abort_command(%ld): failed=%x.\n",
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x103c, "Failed=%x.\n", rval);
        } else {
-               DEBUG11(printk("qla2x00_abort_command(%ld): done.\n",
-                   ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x103d, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
 int
-qla2x00_abort_target(struct fc_port *fcport, unsigned int l)
+qla2x00_abort_target(struct fc_port *fcport, unsigned int l, int tag)
 {
        int rval, rval2;
        mbx_cmd_t  mc;
        mbx_cmd_t  *mcp = &mc;
-       scsi_qla_host_t *ha;
-
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->ha->host_no));
+       scsi_qla_host_t *vha;
+       struct req_que *req;
+       struct rsp_que *rsp;
 
        l = l;
-       ha = fcport->ha;
+       vha = fcport->vha;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x103e, "Entered %s.\n", __func__);
+
+       req = vha->hw->req_q_map[0];
+       rsp = req->rsp;
        mcp->mb[0] = MBC_ABORT_TARGET;
        mcp->out_mb = MBX_9|MBX_2|MBX_1|MBX_0;
-       if (HAS_EXTENDED_IDS(ha)) {
+       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] = ha->loop_reset_delay;
-       mcp->mb[9] = ha->vp_idx;
+       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(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x103f, "Failed=%x.\n", rval);
        }
 
        /* Issue marker IOCB. */
-       rval2 = qla2x00_marker(ha, fcport->loop_id, 0, MK_SYNC_ID);
+       rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, 0,
+                                                       MK_SYNC_ID);
        if (rval2 != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
-                   "(%x).\n", __func__, ha->host_no, rval2));
+               ql_dbg(ql_dbg_mbx, vha, 0x1040,
+                   "Failed to issue marker IOCB (%x).\n", rval2);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1041, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
 int
-qla2x00_lun_reset(struct fc_port *fcport, unsigned int l)
+qla2x00_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
 {
        int rval, rval2;
        mbx_cmd_t  mc;
        mbx_cmd_t  *mcp = &mc;
-       scsi_qla_host_t *ha;
+       scsi_qla_host_t *vha;
+       struct req_que *req;
+       struct rsp_que *rsp;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->ha->host_no));
+       vha = fcport->vha;
 
-       ha = fcport->ha;
+       ql_dbg(ql_dbg_mbx, vha, 0x1042, "Entered %s.\n", __func__);
+
+       req = vha->hw->req_q_map[0];
+       rsp = req->rsp;
        mcp->mb[0] = MBC_LUN_RESET;
        mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
-       if (HAS_EXTENDED_IDS(ha))
+       if (HAS_EXTENDED_IDS(vha->hw))
                mcp->mb[1] = fcport->loop_id;
        else
                mcp->mb[1] = fcport->loop_id << 8;
        mcp->mb[2] = l;
        mcp->mb[3] = 0;
-       mcp->mb[9] = ha->vp_idx;
+       mcp->mb[9] = vha->vp_idx;
 
        mcp->in_mb = MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x1043, "Failed=%x.\n", rval);
        }
 
        /* Issue marker IOCB. */
-       rval2 = qla2x00_marker(ha, fcport->loop_id, l, MK_SYNC_ID_LUN);
+       rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
+                                                               MK_SYNC_ID_LUN);
        if (rval2 != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
-                   "(%x).\n", __func__, ha->host_no, rval2));
+               ql_dbg(ql_dbg_mbx, vha, 0x1044,
+                   "Failed to issue marker IOCB (%x).\n", rval2);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1045, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -899,23 +994,24 @@ qla2x00_lun_reset(struct fc_port *fcport, unsigned int l)
  *     Kernel context.
  */
 int
-qla2x00_get_adapter_id(scsi_qla_host_t *ha, uint16_t *id, uint8_t *al_pa,
+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;
 
-       DEBUG11(printk("qla2x00_get_adapter_id(%ld): entered.\n",
-           ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1046, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
-       mcp->mb[9] = ha->vp_idx;
+       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_QLA8XXX_TYPE(vha->hw))
+               mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       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)
@@ -931,12 +1027,20 @@ qla2x00_get_adapter_id(scsi_qla_host_t *ha, uint16_t *id, uint8_t *al_pa,
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("qla2x00_get_adapter_id(%ld): failed=%x.\n",
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x1047, "Failed=%x.\n", rval);
        } else {
-               /*EMPTY*/
-               DEBUG11(printk("qla2x00_get_adapter_id(%ld): done.\n",
-                   ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1048, "Done %s.\n", __func__);
+
+               if (IS_QLA8XXX_TYPE(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;
+               }
        }
 
        return rval;
@@ -958,7 +1062,7 @@ qla2x00_get_adapter_id(scsi_qla_host_t *ha, uint16_t *id, uint8_t *al_pa,
  *     Kernel context.
  */
 int
-qla2x00_get_retry_cnt(scsi_qla_host_t *ha, uint8_t *retry_cnt, uint8_t *tov,
+qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
     uint16_t *r_a_tov)
 {
        int rval;
@@ -966,20 +1070,19 @@ qla2x00_get_retry_cnt(scsi_qla_host_t *ha, uint8_t *retry_cnt, uint8_t *tov,
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("qla2x00_get_retry_cnt(%ld): entered.\n",
-                       ha->host_no));
+       ql_dbg(ql_dbg_mbx, 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(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("qla2x00_get_retry_cnt(%ld): failed = %x.\n",
-                   ha->host_no, mcp->mb[0]));
+               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;
@@ -990,8 +1093,8 @@ qla2x00_get_retry_cnt(scsi_qla_host_t *ha, uint8_t *retry_cnt, uint8_t *tov,
                        *tov = ratov;
                }
 
-               DEBUG11(printk("qla2x00_get_retry_cnt(%ld): done. mb3=%d "
-                   "ratov=%d.\n", ha->host_no, mcp->mb[3], ratov));
+               ql_dbg(ql_dbg_mbx, vha, 0x104b,
+                   "Done %s mb3=%d ratov=%d.\n", __func__, mcp->mb[3], ratov);
        }
 
        return rval;
@@ -1015,42 +1118,52 @@ qla2x00_get_retry_cnt(scsi_qla_host_t *ha, uint8_t *retry_cnt, uint8_t *tov,
  *     Kernel context.
  */
 int
-qla2x00_init_firmware(scsi_qla_host_t *ha, uint16_t size)
+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, vha, 0x104c, "Entered %s.\n", __func__);
 
-       DEBUG11(printk("qla2x00_init_firmware(%ld): entered.\n",
-           ha->host_no));
+       if (IS_QLA82XX(ha) && ql2xdbwr)
+               qla82xx_wr_32(ha, 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[4] = 0;
-       mcp->mb[5] = 0;
        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_0;
-       mcp->in_mb = MBX_5|MBX_4|MBX_0;
+       mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
+       if (IS_QLA81XX(ha) && 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;
+       }
+       mcp->in_mb = MBX_0;
        mcp->buf_size = size;
        mcp->flags = MBX_DMA_OUT;
        mcp->tov = MBX_TOV_SECONDS;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("qla2x00_init_firmware(%ld): failed=%x "
-                   "mb0=%x.\n",
-                   ha->host_no, rval, mcp->mb[0]));
+               ql_dbg(ql_dbg_mbx, vha, 0x104d,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
        } else {
                /*EMPTY*/
-               DEBUG11(printk("qla2x00_init_firmware(%ld): done.\n",
-                   ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x104e, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -1073,7 +1186,7 @@ qla2x00_init_firmware(scsi_qla_host_t *ha, uint16_t size)
  *     Kernel context.
  */
 int
-qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt)
+qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
 {
        int rval;
        mbx_cmd_t mc;
@@ -1081,14 +1194,15 @@ qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt)
        port_database_t *pd;
        struct port_database_24xx *pd24;
        dma_addr_t pd_dma;
+       struct qla_hw_data *ha = vha->hw;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x104f, "Entered %s.\n", __func__);
 
        pd24 = NULL;
        pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
        if (pd  == NULL) {
-               DEBUG2_3(printk("%s(%ld): failed to allocate Port Database "
-                   "structure.\n", __func__, ha->host_no));
+               ql_log(ql_log_warn, vha, 0x1050,
+                   "Failed to allocate port database structure.\n");
                return QLA_MEMORY_ALLOC_FAILED;
        }
        memset(pd, 0, max(PORT_DATABASE_SIZE, PORT_DATABASE_24XX_SIZE));
@@ -1100,7 +1214,7 @@ qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt)
        mcp->mb[3] = LSW(pd_dma);
        mcp->mb[6] = MSW(MSD(pd_dma));
        mcp->mb[7] = LSW(MSD(pd_dma));
-       mcp->mb[9] = ha->vp_idx;
+       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)) {
@@ -1120,7 +1234,7 @@ qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt)
            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(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
        if (rval != QLA_SUCCESS)
                goto gpd_error_out;
 
@@ -1130,11 +1244,10 @@ qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt)
                /* Check for logged in state. */
                if (pd24->current_login_state != PDS_PRLI_COMPLETE &&
                    pd24->last_login_state != PDS_PRLI_COMPLETE) {
-                       DEBUG2(printk("%s(%ld): Unable to verify "
-                           "login-state (%x/%x) for loop_id %x\n",
-                           __func__, ha->host_no,
-                           pd24->current_login_state,
-                           pd24->last_login_state, fcport->loop_id));
+                       ql_dbg(ql_dbg_mbx, vha, 0x1051,
+                           "Unable to verify login-state (%x/%x) for "
+                           "loop_id %x.\n", pd24->current_login_state,
+                           pd24->last_login_state, fcport->loop_id);
                        rval = QLA_FUNCTION_FAILED;
                        goto gpd_error_out;
                }
@@ -1158,6 +1271,11 @@ qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt)
                /* 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;
                }
@@ -1172,10 +1290,6 @@ qla2x00_get_port_database(scsi_qla_host_t *ha, fc_port_t *fcport, uint8_t opt)
                fcport->d_id.b.al_pa = pd->port_id[2];
                fcport->d_id.b.rsvd_1 = 0;
 
-               /* Check for device require authentication. */
-               pd->common_features & BIT_5 ? (fcport->flags |= FCF_AUTH_REQ) :
-                   (fcport->flags &= ~FCF_AUTH_REQ);
-
                /* 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;
@@ -1191,10 +1305,11 @@ gpd_error_out:
        dma_pool_free(ha->s_dma_pool, pd, pd_dma);
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                   __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+               ql_dbg(ql_dbg_mbx, vha, 0x1052,
+                   "Failed=%x mb[0]=%x mb[1]=%x.\n", rval,
+                   mcp->mb[0], mcp->mb[1]);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1053, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -1217,35 +1332,39 @@ gpd_error_out:
  *     Kernel context.
  */
 int
-qla2x00_get_firmware_state(scsi_qla_host_t *ha, uint16_t *states)
+qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("qla2x00_get_firmware_state(%ld): entered.\n",
-           ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1054, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
        mcp->out_mb = MBX_0;
-       mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
+       if (IS_FWI2_CAPABLE(vha->hw))
+               mcp->in_mb = 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(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        /* Return firmware states. */
        states[0] = mcp->mb[1];
-       states[1] = mcp->mb[2];
-       states[2] = mcp->mb[3];
+       if (IS_FWI2_CAPABLE(vha->hw)) {
+               states[1] = mcp->mb[2];
+               states[2] = mcp->mb[3];
+               states[3] = mcp->mb[4];
+               states[4] = mcp->mb[5];
+       }
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("qla2x00_get_firmware_state(%ld): "
-                   "failed=%x.\n", ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x1055, "Failed=%x.\n", rval);
        } else {
                /*EMPTY*/
-               DEBUG11(printk("qla2x00_get_firmware_state(%ld): done.\n",
-                   ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1056, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -1270,20 +1389,19 @@ qla2x00_get_firmware_state(scsi_qla_host_t *ha, uint16_t *states)
  *     Kernel context.
  */
 int
-qla2x00_get_port_name(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t *name,
+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;
 
-       DEBUG11(printk("qla2x00_get_port_name(%ld): entered.\n",
-           ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1057, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_GET_PORT_NAME;
-       mcp->mb[9] = ha->vp_idx;
+       mcp->mb[9] = vha->vp_idx;
        mcp->out_mb = MBX_9|MBX_1|MBX_0;
-       if (HAS_EXTENDED_IDS(ha)) {
+       if (HAS_EXTENDED_IDS(vha->hw)) {
                mcp->mb[1] = loop_id;
                mcp->mb[10] = opt;
                mcp->out_mb |= MBX_10;
@@ -1294,12 +1412,11 @@ qla2x00_get_port_name(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t *name,
        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(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("qla2x00_get_port_name(%ld): failed=%x.\n",
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x1058, "Failed=%x.\n", rval);
        } else {
                if (name != NULL) {
                        /* This function returns name in big endian. */
@@ -1313,8 +1430,7 @@ qla2x00_get_port_name(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t *name,
                        name[7] = LSB(mcp->mb[7]);
                }
 
-               DEBUG11(printk("qla2x00_get_port_name(%ld): done.\n",
-                   ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1059, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -1336,45 +1452,50 @@ qla2x00_get_port_name(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t *name,
  *     Kernel context.
  */
 int
-qla2x00_lip_reset(scsi_qla_host_t *ha)
+qla2x00_lip_reset(scsi_qla_host_t *vha)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x105a, "Entered %s.\n", __func__);
 
-       if (IS_FWI2_CAPABLE(ha)) {
+       if (IS_QLA8XXX_TYPE(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_6;
                mcp->mb[2] = 0;
-               mcp->mb[3] = ha->loop_reset_delay;
+               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(ha)) {
+               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] = ha->loop_reset_delay;
+               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(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n",
-                   __func__, ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x105b, "Failed=%x.\n", rval);
        } else {
                /*EMPTY*/
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x105c, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -1399,18 +1520,18 @@ qla2x00_lip_reset(scsi_qla_host_t *ha)
  *     Kernel context.
  */
 int
-qla2x00_send_sns(scsi_qla_host_t *ha, dma_addr_t sns_phys_address,
+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;
 
-       DEBUG11(printk("qla2x00_send_sns(%ld): entered.\n",
-           ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x105d, "Entered %s.\n", __func__);
 
-       DEBUG11(printk("qla2x00_send_sns: retry cnt=%d ratov=%d total "
-           "tov=%d.\n", ha->retry_count, ha->login_timeout, mcp->tov));
+       ql_dbg(ql_dbg_mbx, 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;
@@ -1422,25 +1543,24 @@ qla2x00_send_sns(scsi_qla_host_t *ha, dma_addr_t sns_phys_address,
        mcp->in_mb = MBX_0|MBX_1;
        mcp->buf_size = buf_size;
        mcp->flags = MBX_DMA_OUT|MBX_DMA_IN;
-       mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
-       rval = qla2x00_mailbox_command(ha, mcp);
+       mcp->tov = (vha->hw->login_timeout * 2) + (vha->hw->login_timeout / 2);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
-                   "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
-               DEBUG2_3_11(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
-                   "mb[1]=%x.\n", ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+               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*/
-               DEBUG11(printk("qla2x00_send_sns(%ld): done.\n", ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1060, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
 int
-qla24xx_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
+qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
 {
        int             rval;
@@ -1448,19 +1568,29 @@ qla24xx_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
        struct logio_entry_24xx *lg;
        dma_addr_t      lg_dma;
        uint32_t        iop[2];
+       struct qla_hw_data *ha = vha->hw;
+       struct req_que *req;
+       struct rsp_que *rsp;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1061, "Entered %s.\n", __func__);
+
+       if (ha->flags.cpu_affinity_enabled)
+               req = ha->req_q_map[0];
+       else
+               req = vha->req;
+       rsp = req->rsp;
 
        lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
        if (lg == NULL) {
-               DEBUG2_3(printk("%s(%ld): failed to allocate Login IOCB.\n",
-                   __func__, ha->host_no));
+               ql_log(ql_log_warn, vha, 0x1062,
+                   "Failed to allocate login IOCB.\n");
                return QLA_MEMORY_ALLOC_FAILED;
        }
        memset(lg, 0, sizeof(struct logio_entry_24xx));
 
        lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
        lg->entry_count = 1;
+       lg->handle = MAKE_HANDLE(req->id, lg->handle);
        lg->nport_handle = cpu_to_le16(loop_id);
        lg->control_flags = __constant_cpu_to_le16(LCF_COMMAND_PLOGI);
        if (opt & BIT_0)
@@ -1470,24 +1600,24 @@ qla24xx_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
        lg->port_id[0] = al_pa;
        lg->port_id[1] = area;
        lg->port_id[2] = domain;
-       lg->vp_index = ha->vp_idx;
-       rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0);
+       lg->vp_index = vha->vp_idx;
+       rval = qla2x00_issue_iocb(vha, lg, lg_dma, 0);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed to issue Login IOCB "
-                   "(%x).\n", __func__, ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x1063,
+                   "Failed to issue login IOCB (%x).\n", rval);
        } else if (lg->entry_status != 0) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- error status (%x).\n", __func__, ha->host_no,
-                   lg->entry_status));
+               ql_dbg(ql_dbg_mbx, vha, 0x1064,
+                   "Failed to complete IOCB -- error status (%x).\n",
+                   lg->entry_status);
                rval = QLA_FUNCTION_FAILED;
        } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
                iop[0] = le32_to_cpu(lg->io_parameter[0]);
                iop[1] = le32_to_cpu(lg->io_parameter[1]);
 
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
-                   ha->host_no, le16_to_cpu(lg->comp_status), iop[0],
-                   iop[1]));
+               ql_dbg(ql_dbg_mbx, vha, 0x1065,
+                   "Failed to complete IOCB -- completion  status (%x) "
+                   "ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
+                   iop[0], iop[1]);
 
                switch (iop[0]) {
                case LSC_SCODE_PORTID_USED:
@@ -1515,7 +1645,7 @@ qla24xx_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
                        break;
                }
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1066, "Done %s.\n", __func__);
 
                iop[0] = le32_to_cpu(lg->io_parameter[0]);
 
@@ -1562,14 +1692,15 @@ qla24xx_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
  *     Kernel context.
  */
 int
-qla2x00_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
+qla2x00_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
     uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
+       struct qla_hw_data *ha = vha->hw;
 
-       DEBUG11(printk("qla2x00_login_fabric(%ld): entered.\n", ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1067, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
        mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
@@ -1586,7 +1717,7 @@ qla2x00_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
        mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
        mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        /* Return mailbox statuses. */
        if (mb != NULL) {
@@ -1612,13 +1743,12 @@ qla2x00_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
                        rval = QLA_SUCCESS;
 
                /*EMPTY*/
-               DEBUG2_3_11(printk("qla2x00_login_fabric(%ld): failed=%x "
-                   "mb[0]=%x mb[1]=%x mb[2]=%x.\n", ha->host_no, rval,
-                   mcp->mb[0], mcp->mb[1], mcp->mb[2]));
+               ql_dbg(ql_dbg_mbx, vha, 0x1068,
+                   "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
        } else {
                /*EMPTY*/
-               DEBUG11(printk("qla2x00_login_fabric(%ld): done.\n",
-                   ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1069, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -1641,20 +1771,21 @@ qla2x00_login_fabric(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
  *
  */
 int
-qla2x00_login_local_device(scsi_qla_host_t *ha, fc_port_t *fcport,
+qla2x00_login_local_device(scsi_qla_host_t *vha, fc_port_t *fcport,
     uint16_t *mb_ret, uint8_t opt)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
+       struct qla_hw_data *ha = vha->hw;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x106a, "Entered %s.\n", __func__);
 
        if (IS_FWI2_CAPABLE(ha))
-               return qla24xx_login_fabric(ha, fcport->loop_id,
+               return qla24xx_login_fabric(vha, fcport->loop_id,
                    fcport->d_id.b.domain, fcport->d_id.b.area,
                    fcport->d_id.b.al_pa, mb_ret, opt);
 
-       DEBUG3(printk("%s(%ld): entered.\n", __func__, ha->host_no));
-
        mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
        if (HAS_EXTENDED_IDS(ha))
                mcp->mb[1] = fcport->loop_id;
@@ -1665,7 +1796,7 @@ qla2x00_login_local_device(scsi_qla_host_t *ha, fc_port_t *fcport,
        mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0;
        mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        /* Return mailbox statuses. */
        if (mb_ret != NULL) {
@@ -1685,65 +1816,73 @@ qla2x00_login_local_device(scsi_qla_host_t *ha, fc_port_t *fcport,
                if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006)
                        rval = QLA_SUCCESS;
 
-               DEBUG(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
-                   "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval,
-                   mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]));
-               DEBUG2_3(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
-                   "mb[6]=%x mb[7]=%x.\n", __func__, ha->host_no, rval,
-                   mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]));
+               ql_dbg(ql_dbg_mbx, vha, 0x106b,
+                   "Failed=%x mb[0]=%x mb[1]=%x mb[6]=%x mb[7]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);
        } else {
                /*EMPTY*/
-               DEBUG3(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x106c, "Done %s.\n", __func__);
        }
 
        return (rval);
 }
 
 int
-qla24xx_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
+qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
     uint8_t area, uint8_t al_pa)
 {
        int             rval;
        struct logio_entry_24xx *lg;
        dma_addr_t      lg_dma;
+       struct qla_hw_data *ha = vha->hw;
+       struct req_que *req;
+       struct rsp_que *rsp;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x106d, "Entered %s.\n", __func__);
 
        lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
        if (lg == NULL) {
-               DEBUG2_3(printk("%s(%ld): failed to allocate Logout IOCB.\n",
-                   __func__, ha->host_no));
+               ql_log(ql_log_warn, vha, 0x106e,
+                   "Failed to allocate logout IOCB.\n");
                return QLA_MEMORY_ALLOC_FAILED;
        }
        memset(lg, 0, sizeof(struct logio_entry_24xx));
 
+       if (ql2xmaxqueues > 1)
+               req = ha->req_q_map[0];
+       else
+               req = vha->req;
+       rsp = req->rsp;
        lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
        lg->entry_count = 1;
+       lg->handle = MAKE_HANDLE(req->id, lg->handle);
        lg->nport_handle = cpu_to_le16(loop_id);
        lg->control_flags =
-           __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO);
+           __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO|
+               LCF_FREE_NPORT);
        lg->port_id[0] = al_pa;
        lg->port_id[1] = area;
        lg->port_id[2] = domain;
-       lg->vp_index = ha->vp_idx;
-       rval = qla2x00_issue_iocb(ha, lg, lg_dma, 0);
+       lg->vp_index = vha->vp_idx;
+
+       rval = qla2x00_issue_iocb(vha, lg, lg_dma, 0);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed to issue Logout IOCB "
-                   "(%x).\n", __func__, ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x106f,
+                   "Failed to issue logout IOCB (%x).\n", rval);
        } else if (lg->entry_status != 0) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- error status (%x).\n", __func__, ha->host_no,
-                   lg->entry_status));
+               ql_dbg(ql_dbg_mbx, vha, 0x1070,
+                   "Failed to complete IOCB -- error status (%x).\n",
+                   lg->entry_status);
                rval = QLA_FUNCTION_FAILED;
        } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
-                   ha->host_no, le16_to_cpu(lg->comp_status),
+               ql_dbg(ql_dbg_mbx, vha, 0x1071,
+                   "Failed to complete IOCB -- completion status (%x) "
+                   "ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
                    le32_to_cpu(lg->io_parameter[0]),
-                   le32_to_cpu(lg->io_parameter[1])));
+                   le32_to_cpu(lg->io_parameter[1]));
        } else {
                /*EMPTY*/
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1072, "Done %s.\n", __func__);
        }
 
        dma_pool_free(ha->s_dma_pool, lg, lg_dma);
@@ -1768,19 +1907,18 @@ qla24xx_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
  *     Kernel context.
  */
 int
-qla2x00_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
+qla2x00_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
     uint8_t area, uint8_t al_pa)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("qla2x00_fabric_logout(%ld): entered.\n",
-           ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1073, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
        mcp->out_mb = MBX_1|MBX_0;
-       if (HAS_EXTENDED_IDS(ha)) {
+       if (HAS_EXTENDED_IDS(vha->hw)) {
                mcp->mb[1] = loop_id;
                mcp->mb[10] = 0;
                mcp->out_mb |= MBX_10;
@@ -1791,16 +1929,15 @@ qla2x00_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
        mcp->in_mb = MBX_1|MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("qla2x00_fabric_logout(%ld): failed=%x "
-                   "mbx1=%x.\n", ha->host_no, rval, mcp->mb[1]));
+               ql_dbg(ql_dbg_mbx, vha, 0x1074,
+                   "Failed=%x mb[1]=%x.\n", rval, mcp->mb[1]);
        } else {
                /*EMPTY*/
-               DEBUG11(printk("qla2x00_fabric_logout(%ld): done.\n",
-                   ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1075, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -1822,33 +1959,30 @@ qla2x00_fabric_logout(scsi_qla_host_t *ha, uint16_t loop_id, uint8_t domain,
  *     Kernel context.
  */
 int
-qla2x00_full_login_lip(scsi_qla_host_t *ha)
+qla2x00_full_login_lip(scsi_qla_host_t *vha)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("qla2x00_full_login_lip(%ld): entered.\n",
-           ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1076, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_LIP_FULL_LOGIN;
-       mcp->mb[1] = IS_FWI2_CAPABLE(ha) ? BIT_3: 0;
+       mcp->mb[1] = IS_FWI2_CAPABLE(vha->hw) ? BIT_3 : 0;
        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(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("qla2x00_full_login_lip(%ld): failed=%x.\n",
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x1077, "Failed=%x.\n", rval);
        } else {
                /*EMPTY*/
-               DEBUG11(printk("qla2x00_full_login_lip(%ld): done.\n",
-                   ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1078, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -1867,28 +2001,27 @@ qla2x00_full_login_lip(scsi_qla_host_t *ha)
  *     Kernel context.
  */
 int
-qla2x00_get_id_list(scsi_qla_host_t *ha, void *id_list, dma_addr_t id_list_dma,
+qla2x00_get_id_list(scsi_qla_host_t *vha, void *id_list, dma_addr_t id_list_dma,
     uint16_t *entries)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("qla2x00_get_id_list(%ld): entered.\n",
-           ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1079, "Entered %s.\n", __func__);
 
        if (id_list == NULL)
                return QLA_FUNCTION_FAILED;
 
        mcp->mb[0] = MBC_GET_ID_LIST;
        mcp->out_mb = MBX_0;
-       if (IS_FWI2_CAPABLE(ha)) {
+       if (IS_FWI2_CAPABLE(vha->hw)) {
                mcp->mb[2] = MSW(id_list_dma);
                mcp->mb[3] = LSW(id_list_dma);
                mcp->mb[6] = MSW(MSD(id_list_dma));
                mcp->mb[7] = LSW(MSD(id_list_dma));
                mcp->mb[8] = 0;
-               mcp->mb[9] = ha->vp_idx;
+               mcp->mb[9] = vha->vp_idx;
                mcp->out_mb |= MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2;
        } else {
                mcp->mb[1] = MSW(id_list_dma);
@@ -1900,16 +2033,14 @@ qla2x00_get_id_list(scsi_qla_host_t *ha, void *id_list, dma_addr_t id_list_dma,
        mcp->in_mb = MBX_1|MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("qla2x00_get_id_list(%ld): failed=%x.\n",
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x107a, "Failed=%x.\n", rval);
        } else {
                *entries = mcp->mb[1];
-               DEBUG11(printk("qla2x00_get_id_list(%ld): done.\n",
-                   ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x107b, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -1929,32 +2060,35 @@ qla2x00_get_id_list(scsi_qla_host_t *ha, void *id_list, dma_addr_t id_list_dma,
  *     Kernel context.
  */
 int
-qla2x00_get_resource_cnts(scsi_qla_host_t *ha, uint16_t *cur_xchg_cnt,
+qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
     uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt,
-    uint16_t *orig_iocb_cnt, uint16_t *max_npiv_vports)
+    uint16_t *orig_iocb_cnt, uint16_t *max_npiv_vports, uint16_t *max_fcfs)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x107c, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
        mcp->out_mb = MBX_0;
        mcp->in_mb = MBX_11|MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
+       if (IS_QLA81XX(vha->hw))
+               mcp->in_mb |= MBX_12;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("%s(%ld): failed = %x.\n", __func__,
-                   ha->host_no, mcp->mb[0]));
+               ql_dbg(ql_dbg_mbx, vha, 0x107d,
+                   "Failed mb[0]=%x.\n", mcp->mb[0]);
        } else {
-               DEBUG11(printk("%s(%ld): done. mb1=%x mb2=%x mb3=%x mb6=%x "
-                   "mb7=%x mb10=%x mb11=%x.\n", __func__, ha->host_no,
-                   mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[6], mcp->mb[7],
-                   mcp->mb[10], mcp->mb[11]));
+               ql_dbg(ql_dbg_mbx, vha, 0x107e,
+                   "Done %s mb1=%x mb2=%x mb3=%x mb6=%x mb7=%x mb10=%x "
+                   "mb11=%x mb12=%x.\n", __func__, mcp->mb[1], mcp->mb[2],
+                   mcp->mb[3], mcp->mb[6], mcp->mb[7], mcp->mb[10],
+                   mcp->mb[11], mcp->mb[12]);
 
                if (cur_xchg_cnt)
                        *cur_xchg_cnt = mcp->mb[3];
@@ -1964,14 +2098,15 @@ qla2x00_get_resource_cnts(scsi_qla_host_t *ha, uint16_t *cur_xchg_cnt,
                        *cur_iocb_cnt = mcp->mb[7];
                if (orig_iocb_cnt)
                        *orig_iocb_cnt = mcp->mb[10];
-               if (ha->flags.npiv_supported && max_npiv_vports)
+               if (vha->hw->flags.npiv_supported && max_npiv_vports)
                        *max_npiv_vports = mcp->mb[11];
+               if (IS_QLA81XX(vha->hw) && max_fcfs)
+                       *max_fcfs = mcp->mb[12];
        }
 
        return (rval);
 }
 
-#if defined(QL_DEBUG_LEVEL_3)
 /*
  * qla2x00_get_fcal_position_map
  *     Get FCAL (LILP) position map using mailbox command
@@ -1987,18 +2122,21 @@ qla2x00_get_resource_cnts(scsi_qla_host_t *ha, uint16_t *cur_xchg_cnt,
  *     Kernel context.
  */
 int
-qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map)
+qla2x00_get_fcal_position_map(scsi_qla_host_t *vha, char *pos_map)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
        char *pmap;
        dma_addr_t pmap_dma;
+       struct qla_hw_data *ha = vha->hw;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x107f, "Entered %s.\n", __func__);
 
        pmap = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pmap_dma);
        if (pmap  == NULL) {
-               DEBUG2_3_11(printk("%s(%ld): **** Mem Alloc Failed ****",
-                   __func__, ha->host_no));
+               ql_log(ql_log_warn, vha, 0x1080,
+                   "Memory alloc failed.\n");
                return QLA_MEMORY_ALLOC_FAILED;
        }
        memset(pmap, 0, FCAL_MAP_SIZE);
@@ -2013,13 +2151,14 @@ qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map)
        mcp->buf_size = FCAL_MAP_SIZE;
        mcp->flags = MBX_DMA_IN;
        mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval == QLA_SUCCESS) {
-               DEBUG11(printk("%s(%ld): (mb0=%x/mb1=%x) FC/AL Position Map "
-                   "size (%x)\n", __func__, ha->host_no, mcp->mb[0],
-                   mcp->mb[1], (unsigned)pmap[0]));
-               DEBUG11(qla2x00_dump_buffer(pmap, pmap[0] + 1));
+               ql_dbg(ql_dbg_mbx, vha, 0x1081,
+                   "mb0/mb1=%x/%X FC/AL position map size (%x).\n",
+                   mcp->mb[0], mcp->mb[1], (unsigned)pmap[0]);
+               ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111d,
+                   pmap, pmap[0] + 1);
 
                if (pos_map)
                        memcpy(pos_map, pmap, FCAL_MAP_SIZE);
@@ -2027,15 +2166,13 @@ qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map)
        dma_pool_free(ha->s_dma_pool, pmap, pmap_dma);
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x1082, "Failed=%x.\n", rval);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1083, "Done %s.\n", __func__);
        }
 
        return rval;
 }
-#endif
 
 /*
  * qla2x00_get_link_status
@@ -2051,15 +2188,16 @@ qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map)
  *     BIT_1 = mailbox error.
  */
 int
-qla2x00_get_link_status(scsi_qla_host_t *ha, uint16_t loop_id,
+qla2x00_get_link_status(scsi_qla_host_t *vha, uint16_t loop_id,
     struct link_statistics *stats, dma_addr_t stats_dma)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
        uint32_t *siter, *diter, dwords;
+       struct qla_hw_data *ha = vha->hw;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1084, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_GET_LINK_STATUS;
        mcp->mb[2] = MSW(stats_dma);
@@ -2084,15 +2222,16 @@ qla2x00_get_link_status(scsi_qla_host_t *ha, uint16_t loop_id,
        }
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = IOCTL_CMD;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval == QLA_SUCCESS) {
                if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
-                       DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
-                           __func__, ha->host_no, mcp->mb[0]));
+                       ql_dbg(ql_dbg_mbx, vha, 0x1085,
+                           "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
                        rval = QLA_FUNCTION_FAILED;
                } else {
                        /* Copy over data -- firmware data is LE. */
+                       ql_dbg(ql_dbg_mbx, vha, 0x1086, "Done %s.\n", __func__);
                        dwords = offsetof(struct link_statistics, unused1) / 4;
                        siter = diter = &stats->link_fail_cnt;
                        while (dwords--)
@@ -2100,15 +2239,14 @@ qla2x00_get_link_status(scsi_qla_host_t *ha, uint16_t loop_id,
                }
        } else {
                /* Failed. */
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x1087, "Failed=%x.\n", rval);
        }
 
        return rval;
 }
 
 int
-qla24xx_get_isp_stats(scsi_qla_host_t *ha, struct link_statistics *stats,
+qla24xx_get_isp_stats(scsi_qla_host_t *vha, struct link_statistics *stats,
     dma_addr_t stats_dma)
 {
        int rval;
@@ -2116,7 +2254,7 @@ qla24xx_get_isp_stats(scsi_qla_host_t *ha, struct link_statistics *stats,
        mbx_cmd_t *mcp = &mc;
        uint32_t *siter, *diter, dwords;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1088, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_GET_LINK_PRIV_STATS;
        mcp->mb[2] = MSW(stats_dma);
@@ -2124,20 +2262,21 @@ qla24xx_get_isp_stats(scsi_qla_host_t *ha, struct link_statistics *stats,
        mcp->mb[6] = MSW(MSD(stats_dma));
        mcp->mb[7] = LSW(MSD(stats_dma));
        mcp->mb[8] = sizeof(struct link_statistics) / 4;
-       mcp->mb[9] = ha->vp_idx;
+       mcp->mb[9] = vha->vp_idx;
        mcp->mb[10] = 0;
        mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
        mcp->in_mb = MBX_2|MBX_1|MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = IOCTL_CMD;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval == QLA_SUCCESS) {
                if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
-                       DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
-                           __func__, ha->host_no, mcp->mb[0]));
+                       ql_dbg(ql_dbg_mbx, vha, 0x1089,
+                           "Failed mb[0]=%x.\n", mcp->mb[0]);
                        rval = QLA_FUNCTION_FAILED;
                } else {
+                       ql_dbg(ql_dbg_mbx, vha, 0x108a, "Done %s.\n", __func__);
                        /* Copy over data -- firmware data is LE. */
                        dwords = sizeof(struct link_statistics) / 4;
                        siter = diter = &stats->link_fail_cnt;
@@ -2146,35 +2285,34 @@ qla24xx_get_isp_stats(scsi_qla_host_t *ha, struct link_statistics *stats,
                }
        } else {
                /* Failed. */
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x108b, "Failed=%x.\n", rval);
        }
 
        return rval;
 }
 
 int
-qla24xx_abort_command(scsi_qla_host_t *ha, srb_t *sp)
+qla24xx_abort_command(srb_t *sp)
 {
        int             rval;
-       fc_port_t       *fcport;
        unsigned long   flags = 0;
 
        struct abort_entry_24xx *abt;
        dma_addr_t      abt_dma;
        uint32_t        handle;
-       scsi_qla_host_t *pha = to_qla_parent(ha);
-
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       fc_port_t       *fcport = sp->fcport;
+       struct scsi_qla_host *vha = fcport->vha;
+       struct qla_hw_data *ha = vha->hw;
+       struct req_que *req = vha->req;
 
-       fcport = sp->fcport;
+       ql_dbg(ql_dbg_mbx, vha, 0x108c, "Entered %s.\n", __func__);
 
-       spin_lock_irqsave(&pha->hardware_lock, flags);
+       spin_lock_irqsave(&ha->hardware_lock, flags);
        for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
-               if (pha->outstanding_cmds[handle] == sp)
+               if (req->outstanding_cmds[handle] == sp)
                        break;
        }
-       spin_unlock_irqrestore(&pha->hardware_lock, flags);
+       spin_unlock_irqrestore(&ha->hardware_lock, flags);
        if (handle == MAX_OUTSTANDING_COMMANDS) {
                /* Command not found. */
                return QLA_FUNCTION_FAILED;
@@ -2182,36 +2320,40 @@ qla24xx_abort_command(scsi_qla_host_t *ha, srb_t *sp)
 
        abt = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma);
        if (abt == NULL) {
-               DEBUG2_3(printk("%s(%ld): failed to allocate Abort IOCB.\n",
-                   __func__, ha->host_no));
+               ql_log(ql_log_warn, vha, 0x108d,
+                   "Failed to allocate abort IOCB.\n");
                return QLA_MEMORY_ALLOC_FAILED;
        }
        memset(abt, 0, sizeof(struct abort_entry_24xx));
 
        abt->entry_type = ABORT_IOCB_TYPE;
        abt->entry_count = 1;
+       abt->handle = MAKE_HANDLE(req->id, abt->handle);
        abt->nport_handle = cpu_to_le16(fcport->loop_id);
-       abt->handle_to_abort = handle;
+       abt->handle_to_abort = MAKE_HANDLE(req->id, handle);
        abt->port_id[0] = fcport->d_id.b.al_pa;
        abt->port_id[1] = fcport->d_id.b.area;
        abt->port_id[2] = fcport->d_id.b.domain;
        abt->vp_index = fcport->vp_idx;
-       rval = qla2x00_issue_iocb(ha, abt, abt_dma, 0);
+
+       abt->req_que_no = cpu_to_le16(req->id);
+
+       rval = qla2x00_issue_iocb(vha, abt, abt_dma, 0);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed to issue IOCB (%x).\n",
-                   __func__, ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x108e,
+                   "Failed to issue IOCB (%x).\n", rval);
        } else if (abt->entry_status != 0) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- error status (%x).\n", __func__, ha->host_no,
-                   abt->entry_status));
+               ql_dbg(ql_dbg_mbx, vha, 0x108f,
+                   "Failed to complete IOCB -- error status (%x).\n",
+                   abt->entry_status);
                rval = QLA_FUNCTION_FAILED;
        } else if (abt->nport_handle != __constant_cpu_to_le16(0)) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- completion status (%x).\n", __func__, ha->host_no,
-                   le16_to_cpu(abt->nport_handle)));
+               ql_dbg(ql_dbg_mbx, vha, 0x1090,
+                   "Failed to complete IOCB -- completion status (%x).\n",
+                   le16_to_cpu(abt->nport_handle));
                rval = QLA_FUNCTION_FAILED;
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1091, "Done %s.\n", __func__);
        }
 
        dma_pool_free(ha->s_dma_pool, abt, abt_dma);
@@ -2228,27 +2370,38 @@ struct tsk_mgmt_cmd {
 
 static int
 __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
-    unsigned int l)
+    unsigned int l, int tag)
 {
        int             rval, rval2;
        struct tsk_mgmt_cmd *tsk;
+       struct sts_entry_24xx *sts;
        dma_addr_t      tsk_dma;
-       scsi_qla_host_t *ha, *pha;
+       scsi_qla_host_t *vha;
+       struct qla_hw_data *ha;
+       struct req_que *req;
+       struct rsp_que *rsp;
+
+       vha = fcport->vha;
+       ha = vha->hw;
+       req = vha->req;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1092, "Entered %s.\n", __func__);
 
-       ha = fcport->ha;
-       pha = to_qla_parent(ha);
-       tsk = dma_pool_alloc(pha->s_dma_pool, GFP_KERNEL, &tsk_dma);
+       if (ha->flags.cpu_affinity_enabled)
+               rsp = ha->rsp_q_map[tag + 1];
+       else
+               rsp = req->rsp;
+       tsk = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma);
        if (tsk == NULL) {
-               DEBUG2_3(printk("%s(%ld): failed to allocate Task Management "
-                   "IOCB.\n", __func__, ha->host_no));
+               ql_log(ql_log_warn, vha, 0x1093,
+                   "Failed to allocate task management IOCB.\n");
                return QLA_MEMORY_ALLOC_FAILED;
        }
        memset(tsk, 0, sizeof(struct tsk_mgmt_cmd));
 
        tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE;
        tsk->p.tsk.entry_count = 1;
+       tsk->p.tsk.handle = MAKE_HANDLE(req->id, tsk->p.tsk.handle);
        tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id);
        tsk->p.tsk.timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
        tsk->p.tsk.control_flags = cpu_to_le32(type);
@@ -2262,74 +2415,98 @@ __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
                    sizeof(tsk->p.tsk.lun));
        }
 
-       rval = qla2x00_issue_iocb(ha, tsk, tsk_dma, 0);
+       sts = &tsk->p.sts;
+       rval = qla2x00_issue_iocb(vha, tsk, tsk_dma, 0);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed to issue %s Reset IOCB "
-                   "(%x).\n", __func__, ha->host_no, name, rval));
-       } else if (tsk->p.sts.entry_status != 0) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- error status (%x).\n", __func__, ha->host_no,
-                   tsk->p.sts.entry_status));
+               ql_dbg(ql_dbg_mbx, vha, 0x1094,
+                   "Failed to issue %s reset IOCB (%x).\n", name, rval);
+       } else if (sts->entry_status != 0) {
+               ql_dbg(ql_dbg_mbx, vha, 0x1095,
+                   "Failed to complete IOCB -- error status (%x).\n",
+                   sts->entry_status);
                rval = QLA_FUNCTION_FAILED;
-       } else if (tsk->p.sts.comp_status !=
+       } else if (sts->comp_status !=
            __constant_cpu_to_le16(CS_COMPLETE)) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- completion status (%x).\n", __func__,
-                   ha->host_no, le16_to_cpu(tsk->p.sts.comp_status)));
+               ql_dbg(ql_dbg_mbx, vha, 0x1096,
+                   "Failed to complete IOCB -- completion status (%x).\n",
+                   le16_to_cpu(sts->comp_status));
                rval = QLA_FUNCTION_FAILED;
+       } else if (le16_to_cpu(sts->scsi_status) &
+           SS_RESPONSE_INFO_LEN_VALID) {
+               if (le32_to_cpu(sts->rsp_data_len) < 4) {
+                       ql_dbg(ql_dbg_mbx, vha, 0x1097,
+                           "Ignoring inconsistent data length -- not enough "
+                           "response info (%d).\n",
+                           le32_to_cpu(sts->rsp_data_len));
+               } else if (sts->data[3]) {
+                       ql_dbg(ql_dbg_mbx, vha, 0x1098,
+                           "Failed to complete IOCB -- response (%x).\n",
+                           sts->data[3]);
+                       rval = QLA_FUNCTION_FAILED;
+               }
        }
 
        /* Issue marker IOCB. */
-       rval2 = qla2x00_marker(ha, fcport->loop_id, l,
+       rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
            type == TCF_LUN_RESET ? MK_SYNC_ID_LUN: MK_SYNC_ID);
        if (rval2 != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
-                   "(%x).\n", __func__, ha->host_no, rval2));
+               ql_dbg(ql_dbg_mbx, vha, 0x1099,
+                   "Failed to issue marker IOCB (%x).\n", rval2);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x109a, "Done %s.\n", __func__);
        }
 
-       dma_pool_free(pha->s_dma_pool, tsk, tsk_dma);
+       dma_pool_free(ha->s_dma_pool, tsk, tsk_dma);
 
        return rval;
 }
 
 int
-qla24xx_abort_target(struct fc_port *fcport, unsigned int l)
+qla24xx_abort_target(struct fc_port *fcport, unsigned int l, int tag)
 {
-       return __qla24xx_issue_tmf("Target", TCF_TARGET_RESET, fcport, l);
+       struct qla_hw_data *ha = fcport->vha->hw;
+
+       if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
+               return qla2x00_async_tm_cmd(fcport, TCF_TARGET_RESET, l, tag);
+
+       return __qla24xx_issue_tmf("Target", TCF_TARGET_RESET, fcport, l, tag);
 }
 
 int
-qla24xx_lun_reset(struct fc_port *fcport, unsigned int l)
+qla24xx_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
 {
-       return __qla24xx_issue_tmf("Lun", TCF_LUN_RESET, fcport, l);
+       struct qla_hw_data *ha = fcport->vha->hw;
+
+       if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
+               return qla2x00_async_tm_cmd(fcport, TCF_LUN_RESET, l, tag);
+
+       return __qla24xx_issue_tmf("Lun", TCF_LUN_RESET, fcport, l, tag);
 }
 
 int
-qla2x00_system_error(scsi_qla_host_t *ha)
+qla2x00_system_error(scsi_qla_host_t *vha)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
+       struct qla_hw_data *ha = vha->hw;
 
        if (!IS_QLA23XX(ha) && !IS_FWI2_CAPABLE(ha))
                return QLA_FUNCTION_FAILED;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x109b, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_GEN_SYSTEM_ERROR;
        mcp->out_mb = MBX_0;
        mcp->in_mb = MBX_0;
        mcp->tov = 5;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x109c, "Failed=%x.\n", rval);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x109d, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -2342,14 +2519,14 @@ qla2x00_system_error(scsi_qla_host_t *ha)
  * Returns
  */
 int
-qla2x00_set_serdes_params(scsi_qla_host_t *ha, uint16_t sw_em_1g,
+qla2x00_set_serdes_params(scsi_qla_host_t *vha, uint16_t sw_em_1g,
     uint16_t sw_em_2g, uint16_t sw_em_4g)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x109e, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_SERDES_PARAMS;
        mcp->mb[1] = BIT_0;
@@ -2360,61 +2537,65 @@ qla2x00_set_serdes_params(scsi_qla_host_t *ha, uint16_t sw_em_1g,
        mcp->in_mb = MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
                /*EMPTY*/
-               DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
-                   ha->host_no, rval, mcp->mb[0]));
+               ql_dbg(ql_dbg_mbx, vha, 0x109f,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
        } else {
                /*EMPTY*/
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x10a0, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
 int
-qla2x00_stop_firmware(scsi_qla_host_t *ha)
+qla2x00_stop_firmware(scsi_qla_host_t *vha)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       if (!IS_FWI2_CAPABLE(ha))
+       if (!IS_FWI2_CAPABLE(vha->hw))
                return QLA_FUNCTION_FAILED;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x10a1, "Entered %s.\n", __func__);
 
        mcp->mb[0] = MBC_STOP_FIRMWARE;
        mcp->out_mb = MBX_0;
        mcp->in_mb = MBX_0;
        mcp->tov = 5;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x10a2, "Failed=%x.\n", rval);
+               if (mcp->mb[0] == MBS_INVALID_COMMAND)
+                       rval = QLA_INVALID_COMMAND;
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x10a3, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
 int
-qla2x00_enable_eft_trace(scsi_qla_host_t *ha, dma_addr_t eft_dma,
+qla2x00_enable_eft_trace(scsi_qla_host_t *vha, dma_addr_t eft_dma,
     uint16_t buffers)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       if (!IS_FWI2_CAPABLE(ha))
+       ql_dbg(ql_dbg_mbx, vha, 0x10a4, "Entered %s.\n", __func__);
+
+       if (!IS_FWI2_CAPABLE(vha->hw))
                return QLA_FUNCTION_FAILED;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       if (unlikely(pci_channel_offline(vha->hw->pdev)))
+               return QLA_FUNCTION_FAILED;
 
        mcp->mb[0] = MBC_TRACE_CONTROL;
        mcp->mb[1] = TC_EFT_ENABLE;
@@ -2428,28 +2609,32 @@ qla2x00_enable_eft_trace(scsi_qla_host_t *ha, dma_addr_t eft_dma,
        mcp->in_mb = MBX_1|MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                   __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+               ql_dbg(ql_dbg_mbx, vha, 0x10a5,
+                   "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1]);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x10a6, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
 int
-qla2x00_disable_eft_trace(scsi_qla_host_t *ha)
+qla2x00_disable_eft_trace(scsi_qla_host_t *vha)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       if (!IS_FWI2_CAPABLE(ha))
+       ql_dbg(ql_dbg_mbx, vha, 0x10a7, "Entered %s.\n", __func__);
+
+       if (!IS_FWI2_CAPABLE(vha->hw))
                return QLA_FUNCTION_FAILED;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       if (unlikely(pci_channel_offline(vha->hw->pdev)))
+               return QLA_FUNCTION_FAILED;
 
        mcp->mb[0] = MBC_TRACE_CONTROL;
        mcp->mb[1] = TC_EFT_DISABLE;
@@ -2457,29 +2642,33 @@ qla2x00_disable_eft_trace(scsi_qla_host_t *ha)
        mcp->in_mb = MBX_1|MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                   __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+               ql_dbg(ql_dbg_mbx, vha, 0x10a8,
+                   "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1]);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x10a9, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
 int
-qla2x00_enable_fce_trace(scsi_qla_host_t *ha, dma_addr_t fce_dma,
+qla2x00_enable_fce_trace(scsi_qla_host_t *vha, dma_addr_t fce_dma,
     uint16_t buffers, uint16_t *mb, uint32_t *dwords)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       if (!IS_QLA25XX(ha))
+       ql_dbg(ql_dbg_mbx, vha, 0x10aa, "Entered %s.\n", __func__);
+
+       if (!IS_QLA25XX(vha->hw) && !IS_QLA81XX(vha->hw))
                return QLA_FUNCTION_FAILED;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       if (unlikely(pci_channel_offline(vha->hw->pdev)))
+               return QLA_FUNCTION_FAILED;
 
        mcp->mb[0] = MBC_TRACE_CONTROL;
        mcp->mb[1] = TC_FCE_ENABLE;
@@ -2497,12 +2686,13 @@ qla2x00_enable_fce_trace(scsi_qla_host_t *ha, dma_addr_t fce_dma,
        mcp->in_mb = 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(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                   __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+               ql_dbg(ql_dbg_mbx, vha, 0x10ab,
+                   "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1]);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x10ac, "Done %s.\n", __func__);
 
                if (mb)
                        memcpy(mb, mcp->mb, 8 * sizeof(*mb));
@@ -2514,16 +2704,19 @@ qla2x00_enable_fce_trace(scsi_qla_host_t *ha, dma_addr_t fce_dma,
 }
 
 int
-qla2x00_disable_fce_trace(scsi_qla_host_t *ha, uint64_t *wr, uint64_t *rd)
+qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       if (!IS_FWI2_CAPABLE(ha))
+       ql_dbg(ql_dbg_mbx, vha, 0x10ad, "Entered %s.\n", __func__);
+
+       if (!IS_FWI2_CAPABLE(vha->hw))
                return QLA_FUNCTION_FAILED;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       if (unlikely(pci_channel_offline(vha->hw->pdev)))
+               return QLA_FUNCTION_FAILED;
 
        mcp->mb[0] = MBC_TRACE_CONTROL;
        mcp->mb[1] = TC_FCE_DISABLE;
@@ -2533,12 +2726,13 @@ qla2x00_disable_fce_trace(scsi_qla_host_t *ha, uint64_t *wr, uint64_t *rd)
            MBX_1|MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                   __func__, ha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+               ql_dbg(ql_dbg_mbx, vha, 0x10ae,
+                   "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1]);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x10af, "Done %s.\n", __func__);
 
                if (wr)
                        *wr = (uint64_t) mcp->mb[5] << 48 |
@@ -2556,137 +2750,156 @@ qla2x00_disable_fce_trace(scsi_qla_host_t *ha, uint64_t *wr, uint64_t *rd)
 }
 
 int
-qla2x00_read_sfp(scsi_qla_host_t *ha, dma_addr_t sfp_dma, uint16_t addr,
-    uint16_t off, uint16_t count)
+qla2x00_get_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
+       uint16_t *port_speed, uint16_t *mb)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       if (!IS_FWI2_CAPABLE(ha))
-               return QLA_FUNCTION_FAILED;
+       ql_dbg(ql_dbg_mbx, vha, 0x10b0, "Entered %s.\n", __func__);
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       if (!IS_IIDMA_CAPABLE(vha->hw))
+               return QLA_FUNCTION_FAILED;
 
-       mcp->mb[0] = MBC_READ_SFP;
-       mcp->mb[1] = addr;
-       mcp->mb[2] = MSW(sfp_dma);
-       mcp->mb[3] = LSW(sfp_dma);
-       mcp->mb[6] = MSW(MSD(sfp_dma));
-       mcp->mb[7] = LSW(MSD(sfp_dma));
-       mcp->mb[8] = count;
-       mcp->mb[9] = off;
-       mcp->mb[10] = 0;
-       mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
-       mcp->in_mb = MBX_0;
+       mcp->mb[0] = MBC_PORT_PARAMS;
+       mcp->mb[1] = loop_id;
+       mcp->mb[2] = mcp->mb[3] = 0;
+       mcp->mb[9] = vha->vp_idx;
+       mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_3|MBX_1|MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
+
+       /* Return mailbox statuses. */
+       if (mb != NULL) {
+               mb[0] = mcp->mb[0];
+               mb[1] = mcp->mb[1];
+               mb[3] = mcp->mb[3];
+       }
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
-                   ha->host_no, rval, mcp->mb[0]));
+               ql_dbg(ql_dbg_mbx, vha, 0x10b1, "Failed=%x.\n", rval);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x10b2, "Done %s.\n", __func__);
+               if (port_speed)
+                       *port_speed = mcp->mb[3];
        }
 
        return rval;
 }
 
 int
-qla2x00_set_idma_speed(scsi_qla_host_t *ha, uint16_t loop_id,
+qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
     uint16_t port_speed, uint16_t *mb)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       if (!IS_IIDMA_CAPABLE(ha))
-               return QLA_FUNCTION_FAILED;
+       ql_dbg(ql_dbg_mbx, vha, 0x10b3, "Entered %s.\n", __func__);
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       if (!IS_IIDMA_CAPABLE(vha->hw))
+               return QLA_FUNCTION_FAILED;
 
        mcp->mb[0] = MBC_PORT_PARAMS;
        mcp->mb[1] = loop_id;
        mcp->mb[2] = BIT_0;
-       mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0);
-       mcp->mb[4] = mcp->mb[5] = 0;
-       mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
-       mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_1|MBX_0;
+       if (IS_QLA8XXX_TYPE(vha->hw))
+               mcp->mb[3] = port_speed & (BIT_5|BIT_4|BIT_3|BIT_2|BIT_1|BIT_0);
+       else
+               mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0);
+       mcp->mb[9] = vha->vp_idx;
+       mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_3|MBX_1|MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        /* Return mailbox statuses. */
        if (mb != NULL) {
                mb[0] = mcp->mb[0];
                mb[1] = mcp->mb[1];
                mb[3] = mcp->mb[3];
-               mb[4] = mcp->mb[4];
-               mb[5] = mcp->mb[5];
        }
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x10b4, "Failed=%x.\n", rval);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x10b5, "Done %s.\n", __func__);
        }
 
        return rval;
 }
 
 void
-qla24xx_report_id_acquisition(scsi_qla_host_t *ha,
+qla24xx_report_id_acquisition(scsi_qla_host_t *vha,
        struct vp_rpt_id_entry_24xx *rptid_entry)
 {
        uint8_t vp_idx;
        uint16_t stat = le16_to_cpu(rptid_entry->vp_idx);
-       scsi_qla_host_t *vha;
+       struct qla_hw_data *ha = vha->hw;
+       scsi_qla_host_t *vp;
+       unsigned long   flags;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10b6, "Entered %s.\n", __func__);
 
        if (rptid_entry->entry_status != 0)
                return;
 
        if (rptid_entry->format == 0) {
-               DEBUG15(printk("%s:format 0 : scsi(%ld) number of VPs setup %d,"
-                       " number of VPs acquired %d\n", __func__, ha->host_no,
-                       MSB(rptid_entry->vp_count), LSB(rptid_entry->vp_count)));
-               DEBUG15(printk("%s primary port id %02x%02x%02x\n", __func__,
-                       rptid_entry->port_id[2], rptid_entry->port_id[1],
-                       rptid_entry->port_id[0]));
+               ql_dbg(ql_dbg_mbx, vha, 0x10b7,
+                   "Format 0 : Number of VPs setup %d, number of "
+                   "VPs acquired %d.\n",
+                   MSB(le16_to_cpu(rptid_entry->vp_count)),
+                   LSB(le16_to_cpu(rptid_entry->vp_count)));
+               ql_dbg(ql_dbg_mbx, vha, 0x10b8,
+                   "Primary port id %02x%02x%02x.\n",
+                   rptid_entry->port_id[2], rptid_entry->port_id[1],
+                   rptid_entry->port_id[0]);
        } else if (rptid_entry->format == 1) {
                vp_idx = LSB(stat);
-               DEBUG15(printk("%s:format 1: scsi(%ld): VP[%d] enabled "
-                   "- status %d - "
-                   "with port id %02x%02x%02x\n",__func__,ha->host_no,
-                   vp_idx, MSB(stat),
+               ql_dbg(ql_dbg_mbx, vha, 0x10b9,
+                   "Format 1: VP[%d] enabled - status %d - with "
+                   "port id %02x%02x%02x.\n", vp_idx, MSB(stat),
                    rptid_entry->port_id[2], rptid_entry->port_id[1],
-                   rptid_entry->port_id[0]));
-               if (vp_idx == 0)
-                       return;
+                   rptid_entry->port_id[0]);
 
-               if (MSB(stat) == 1)
+               vp = vha;
+               if (vp_idx == 0 && (MSB(stat) != 1))
+                       goto reg_needed;
+
+               if (MSB(stat) == 1) {
+                       ql_dbg(ql_dbg_mbx, vha, 0x10ba,
+                           "Could not acquire ID for VP[%d].\n", vp_idx);
                        return;
+               }
 
-               list_for_each_entry(vha, &ha->vp_list, vp_list)
-                       if (vp_idx == vha->vp_idx)
+               spin_lock_irqsave(&ha->vport_slock, flags);
+               list_for_each_entry(vp, &ha->vp_list, list)
+                       if (vp_idx == vp->vp_idx)
                                break;
+               spin_unlock_irqrestore(&ha->vport_slock, flags);
 
-               if (!vha)
+               if (!vp)
                        return;
 
-               vha->d_id.b.domain = rptid_entry->port_id[2];
-               vha->d_id.b.area =  rptid_entry->port_id[1];
-               vha->d_id.b.al_pa = rptid_entry->port_id[0];
+               vp->d_id.b.domain = rptid_entry->port_id[2];
+               vp->d_id.b.area =  rptid_entry->port_id[1];
+               vp->d_id.b.al_pa = rptid_entry->port_id[0];
 
                /*
                 * Cannot configure here as we are still sitting on the
                 * response queue. Handle it in dpc context.
                 */
-               set_bit(VP_IDX_ACQUIRED, &vha->vp_flags);
-               set_bit(VP_DPC_NEEDED, &ha->dpc_flags);
+               set_bit(VP_IDX_ACQUIRED, &vp->vp_flags);
 
-               qla2xxx_wake_dpc(ha);
+reg_needed:
+               set_bit(REGISTER_FC4_NEEDED, &vp->dpc_flags);
+               set_bit(REGISTER_FDMI_NEEDED, &vp->dpc_flags);
+               set_bit(VP_DPC_NEEDED, &vha->dpc_flags);
+               qla2xxx_wake_dpc(vha);
        }
 }
 
@@ -2709,15 +2922,17 @@ qla24xx_modify_vp_config(scsi_qla_host_t *vha)
        int             rval;
        struct vp_config_entry_24xx *vpmod;
        dma_addr_t      vpmod_dma;
-       scsi_qla_host_t *pha;
+       struct qla_hw_data *ha = vha->hw;
+       struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
 
        /* This can be called by the parent */
-       pha = to_qla_parent(vha);
 
-       vpmod = dma_pool_alloc(pha->s_dma_pool, GFP_KERNEL, &vpmod_dma);
+       ql_dbg(ql_dbg_mbx, vha, 0x10bb, "Entered %s.\n", __func__);
+
+       vpmod = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vpmod_dma);
        if (!vpmod) {
-               DEBUG2_3(printk("%s(%ld): failed to allocate Modify VP "
-                   "IOCB.\n", __func__, pha->host_no));
+               ql_log(ql_log_warn, vha, 0x10bc,
+                   "Failed to allocate modify VP IOCB.\n");
                return QLA_MEMORY_ALLOC_FAILED;
        }
 
@@ -2732,26 +2947,26 @@ qla24xx_modify_vp_config(scsi_qla_host_t *vha)
        memcpy(vpmod->port_name_idx1, vha->port_name, WWN_SIZE);
        vpmod->entry_count = 1;
 
-       rval = qla2x00_issue_iocb(pha, vpmod, vpmod_dma, 0);
+       rval = qla2x00_issue_iocb(base_vha, vpmod, vpmod_dma, 0);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed to issue VP config IOCB"
-                       "(%x).\n", __func__, pha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x10bd,
+                   "Failed to issue VP config IOCB (%x).\n", rval);
        } else if (vpmod->comp_status != 0) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                       "-- error status (%x).\n", __func__, pha->host_no,
-                       vpmod->comp_status));
+               ql_dbg(ql_dbg_mbx, vha, 0x10be,
+                   "Failed to complete IOCB -- error status (%x).\n",
+                   vpmod->comp_status);
                rval = QLA_FUNCTION_FAILED;
        } else if (vpmod->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- completion status (%x).\n", __func__, pha->host_no,
-                   le16_to_cpu(vpmod->comp_status)));
+               ql_dbg(ql_dbg_mbx, vha, 0x10bf,
+                   "Failed to complete IOCB -- completion status (%x).\n",
+                   le16_to_cpu(vpmod->comp_status));
                rval = QLA_FUNCTION_FAILED;
        } else {
                /* EMPTY */
-               DEBUG11(printk("%s(%ld): done.\n", __func__, pha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x10c0, "Done %s.\n", __func__);
                fc_vport_set_state(vha->fc_vport, FC_VPORT_INITIALIZING);
        }
-       dma_pool_free(pha->s_dma_pool, vpmod, vpmod_dma);
+       dma_pool_free(ha->s_dma_pool, vpmod, vpmod_dma);
 
        return rval;
 }
@@ -2778,20 +2993,20 @@ qla24xx_control_vp(scsi_qla_host_t *vha, int cmd)
        int             map, pos;
        struct vp_ctrl_entry_24xx   *vce;
        dma_addr_t      vce_dma;
-       scsi_qla_host_t *ha = vha->parent;
+       struct qla_hw_data *ha = vha->hw;
        int     vp_index = vha->vp_idx;
+       struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
 
-       DEBUG11(printk("%s(%ld): entered. Enabling index %d\n", __func__,
-           ha->host_no, vp_index));
+       ql_dbg(ql_dbg_mbx, vha, 0x10c1,
+           "Entered %s enabling index %d.\n", __func__, vp_index);
 
        if (vp_index == 0 || vp_index >= ha->max_npiv_vports)
                return QLA_PARAMETER_ERROR;
 
        vce = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vce_dma);
        if (!vce) {
-               DEBUG2_3(printk("%s(%ld): "
-                   "failed to allocate VP Control IOCB.\n", __func__,
-                   ha->host_no));
+               ql_log(ql_log_warn, vha, 0x10c2,
+                   "Failed to allocate VP control IOCB.\n");
                return QLA_MEMORY_ALLOC_FAILED;
        }
        memset(vce, 0, sizeof(struct vp_ctrl_entry_24xx));
@@ -2810,30 +3025,22 @@ qla24xx_control_vp(scsi_qla_host_t *vha, int cmd)
        vce->vp_idx_map[map] |= 1 << pos;
        mutex_unlock(&ha->vport_lock);
 
-       rval = qla2x00_issue_iocb(ha, vce, vce_dma, 0);
+       rval = qla2x00_issue_iocb(base_vha, vce, vce_dma, 0);
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed to issue VP control IOCB"
-                   "(%x).\n", __func__, ha->host_no, rval));
-               printk("%s(%ld): failed to issue VP control IOCB"
-                   "(%x).\n", __func__, ha->host_no, rval);
+               ql_dbg(ql_dbg_mbx, vha, 0x10c3,
+                   "Failed to issue VP control IOCB (%x).\n", rval);
        } else if (vce->entry_status != 0) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- error status (%x).\n", __func__, ha->host_no,
-                   vce->entry_status));
-               printk("%s(%ld): failed to complete IOCB "
-                   "-- error status (%x).\n", __func__, ha->host_no,
+               ql_dbg(ql_dbg_mbx, vha, 0x10c4,
+                   "Failed to complete IOCB -- error status (%x).\n",
                    vce->entry_status);
                rval = QLA_FUNCTION_FAILED;
        } else if (vce->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
-               DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                   "-- completion status (%x).\n", __func__, ha->host_no,
-                   le16_to_cpu(vce->comp_status)));
-               printk("%s(%ld): failed to complete IOCB "
-                   "-- completion status (%x).\n", __func__, ha->host_no,
+               ql_dbg(ql_dbg_mbx, vha, 0x10c5,
+                   "Failed to complet IOCB -- completion status (%x).\n",
                    le16_to_cpu(vce->comp_status));
                rval = QLA_FUNCTION_FAILED;
        } else {
-               DEBUG2(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x10c6, "Done %s.\n", __func__);
        }
 
        dma_pool_free(ha->s_dma_pool, vce, vce_dma);
@@ -2863,13 +3070,15 @@ qla24xx_control_vp(scsi_qla_host_t *vha, int cmd)
  */
 
 int
-qla2x00_send_change_request(scsi_qla_host_t *ha, uint16_t format,
+qla2x00_send_change_request(scsi_qla_host_t *vha, uint16_t format,
                            uint16_t vp_idx)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
+       ql_dbg(ql_dbg_mbx, vha, 0x10c7, "Entered %s.\n", __func__);
+
        /*
         * This command is implicitly executed by firmware during login for the
         * physical hosts
@@ -2884,7 +3093,7 @@ qla2x00_send_change_request(scsi_qla_host_t *ha, uint16_t format,
        mcp->in_mb = MBX_0|MBX_1;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval == QLA_SUCCESS) {
                if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
@@ -2897,16 +3106,16 @@ qla2x00_send_change_request(scsi_qla_host_t *ha, uint16_t format,
 }
 
 int
-qla2x00_dump_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint32_t addr,
+qla2x00_dump_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
     uint32_t size)
 {
        int rval;
        mbx_cmd_t mc;
        mbx_cmd_t *mcp = &mc;
 
-       DEBUG11(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x1009, "Entered %s.\n", __func__);
 
-       if (MSW(addr) || IS_FWI2_CAPABLE(ha)) {
+       if (MSW(addr) || IS_FWI2_CAPABLE(vha->hw)) {
                mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
                mcp->mb[8] = MSW(addr);
                mcp->out_mb = MBX_8|MBX_0;
@@ -2920,7 +3129,7 @@ qla2x00_dump_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint32_t addr,
        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)) {
+       if (IS_FWI2_CAPABLE(vha->hw)) {
                mcp->mb[4] = MSW(size);
                mcp->mb[5] = LSW(size);
                mcp->out_mb |= MBX_5|MBX_4;
@@ -2932,13 +3141,13 @@ qla2x00_dump_ram(scsi_qla_host_t *ha, dma_addr_t req_dma, uint32_t addr,
        mcp->in_mb = MBX_0;
        mcp->tov = MBX_TOV_SECONDS;
        mcp->flags = 0;
-       rval = qla2x00_mailbox_command(ha, mcp);
+       rval = qla2x00_mailbox_command(vha, mcp);
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
-                   ha->host_no, rval, mcp->mb[0]));
+               ql_dbg(ql_dbg_mbx, vha, 0x1008,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
        } else {
-               DEBUG11(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1007, "Done %s.\n", __func__);
        }
 
        return rval;
@@ -2954,20 +3163,19 @@ struct cs84xx_mgmt_cmd {
 };
 
 int
-qla84xx_verify_chip(struct scsi_qla_host *ha, uint16_t *status)
+qla84xx_verify_chip(struct scsi_qla_host *vha, uint16_t *status)
 {
        int rval, retry;
        struct cs84xx_mgmt_cmd *mn;
        dma_addr_t mn_dma;
        uint16_t options;
        unsigned long flags;
+       struct qla_hw_data *ha = vha->hw;
 
-       DEBUG16(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+       ql_dbg(ql_dbg_mbx, vha, 0x10c8, "Entered %s.\n", __func__);
 
        mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
        if (mn == NULL) {
-               DEBUG2_3(printk("%s(%ld): failed to allocate Verify ISP84XX "
-                   "IOCB.\n", __func__, ha->host_no));
                return QLA_MEMORY_ALLOC_FAILED;
        }
 
@@ -2985,43 +3193,43 @@ qla84xx_verify_chip(struct scsi_qla_host *ha, uint16_t *status)
                mn->p.req.entry_count = 1;
                mn->p.req.options = cpu_to_le16(options);
 
-               DEBUG16(printk("%s(%ld): Dump of Verify Request.\n", __func__,
-                   ha->host_no));
-               DEBUG16(qla2x00_dump_buffer((uint8_t *)mn,
-                   sizeof(*mn)));
+               ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111c,
+                   "Dump of Verify Request.\n");
+               ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111e,
+                   (uint8_t *)mn, sizeof(*mn));
 
-               rval = qla2x00_issue_iocb_timeout(ha, mn, mn_dma, 0, 120);
+               rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
                if (rval != QLA_SUCCESS) {
-                       DEBUG2_16(printk("%s(%ld): failed to issue Verify "
-                           "IOCB (%x).\n", __func__, ha->host_no, rval));
+                       ql_dbg(ql_dbg_mbx, vha, 0x10cb,
+                           "Failed to issue verify IOCB (%x).\n", rval);
                        goto verify_done;
                }
 
-               DEBUG16(printk("%s(%ld): Dump of Verify Response.\n", __func__,
-                   ha->host_no));
-               DEBUG16(qla2x00_dump_buffer((uint8_t *)mn,
-                   sizeof(*mn)));
+               ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1110,
+                   "Dump of Verify Response.\n");
+               ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1118,
+                   (uint8_t *)mn, sizeof(*mn));
 
                status[0] = le16_to_cpu(mn->p.rsp.comp_status);
                status[1] = status[0] == CS_VCS_CHIP_FAILURE ?
                    le16_to_cpu(mn->p.rsp.failure_code) : 0;
-               DEBUG2_16(printk("%s(%ld): cs=%x fc=%x\n", __func__,
-                   ha->host_no, status[0], status[1]));
+               ql_dbg(ql_dbg_mbx, vha, 0x10ce,
+                   "cs=%x fc=%x.\n", status[0], status[1]);
 
                if (status[0] != CS_COMPLETE) {
                        rval = QLA_FUNCTION_FAILED;
                        if (!(options & VCO_DONT_UPDATE_FW)) {
-                               DEBUG2_16(printk("%s(%ld): Firmware update "
-                                   "failed. Retrying without update "
-                                   "firmware.\n", __func__, ha->host_no));
+                               ql_dbg(ql_dbg_mbx, vha, 0x10cf,
+                                   "Firmware update failed. Retrying "
+                                   "without update firmware.\n");
                                options |= VCO_DONT_UPDATE_FW;
                                options &= ~VCO_FORCE_UPDATE;
                                retry = 1;
                        }
                } else {
-                       DEBUG2_16(printk("%s(%ld): firmware updated to %x.\n",
-                           __func__, ha->host_no,
-                           le32_to_cpu(mn->p.rsp.fw_ver)));
+                       ql_dbg(ql_dbg_mbx, vha, 0x10d0,
+                           "Firmware updated to %x.\n",
+                           le32_to_cpu(mn->p.rsp.fw_ver));
 
                        /* NOTE: we only update OP firmware. */
                        spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
@@ -3036,10 +3244,1071 @@ verify_done:
        dma_pool_free(ha->s_dma_pool, mn, mn_dma);
 
        if (rval != QLA_SUCCESS) {
-               DEBUG2_16(printk("%s(%ld): failed=%x.\n", __func__,
-                   ha->host_no, rval));
+               ql_dbg(ql_dbg_mbx, vha, 0x10d1, "Failed=%x.\n", rval);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10d2, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla25xx_init_req_que(struct scsi_qla_host *vha, struct req_que *req)
+{
+       int rval;
+       unsigned long flags;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+       struct device_reg_25xxmq __iomem *reg;
+       struct qla_hw_data *ha = vha->hw;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10d3, "Entered %s.\n", __func__);
+
+       mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
+       mcp->mb[1] = req->options;
+       mcp->mb[2] = MSW(LSD(req->dma));
+       mcp->mb[3] = LSW(LSD(req->dma));
+       mcp->mb[6] = MSW(MSD(req->dma));
+       mcp->mb[7] = LSW(MSD(req->dma));
+       mcp->mb[5] = req->length;
+       if (req->rsp)
+               mcp->mb[10] = req->rsp->id;
+       mcp->mb[12] = req->qos;
+       mcp->mb[11] = req->vp_idx;
+       mcp->mb[13] = req->rid;
+
+       reg = (struct device_reg_25xxmq *)((void *)(ha->mqiobase) +
+               QLA_QUE_PAGE * req->id);
+
+       mcp->mb[4] = req->id;
+       /* que in ptr index */
+       mcp->mb[8] = 0;
+       /* que out ptr index */
+       mcp->mb[9] = 0;
+       mcp->out_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|MBX_7|
+                       MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_0;
+       mcp->flags = MBX_DMA_OUT;
+       mcp->tov = 60;
+
+       spin_lock_irqsave(&ha->hardware_lock, flags);
+       if (!(req->options & BIT_0)) {
+               WRT_REG_DWORD(&reg->req_q_in, 0);
+               WRT_REG_DWORD(&reg->req_q_out, 0);
+       }
+       req->req_q_in = &reg->req_q_in;
+       req->req_q_out = &reg->req_q_out;
+       spin_unlock_irqrestore(&ha->hardware_lock, flags);
+
+       rval = qla2x00_mailbox_command(vha, mcp);
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x10d4,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10d5, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla25xx_init_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
+{
+       int rval;
+       unsigned long flags;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+       struct device_reg_25xxmq __iomem *reg;
+       struct qla_hw_data *ha = vha->hw;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10d6, "Entered %s.\n", __func__);
+
+       mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
+       mcp->mb[1] = rsp->options;
+       mcp->mb[2] = MSW(LSD(rsp->dma));
+       mcp->mb[3] = LSW(LSD(rsp->dma));
+       mcp->mb[6] = MSW(MSD(rsp->dma));
+       mcp->mb[7] = LSW(MSD(rsp->dma));
+       mcp->mb[5] = rsp->length;
+       mcp->mb[14] = rsp->msix->entry;
+       mcp->mb[13] = rsp->rid;
+
+       reg = (struct device_reg_25xxmq *)((void *)(ha->mqiobase) +
+               QLA_QUE_PAGE * rsp->id);
+
+       mcp->mb[4] = rsp->id;
+       /* que in ptr index */
+       mcp->mb[8] = 0;
+       /* que out ptr index */
+       mcp->mb[9] = 0;
+       mcp->out_mb = MBX_14|MBX_13|MBX_9|MBX_8|MBX_7
+                       |MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_0;
+       mcp->flags = MBX_DMA_OUT;
+       mcp->tov = 60;
+
+       spin_lock_irqsave(&ha->hardware_lock, flags);
+       if (!(rsp->options & BIT_0)) {
+               WRT_REG_DWORD(&reg->rsp_q_out, 0);
+               WRT_REG_DWORD(&reg->rsp_q_in, 0);
+       }
+
+       spin_unlock_irqrestore(&ha->hardware_lock, flags);
+
+       rval = qla2x00_mailbox_command(vha, mcp);
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x10d7,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10d8, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla81xx_idc_ack(scsi_qla_host_t *vha, uint16_t *mb)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10d9, "Entered %s.\n", __func__);
+
+       mcp->mb[0] = MBC_IDC_ACK;
+       memcpy(&mcp->mb[1], mb, QLA_IDC_ACK_REGS * sizeof(uint16_t));
+       mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|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, 0x10da,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10db, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla81xx_fac_get_sector_size(scsi_qla_host_t *vha, uint32_t *sector_size)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10dc, "Entered %s.\n", __func__);
+
+       if (!IS_QLA81XX(vha->hw))
+               return QLA_FUNCTION_FAILED;
+
+       mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
+       mcp->mb[1] = FAC_OPT_CMD_GET_SECTOR_SIZE;
+       mcp->out_mb = MBX_1|MBX_0;
+       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, 0x10dd,
+                   "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10de, "Done %s.\n", __func__);
+               *sector_size = mcp->mb[1];
+       }
+
+       return rval;
+}
+
+int
+qla81xx_fac_do_write_enable(scsi_qla_host_t *vha, int enable)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       if (!IS_QLA81XX(vha->hw))
+               return QLA_FUNCTION_FAILED;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10df, "Entered %s.\n", __func__);
+
+       mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
+       mcp->mb[1] = enable ? FAC_OPT_CMD_WRITE_ENABLE :
+           FAC_OPT_CMD_WRITE_PROTECT;
+       mcp->out_mb = MBX_1|MBX_0;
+       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, 0x10e0,
+                   "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10e1, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla81xx_fac_erase_sector(scsi_qla_host_t *vha, uint32_t start, uint32_t finish)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       if (!IS_QLA81XX(vha->hw))
+               return QLA_FUNCTION_FAILED;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10e2, "Entered %s.\n", __func__);
+
+       mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
+       mcp->mb[1] = FAC_OPT_CMD_ERASE_SECTOR;
+       mcp->mb[2] = LSW(start);
+       mcp->mb[3] = MSW(start);
+       mcp->mb[4] = LSW(finish);
+       mcp->mb[5] = MSW(finish);
+       mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_2|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, 0x10e3,
+                   "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10e4, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
+{
+       int rval = 0;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10e5, "Entered %s.\n", __func__);
+
+       mcp->mb[0] = MBC_RESTART_MPI_FW;
+       mcp->out_mb = MBX_0;
+       mcp->in_mb = MBX_0|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, 0x10e6,
+                   "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10e7, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
+       uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+       struct qla_hw_data *ha = vha->hw;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10e8, "Entered %s.\n", __func__);
+
+       if (!IS_FWI2_CAPABLE(ha))
+               return QLA_FUNCTION_FAILED;
+
+       if (len == 1)
+               opt |= BIT_0;
+
+       mcp->mb[0] = MBC_READ_SFP;
+       mcp->mb[1] = dev;
+       mcp->mb[2] = MSW(sfp_dma);
+       mcp->mb[3] = LSW(sfp_dma);
+       mcp->mb[6] = MSW(MSD(sfp_dma));
+       mcp->mb[7] = LSW(MSD(sfp_dma));
+       mcp->mb[8] = len;
+       mcp->mb[9] = off;
+       mcp->mb[10] = opt;
+       mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_1|MBX_0;
+       mcp->tov = MBX_TOV_SECONDS;
+       mcp->flags = 0;
+       rval = qla2x00_mailbox_command(vha, mcp);
+
+       if (opt & BIT_0)
+               *sfp = mcp->mb[1];
+
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x10e9,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10ea, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla2x00_write_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
+       uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+       struct qla_hw_data *ha = vha->hw;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10eb, "Entered %s.\n", __func__);
+
+       if (!IS_FWI2_CAPABLE(ha))
+               return QLA_FUNCTION_FAILED;
+
+       if (len == 1)
+               opt |= BIT_0;
+
+       if (opt & BIT_0)
+               len = *sfp;
+
+       mcp->mb[0] = MBC_WRITE_SFP;
+       mcp->mb[1] = dev;
+       mcp->mb[2] = MSW(sfp_dma);
+       mcp->mb[3] = LSW(sfp_dma);
+       mcp->mb[6] = MSW(MSD(sfp_dma));
+       mcp->mb[7] = LSW(MSD(sfp_dma));
+       mcp->mb[8] = len;
+       mcp->mb[9] = off;
+       mcp->mb[10] = opt;
+       mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
+       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, 0x10ec,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10ed, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla2x00_get_xgmac_stats(scsi_qla_host_t *vha, dma_addr_t stats_dma,
+    uint16_t size_in_bytes, uint16_t *actual_size)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10ee, "Entered %s.\n", __func__);
+
+       if (!IS_QLA8XXX_TYPE(vha->hw))
+               return QLA_FUNCTION_FAILED;
+
+       mcp->mb[0] = MBC_GET_XGMAC_STATS;
+       mcp->mb[2] = MSW(stats_dma);
+       mcp->mb[3] = LSW(stats_dma);
+       mcp->mb[6] = MSW(MSD(stats_dma));
+       mcp->mb[7] = LSW(MSD(stats_dma));
+       mcp->mb[8] = size_in_bytes >> 2;
+       mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
+       mcp->in_mb = MBX_2|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, 0x10ef,
+                   "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10f0, "Done %s.\n", __func__);
+
+
+               *actual_size = mcp->mb[2] << 2;
+       }
+
+       return rval;
+}
+
+int
+qla2x00_get_dcbx_params(scsi_qla_host_t *vha, dma_addr_t tlv_dma,
+    uint16_t size)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10f1, "Entered %s.\n", __func__);
+
+       if (!IS_QLA8XXX_TYPE(vha->hw))
+               return QLA_FUNCTION_FAILED;
+
+       mcp->mb[0] = MBC_GET_DCBX_PARAMS;
+       mcp->mb[1] = 0;
+       mcp->mb[2] = MSW(tlv_dma);
+       mcp->mb[3] = LSW(tlv_dma);
+       mcp->mb[6] = MSW(MSD(tlv_dma));
+       mcp->mb[7] = LSW(MSD(tlv_dma));
+       mcp->mb[8] = size;
+       mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_2|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, 0x10f2,
+                   "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10f3, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10f4, "Entered %s.\n", __func__);
+
+       if (!IS_FWI2_CAPABLE(vha->hw))
+               return QLA_FUNCTION_FAILED;
+
+       mcp->mb[0] = MBC_READ_RAM_EXTENDED;
+       mcp->mb[1] = LSW(risc_addr);
+       mcp->mb[8] = MSW(risc_addr);
+       mcp->out_mb = MBX_8|MBX_1|MBX_0;
+       mcp->in_mb = MBX_3|MBX_2|MBX_0;
+       mcp->tov = 30;
+       mcp->flags = 0;
+       rval = qla2x00_mailbox_command(vha, mcp);
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x10f5,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10f6, "Done %s.\n", __func__);
+               *data = mcp->mb[3] << 16 | mcp->mb[2];
+       }
+
+       return rval;
+}
+
+int
+qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
+       uint16_t *mresp)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+       uint32_t iter_cnt = 0x1;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10f7, "Entered %s.\n", __func__);
+
+       memset(mcp->mb, 0 , sizeof(mcp->mb));
+       mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
+       mcp->mb[1] = mreq->options | BIT_6;     // BIT_6 specifies 64 bit addressing
+
+       /* transfer count */
+       mcp->mb[10] = LSW(mreq->transfer_size);
+       mcp->mb[11] = MSW(mreq->transfer_size);
+
+       /* send data address */
+       mcp->mb[14] = LSW(mreq->send_dma);
+       mcp->mb[15] = MSW(mreq->send_dma);
+       mcp->mb[20] = LSW(MSD(mreq->send_dma));
+       mcp->mb[21] = MSW(MSD(mreq->send_dma));
+
+       /* receive data address */
+       mcp->mb[16] = LSW(mreq->rcv_dma);
+       mcp->mb[17] = MSW(mreq->rcv_dma);
+       mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
+       mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
+
+       /* Iteration count */
+       mcp->mb[18] = LSW(iter_cnt);
+       mcp->mb[19] = MSW(iter_cnt);
+
+       mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
+           MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
+       if (IS_QLA8XXX_TYPE(vha->hw))
+               mcp->out_mb |= MBX_2;
+       mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
+
+       mcp->buf_size = mreq->transfer_size;
+       mcp->tov = MBX_TOV_SECONDS;
+       mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+
+       rval = qla2x00_mailbox_command(vha, mcp);
+
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x10f8,
+                   "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[3]=%x mb[18]=%x "
+                   "mb[19]=%x.\n", rval, mcp->mb[0], mcp->mb[1], mcp->mb[2],
+                   mcp->mb[3], mcp->mb[18], mcp->mb[19]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10f9, "Done %s.\n", __func__);
+       }
+
+       /* Copy mailbox information */
+       memcpy( mresp, mcp->mb, 64);
+       return rval;
+}
+
+int
+qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
+       uint16_t *mresp)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+       struct qla_hw_data *ha = vha->hw;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10fa, "Entered %s.\n", __func__);
+
+       memset(mcp->mb, 0 , sizeof(mcp->mb));
+       mcp->mb[0] = MBC_DIAGNOSTIC_ECHO;
+       mcp->mb[1] = mreq->options | BIT_6;     /* BIT_6 specifies 64bit address */
+       if (IS_QLA8XXX_TYPE(ha)) {
+               mcp->mb[1] |= BIT_15;
+               mcp->mb[2] = vha->fcoe_fcf_idx;
+       }
+       mcp->mb[16] = LSW(mreq->rcv_dma);
+       mcp->mb[17] = MSW(mreq->rcv_dma);
+       mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
+       mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
+
+       mcp->mb[10] = LSW(mreq->transfer_size);
+
+       mcp->mb[14] = LSW(mreq->send_dma);
+       mcp->mb[15] = MSW(mreq->send_dma);
+       mcp->mb[20] = LSW(MSD(mreq->send_dma));
+       mcp->mb[21] = MSW(MSD(mreq->send_dma));
+
+       mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|
+           MBX_14|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
+       if (IS_QLA8XXX_TYPE(ha))
+               mcp->out_mb |= MBX_2;
+
+       mcp->in_mb = MBX_0;
+       if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) || IS_QLA8XXX_TYPE(ha))
+               mcp->in_mb |= MBX_1;
+       if (IS_QLA8XXX_TYPE(ha))
+               mcp->in_mb |= MBX_3;
+
+       mcp->tov = MBX_TOV_SECONDS;
+       mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+       mcp->buf_size = mreq->transfer_size;
+
+       rval = qla2x00_mailbox_command(vha, mcp);
+
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x10fb,
+                   "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                   rval, mcp->mb[0], mcp->mb[1]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10fc, "Done %s.\n", __func__);
+       }
+
+       /* Copy mailbox information */
+       memcpy(mresp, mcp->mb, 64);
+       return rval;
+}
+
+int
+qla84xx_reset_chip(scsi_qla_host_t *vha, uint16_t enable_diagnostic)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10fd,
+           "Entered %s enable_diag=%d.\n", __func__, enable_diagnostic);
+
+       mcp->mb[0] = MBC_ISP84XX_RESET;
+       mcp->mb[1] = enable_diagnostic;
+       mcp->out_mb = MBX_1|MBX_0;
+       mcp->in_mb = MBX_1|MBX_0;
+       mcp->tov = MBX_TOV_SECONDS;
+       mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+       rval = qla2x00_mailbox_command(vha, mcp);
+
+       if (rval != QLA_SUCCESS)
+               ql_dbg(ql_dbg_mbx, vha, 0x10fe, "Failed=%x.\n", rval);
+       else
+               ql_dbg(ql_dbg_mbx, vha, 0x10ff, "Done %s.\n", __func__);
+
+       return rval;
+}
+
+int
+qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x1100, "Entered %s.\n", __func__);
+
+       if (!IS_FWI2_CAPABLE(vha->hw))
+               return QLA_FUNCTION_FAILED;
+
+       mcp->mb[0] = MBC_WRITE_RAM_WORD_EXTENDED;
+       mcp->mb[1] = LSW(risc_addr);
+       mcp->mb[2] = LSW(data);
+       mcp->mb[3] = MSW(data);
+       mcp->mb[8] = MSW(risc_addr);
+       mcp->out_mb = MBX_8|MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_0;
+       mcp->tov = 30;
+       mcp->flags = 0;
+       rval = qla2x00_mailbox_command(vha, mcp);
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x1101,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x1102, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla81xx_write_mpi_register(scsi_qla_host_t *vha, uint16_t *mb)
+{
+       int rval;
+       uint32_t stat, timer;
+       uint16_t mb0 = 0;
+       struct qla_hw_data *ha = vha->hw;
+       struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+
+       rval = QLA_SUCCESS;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x1103, "Entered %s.\n", __func__);
+
+       clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
+
+       /* Write the MBC data to the registers */
+       WRT_REG_WORD(&reg->mailbox0, MBC_WRITE_MPI_REGISTER);
+       WRT_REG_WORD(&reg->mailbox1, mb[0]);
+       WRT_REG_WORD(&reg->mailbox2, mb[1]);
+       WRT_REG_WORD(&reg->mailbox3, mb[2]);
+       WRT_REG_WORD(&reg->mailbox4, mb[3]);
+
+       WRT_REG_DWORD(&reg->hccr, HCCRX_SET_HOST_INT);
+
+       /* Poll for MBC interrupt */
+       for (timer = 6000000; timer; timer--) {
+               /* Check for pending interrupts. */
+               stat = RD_REG_DWORD(&reg->host_status);
+               if (stat & HSRX_RISC_INT) {
+                       stat &= 0xff;
+
+                       if (stat == 0x1 || stat == 0x2 ||
+                           stat == 0x10 || stat == 0x11) {
+                               set_bit(MBX_INTERRUPT,
+                                   &ha->mbx_cmd_flags);
+                               mb0 = RD_REG_WORD(&reg->mailbox0);
+                               WRT_REG_DWORD(&reg->hccr,
+                                   HCCRX_CLR_RISC_INT);
+                               RD_REG_DWORD(&reg->hccr);
+                               break;
+                       }
+               }
+               udelay(5);
+       }
+
+       if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags))
+               rval = mb0 & MBS_MASK;
+       else
+               rval = QLA_FUNCTION_FAILED;
+
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x1104,
+                   "Failed=%x mb[0]=%x.\n", rval, mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x1105, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+int
+qla2x00_get_data_rate(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, vha, 0x1106, "Entered %s.\n", __func__);
+
+       if (!IS_FWI2_CAPABLE(ha))
+               return QLA_FUNCTION_FAILED;
+
+       mcp->mb[0] = MBC_DATA_RATE;
+       mcp->mb[1] = 0;
+       mcp->out_mb = MBX_1|MBX_0;
+       mcp->in_mb = MBX_2|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, 0x1107,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x1108, "Done %s.\n", __func__);
+               if (mcp->mb[1] != 0x7)
+                       ha->link_data_rate = mcp->mb[1];
+       }
+
+       return rval;
+}
+
+int
+qla81xx_get_port_config(scsi_qla_host_t *vha, uint16_t *mb)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+       struct qla_hw_data *ha = vha->hw;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x1109, "Entered %s.\n", __func__);
+
+       if (!IS_QLA81XX(ha))
+               return QLA_FUNCTION_FAILED;
+       mcp->mb[0] = MBC_GET_PORT_CONFIG;
+       mcp->out_mb = MBX_0;
+       mcp->in_mb = 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) {
+               ql_dbg(ql_dbg_mbx, vha, 0x110a,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               /* Copy all bits to preserve original value */
+               memcpy(mb, &mcp->mb[1], sizeof(uint16_t) * 4);
+
+               ql_dbg(ql_dbg_mbx, vha, 0x110b, "Done %s.\n", __func__);
+       }
+       return rval;
+}
+
+int
+qla81xx_set_port_config(scsi_qla_host_t *vha, uint16_t *mb)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x110c, "Entered %s.\n", __func__);
+
+       mcp->mb[0] = MBC_SET_PORT_CONFIG;
+       /* Copy all bits to preserve original setting */
+       memcpy(&mcp->mb[1], mb, sizeof(uint16_t) * 4);
+       mcp->out_mb = MBX_4|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, 0x110d,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else
+               ql_dbg(ql_dbg_mbx, vha, 0x110e, "Done %s.\n", __func__);
+
+       return rval;
+}
+
+
+int
+qla24xx_set_fcp_prio(scsi_qla_host_t *vha, uint16_t loop_id, uint16_t priority,
+               uint16_t *mb)
+{
+       int rval;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+       struct qla_hw_data *ha = vha->hw;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x110f, "Entered %s.\n", __func__);
+
+       if (!IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha))
+               return QLA_FUNCTION_FAILED;
+
+       mcp->mb[0] = MBC_PORT_PARAMS;
+       mcp->mb[1] = loop_id;
+       if (ha->flags.fcp_prio_enabled)
+               mcp->mb[2] = BIT_1;
+       else
+               mcp->mb[2] = BIT_2;
+       mcp->mb[4] = priority & 0xf;
+       mcp->mb[9] = vha->vp_idx;
+       mcp->out_mb = MBX_9|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
+       mcp->tov = 30;
+       mcp->flags = 0;
+       rval = qla2x00_mailbox_command(vha, mcp);
+       if (mb != NULL) {
+               mb[0] = mcp->mb[0];
+               mb[1] = mcp->mb[1];
+               mb[3] = mcp->mb[3];
+               mb[4] = mcp->mb[4];
+       }
+
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x10cd, "Failed=%x.\n", rval);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x10cc, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla2x00_get_thermal_temp(scsi_qla_host_t *vha, uint16_t *temp, uint16_t *frac)
+{
+       int rval;
+       uint8_t byte;
+       struct qla_hw_data *ha = vha->hw;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x10ca, "Entered %s.\n", __func__);
+
+       /* Integer part */
+       rval = qla2x00_read_sfp(vha, 0, &byte, 0x98, 0x01, 1, BIT_13|BIT_0);
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x10c9, "Failed=%x.\n", rval);
+               ha->flags.thermal_supported = 0;
+               goto fail;
+       }
+       *temp = byte;
+
+       /* Fraction part */
+       rval = qla2x00_read_sfp(vha, 0, &byte, 0x98, 0x10, 1, BIT_13|BIT_0);
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x1019, "Failed=%x.\n", rval);
+               ha->flags.thermal_supported = 0;
+               goto fail;
+       }
+       *frac = (byte >> 6) * 25;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x1018, "Done %s.\n", __func__);
+fail:
+       return rval;
+}
+
+int
+qla82xx_mbx_intr_enable(scsi_qla_host_t *vha)
+{
+       int rval;
+       struct qla_hw_data *ha = vha->hw;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x1017, "Entered %s.\n", __func__);
+
+       if (!IS_FWI2_CAPABLE(ha))
+               return QLA_FUNCTION_FAILED;
+
+       memset(mcp, 0, sizeof(mbx_cmd_t));
+       mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
+       mcp->mb[1] = 1;
+
+       mcp->out_mb = MBX_1|MBX_0;
+       mcp->in_mb = MBX_0;
+       mcp->tov = 30;
+       mcp->flags = 0;
+
+       rval = qla2x00_mailbox_command(vha, mcp);
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x1016,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x100e, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla82xx_mbx_intr_disable(scsi_qla_host_t *vha)
+{
+       int rval;
+       struct qla_hw_data *ha = vha->hw;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x100d, "Entered %s.\n", __func__);
+
+       if (!IS_QLA82XX(ha))
+               return QLA_FUNCTION_FAILED;
+
+       memset(mcp, 0, sizeof(mbx_cmd_t));
+       mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
+       mcp->mb[1] = 0;
+
+       mcp->out_mb = MBX_1|MBX_0;
+       mcp->in_mb = MBX_0;
+       mcp->tov = 30;
+       mcp->flags = 0;
+
+       rval = qla2x00_mailbox_command(vha, mcp);
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x100c,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x100b, "Done %s.\n", __func__);
+       }
+
+       return rval;
+}
+
+int
+qla82xx_md_get_template_size(scsi_qla_host_t *vha)
+{
+       struct qla_hw_data *ha = vha->hw;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+       int rval = QLA_FUNCTION_FAILED;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x111f, "Entered %s.\n", __func__);
+
+       memset(mcp->mb, 0 , sizeof(mcp->mb));
+       mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
+       mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
+       mcp->mb[2] = LSW(RQST_TMPLT_SIZE);
+       mcp->mb[3] = MSW(RQST_TMPLT_SIZE);
+
+       mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|
+           MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
+
+       mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+       mcp->tov = MBX_TOV_SECONDS;
+       rval = qla2x00_mailbox_command(vha, mcp);
+
+       /* Always copy back return mailbox values. */
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x1120,
+                   "mailbox command FAILED=0x%x, subcode=%x.\n",
+                   (mcp->mb[1] << 16) | mcp->mb[0],
+                   (mcp->mb[3] << 16) | mcp->mb[2]);
+       } else {
+               ql_dbg(ql_dbg_mbx, vha, 0x1121, "Done %s.\n", __func__);
+               ha->md_template_size = ((mcp->mb[3] << 16) | mcp->mb[2]);
+               if (!ha->md_template_size) {
+                       ql_dbg(ql_dbg_mbx, vha, 0x1122,
+                           "Null template size obtained.\n");
+                       rval = QLA_FUNCTION_FAILED;
+               }
+       }
+       return rval;
+}
+
+int
+qla82xx_md_get_template(scsi_qla_host_t *vha)
+{
+       struct qla_hw_data *ha = vha->hw;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+       int rval = QLA_FUNCTION_FAILED;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x1123, "Entered %s.\n", __func__);
+
+       ha->md_tmplt_hdr = dma_alloc_coherent(&ha->pdev->dev,
+          ha->md_template_size, &ha->md_tmplt_hdr_dma, GFP_KERNEL);
+       if (!ha->md_tmplt_hdr) {
+               ql_log(ql_log_warn, vha, 0x1124,
+                   "Unable to allocate memory for Minidump template.\n");
+               return rval;
+       }
+
+       memset(mcp->mb, 0 , sizeof(mcp->mb));
+       mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
+       mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
+       mcp->mb[2] = LSW(RQST_TMPLT);
+       mcp->mb[3] = MSW(RQST_TMPLT);
+       mcp->mb[4] = LSW(LSD(ha->md_tmplt_hdr_dma));
+       mcp->mb[5] = MSW(LSD(ha->md_tmplt_hdr_dma));
+       mcp->mb[6] = LSW(MSD(ha->md_tmplt_hdr_dma));
+       mcp->mb[7] = MSW(MSD(ha->md_tmplt_hdr_dma));
+       mcp->mb[8] = LSW(ha->md_template_size);
+       mcp->mb[9] = MSW(ha->md_template_size);
+
+       mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+       mcp->tov = MBX_TOV_SECONDS;
+       mcp->out_mb = MBX_11|MBX_10|MBX_9|MBX_8|
+           MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
+       mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
+       rval = qla2x00_mailbox_command(vha, mcp);
+
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x1125,
+                   "mailbox command FAILED=0x%x, subcode=%x.\n",
+                   ((mcp->mb[1] << 16) | mcp->mb[0]),
+                   ((mcp->mb[3] << 16) | mcp->mb[2]));
+       } else
+               ql_dbg(ql_dbg_mbx, vha, 0x1126, "Done %s.\n", __func__);
+       return rval;
+}
+
+int
+qla82xx_mbx_beacon_ctl(scsi_qla_host_t *vha, int enable)
+{
+       int rval;
+       struct qla_hw_data *ha = vha->hw;
+       mbx_cmd_t mc;
+       mbx_cmd_t *mcp = &mc;
+
+       if (!IS_QLA82XX(ha))
+               return QLA_FUNCTION_FAILED;
+
+       ql_dbg(ql_dbg_mbx, vha, 0x1127,
+               "Entered %s.\n", __func__);
+
+       memset(mcp, 0, sizeof(mbx_cmd_t));
+       mcp->mb[0] = MBC_SET_LED_CONFIG;
+       if (enable)
+               mcp->mb[7] = 0xE;
+       else
+               mcp->mb[7] = 0xD;
+
+       mcp->out_mb = MBX_7|MBX_0;
+       mcp->in_mb = MBX_0;
+       mcp->tov = 30;
+       mcp->flags = 0;
+
+       rval = qla2x00_mailbox_command(vha, mcp);
+       if (rval != QLA_SUCCESS) {
+               ql_dbg(ql_dbg_mbx, vha, 0x1128,
+                   "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
        } else {
-               DEBUG16(printk("%s(%ld): done.\n", __func__, ha->host_no));
+               ql_dbg(ql_dbg_mbx, vha, 0x1129,
+                   "Done %s.\n", __func__);
        }
 
        return rval;