1 files changed, 443 insertions, 160 deletions

diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.c b/drivers/scsi/mpt2sas/mpt2sas_base.c
index d95d2f274cb3..89d02401b9ec 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.c
@@ -3,7 +3,7 @@
  * for access to MPT (Message Passing Technology) firmware.
  *
  * This code is based on drivers/scsi/mpt2sas/mpt2_base.c
- * Copyright (C) 2007-2008  LSI Corporation
+ * Copyright (C) 2007-2009  LSI Corporation
  *  (mailto:DL-MPTFusionLinux@lsi.com)
  *
  * This program is free software; you can redistribute it and/or
@@ -57,13 +57,14 @@
 #include <linux/dma-mapping.h>
 #include <linux/sort.h>
 #include <linux/io.h>
+#include <linux/time.h>
 
 #include "mpt2sas_base.h"
 
 static MPT_CALLBACK     mpt_callbacks[MPT_MAX_CALLBACKS];
 
 #define FAULT_POLLING_INTERVAL 1000 /* in milliseconds */
-#define MPT2SAS_MAX_REQUEST_QUEUE 500 /* maximum controller queue depth */
+#define MPT2SAS_MAX_REQUEST_QUEUE 600 /* maximum controller queue depth */
 
 static int max_queue_depth = -1;
 module_param(max_queue_depth, int, 0);
@@ -77,6 +78,44 @@ static int msix_disable = -1;
 module_param(msix_disable, int, 0);
 MODULE_PARM_DESC(msix_disable, " disable msix routed interrupts (default=0)");
 
+/* diag_buffer_enable is bitwise
+ * bit 0 set = TRACE
+ * bit 1 set = SNAPSHOT
+ * bit 2 set = EXTENDED
+ *
+ * Either bit can be set, or both
+ */
+static int diag_buffer_enable;
+module_param(diag_buffer_enable, int, 0);
+MODULE_PARM_DESC(diag_buffer_enable, " post diag buffers "
+    "(TRACE=1/SNAPSHOT=2/EXTENDED=4/default=0)");
+
+int mpt2sas_fwfault_debug;
+MODULE_PARM_DESC(mpt2sas_fwfault_debug, " enable detection of firmware fault "
+    "and halt firmware - (default=0)");
+
+/**
+ * _scsih_set_fwfault_debug - global setting of ioc->fwfault_debug.
+ *
+ */
+static int
+_scsih_set_fwfault_debug(const char *val, struct kernel_param *kp)
+{
+        int ret = param_set_int(val, kp);
+        struct MPT2SAS_ADAPTER *ioc;
+
+        if (ret)
+                return ret;
+
+        printk(KERN_INFO "setting logging_level(0x%08x)\n",
+                                mpt2sas_fwfault_debug);
+        list_for_each_entry(ioc, &mpt2sas_ioc_list, list)
+                ioc->fwfault_debug = mpt2sas_fwfault_debug;
+        return 0;
+}
+module_param_call(mpt2sas_fwfault_debug, _scsih_set_fwfault_debug,
+    param_get_int, &mpt2sas_fwfault_debug, 0644);
+
 /**
  * _base_fault_reset_work - workq handling ioc fault conditions
  * @work: input argument, used to derive ioc
@@ -121,7 +160,7 @@ _base_fault_reset_work(struct work_struct *work)
 
 /**
  * mpt2sas_base_start_watchdog - start the fault_reset_work_q
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * Context: sleep.
  *
  * Return nothing.
@@ -155,7 +194,7 @@ mpt2sas_base_start_watchdog(struct MPT2SAS_ADAPTER *ioc)
 
 /**
  * mpt2sas_base_stop_watchdog - stop the fault_reset_work_q
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * Context: sleep.
  *
  * Return nothing.
@@ -177,10 +216,55 @@ mpt2sas_base_stop_watchdog(struct MPT2SAS_ADAPTER *ioc)
         }
 }
 
+/**
+ * mpt2sas_base_fault_info - verbose translation of firmware FAULT code
+ * @ioc: per adapter object
+ * @fault_code: fault code
+ *
+ * Return nothing.
+ */
+void
+mpt2sas_base_fault_info(struct MPT2SAS_ADAPTER *ioc , u16 fault_code)
+{
+        printk(MPT2SAS_ERR_FMT "fault_state(0x%04x)!\n",
+            ioc->name, fault_code);
+}
+
+/**
+ * mpt2sas_halt_firmware - halt's mpt controller firmware
+ * @ioc: per adapter object
+ *
+ * For debugging timeout related issues.  Writing 0xCOFFEE00
+ * to the doorbell register will halt controller firmware. With
+ * the purpose to stop both driver and firmware, the enduser can
+ * obtain a ring buffer from controller UART.
+ */
+void
+mpt2sas_halt_firmware(struct MPT2SAS_ADAPTER *ioc)
+{
+        u32 doorbell;
+
+        if (!ioc->fwfault_debug)
+                return;
+
+        dump_stack();
+
+        doorbell = readl(&ioc->chip->Doorbell);
+        if ((doorbell & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT)
+                mpt2sas_base_fault_info(ioc , doorbell);
+        else {
+                writel(0xC0FFEE00, &ioc->chip->Doorbell);
+                printk(MPT2SAS_ERR_FMT "Firmware is halted due to command "
+                    "timeout\n", ioc->name);
+        }
+
+        panic("panic in %s\n", __func__);
+}
+
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
 /**
  * _base_sas_ioc_info - verbose translation of the ioc status
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @mpi_reply: reply mf payload returned from firmware
  * @request_hdr: request mf
  *
@@ -394,7 +478,7 @@ _base_sas_ioc_info(struct MPT2SAS_ADAPTER *ioc, MPI2DefaultReply_t *mpi_reply,
 
 /**
  * _base_display_event_data - verbose translation of firmware asyn events
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @mpi_reply: reply mf payload returned from firmware
  *
  * Return nothing.
@@ -474,7 +558,7 @@ _base_display_event_data(struct MPT2SAS_ADAPTER *ioc,
 
 /**
  * _base_sas_log_info - verbose translation of firmware log info
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @log_info: log info
  *
  * Return nothing.
@@ -526,30 +610,16 @@ _base_sas_log_info(struct MPT2SAS_ADAPTER *ioc , u32 log_info)
 }
 
 /**
- * mpt2sas_base_fault_info - verbose translation of firmware FAULT code
- * @ioc: pointer to scsi command object
- * @fault_code: fault code
- *
- * Return nothing.
- */
-void
-mpt2sas_base_fault_info(struct MPT2SAS_ADAPTER *ioc , u16 fault_code)
-{
-        printk(MPT2SAS_ERR_FMT "fault_state(0x%04x)!\n",
-            ioc->name, fault_code);
-}
-
-/**
  * _base_display_reply_info -
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @smid: system request message index
- * @VF_ID: virtual function id
+ * @msix_index: MSIX table index supplied by the OS
  * @reply: reply message frame(lower 32bit addr)
  *
  * Return nothing.
  */
 static void
-_base_display_reply_info(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 VF_ID,
+_base_display_reply_info(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
     u32 reply)
 {
         MPI2DefaultReply_t *mpi_reply;
@@ -570,24 +640,26 @@ _base_display_reply_info(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 VF_ID,
 
 /**
  * mpt2sas_base_done - base internal command completion routine
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @smid: system request message index
- * @VF_ID: virtual function id
+ * @msix_index: MSIX table index supplied by the OS
  * @reply: reply message frame(lower 32bit addr)
  *
- * Return nothing.
+ * Return 1 meaning mf should be freed from _base_interrupt
+ *        0 means the mf is freed from this function.
  */
-void
-mpt2sas_base_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 VF_ID, u32 reply)
+u8
+mpt2sas_base_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
+    u32 reply)
 {
         MPI2DefaultReply_t *mpi_reply;
 
         mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
         if (mpi_reply && mpi_reply->Function == MPI2_FUNCTION_EVENT_ACK)
-                return;
+                return 1;
 
         if (ioc->base_cmds.status == MPT2_CMD_NOT_USED)
-                return;
+                return 1;
 
         ioc->base_cmds.status |= MPT2_CMD_COMPLETE;
         if (mpi_reply) {
@@ -596,18 +668,20 @@ mpt2sas_base_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 VF_ID, u32 reply)
         }
         ioc->base_cmds.status &= ~MPT2_CMD_PENDING;
         complete(&ioc->base_cmds.done);
+        return 1;
 }
 
 /**
  * _base_async_event - main callback handler for firmware asyn events
- * @ioc: pointer to scsi command object
- * @VF_ID: virtual function id
+ * @ioc: per adapter object
+ * @msix_index: MSIX table index supplied by the OS
  * @reply: reply message frame(lower 32bit addr)
  *
- * Return nothing.
+ * Return 1 meaning mf should be freed from _base_interrupt
+ *        0 means the mf is freed from this function.
  */
-static void
-_base_async_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, u32 reply)
+static u8
+_base_async_event(struct MPT2SAS_ADAPTER *ioc, u8 msix_index, u32 reply)
 {
         Mpi2EventNotificationReply_t *mpi_reply;
         Mpi2EventAckRequest_t *ack_request;
@@ -615,9 +689,9 @@ _base_async_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, u32 reply)
 
         mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
         if (!mpi_reply)
-                return;
+                return 1;
         if (mpi_reply->Function != MPI2_FUNCTION_EVENT_NOTIFICATION)
-                return;
+                return 1;
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
         _base_display_event_data(ioc, mpi_reply);
 #endif
@@ -635,21 +709,52 @@ _base_async_event(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, u32 reply)
         ack_request->Function = MPI2_FUNCTION_EVENT_ACK;
         ack_request->Event = mpi_reply->Event;
         ack_request->EventContext = mpi_reply->EventContext;
-        ack_request->VF_ID = VF_ID;
-        mpt2sas_base_put_smid_default(ioc, smid, VF_ID);
+        ack_request->VF_ID = 0;  /* TODO */
+        ack_request->VP_ID = 0;
+        mpt2sas_base_put_smid_default(ioc, smid);
 
  out:
 
         /* scsih callback handler */
-        mpt2sas_scsih_event_callback(ioc, VF_ID, reply);
+        mpt2sas_scsih_event_callback(ioc, msix_index, reply);
 
         /* ctl callback handler */
-        mpt2sas_ctl_event_callback(ioc, VF_ID, reply);
+        mpt2sas_ctl_event_callback(ioc, msix_index, reply);
+
+        return 1;
+}
+
+/**
+ * _base_get_cb_idx - obtain the callback index
+ * @ioc: per adapter object
+ * @smid: system request message index
+ *
+ * Return callback index.
+ */
+static u8
+_base_get_cb_idx(struct MPT2SAS_ADAPTER *ioc, u16 smid)
+{
+        int i;
+        u8 cb_idx = 0xFF;
+
+        if (smid >= ioc->hi_priority_smid) {
+                if (smid < ioc->internal_smid) {
+                        i = smid - ioc->hi_priority_smid;
+                        cb_idx = ioc->hpr_lookup[i].cb_idx;
+                } else {
+                        i = smid - ioc->internal_smid;
+                        cb_idx = ioc->internal_lookup[i].cb_idx;
+                }
+        } else {
+                i = smid - 1;
+                cb_idx = ioc->scsi_lookup[i].cb_idx;
+        }
+        return cb_idx;
 }
 
 /**
  * _base_mask_interrupts - disable interrupts
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  *
  * Disabling ResetIRQ, Reply and Doorbell Interrupts
  *
@@ -669,7 +774,7 @@ _base_mask_interrupts(struct MPT2SAS_ADAPTER *ioc)
 
 /**
  * _base_unmask_interrupts - enable interrupts
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  *
  * Enabling only Reply Interrupts
  *
@@ -680,7 +785,6 @@ _base_unmask_interrupts(struct MPT2SAS_ADAPTER *ioc)
 {
         u32 him_register;
 
-        writel(0, &ioc->chip->HostInterruptStatus);
         him_register = readl(&ioc->chip->HostInterruptMask);
         him_register &= ~MPI2_HIM_RIM;
         writel(him_register, &ioc->chip->HostInterruptMask);
@@ -712,9 +816,10 @@ _base_interrupt(int irq, void *bus_id)
         u16 smid;
         u8 cb_idx;
         u32 reply;
-        u8 VF_ID;
+        u8 msix_index;
         struct MPT2SAS_ADAPTER *ioc = bus_id;
         Mpi2ReplyDescriptorsUnion_t *rpf;
+        u8 rc;
 
         if (ioc->mask_interrupts)
                 return IRQ_NONE;
@@ -733,7 +838,7 @@ _base_interrupt(int irq, void *bus_id)
                 reply = 0;
                 cb_idx = 0xFF;
                 smid = le16_to_cpu(rpf->Default.DescriptorTypeDependent1);
-                VF_ID = rpf->Default.VF_ID;
+                msix_index = rpf->Default.MSIxIndex;
                 if (request_desript_type ==
                     MPI2_RPY_DESCRIPT_FLAGS_ADDRESS_REPLY) {
                         reply = le32_to_cpu
@@ -745,16 +850,18 @@ _base_interrupt(int irq, void *bus_id)
                     MPI2_RPY_DESCRIPT_FLAGS_TARGETASSIST_SUCCESS)
                         goto next;
                 if (smid)
-                        cb_idx = ioc->scsi_lookup[smid - 1].cb_idx;
+                        cb_idx = _base_get_cb_idx(ioc, smid);
                 if (smid && cb_idx != 0xFF) {
-                        mpt_callbacks[cb_idx](ioc, smid, VF_ID, reply);
+                        rc = mpt_callbacks[cb_idx](ioc, smid, msix_index,
+                            reply);
                         if (reply)
-                                _base_display_reply_info(ioc, smid, VF_ID,
+                                _base_display_reply_info(ioc, smid, msix_index,
                                     reply);
-                        mpt2sas_base_free_smid(ioc, smid);
+                        if (rc)
+                                mpt2sas_base_free_smid(ioc, smid);
                 }
                 if (!smid)
-                        _base_async_event(ioc, VF_ID, reply);
+                        _base_async_event(ioc, msix_index, reply);
 
                 /* reply free queue handling */
                 if (reply) {
@@ -1191,19 +1298,6 @@ mpt2sas_base_map_resources(struct MPT2SAS_ADAPTER *ioc)
 }
 
 /**
- * mpt2sas_base_get_msg_frame_dma - obtain request mf pointer phys addr
- * @ioc: per adapter object
- * @smid: system request message index(smid zero is invalid)
- *
- * Returns phys pointer to message frame.
- */
-dma_addr_t
-mpt2sas_base_get_msg_frame_dma(struct MPT2SAS_ADAPTER *ioc, u16 smid)
-{
-        return ioc->request_dma + (smid * ioc->request_sz);
-}
-
-/**
  * mpt2sas_base_get_msg_frame - obtain request mf pointer
  * @ioc: per adapter object
  * @smid: system request message index(smid zero is invalid)
@@ -1234,12 +1328,13 @@ mpt2sas_base_get_sense_buffer(struct MPT2SAS_ADAPTER *ioc, u16 smid)
  * @ioc: per adapter object
  * @smid: system request message index
  *
- * Returns phys pointer to sense buffer.
+ * Returns phys pointer to the low 32bit address of the sense buffer.
  */
-dma_addr_t
+__le32
 mpt2sas_base_get_sense_buffer_dma(struct MPT2SAS_ADAPTER *ioc, u16 smid)
 {
-        return ioc->sense_dma + ((smid - 1) * SCSI_SENSE_BUFFERSIZE);
+        return cpu_to_le32(ioc->sense_dma +
+                        ((smid - 1) * SCSI_SENSE_BUFFERSIZE));
 }
 
 /**
@@ -1258,7 +1353,7 @@ mpt2sas_base_get_reply_virt_addr(struct MPT2SAS_ADAPTER *ioc, u32 phys_addr)
 }
 
 /**
- * mpt2sas_base_get_smid - obtain a free smid
+ * mpt2sas_base_get_smid - obtain a free smid from internal queue
  * @ioc: per adapter object
  * @cb_idx: callback index
  *
@@ -1272,6 +1367,39 @@ mpt2sas_base_get_smid(struct MPT2SAS_ADAPTER *ioc, u8 cb_idx)
         u16 smid;
 
         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
+        if (list_empty(&ioc->internal_free_list)) {
+                spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
+                printk(MPT2SAS_ERR_FMT "%s: smid not available\n",
+                    ioc->name, __func__);
+                return 0;
+        }
+
+        request = list_entry(ioc->internal_free_list.next,
+            struct request_tracker, tracker_list);
+        request->cb_idx = cb_idx;
+        smid = request->smid;
+        list_del(&request->tracker_list);
+        spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
+        return smid;
+}
+
+/**
+ * mpt2sas_base_get_smid_scsiio - obtain a free smid from scsiio queue
+ * @ioc: per adapter object
+ * @cb_idx: callback index
+ * @scmd: pointer to scsi command object
+ *
+ * Returns smid (zero is invalid)
+ */
+u16
+mpt2sas_base_get_smid_scsiio(struct MPT2SAS_ADAPTER *ioc, u8 cb_idx,
+    struct scsi_cmnd *scmd)
+{
+        unsigned long flags;
+        struct request_tracker *request;
+        u16 smid;
+
+        spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
         if (list_empty(&ioc->free_list)) {
                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
                 printk(MPT2SAS_ERR_FMT "%s: smid not available\n",
@@ -1281,6 +1409,36 @@ mpt2sas_base_get_smid(struct MPT2SAS_ADAPTER *ioc, u8 cb_idx)
 
         request = list_entry(ioc->free_list.next,
             struct request_tracker, tracker_list);
+        request->scmd = scmd;
+        request->cb_idx = cb_idx;
+        smid = request->smid;
+        list_del(&request->tracker_list);
+        spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
+        return smid;
+}
+
+/**
+ * mpt2sas_base_get_smid_hpr - obtain a free smid from hi-priority queue
+ * @ioc: per adapter object
+ * @cb_idx: callback index
+ *
+ * Returns smid (zero is invalid)
+ */
+u16
+mpt2sas_base_get_smid_hpr(struct MPT2SAS_ADAPTER *ioc, u8 cb_idx)
+{
+        unsigned long flags;
+        struct request_tracker *request;
+        u16 smid;
+
+        spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
+        if (list_empty(&ioc->hpr_free_list)) {
+                spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
+                return 0;
+        }
+
+        request = list_entry(ioc->hpr_free_list.next,
+            struct request_tracker, tracker_list);
         request->cb_idx = cb_idx;
         smid = request->smid;
         list_del(&request->tracker_list);
@@ -1300,10 +1458,32 @@ void
 mpt2sas_base_free_smid(struct MPT2SAS_ADAPTER *ioc, u16 smid)
 {
         unsigned long flags;
+        int i;
 
         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
-        ioc->scsi_lookup[smid - 1].cb_idx = 0xFF;
-        list_add_tail(&ioc->scsi_lookup[smid - 1].tracker_list,
+        if (smid >= ioc->hi_priority_smid) {
+                if (smid < ioc->internal_smid) {
+                        /* hi-priority */
+                        i = smid - ioc->hi_priority_smid;
+                        ioc->hpr_lookup[i].cb_idx = 0xFF;
+                        list_add_tail(&ioc->hpr_lookup[i].tracker_list,
+                            &ioc->hpr_free_list);
+                } else {
+                        /* internal queue */
+                        i = smid - ioc->internal_smid;
+                        ioc->internal_lookup[i].cb_idx = 0xFF;
+                        list_add_tail(&ioc->internal_lookup[i].tracker_list,
+                            &ioc->internal_free_list);
+                }
+                spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
+                return;
+        }
+
+        /* scsiio queue */
+        i = smid - 1;
+        ioc->scsi_lookup[i].cb_idx = 0xFF;
+        ioc->scsi_lookup[i].scmd = NULL;
+        list_add_tail(&ioc->scsi_lookup[i].tracker_list,
             &ioc->free_list);
         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
 
@@ -1352,21 +1532,19 @@ static inline void _base_writeq(__u64 b, volatile void __iomem *addr,
  * mpt2sas_base_put_smid_scsi_io - send SCSI_IO request to firmware
  * @ioc: per adapter object
  * @smid: system request message index
- * @vf_id: virtual function id
  * @handle: device handle
  *
  * Return nothing.
  */
 void
-mpt2sas_base_put_smid_scsi_io(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 vf_id,
-    u16 handle)
+mpt2sas_base_put_smid_scsi_io(struct MPT2SAS_ADAPTER *ioc, u16 smid, u16 handle)
 {
         Mpi2RequestDescriptorUnion_t descriptor;
         u64 *request = (u64 *)&descriptor;
 
 
         descriptor.SCSIIO.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO;
-        descriptor.SCSIIO.VF_ID = vf_id;
+        descriptor.SCSIIO.MSIxIndex = 0; /* TODO */
         descriptor.SCSIIO.SMID = cpu_to_le16(smid);
         descriptor.SCSIIO.DevHandle = cpu_to_le16(handle);
         descriptor.SCSIIO.LMID = 0;
@@ -1379,20 +1557,18 @@ mpt2sas_base_put_smid_scsi_io(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 vf_id,
  * mpt2sas_base_put_smid_hi_priority - send Task Managment request to firmware
  * @ioc: per adapter object
  * @smid: system request message index
- * @vf_id: virtual function id
  *
  * Return nothing.
  */
 void
-mpt2sas_base_put_smid_hi_priority(struct MPT2SAS_ADAPTER *ioc, u16 smid,
-    u8 vf_id)
+mpt2sas_base_put_smid_hi_priority(struct MPT2SAS_ADAPTER *ioc, u16 smid)
 {
         Mpi2RequestDescriptorUnion_t descriptor;
         u64 *request = (u64 *)&descriptor;
 
         descriptor.HighPriority.RequestFlags =
             MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY;
-        descriptor.HighPriority.VF_ID = vf_id;
+        descriptor.HighPriority.MSIxIndex = 0; /* TODO */
         descriptor.HighPriority.SMID = cpu_to_le16(smid);
         descriptor.HighPriority.LMID = 0;
         descriptor.HighPriority.Reserved1 = 0;
@@ -1404,18 +1580,17 @@ mpt2sas_base_put_smid_hi_priority(struct MPT2SAS_ADAPTER *ioc, u16 smid,
  * mpt2sas_base_put_smid_default - Default, primarily used for config pages
  * @ioc: per adapter object
  * @smid: system request message index
- * @vf_id: virtual function id
  *
  * Return nothing.
  */
 void
-mpt2sas_base_put_smid_default(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 vf_id)
+mpt2sas_base_put_smid_default(struct MPT2SAS_ADAPTER *ioc, u16 smid)
 {
         Mpi2RequestDescriptorUnion_t descriptor;
         u64 *request = (u64 *)&descriptor;
 
         descriptor.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
-        descriptor.Default.VF_ID = vf_id;
+        descriptor.Default.MSIxIndex = 0; /* TODO */
         descriptor.Default.SMID = cpu_to_le16(smid);
         descriptor.Default.LMID = 0;
         descriptor.Default.DescriptorTypeDependent = 0;
@@ -1427,21 +1602,20 @@ mpt2sas_base_put_smid_default(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 vf_id)
  * mpt2sas_base_put_smid_target_assist - send Target Assist/Status to firmware
  * @ioc: per adapter object
  * @smid: system request message index
- * @vf_id: virtual function id
  * @io_index: value used to track the IO
  *
  * Return nothing.
  */
 void
 mpt2sas_base_put_smid_target_assist(struct MPT2SAS_ADAPTER *ioc, u16 smid,
-    u8 vf_id, u16 io_index)
+    u16 io_index)
 {
         Mpi2RequestDescriptorUnion_t descriptor;
         u64 *request = (u64 *)&descriptor;
 
         descriptor.SCSITarget.RequestFlags =
             MPI2_REQ_DESCRIPT_FLAGS_SCSI_TARGET;
-        descriptor.SCSITarget.VF_ID = vf_id;
+        descriptor.SCSITarget.MSIxIndex = 0; /* TODO */
         descriptor.SCSITarget.SMID = cpu_to_le16(smid);
         descriptor.SCSITarget.LMID = 0;
         descriptor.SCSITarget.IoIndex = cpu_to_le16(io_index);
@@ -1594,6 +1768,12 @@ _base_display_ioc_capabilities(struct MPT2SAS_ADAPTER *ioc)
         }
 
         if (ioc->facts.IOCCapabilities &
+            MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER) {
+                printk(KERN_INFO "%sDiag Extended Buffer", i ? "," : "");
+                i++;
+        }
+
+        if (ioc->facts.IOCCapabilities &
             MPI2_IOCFACTS_CAPABILITY_TASK_SET_FULL_HANDLING) {
                 printk("%sTask Set Full", i ? "," : "");
                 i++;
@@ -1717,6 +1897,8 @@ _base_release_memory_pools(struct MPT2SAS_ADAPTER *ioc)
         }
 
         kfree(ioc->scsi_lookup);
+        kfree(ioc->hpr_lookup);
+        kfree(ioc->internal_lookup);
 }
 
 
@@ -1736,7 +1918,6 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
         u16 num_of_reply_frames;
         u16 chains_needed_per_io;
         u32 sz, total_sz;
-        u16 i;
         u32 retry_sz;
         u16 max_request_credit;
 
@@ -1764,7 +1945,10 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
                     MPT2SAS_MAX_REQUEST_QUEUE) ? MPT2SAS_MAX_REQUEST_QUEUE :
                     facts->RequestCredit;
         }
-        ioc->request_depth = max_request_credit;
+
+        ioc->hba_queue_depth = max_request_credit;
+        ioc->hi_priority_depth = facts->HighPriorityCredit;
+        ioc->internal_depth = ioc->hi_priority_depth + 5;
 
         /* request frame size */
         ioc->request_sz = facts->IOCRequestFrameSize * 4;
@@ -1802,7 +1986,7 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
         ioc->chains_needed_per_io = chains_needed_per_io;
 
         /* reply free queue sizing - taking into account for events */
-        num_of_reply_frames = ioc->request_depth + 32;
+        num_of_reply_frames = ioc->hba_queue_depth + 32;
 
         /* number of replies frames can't be a multiple of 16 */
         /* decrease number of reply frames by 1 */
@@ -1823,7 +2007,7 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
          * frames
          */
 
-        queue_size = ioc->request_depth + num_of_reply_frames + 1;
+        queue_size = ioc->hba_queue_depth + num_of_reply_frames + 1;
         /* round up to 16 byte boundary */
         if (queue_size % 16)
                 queue_size += 16 - (queue_size % 16);
@@ -1837,60 +2021,85 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
                 if (queue_diff % 16)
                         queue_diff += 16 - (queue_diff % 16);
 
-                /* adjust request_depth, reply_free_queue_depth,
+                /* adjust hba_queue_depth, reply_free_queue_depth,
                  * and queue_size
                  */
-                ioc->request_depth -= queue_diff;
+                ioc->hba_queue_depth -= queue_diff;
                 ioc->reply_free_queue_depth -= queue_diff;
                 queue_size -= queue_diff;
         }
         ioc->reply_post_queue_depth = queue_size;
 
-        /* max scsi host queue depth */
-        ioc->shost->can_queue = ioc->request_depth - INTERNAL_CMDS_COUNT;
-        dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "scsi host queue: depth"
-            "(%d)\n", ioc->name, ioc->shost->can_queue));
-
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "scatter gather: "
             "sge_in_main_msg(%d), sge_per_chain(%d), sge_per_io(%d), "
             "chains_per_io(%d)\n", ioc->name, ioc->max_sges_in_main_message,
             ioc->max_sges_in_chain_message, ioc->shost->sg_tablesize,
             ioc->chains_needed_per_io));
 
+        ioc->scsiio_depth = ioc->hba_queue_depth -
+            ioc->hi_priority_depth - ioc->internal_depth;
+
+        /* set the scsi host can_queue depth
+         * with some internal commands that could be outstanding
+         */
+        ioc->shost->can_queue = ioc->scsiio_depth - (2);
+        dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "scsi host: "
+            "can_queue depth (%d)\n", ioc->name, ioc->shost->can_queue));
+
         /* contiguous pool for request and chains, 16 byte align, one extra "
          * "frame for smid=0
          */
-        ioc->chain_depth = ioc->chains_needed_per_io * ioc->request_depth;
-        sz = ((ioc->request_depth + 1 + ioc->chain_depth) * ioc->request_sz);
+        ioc->chain_depth = ioc->chains_needed_per_io * ioc->scsiio_depth;
+        sz = ((ioc->scsiio_depth + 1 + ioc->chain_depth) * ioc->request_sz);
+
+        /* hi-priority queue */
+        sz += (ioc->hi_priority_depth * ioc->request_sz);
+
+        /* internal queue */
+        sz += (ioc->internal_depth * ioc->request_sz);
 
         ioc->request_dma_sz = sz;
         ioc->request = pci_alloc_consistent(ioc->pdev, sz, &ioc->request_dma);
         if (!ioc->request) {
                 printk(MPT2SAS_ERR_FMT "request pool: pci_alloc_consistent "
-                    "failed: req_depth(%d), chains_per_io(%d), frame_sz(%d), "
-                    "total(%d kB)\n", ioc->name, ioc->request_depth,
+                    "failed: hba_depth(%d), chains_per_io(%d), frame_sz(%d), "
+                    "total(%d kB)\n", ioc->name, ioc->hba_queue_depth,
                     ioc->chains_needed_per_io, ioc->request_sz, sz/1024);
-                if (ioc->request_depth < MPT2SAS_SAS_QUEUE_DEPTH)
+                if (ioc->scsiio_depth < MPT2SAS_SAS_QUEUE_DEPTH)
                         goto out;
                 retry_sz += 64;
-                ioc->request_depth = max_request_credit - retry_sz;
+                ioc->hba_queue_depth = max_request_credit - retry_sz;
                 goto retry_allocation;
         }
 
         if (retry_sz)
                 printk(MPT2SAS_ERR_FMT "request pool: pci_alloc_consistent "
-                    "succeed: req_depth(%d), chains_per_io(%d), frame_sz(%d), "
-                    "total(%d kb)\n", ioc->name, ioc->request_depth,
+                    "succeed: hba_depth(%d), chains_per_io(%d), frame_sz(%d), "
+                    "total(%d kb)\n", ioc->name, ioc->hba_queue_depth,
                     ioc->chains_needed_per_io, ioc->request_sz, sz/1024);
 
-        ioc->chain = ioc->request + ((ioc->request_depth + 1) *
+
+        /* hi-priority queue */
+        ioc->hi_priority = ioc->request + ((ioc->scsiio_depth + 1) *
+            ioc->request_sz);
+        ioc->hi_priority_dma = ioc->request_dma + ((ioc->scsiio_depth + 1) *
+            ioc->request_sz);
+
+        /* internal queue */
+        ioc->internal = ioc->hi_priority + (ioc->hi_priority_depth *
+            ioc->request_sz);
+        ioc->internal_dma = ioc->hi_priority_dma + (ioc->hi_priority_depth *
+            ioc->request_sz);
+
+        ioc->chain = ioc->internal + (ioc->internal_depth *
             ioc->request_sz);
-        ioc->chain_dma = ioc->request_dma + ((ioc->request_depth + 1) *
+        ioc->chain_dma = ioc->internal_dma + (ioc->internal_depth *
             ioc->request_sz);
+
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "request pool(0x%p): "
             "depth(%d), frame_size(%d), pool_size(%d kB)\n", ioc->name,
-            ioc->request, ioc->request_depth, ioc->request_sz,
-            ((ioc->request_depth + 1) * ioc->request_sz)/1024));
+            ioc->request, ioc->hba_queue_depth, ioc->request_sz,
+            (ioc->hba_queue_depth * ioc->request_sz)/1024));
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "chain pool(0x%p): depth"
             "(%d), frame_size(%d), pool_size(%d kB)\n", ioc->name, ioc->chain,
             ioc->chain_depth, ioc->request_sz, ((ioc->chain_depth *
@@ -1899,7 +2108,7 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
             ioc->name, (unsigned long long) ioc->request_dma));
         total_sz += sz;
 
-        ioc->scsi_lookup = kcalloc(ioc->request_depth,
+        ioc->scsi_lookup = kcalloc(ioc->scsiio_depth,
             sizeof(struct request_tracker), GFP_KERNEL);
         if (!ioc->scsi_lookup) {
                 printk(MPT2SAS_ERR_FMT "scsi_lookup: kcalloc failed\n",
@@ -1907,12 +2116,38 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
                 goto out;
         }
 
-         /* initialize some bits */
-        for (i = 0; i < ioc->request_depth; i++)
-                ioc->scsi_lookup[i].smid = i + 1;
+        dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "scsiio(0x%p): "
+            "depth(%d)\n", ioc->name, ioc->request,
+            ioc->scsiio_depth));
+
+        /* initialize hi-priority queue smid's */
+        ioc->hpr_lookup = kcalloc(ioc->hi_priority_depth,
+            sizeof(struct request_tracker), GFP_KERNEL);
+        if (!ioc->hpr_lookup) {
+                printk(MPT2SAS_ERR_FMT "hpr_lookup: kcalloc failed\n",
+                    ioc->name);
+                goto out;
+        }
+        ioc->hi_priority_smid = ioc->scsiio_depth + 1;
+        dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "hi_priority(0x%p): "
+            "depth(%d), start smid(%d)\n", ioc->name, ioc->hi_priority,
+            ioc->hi_priority_depth, ioc->hi_priority_smid));
+
+        /* initialize internal queue smid's */
+        ioc->internal_lookup = kcalloc(ioc->internal_depth,
+            sizeof(struct request_tracker), GFP_KERNEL);
+        if (!ioc->internal_lookup) {
+                printk(MPT2SAS_ERR_FMT "internal_lookup: kcalloc failed\n",
+                    ioc->name);
+                goto out;
+        }
+        ioc->internal_smid = ioc->hi_priority_smid + ioc->hi_priority_depth;
+        dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "internal(0x%p): "
+            "depth(%d), start smid(%d)\n", ioc->name, ioc->internal,
+             ioc->internal_depth, ioc->internal_smid));
 
         /* sense buffers, 4 byte align */
-        sz = ioc->request_depth * SCSI_SENSE_BUFFERSIZE;
+        sz = ioc->scsiio_depth * SCSI_SENSE_BUFFERSIZE;
         ioc->sense_dma_pool = pci_pool_create("sense pool", ioc->pdev, sz, 4,
             0);
         if (!ioc->sense_dma_pool) {
@@ -1929,7 +2164,7 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
         }
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT
             "sense pool(0x%p): depth(%d), element_size(%d), pool_size"
-            "(%d kB)\n", ioc->name, ioc->sense, ioc->request_depth,
+            "(%d kB)\n", ioc->name, ioc->sense, ioc->scsiio_depth,
             SCSI_SENSE_BUFFERSIZE, sz/1024));
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "sense_dma(0x%llx)\n",
             ioc->name, (unsigned long long)ioc->sense_dma));
@@ -2304,7 +2539,7 @@ _base_handshake_req_reply_wait(struct MPT2SAS_ADAPTER *ioc, int request_bytes,
             ((request_bytes/4)<<MPI2_DOORBELL_ADD_DWORDS_SHIFT)),
             &ioc->chip->Doorbell);
 
-        if ((_base_wait_for_doorbell_int(ioc, 5, sleep_flag))) {
+        if ((_base_wait_for_doorbell_int(ioc, 5, NO_SLEEP))) {
                 printk(MPT2SAS_ERR_FMT "doorbell handshake "
                    "int failed (line=%d)\n", ioc->name, __LINE__);
                 return -EFAULT;
@@ -2454,7 +2689,8 @@ mpt2sas_base_sas_iounit_control(struct MPT2SAS_ADAPTER *ioc,
         if (mpi_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET ||
             mpi_request->Operation == MPI2_SAS_OP_PHY_LINK_RESET)
                 ioc->ioc_link_reset_in_progress = 1;
-        mpt2sas_base_put_smid_default(ioc, smid, mpi_request->VF_ID);
+        mpt2sas_base_put_smid_default(ioc, smid);
+        init_completion(&ioc->base_cmds.done);
         timeleft = wait_for_completion_timeout(&ioc->base_cmds.done,
             msecs_to_jiffies(10000));
         if ((mpi_request->Operation == MPI2_SAS_OP_PHY_HARD_RESET ||
@@ -2555,7 +2791,8 @@ mpt2sas_base_scsi_enclosure_processor(struct MPT2SAS_ADAPTER *ioc,
         request = mpt2sas_base_get_msg_frame(ioc, smid);
         ioc->base_cmds.smid = smid;
         memcpy(request, mpi_request, sizeof(Mpi2SepReply_t));
-        mpt2sas_base_put_smid_default(ioc, smid, mpi_request->VF_ID);
+        mpt2sas_base_put_smid_default(ioc, smid);
+        init_completion(&ioc->base_cmds.done);
         timeleft = wait_for_completion_timeout(&ioc->base_cmds.done,
             msecs_to_jiffies(10000));
         if (!(ioc->base_cmds.status & MPT2_CMD_COMPLETE)) {
@@ -2701,17 +2938,18 @@ _base_get_ioc_facts(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
 /**
  * _base_send_ioc_init - send ioc_init to firmware
  * @ioc: per adapter object
- * @VF_ID: virtual function id
  * @sleep_flag: CAN_SLEEP or NO_SLEEP
  *
  * Returns 0 for success, non-zero for failure.
  */
 static int
-_base_send_ioc_init(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, int sleep_flag)
+_base_send_ioc_init(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
 {
         Mpi2IOCInitRequest_t mpi_request;
         Mpi2IOCInitReply_t mpi_reply;
         int r;
+        struct timeval current_time;
+        u16 ioc_status;
 
         dinitprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
             __func__));
@@ -2719,7 +2957,8 @@ _base_send_ioc_init(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, int sleep_flag)
         memset(&mpi_request, 0, sizeof(Mpi2IOCInitRequest_t));
         mpi_request.Function = MPI2_FUNCTION_IOC_INIT;
         mpi_request.WhoInit = MPI2_WHOINIT_HOST_DRIVER;
-        mpi_request.VF_ID = VF_ID;
+        mpi_request.VF_ID = 0; /* TODO */
+        mpi_request.VP_ID = 0;
         mpi_request.MsgVersion = cpu_to_le16(MPI2_VERSION);
         mpi_request.HeaderVersion = cpu_to_le16(MPI2_HEADER_VERSION);
 
@@ -2761,6 +3000,13 @@ _base_send_ioc_init(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, int sleep_flag)
             cpu_to_le32(ioc->reply_post_free_dma);
 #endif
 
+        /* This time stamp specifies number of milliseconds
+         * since epoch ~ midnight January 1, 1970.
+         */
+        do_gettimeofday(&current_time);
+        mpi_request.TimeStamp = (current_time.tv_sec * 1000) +
+            (current_time.tv_usec >> 3);
+
         if (ioc->logging_level & MPT_DEBUG_INIT) {
                 u32 *mfp;
                 int i;
@@ -2783,7 +3029,8 @@ _base_send_ioc_init(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, int sleep_flag)
                 return r;
         }
 
-        if (mpi_reply.IOCStatus != MPI2_IOCSTATUS_SUCCESS ||
+        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
+        if (ioc_status != MPI2_IOCSTATUS_SUCCESS ||
             mpi_reply.IOCLogInfo) {
                 printk(MPT2SAS_ERR_FMT "%s: failed\n", ioc->name, __func__);
                 r = -EIO;
@@ -2795,13 +3042,12 @@ _base_send_ioc_init(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, int sleep_flag)
 /**
  * _base_send_port_enable - send port_enable(discovery stuff) to firmware
  * @ioc: per adapter object
- * @VF_ID: virtual function id
  * @sleep_flag: CAN_SLEEP or NO_SLEEP
  *
  * Returns 0 for success, non-zero for failure.
  */
 static int
-_base_send_port_enable(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, int sleep_flag)
+_base_send_port_enable(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
 {
         Mpi2PortEnableRequest_t *mpi_request;
         u32 ioc_state;
@@ -2829,9 +3075,11 @@ _base_send_port_enable(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, int sleep_flag)
         ioc->base_cmds.smid = smid;
         memset(mpi_request, 0, sizeof(Mpi2PortEnableRequest_t));
         mpi_request->Function = MPI2_FUNCTION_PORT_ENABLE;
-        mpi_request->VF_ID = VF_ID;
+        mpi_request->VF_ID = 0; /* TODO */
+        mpi_request->VP_ID = 0;
 
-        mpt2sas_base_put_smid_default(ioc, smid, VF_ID);
+        mpt2sas_base_put_smid_default(ioc, smid);
+        init_completion(&ioc->base_cmds.done);
         timeleft = wait_for_completion_timeout(&ioc->base_cmds.done,
             300*HZ);
         if (!(ioc->base_cmds.status & MPT2_CMD_COMPLETE)) {
@@ -2892,13 +3140,12 @@ _base_unmask_events(struct MPT2SAS_ADAPTER *ioc, u16 event)
 /**
  * _base_event_notification - send event notification
  * @ioc: per adapter object
- * @VF_ID: virtual function id
  * @sleep_flag: CAN_SLEEP or NO_SLEEP
  *
  * Returns 0 for success, non-zero for failure.
  */
 static int
-_base_event_notification(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, int sleep_flag)
+_base_event_notification(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
 {
         Mpi2EventNotificationRequest_t *mpi_request;
         unsigned long timeleft;
@@ -2926,11 +3173,13 @@ _base_event_notification(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID, int sleep_flag)
         ioc->base_cmds.smid = smid;
         memset(mpi_request, 0, sizeof(Mpi2EventNotificationRequest_t));
         mpi_request->Function = MPI2_FUNCTION_EVENT_NOTIFICATION;
-        mpi_request->VF_ID = VF_ID;
+        mpi_request->VF_ID = 0; /* TODO */
+        mpi_request->VP_ID = 0;
         for (i = 0; i < MPI2_EVENT_NOTIFY_EVENTMASK_WORDS; i++)
                 mpi_request->EventMasks[i] =
                     le32_to_cpu(ioc->event_masks[i]);
-        mpt2sas_base_put_smid_default(ioc, smid, VF_ID);
+        mpt2sas_base_put_smid_default(ioc, smid);
+        init_completion(&ioc->base_cmds.done);
         timeleft = wait_for_completion_timeout(&ioc->base_cmds.done, 30*HZ);
         if (!(ioc->base_cmds.status & MPT2_CMD_COMPLETE)) {
                 printk(MPT2SAS_ERR_FMT "%s: timeout\n",
@@ -2981,7 +3230,7 @@ mpt2sas_base_validate_event_type(struct MPT2SAS_ADAPTER *ioc, u32 *event_type)
                 return;
 
         mutex_lock(&ioc->base_cmds.mutex);
-        _base_event_notification(ioc, 0, CAN_SLEEP);
+        _base_event_notification(ioc, CAN_SLEEP);
         mutex_unlock(&ioc->base_cmds.mutex);
 }
 
@@ -3006,7 +3255,6 @@ _base_diag_reset(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
 
         drsprintk(ioc, printk(MPT2SAS_DEBUG_FMT "clear interrupts\n",
             ioc->name));
-        writel(0, &ioc->chip->HostInterruptStatus);
 
         count = 0;
         do {
@@ -3160,30 +3408,60 @@ _base_make_ioc_ready(struct MPT2SAS_ADAPTER *ioc, int sleep_flag,
 /**
  * _base_make_ioc_operational - put controller in OPERATIONAL state
  * @ioc: per adapter object
- * @VF_ID: virtual function id
  * @sleep_flag: CAN_SLEEP or NO_SLEEP
  *
  * Returns 0 for success, non-zero for failure.
  */
 static int
-_base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
-    int sleep_flag)
+_base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
 {
         int r, i;
         unsigned long   flags;
         u32 reply_address;
+        u16 smid;
+        struct _tr_list *delayed_tr, *delayed_tr_next;
 
         dinitprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
             __func__));
 
+        /* clean the delayed target reset list */
+        list_for_each_entry_safe(delayed_tr, delayed_tr_next,
+            &ioc->delayed_tr_list, list) {
+                list_del(&delayed_tr->list);
+                kfree(delayed_tr);
+        }
+
         /* initialize the scsi lookup free list */
         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
         INIT_LIST_HEAD(&ioc->free_list);
-        for (i = 0; i < ioc->request_depth; i++) {
+        smid = 1;
+        for (i = 0; i < ioc->scsiio_depth; i++, smid++) {
                 ioc->scsi_lookup[i].cb_idx = 0xFF;
+                ioc->scsi_lookup[i].smid = smid;
+                ioc->scsi_lookup[i].scmd = NULL;
                 list_add_tail(&ioc->scsi_lookup[i].tracker_list,
                     &ioc->free_list);
         }
+
+        /* hi-priority queue */
+        INIT_LIST_HEAD(&ioc->hpr_free_list);
+        smid = ioc->hi_priority_smid;
+        for (i = 0; i < ioc->hi_priority_depth; i++, smid++) {
+                ioc->hpr_lookup[i].cb_idx = 0xFF;
+                ioc->hpr_lookup[i].smid = smid;
+                list_add_tail(&ioc->hpr_lookup[i].tracker_list,
+                    &ioc->hpr_free_list);
+        }
+
+        /* internal queue */
+        INIT_LIST_HEAD(&ioc->internal_free_list);
+        smid = ioc->internal_smid;
+        for (i = 0; i < ioc->internal_depth; i++, smid++) {
+                ioc->internal_lookup[i].cb_idx = 0xFF;
+                ioc->internal_lookup[i].smid = smid;
+                list_add_tail(&ioc->internal_lookup[i].tracker_list,
+                    &ioc->internal_free_list);
+        }
         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
 
         /* initialize Reply Free Queue */
@@ -3196,7 +3474,7 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
         for (i = 0; i < ioc->reply_post_queue_depth; i++)
                 ioc->reply_post_free[i].Words = ULLONG_MAX;
 
-        r = _base_send_ioc_init(ioc, VF_ID, sleep_flag);
+        r = _base_send_ioc_init(ioc, sleep_flag);
         if (r)
                 return r;
 
@@ -3207,14 +3485,14 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, u8 VF_ID,
         writel(0, &ioc->chip->ReplyPostHostIndex);
 
         _base_unmask_interrupts(ioc);
-        r = _base_event_notification(ioc, VF_ID, sleep_flag);
+        r = _base_event_notification(ioc, sleep_flag);
         if (r)
                 return r;
 
         if (sleep_flag == CAN_SLEEP)
                 _base_static_config_pages(ioc);
 
-        r = _base_send_port_enable(ioc, VF_ID, sleep_flag);
+        r = _base_send_port_enable(ioc, sleep_flag);
         if (r)
                 return r;
 
@@ -3270,14 +3548,25 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
                 return r;
 
         pci_set_drvdata(ioc->pdev, ioc->shost);
-        r = _base_make_ioc_ready(ioc, CAN_SLEEP, SOFT_RESET);
+        r = _base_get_ioc_facts(ioc, CAN_SLEEP);
         if (r)
                 goto out_free_resources;
 
-        r = _base_get_ioc_facts(ioc, CAN_SLEEP);
+        r = _base_make_ioc_ready(ioc, CAN_SLEEP, SOFT_RESET);
         if (r)
                 goto out_free_resources;
 
+        ioc->pfacts = kcalloc(ioc->facts.NumberOfPorts,
+            sizeof(Mpi2PortFactsReply_t), GFP_KERNEL);
+        if (!ioc->pfacts)
+                goto out_free_resources;
+
+        for (i = 0 ; i < ioc->facts.NumberOfPorts; i++) {
+                r = _base_get_port_facts(ioc, i, CAN_SLEEP);
+                if (r)
+                        goto out_free_resources;
+        }
+
         r = _base_allocate_memory_pools(ioc, CAN_SLEEP);
         if (r)
                 goto out_free_resources;
@@ -3286,7 +3575,6 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
 
         /* base internal command bits */
         mutex_init(&ioc->base_cmds.mutex);
-        init_completion(&ioc->base_cmds.done);
         ioc->base_cmds.reply = kzalloc(ioc->reply_sz, GFP_KERNEL);
         ioc->base_cmds.status = MPT2_CMD_NOT_USED;
 
@@ -3294,7 +3582,11 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
         ioc->transport_cmds.reply = kzalloc(ioc->reply_sz, GFP_KERNEL);
         ioc->transport_cmds.status = MPT2_CMD_NOT_USED;
         mutex_init(&ioc->transport_cmds.mutex);
-        init_completion(&ioc->transport_cmds.done);
+
+        /* scsih internal command bits */
+        ioc->scsih_cmds.reply = kzalloc(ioc->reply_sz, GFP_KERNEL);
+        ioc->scsih_cmds.status = MPT2_CMD_NOT_USED;
+        mutex_init(&ioc->scsih_cmds.mutex);
 
         /* task management internal command bits */
         ioc->tm_cmds.reply = kzalloc(ioc->reply_sz, GFP_KERNEL);
@@ -3310,7 +3602,6 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
         ioc->ctl_cmds.reply = kzalloc(ioc->reply_sz, GFP_KERNEL);
         ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
         mutex_init(&ioc->ctl_cmds.mutex);
-        init_completion(&ioc->ctl_cmds.done);
 
         for (i = 0; i < MPI2_EVENT_NOTIFY_EVENTMASK_WORDS; i++)
                 ioc->event_masks[i] = -1;
@@ -3327,22 +3618,13 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
         _base_unmask_events(ioc, MPI2_EVENT_IR_OPERATION_STATUS);
         _base_unmask_events(ioc, MPI2_EVENT_TASK_SET_FULL);
         _base_unmask_events(ioc, MPI2_EVENT_LOG_ENTRY_ADDED);
-
-        ioc->pfacts = kcalloc(ioc->facts.NumberOfPorts,
-            sizeof(Mpi2PortFactsReply_t), GFP_KERNEL);
-        if (!ioc->pfacts)
-                goto out_free_resources;
-
-        for (i = 0 ; i < ioc->facts.NumberOfPorts; i++) {
-                r = _base_get_port_facts(ioc, i, CAN_SLEEP);
-                if (r)
-                        goto out_free_resources;
-        }
-        r = _base_make_ioc_operational(ioc, 0, CAN_SLEEP);
+        r = _base_make_ioc_operational(ioc, CAN_SLEEP);
         if (r)
                 goto out_free_resources;
 
         mpt2sas_base_start_watchdog(ioc);
+        if (diag_buffer_enable != 0)
+                mpt2sas_enable_diag_buffer(ioc, diag_buffer_enable);
         return 0;
 
  out_free_resources:
@@ -3466,7 +3748,7 @@ _wait_for_commands_to_complete(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
 
         /* pending command count */
         spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
-        for (i = 0; i < ioc->request_depth; i++)
+        for (i = 0; i < ioc->scsiio_depth; i++)
                 if (ioc->scsi_lookup[i].cb_idx != 0xFF)
                         ioc->pending_io_count++;
         spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
@@ -3490,12 +3772,15 @@ int
 mpt2sas_base_hard_reset_handler(struct MPT2SAS_ADAPTER *ioc, int sleep_flag,
     enum reset_type type)
 {
-        int r, i;
+        int r;
         unsigned long flags;
 
         dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
             __func__));
 
+        if (mpt2sas_fwfault_debug)
+                mpt2sas_halt_firmware(ioc);
+
         spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);
         if (ioc->shost_recovery) {
                 spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock, flags);
@@ -3513,9 +3798,7 @@ mpt2sas_base_hard_reset_handler(struct MPT2SAS_ADAPTER *ioc, int sleep_flag,
         if (r)
                 goto out;
         _base_reset_handler(ioc, MPT2_IOC_AFTER_RESET);
-        for (i = 0 ; i < ioc->facts.NumberOfPorts; i++)
-                r = _base_make_ioc_operational(ioc, ioc->pfacts[i].VF_ID,
-                    sleep_flag);
+        r = _base_make_ioc_operational(ioc, sleep_flag);
         if (!r)
                 _base_reset_handler(ioc, MPT2_IOC_DONE_RESET);
  out: