Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

9 files changed, 333 insertions, 35 deletions

diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index 610e914abe6c..5382b5a44aff 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -126,8 +126,6 @@ static int mfcounter = 0;
  *  Public data...
  */
 
-static struct proc_dir_entry *mpt_proc_root_dir;
-
 #define WHOINIT_UNKNOWN         0xAA
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
@@ -146,6 +144,9 @@ static MPT_EVHANDLER		 MptEvHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 static MPT_RESETHANDLER          MptResetHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 static struct mpt_pci_driver    *MptDeviceDriverHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 
+#ifdef CONFIG_PROC_FS
+static struct proc_dir_entry    *mpt_proc_root_dir;
+#endif
 
 /*
  *  Driver Callback Index's
@@ -1587,7 +1588,7 @@ mpt_mapresources(MPT_ADAPTER *ioc)
 {
         u8              __iomem *mem;
         int              ii;
-        unsigned long    mem_phys;
+        resource_size_t  mem_phys;
         unsigned long    port;
         u32              msize;
         u32              psize;
@@ -1677,8 +1678,8 @@ mpt_mapresources(MPT_ADAPTER *ioc)
                 return -EINVAL;
         }
         ioc->memmap = mem;
-        dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "mem = %p, mem_phys = %lx\n",
-            ioc->name, mem, mem_phys));
+        dinitprintk(ioc, printk(MYIOC_s_INFO_FMT "mem = %p, mem_phys = %llx\n",
+            ioc->name, mem, (unsigned long long)mem_phys));
 
         ioc->mem_phys = mem_phys;
         ioc->chip = (SYSIF_REGS __iomem *)mem;
@@ -4330,6 +4331,8 @@ initChainBuffers(MPT_ADAPTER *ioc)
 
         if (ioc->bus_type == SPI)
                 num_chain *= MPT_SCSI_CAN_QUEUE;
+        else if (ioc->bus_type == SAS)
+                num_chain *= MPT_SAS_CAN_QUEUE;
         else
                 num_chain *= MPT_FC_CAN_QUEUE;
 
diff --git a/drivers/message/fusion/mptbase.h b/drivers/message/fusion/mptbase.h
index 8dd4d219e433..9718c8f2e959 100644
--- a/drivers/message/fusion/mptbase.h
+++ b/drivers/message/fusion/mptbase.h
@@ -76,8 +76,8 @@
 #define COPYRIGHT       "Copyright (c) 1999-2008 " MODULEAUTHOR
 #endif
 
-#define MPT_LINUX_VERSION_COMMON        "3.04.12"
-#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.04.12"
+#define MPT_LINUX_VERSION_COMMON        "3.04.14"
+#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.04.14"
 #define WHAT_MAGIC_STRING               "@" "(" "#" ")"
 
 #define show_mptmod_ver(s,ver)  \
diff --git a/drivers/message/fusion/mptctl.c b/drivers/message/fusion/mptctl.c
index 9b2e2198aee9..caa8f568a41c 100644
--- a/drivers/message/fusion/mptctl.c
+++ b/drivers/message/fusion/mptctl.c
@@ -360,8 +360,8 @@ static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
         u16              iocstatus;
 
         /* bus reset is only good for SCSI IO, RAID PASSTHRU */
-        if (!(function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) ||
-            (function == MPI_FUNCTION_SCSI_IO_REQUEST)) {
+        if (!(function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH ||
+                function == MPI_FUNCTION_SCSI_IO_REQUEST)) {
                 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT
                         "TaskMgmt, not SCSI_IO!!\n", ioc->name));
                 return -EPERM;
@@ -621,11 +621,8 @@ __mptctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
          */
         iocnumX = khdr.iocnum & 0xFF;
         if (((iocnum = mpt_verify_adapter(iocnumX, &iocp)) < 0) ||
-            (iocp == NULL)) {
-                printk(KERN_DEBUG MYNAM "%s::mptctl_ioctl() @%d - ioc%d not found!\n",
-                                __FILE__, __LINE__, iocnumX);
+            (iocp == NULL))
                 return -ENODEV;
-        }
 
         if (!iocp->active) {
                 printk(KERN_DEBUG MYNAM "%s::mptctl_ioctl() @%d - Controller disabled.\n",
diff --git a/drivers/message/fusion/mptfc.c b/drivers/message/fusion/mptfc.c
index ebf6ae024da4..33f7256055b1 100644
--- a/drivers/message/fusion/mptfc.c
+++ b/drivers/message/fusion/mptfc.c
@@ -54,6 +54,7 @@
 #include <linux/reboot.h>       /* notifier code */
 #include <linux/workqueue.h>
 #include <linux/sort.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -195,29 +196,34 @@ mptfc_block_error_handler(struct scsi_cmnd *SCpnt,
         unsigned long           flags;
         int                     ready;
         MPT_ADAPTER             *ioc;
+        int                     loops = 40;     /* seconds */
 
         hd = shost_priv(SCpnt->device->host);
         ioc = hd->ioc;
         spin_lock_irqsave(shost->host_lock, flags);
-        while ((ready = fc_remote_port_chkready(rport) >> 16) == DID_IMM_RETRY) {
+        while ((ready = fc_remote_port_chkready(rport) >> 16) == DID_IMM_RETRY
+         || (loops > 0 && ioc->active == 0)) {
                 spin_unlock_irqrestore(shost->host_lock, flags);
                 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
                         "mptfc_block_error_handler.%d: %d:%d, port status is "
-                        "DID_IMM_RETRY, deferring %s recovery.\n",
+                        "%x, active flag %d, deferring %s recovery.\n",
                         ioc->name, ioc->sh->host_no,
-                        SCpnt->device->id, SCpnt->device->lun, caller));
+                        SCpnt->device->id, SCpnt->device->lun,
+                        ready, ioc->active, caller));
                 msleep(1000);
                 spin_lock_irqsave(shost->host_lock, flags);
+                loops --;
         }
         spin_unlock_irqrestore(shost->host_lock, flags);
 
-        if (ready == DID_NO_CONNECT || !SCpnt->device->hostdata) {
+        if (ready == DID_NO_CONNECT || !SCpnt->device->hostdata
+         || ioc->active == 0) {
                 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
                         "%s.%d: %d:%d, failing recovery, "
-                        "port state %d, vdevice %p.\n", caller,
+                        "port state %x, active %d, vdevice %p.\n", caller,
                         ioc->name, ioc->sh->host_no,
                         SCpnt->device->id, SCpnt->device->lun, ready,
-                        SCpnt->device->hostdata));
+                        ioc->active, SCpnt->device->hostdata));
                 return FAILED;
         }
         dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
diff --git a/drivers/message/fusion/mptlan.c b/drivers/message/fusion/mptlan.c
index 34f3f36f819b..4fa9665cbe93 100644
--- a/drivers/message/fusion/mptlan.c
+++ b/drivers/message/fusion/mptlan.c
@@ -57,6 +57,7 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 
 #define my_VERSION      MPT_LINUX_VERSION_COMMON
 #define MYNAM           "mptlan"
diff --git a/drivers/message/fusion/mptsas.c b/drivers/message/fusion/mptsas.c
index 83873e3d0ce7..76687126b573 100644
--- a/drivers/message/fusion/mptsas.c
+++ b/drivers/message/fusion/mptsas.c
@@ -45,6 +45,7 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/jiffies.h>
@@ -1075,6 +1076,19 @@ mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
         return 0;
 }
 
+static void
+mptsas_block_io_sdev(struct scsi_device *sdev, void *data)
+{
+        scsi_device_set_state(sdev, SDEV_BLOCK);
+}
+
+static void
+mptsas_block_io_starget(struct scsi_target *starget)
+{
+        if (starget)
+                starget_for_each_device(starget, NULL, mptsas_block_io_sdev);
+}
+
 /**
  * mptsas_target_reset_queue
  *
@@ -1098,10 +1112,11 @@ mptsas_target_reset_queue(MPT_ADAPTER *ioc,
         id = sas_event_data->TargetID;
         channel = sas_event_data->Bus;
 
-        if (!(vtarget = mptsas_find_vtarget(ioc, channel, id)))
-                return;
-
-        vtarget->deleted = 1; /* block IO */
+        vtarget = mptsas_find_vtarget(ioc, channel, id);
+        if (vtarget) {
+                mptsas_block_io_starget(vtarget->starget);
+                vtarget->deleted = 1; /* block IO */
+        }
 
         target_reset_list = kzalloc(sizeof(struct mptsas_target_reset_event),
             GFP_ATOMIC);
@@ -1868,7 +1883,8 @@ mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
         if (ioc->sas_discovery_quiesce_io)
                 return SCSI_MLQUEUE_HOST_BUSY;
 
-//      scsi_print_command(SCpnt);
+        if (ioc->debug_level & MPT_DEBUG_SCSI)
+                scsi_print_command(SCpnt);
 
         return mptscsih_qcmd(SCpnt,done);
 }
@@ -2686,6 +2702,187 @@ mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
         return error;
 }
 
+struct rep_manu_request{
+        u8 smp_frame_type;
+        u8 function;
+        u8 reserved;
+        u8 request_length;
+};
+
+struct rep_manu_reply{
+        u8 smp_frame_type; /* 0x41 */
+        u8 function; /* 0x01 */
+        u8 function_result;
+        u8 response_length;
+        u16 expander_change_count;
+        u8 reserved0[2];
+        u8 sas_format:1;
+        u8 reserved1:7;
+        u8 reserved2[3];
+        u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN];
+        u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN];
+        u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN];
+        u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN];
+        u16 component_id;
+        u8 component_revision_id;
+        u8 reserved3;
+        u8 vendor_specific[8];
+};
+
+/**
+  * mptsas_exp_repmanufacture_info -
+  * @ioc: per adapter object
+  * @sas_address: expander sas address
+  * @edev: the sas_expander_device object
+  *
+  * Fills in the sas_expander_device object when SMP port is created.
+  *
+  * Returns 0 for success, non-zero for failure.
+  */
+static int
+mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc,
+        u64 sas_address, struct sas_expander_device *edev)
+{
+        MPT_FRAME_HDR *mf;
+        SmpPassthroughRequest_t *smpreq;
+        SmpPassthroughReply_t *smprep;
+        struct rep_manu_reply *manufacture_reply;
+        struct rep_manu_request *manufacture_request;
+        int ret;
+        int flagsLength;
+        unsigned long timeleft;
+        char *psge;
+        unsigned long flags;
+        void *data_out = NULL;
+        dma_addr_t data_out_dma = 0;
+        u32 sz;
+
+        spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
+        if (ioc->ioc_reset_in_progress) {
+                spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+                printk(MYIOC_s_INFO_FMT "%s: host reset in progress!\n",
+                        __func__, ioc->name);
+                return -EFAULT;
+        }
+        spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+
+        ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
+        if (ret)
+                goto out;
+
+        mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
+        if (!mf) {
+                ret = -ENOMEM;
+                goto out_unlock;
+        }
+
+        smpreq = (SmpPassthroughRequest_t *)mf;
+        memset(smpreq, 0, sizeof(*smpreq));
+
+        sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply);
+
+        data_out = pci_alloc_consistent(ioc->pcidev, sz, &data_out_dma);
+        if (!data_out) {
+                printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n",
+                        __FILE__, __LINE__, __func__);
+                ret = -ENOMEM;
+                goto put_mf;
+        }
+
+        manufacture_request = data_out;
+        manufacture_request->smp_frame_type = 0x40;
+        manufacture_request->function = 1;
+        manufacture_request->reserved = 0;
+        manufacture_request->request_length = 0;
+
+        smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
+        smpreq->PhysicalPort = 0xFF;
+        *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
+        smpreq->RequestDataLength = sizeof(struct rep_manu_request);
+
+        psge = (char *)
+                (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
+
+        flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
+                MPI_SGE_FLAGS_SYSTEM_ADDRESS |
+                MPI_SGE_FLAGS_HOST_TO_IOC |
+                MPI_SGE_FLAGS_END_OF_BUFFER;
+        flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
+        flagsLength |= sizeof(struct rep_manu_request);
+
+        ioc->add_sge(psge, flagsLength, data_out_dma);
+        psge += ioc->SGE_size;
+
+        flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
+                MPI_SGE_FLAGS_SYSTEM_ADDRESS |
+                MPI_SGE_FLAGS_IOC_TO_HOST |
+                MPI_SGE_FLAGS_END_OF_BUFFER;
+        flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
+        flagsLength |= sizeof(struct rep_manu_reply);
+        ioc->add_sge(psge, flagsLength, data_out_dma +
+        sizeof(struct rep_manu_request));
+
+        INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
+        mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
+
+        timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
+        if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
+                ret = -ETIME;
+                mpt_free_msg_frame(ioc, mf);
+                mf = NULL;
+                if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
+                        goto out_free;
+                if (!timeleft)
+                        mpt_HardResetHandler(ioc, CAN_SLEEP);
+                goto out_free;
+        }
+
+        mf = NULL;
+
+        if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
+                u8 *tmp;
+
+        smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
+        if (le16_to_cpu(smprep->ResponseDataLength) !=
+                sizeof(struct rep_manu_reply))
+                        goto out_free;
+
+        manufacture_reply = data_out + sizeof(struct rep_manu_request);
+        strncpy(edev->vendor_id, manufacture_reply->vendor_id,
+                SAS_EXPANDER_VENDOR_ID_LEN);
+        strncpy(edev->product_id, manufacture_reply->product_id,
+                SAS_EXPANDER_PRODUCT_ID_LEN);
+        strncpy(edev->product_rev, manufacture_reply->product_rev,
+                SAS_EXPANDER_PRODUCT_REV_LEN);
+        edev->level = manufacture_reply->sas_format;
+        if (manufacture_reply->sas_format) {
+                strncpy(edev->component_vendor_id,
+                        manufacture_reply->component_vendor_id,
+                                SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
+                tmp = (u8 *)&manufacture_reply->component_id;
+                edev->component_id = tmp[0] << 8 | tmp[1];
+                edev->component_revision_id =
+                        manufacture_reply->component_revision_id;
+                }
+        } else {
+                printk(MYIOC_s_ERR_FMT
+                        "%s: smp passthru reply failed to be returned\n",
+                        ioc->name, __func__);
+                ret = -ENXIO;
+        }
+out_free:
+        if (data_out_dma)
+                pci_free_consistent(ioc->pcidev, sz, data_out, data_out_dma);
+put_mf:
+        if (mf)
+                mpt_free_msg_frame(ioc, mf);
+out_unlock:
+        CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
+        mutex_unlock(&ioc->sas_mgmt.mutex);
+out:
+        return ret;
+ }
+
 static void
 mptsas_parse_device_info(struct sas_identify *identify,
                 struct mptsas_devinfo *device_info)
@@ -2967,6 +3164,11 @@ static int mptsas_probe_one_phy(struct device *dev,
                         goto out;
                 }
                 mptsas_set_rphy(ioc, phy_info, rphy);
+                if (identify.device_type == SAS_EDGE_EXPANDER_DEVICE ||
+                        identify.device_type == SAS_FANOUT_EXPANDER_DEVICE)
+                                mptsas_exp_repmanufacture_info(ioc,
+                                        identify.sas_address,
+                                        rphy_to_expander_device(rphy));
         }
 
  out:
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index c29578614504..6796597dcee0 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -46,6 +46,7 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/kdev_t.h>
@@ -792,11 +793,36 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
                          *  precedence!
                          */
                         sc->result = (DID_OK << 16) | scsi_status;
-                        if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
-                                /* Have already saved the status and sense data
+                        if (!(scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID)) {
+
+                                /*
+                                 * For an Errata on LSI53C1030
+                                 * When the length of request data
+                                 * and transfer data are different
+                                 * with result of command (READ or VERIFY),
+                                 * DID_SOFT_ERROR is set.
                                  */
-                                ;
-                        } else {
+                                if (ioc->bus_type == SPI) {
+                                        if (pScsiReq->CDB[0] == READ_6  ||
+                                            pScsiReq->CDB[0] == READ_10 ||
+                                            pScsiReq->CDB[0] == READ_12 ||
+                                            pScsiReq->CDB[0] == READ_16 ||
+                                            pScsiReq->CDB[0] == VERIFY  ||
+                                            pScsiReq->CDB[0] == VERIFY_16) {
+                                                if (scsi_bufflen(sc) !=
+                                                        xfer_cnt) {
+                                                        sc->result =
+                                                        DID_SOFT_ERROR << 16;
+                                                    printk(KERN_WARNING "Errata"
+                                                    "on LSI53C1030 occurred."
+                                                    "sc->req_bufflen=0x%02x,"
+                                                    "xfer_cnt=0x%02x\n",
+                                                    scsi_bufflen(sc),
+                                                    xfer_cnt);
+                                                }
+                                        }
+                                }
+
                                 if (xfer_cnt < sc->underflow) {
                                         if (scsi_status == SAM_STAT_BUSY)
                                                 sc->result = SAM_STAT_BUSY;
@@ -835,7 +861,58 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
                         sc->result = (DID_OK << 16) | scsi_status;
                         if (scsi_state == 0) {
                                 ;
-                        } else if (scsi_state & MPI_SCSI_STATE_AUTOSENSE_VALID) {
+                        } else if (scsi_state &
+                            MPI_SCSI_STATE_AUTOSENSE_VALID) {
+
+                                /*
+                                 * For potential trouble on LSI53C1030.
+                                 * (date:2007.xx.)
+                                 * It is checked whether the length of
+                                 * request data is equal to
+                                 * the length of transfer and residual.
+                                 * MEDIUM_ERROR is set by incorrect data.
+                                 */
+                                if ((ioc->bus_type == SPI) &&
+                                        (sc->sense_buffer[2] & 0x20)) {
+                                        u32      difftransfer;
+                                        difftransfer =
+                                        sc->sense_buffer[3] << 24 |
+                                        sc->sense_buffer[4] << 16 |
+                                        sc->sense_buffer[5] << 8 |
+                                        sc->sense_buffer[6];
+                                        if (((sc->sense_buffer[3] & 0x80) ==
+                                                0x80) && (scsi_bufflen(sc)
+                                                != xfer_cnt)) {
+                                                sc->sense_buffer[2] =
+                                                    MEDIUM_ERROR;
+                                                sc->sense_buffer[12] = 0xff;
+                                                sc->sense_buffer[13] = 0xff;
+                                                printk(KERN_WARNING"Errata"
+                                                "on LSI53C1030 occurred."
+                                                "sc->req_bufflen=0x%02x,"
+                                                "xfer_cnt=0x%02x\n" ,
+                                                scsi_bufflen(sc),
+                                                xfer_cnt);
+                                        }
+                                        if (((sc->sense_buffer[3] & 0x80)
+                                                != 0x80) &&
+                                                (scsi_bufflen(sc) !=
+                                                xfer_cnt + difftransfer)) {
+                                                sc->sense_buffer[2] =
+                                                        MEDIUM_ERROR;
+                                                sc->sense_buffer[12] = 0xff;
+                                                sc->sense_buffer[13] = 0xff;
+                                                printk(KERN_WARNING
+                                                "Errata on LSI53C1030 occurred"
+                                                "sc->req_bufflen=0x%02x,"
+                                                " xfer_cnt=0x%02x,"
+                                                "difftransfer=0x%02x\n",
+                                                scsi_bufflen(sc),
+                                                xfer_cnt,
+                                                difftransfer);
+                                        }
+                                }
+
                                 /*
                                  * If running against circa 200003dd 909 MPT f/w,
                                  * may get this (AUTOSENSE_VALID) for actual TASK_SET_FULL
@@ -1362,9 +1439,14 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
             && (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES)
             && (SCpnt->device->tagged_supported)) {
                 scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ;
-        } else {
+                if (SCpnt->request && SCpnt->request->ioprio) {
+                        if (((SCpnt->request->ioprio & 0x7) == 1) ||
+                                !(SCpnt->request->ioprio & 0x7))
+                                scsictl |= MPI_SCSIIO_CONTROL_HEADOFQ;
+                }
+        } else
                 scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED;
-        }
+
 
         /* Use the above information to set up the message frame
          */
@@ -1720,7 +1802,7 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "task abort: "
                    "Command not in the active list! (sc=%p)\n", ioc->name,
                    SCpnt));
-                retval = 0;
+                retval = SUCCESS;
                 goto out;
         }
 
@@ -2275,11 +2357,12 @@ mptscsih_slave_destroy(struct scsi_device *sdev)
  *      mptscsih_change_queue_depth - This function will set a devices queue depth
  *      @sdev: per scsi_device pointer
  *      @qdepth: requested queue depth
+ *      @reason: calling context
  *
  *      Adding support for new 'change_queue_depth' api.
 */
 int
-mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
+mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
 {
         MPT_SCSI_HOST           *hd = shost_priv(sdev->host);
         VirtTarget              *vtarget;
@@ -2291,6 +2374,9 @@ mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
         starget = scsi_target(sdev);
         vtarget = starget->hostdata;
 
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (ioc->bus_type == SPI) {
                 if (!(vtarget->tflags & MPT_TARGET_FLAGS_Q_YES))
                         max_depth = 1;
@@ -2357,7 +2443,8 @@ mptscsih_slave_configure(struct scsi_device *sdev)
                     ioc->name, vtarget->negoFlags, vtarget->maxOffset,
                     vtarget->minSyncFactor));
 
-        mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH);
+        mptscsih_change_queue_depth(sdev, MPT_SCSI_CMD_PER_DEV_HIGH,
+                                    SCSI_QDEPTH_DEFAULT);
         dsprintk(ioc, printk(MYIOC_s_DEBUG_FMT
                 "tagged %d, simple %d, ordered %d\n",
                 ioc->name,sdev->tagged_supported, sdev->simple_tags,
diff --git a/drivers/message/fusion/mptscsih.h b/drivers/message/fusion/mptscsih.h
index e0b33e04a33b..45a5ff3eff61 100644
--- a/drivers/message/fusion/mptscsih.h
+++ b/drivers/message/fusion/mptscsih.h
@@ -128,7 +128,8 @@ extern int mptscsih_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_F
 extern int mptscsih_scandv_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *r);
 extern int mptscsih_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
 extern int mptscsih_ioc_reset(MPT_ADAPTER *ioc, int post_reset);
-extern int mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth);
+extern int mptscsih_change_queue_depth(struct scsi_device *sdev, int qdepth,
+                                       int reason);
 extern u8 mptscsih_raid_id_to_num(MPT_ADAPTER *ioc, u8 channel, u8 id);
 extern int mptscsih_is_phys_disk(MPT_ADAPTER *ioc, u8 channel, u8 id);
 extern struct device_attribute *mptscsih_host_attrs[];
diff --git a/drivers/message/fusion/mptspi.c b/drivers/message/fusion/mptspi.c
index 69f4257419b5..e44365193fdf 100644
--- a/drivers/message/fusion/mptspi.c
+++ b/drivers/message/fusion/mptspi.c
@@ -46,6 +46,7 @@
 
 #include <linux/module.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/kdev_t.h>